contrib/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    2001, 2002  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 /* $FreeBSD$ */
  24
  25
  26 /* Process declarations and symbol lookup for C front end.
  27    Also constructs types; the standard scalar types at initialization,
  28    and structure, union, array and enum types when they are declared.  */
  29
  30 /* ??? not all decl nodes are given the most useful possible
  31    line numbers.  For example, the CONST_DECLs for enum values.  */
  32
  33 #include "config.h"
  34 #include "system.h"
  35 #include "tree.h"
  36 #include "rtl.h"
  37 #include "expr.h"
  38 #include "flags.h"
  39 #include "cp-tree.h"
  40 #include "tree-inline.h"
  41 #include "decl.h"
  42 #include "lex.h"
  43 #include "output.h"
  44 #include "except.h"
  45 #include "toplev.h"
  46 #include "../hash.h"
  47 #include "ggc.h"
  48 #include "tm_p.h"
  49 #include "target.h"
  50 #include "c-common.h"
  51 #include "c-pragma.h"
  52 #include "diagnostic.h"
  53
  54 extern const struct attribute_spec *lang_attribute_table;
  55
  56 #ifndef HOST_PTR_PRINTF_FORMAT
  57 #define HOST_PTR_PRINTF_FORMAT HOST_PTR_PRINTF
  58 #endif
  59 #ifndef HOST_PTR_PRINTF_TYPE
  60 #define HOST_PTR_PRINTF_TYPE (void *)
  61 #endif
  62
  63 static tree grokparms                           PARAMS ((tree));
  64 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  65
  66 static void push_binding_level PARAMS ((struct binding_level *, int,
  67                                       int));
  68 static void pop_binding_level PARAMS ((void));
  69 static void suspend_binding_level PARAMS ((void));
  70 static void resume_binding_level PARAMS ((struct binding_level *));
  71 static struct binding_level *make_binding_level PARAMS ((void));
  72 static void declare_namespace_level PARAMS ((void));
  73 static int decl_jump_unsafe PARAMS ((tree));
  74 static void storedecls PARAMS ((tree));
  75 static void require_complete_types_for_parms PARAMS ((tree));
  76 static int ambi_op_p PARAMS ((enum tree_code));
  77 static int unary_op_p PARAMS ((enum tree_code));
  78 static tree store_bindings PARAMS ((tree, tree));
  79 static tree lookup_tag_reverse PARAMS ((tree, tree));
  80 static tree obscure_complex_init PARAMS ((tree, tree));
  81 static tree lookup_name_real PARAMS ((tree, int, int, int));
  82 static void push_local_name PARAMS ((tree));
  83 static void warn_extern_redeclared_static PARAMS ((tree, tree));
  84 static tree grok_reference_init PARAMS ((tree, tree, tree));
  85 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
  86                               enum overload_flags, tree,
  87                               tree, int, int, int, int, int, int, tree));
  88 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
  89 static tree follow_tag_typedef PARAMS ((tree));
  90 static tree lookup_tag PARAMS ((enum tree_code, tree,
  91                               struct binding_level *, int));
  92 static void set_identifier_type_value_with_scope
  93         PARAMS ((tree, tree, struct binding_level *));
  94 static void record_unknown_type PARAMS ((tree, const char *));
  95 static tree builtin_function_1 PARAMS ((const char *, tree, tree, int,
  96                                       enum built_in_class, const char *));
  97 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
  98 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
  99 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
 100                                   int));
 101 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
 102 static void check_for_uninitialized_const_var PARAMS ((tree));
 103 static unsigned long typename_hash PARAMS ((hash_table_key));
 104 static bool typename_compare PARAMS ((hash_table_key, hash_table_key));
 105 static void push_binding PARAMS ((tree, tree, struct binding_level*));
 106 static int add_binding PARAMS ((tree, tree));
 107 static void pop_binding PARAMS ((tree, tree));
 108 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 109 static tree find_binding PARAMS ((tree, tree));
 110 static tree select_decl PARAMS ((tree, int));
 111 static int lookup_flags PARAMS ((int, int));
 112 static tree qualify_lookup PARAMS ((tree, int));
 113 static tree record_builtin_java_type PARAMS ((const char *, int));
 114 static const char *tag_name PARAMS ((enum tag_types code));
 115 static void find_class_binding_level PARAMS ((void));
 116 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 117 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 118 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 119 static int walk_globals_r PARAMS ((tree, void *));
 120 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 121 static tree make_label_decl PARAMS ((tree, int));
 122 static void use_label PARAMS ((tree));
 123 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 124                                            const char *, int));
 125 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 126 static void check_switch_goto PARAMS ((struct binding_level *));
 127 static void check_previous_gotos PARAMS ((tree));
 128 static void pop_label PARAMS ((tree, tree));
 129 static void pop_labels PARAMS ((tree));
 130 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 131 static void layout_var_decl PARAMS ((tree));
 132 static void maybe_commonize_var PARAMS ((tree));
 133 static tree check_initializer PARAMS ((tree, tree));
 134 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 135 static void push_cp_function_context PARAMS ((struct function *));
 136 static void pop_cp_function_context PARAMS ((struct function *));
 137 static void mark_binding_level PARAMS ((void *));
 138 static void mark_named_label_lists PARAMS ((void *, void *));
 139 static void mark_cp_function_context PARAMS ((struct function *));
 140 static void mark_saved_scope PARAMS ((void *));
 141 static void mark_lang_function PARAMS ((struct cp_language_function *));
 142 static void save_function_data PARAMS ((tree));
 143 static void check_function_type PARAMS ((tree, tree));
 144 static void destroy_local_var PARAMS ((tree));
 145 static void begin_constructor_body PARAMS ((void));
 146 static void finish_constructor_body PARAMS ((void));
 147 static void begin_destructor_body PARAMS ((void));
 148 static void finish_destructor_body PARAMS ((void));
 149 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 150 static tree get_atexit_node PARAMS ((void));
 151 static tree get_dso_handle_node PARAMS ((void));
 152 static tree start_cleanup_fn PARAMS ((void));
 153 static void end_cleanup_fn PARAMS ((void));
 154 static tree cp_make_fname_decl PARAMS ((tree, int));
 155 static void initialize_predefined_identifiers PARAMS ((void));
 156 static tree check_special_function_return_type
 157   PARAMS ((special_function_kind, tree, tree));
 158 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 159 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 160 static void store_parm_decls PARAMS ((tree));
 161 static int cp_missing_noreturn_ok_p PARAMS ((tree));
 162
 163 #if defined (DEBUG_CP_BINDING_LEVELS)
 164 static void indent PARAMS ((void));
 165 #endif
 166
 167 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 168 tree error_mark_list;
 169
 170 /* The following symbols are subsumed in the cp_global_trees array, and
 171    listed here individually for documentation purposes.
 172
 173    C++ extensions
 174         tree wchar_decl_node;
 175
 176         tree vtable_entry_type;
 177         tree delta_type_node;
 178         tree __t_desc_type_node;
 179         tree ti_desc_type_node;
 180         tree bltn_desc_type_node, ptr_desc_type_node;
 181         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 182         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 183         tree ptm_desc_type_node;
 184         tree base_desc_type_node;
 185
 186         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 187         tree unknown_type_node;
 188
 189    Array type `vtable_entry_type[]'
 190
 191         tree vtbl_type_node;
 192         tree vtbl_ptr_type_node;
 193
 194    Namespaces,
 195
 196         tree std_node;
 197         tree abi_node;
 198
 199    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 200    one that the user will declare, but sufficient to be called
 201    by routines that want to abort the program.
 202
 203         tree abort_fndecl;
 204
 205    The FUNCTION_DECL for the default `::operator delete'.
 206
 207         tree global_delete_fndecl;
 208
 209    Used by RTTI
 210         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 211         tree tinfo_var_id;
 212
 213 */
 214
 215 tree cp_global_trees[CPTI_MAX];
 216
 217 /* Indicates that there is a type value in some namespace, although
 218    that is not necessarily in scope at the moment.  */
 219
 220 static tree global_type_node;
 221
 222 /* Expect only namespace names now. */
 223 static int only_namespace_names;
 224
 225 /* Used only for jumps to as-yet undefined labels, since jumps to
 226    defined labels can have their validity checked immediately.  */
 227
 228 struct named_label_use_list
 229 {
 230   struct binding_level *binding_level;
 231   tree names_in_scope;
 232   tree label_decl;
 233   const char *filename_o_goto;
 234   int lineno_o_goto;
 235   struct named_label_use_list *next;
 236 };
 237
 238 #define named_label_uses cp_function_chain->x_named_label_uses
 239
 240 #define local_names cp_function_chain->x_local_names
 241
 242 /* A list of objects which have constructors or destructors
 243    which reside in the global scope.  The decl is stored in
 244    the TREE_VALUE slot and the initializer is stored
 245    in the TREE_PURPOSE slot.  */
 246 tree static_aggregates;
 247
 248 /* -- end of C++ */
 249
 250 /* A node for the integer constants 2, and 3.  */
 251
 252 tree integer_two_node, integer_three_node;
 253
 254 /* Similar, for last_function_parm_tags.  */
 255 tree last_function_parms;
 256
 257 /* A list of all LABEL_DECLs in the function that have names.  Here so
 258    we can clear out their names' definitions at the end of the
 259    function, and so we can check the validity of jumps to these labels.  */
 260
 261 struct named_label_list
 262 {
 263   struct binding_level *binding_level;
 264   tree names_in_scope;
 265   tree old_value;
 266   tree label_decl;
 267   tree bad_decls;
 268   struct named_label_list *next;
 269   unsigned int in_try_scope : 1;
 270   unsigned int in_catch_scope : 1;
 271 };
 272
 273 #define named_labels cp_function_chain->x_named_labels
 274
 275 /* Nonzero means use the ISO C94 dialect of C.  */
 276
 277 int flag_isoc94;
 278
 279 /* Nonzero means use the ISO C99 dialect of C.  */
 280
 281 int flag_isoc99;
 282
 283 /* Nonzero means we are a hosted implementation for code shared with C.  */
 284
 285 int flag_hosted = 1;
 286
 287 /* Nonzero means add default format_arg attributes for functions not
 288    in ISO C.  */
 289
 290 int flag_noniso_default_format_attributes = 1;
 291
 292 /* Nonzero if we want to conserve space in the .o files.  We do this
 293    by putting uninitialized data and runtime initialized data into
 294    .common instead of .data at the expense of not flagging multiple
 295    definitions.  */
 296 extern int flag_conserve_space;
 297 \f
 298 /* C and C++ flags are in decl2.c.  */
 299
 300 /* A expression of value 0 with the same precision as a sizetype
 301    node, but signed.  */
 302 tree signed_size_zero_node;
 303
 304 /* The name of the anonymous namespace, throughout this translation
 305    unit.  */
 306 tree anonymous_namespace_name;
 307
 308 /* The number of function bodies which we are currently processing.
 309    (Zero if we are at namespace scope, one inside the body of a
 310    function, two inside the body of a function in a local class, etc.)  */
 311 int function_depth;
 312
 313 /* States indicating how grokdeclarator() should handle declspecs marked
 314    with __attribute__((deprecated)).  An object declared as
 315    __attribute__((deprecated)) suppresses warnings of uses of other
 316    deprecated items.  */
 317
 318 enum deprecated_states {
 319   DEPRECATED_NORMAL,
 320   DEPRECATED_SUPPRESS
 321 };
 322
 323 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
 324
 325 /* Set by add_implicitly_declared_members() to keep those members from
 326    being flagged as deprecated or reported as using deprecated
 327    types.  */
 328 int adding_implicit_members = 0;
 329 \f
 330 /* For each binding contour we allocate a binding_level structure
 331    which records the names defined in that contour.
 332    Contours include:
 333     0) the global one
 334     1) one for each function definition,
 335        where internal declarations of the parameters appear.
 336     2) one for each compound statement,
 337        to record its declarations.
 338
 339    The current meaning of a name can be found by searching the levels
 340    from the current one out to the global one.
 341
 342    Off to the side, may be the class_binding_level.  This exists only
 343    to catch class-local declarations.  It is otherwise nonexistent.
 344
 345    Also there may be binding levels that catch cleanups that must be
 346    run when exceptions occur.  Thus, to see whether a name is bound in
 347    the current scope, it is not enough to look in the
 348    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 349    instead.  */
 350
 351 /* Note that the information in the `names' component of the global contour
 352    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 353
 354 struct binding_level
 355   {
 356     /* A chain of _DECL nodes for all variables, constants, functions,
 357        and typedef types.  These are in the reverse of the order
 358        supplied.  There may be OVERLOADs on this list, too, but they
 359        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 360     tree names;
 361
 362     /* A list of structure, union and enum definitions, for looking up
 363        tag names.
 364        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 365        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 366        or ENUMERAL_TYPE node.
 367
 368        C++: the TREE_VALUE nodes can be simple types for
 369        component_bindings.  */
 370     tree tags;
 371
 372     /* A list of USING_DECL nodes. */
 373     tree usings;
 374
 375     /* A list of used namespaces. PURPOSE is the namespace,
 376        VALUE the common ancestor with this binding_level's namespace. */
 377     tree using_directives;
 378
 379     /* If this binding level is the binding level for a class, then
 380        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 381        is the name of an entity bound in the class.  The TREE_TYPE is
 382        the DECL bound by this name in the class.  */
 383     tree class_shadowed;
 384
 385     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 386        is used for all binding levels. In addition the TREE_VALUE is the
 387        IDENTIFIER_TYPE_VALUE before we entered the class.  */
 388     tree type_shadowed;
 389
 390     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 391        label in this scope.  The TREE_PURPOSE is the previous value of
 392        the IDENTIFIER_LABEL VALUE.  */
 393     tree shadowed_labels;
 394
 395     /* For each level (except not the global one),
 396        a chain of BLOCK nodes for all the levels
 397        that were entered and exited one level down.  */
 398     tree blocks;
 399
 400     /* The _TYPE node for this level, if parm_flag == 2.  */
 401     tree this_class;
 402
 403     /* The binding level which this one is contained in (inherits from).  */
 404     struct binding_level *level_chain;
 405
 406     /* List of VAR_DECLS saved from a previous for statement.
 407        These would be dead in ISO-conforming code, but might
 408        be referenced in ARM-era code.  These are stored in a
 409        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 410     tree dead_vars_from_for;
 411
 412     /* 1 for the level that holds the parameters of a function.
 413        2 for the level that holds a class declaration.  */
 414     unsigned parm_flag : 2;
 415
 416     /* 1 means make a BLOCK for this level regardless of all else.
 417        2 for temporary binding contours created by the compiler.  */
 418     unsigned keep : 2;
 419
 420     /* Nonzero if this level "doesn't exist" for tags.  */
 421     unsigned tag_transparent : 1;
 422
 423     /* Nonzero if this level can safely have additional
 424        cleanup-needing variables added to it.  */
 425     unsigned more_cleanups_ok : 1;
 426     unsigned have_cleanups : 1;
 427
 428     /* Nonzero if this scope is for storing the decls for template
 429        parameters and generic decls; these decls will be discarded and
 430        replaced with a TEMPLATE_DECL.  */
 431     unsigned template_parms_p : 1;
 432
 433     /* Nonzero if this scope corresponds to the `<>' in a
 434        `template <>' clause.  Whenever this flag is set,
 435        TEMPLATE_PARMS_P will be set as well.  */
 436     unsigned template_spec_p : 1;
 437
 438     /* This is set for a namespace binding level.  */
 439     unsigned namespace_p : 1;
 440
 441     /* True if this level is that of a for-statement where we need to
 442        worry about ambiguous (ARM or ISO) scope rules.  */
 443     unsigned is_for_scope : 1;
 444
 445     /* True if this level corresponds to a TRY block.  Currently this
 446        information is only available while building the tree structure.  */
 447     unsigned is_try_scope : 1;
 448
 449     /* True if this level corresponds to a CATCH block.  Currently this
 450        information is only available while building the tree structure.  */
 451     unsigned is_catch_scope : 1;
 452
 453     /* Three bits left for this word.  */
 454
 455 #if defined(DEBUG_CP_BINDING_LEVELS)
 456     /* Binding depth at which this level began.  */
 457     unsigned binding_depth;
 458 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 459   };
 460
 461 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 462
 463 /* The binding level currently in effect.  */
 464
 465 #define current_binding_level                   \
 466   (cfun && cp_function_chain->bindings          \
 467    ? cp_function_chain->bindings                \
 468    : scope_chain->bindings)
 469
 470 /* The binding level of the current class, if any.  */
 471
 472 #define class_binding_level scope_chain->class_bindings
 473
 474 /* A chain of binding_level structures awaiting reuse.  */
 475
 476 static struct binding_level *free_binding_level;
 477
 478 /* The outermost binding level, for names of file scope.
 479    This is created when the compiler is started and exists
 480    through the entire run.  */
 481
 482 static struct binding_level *global_binding_level;
 483
 484 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 485
 486 static int keep_next_level_flag;
 487
 488 /* A TREE_LIST of VAR_DECLs.  The TREE_PURPOSE is a RECORD_TYPE or
 489    UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type.  At the
 490    time the VAR_DECL was declared, the type was incomplete.  */
 491
 492 static tree incomplete_vars;
 493
 494 #if defined(DEBUG_CP_BINDING_LEVELS)
 495 static int binding_depth = 0;
 496 static int is_class_level = 0;
 497
 498 static void
 499 indent ()
 500 {
 501   register unsigned i;
 502
 503   for (i = 0; i < binding_depth*2; i++)
 504     putc (' ', stderr);
 505 }
 506 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 507
 508 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 509
 510 static void
 511 push_binding_level (newlevel, tag_transparent, keep)
 512      struct binding_level *newlevel;
 513      int tag_transparent, keep;
 514 {
 515   /* Add this level to the front of the chain (stack) of levels that
 516      are active.  */
 517   memset ((char*) newlevel, 0, sizeof (struct binding_level));
 518   newlevel->level_chain = current_binding_level;
 519   current_binding_level = newlevel;
 520   newlevel->tag_transparent = tag_transparent;
 521   newlevel->more_cleanups_ok = 1;
 522
 523   newlevel->keep = keep;
 524 #if defined(DEBUG_CP_BINDING_LEVELS)
 525   newlevel->binding_depth = binding_depth;
 526   indent ();
 527   fprintf (stderr, "push %s level 0x%08x line %d\n",
 528            (is_class_level) ? "class" : "block", newlevel, lineno);
 529   is_class_level = 0;
 530   binding_depth++;
 531 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 532 }
 533
 534 /* Find the innermost enclosing class scope, and reset
 535    CLASS_BINDING_LEVEL appropriately.  */
 536
 537 static void
 538 find_class_binding_level ()
 539 {
 540   struct binding_level *level = current_binding_level;
 541
 542   while (level && level->parm_flag != 2)
 543     level = level->level_chain;
 544   if (level && level->parm_flag == 2)
 545     class_binding_level = level;
 546   else
 547     class_binding_level = 0;
 548 }
 549
 550 static void
 551 pop_binding_level ()
 552 {
 553   if (global_binding_level)
 554     {
 555       /* Cannot pop a level, if there are none left to pop.  */
 556       if (current_binding_level == global_binding_level)
 557         abort ();
 558     }
 559   /* Pop the current level, and free the structure for reuse.  */
 560 #if defined(DEBUG_CP_BINDING_LEVELS)
 561   binding_depth--;
 562   indent ();
 563   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 564           (is_class_level) ? "class" : "block",
 565           current_binding_level, lineno);
 566   if (is_class_level != (current_binding_level == class_binding_level))
 567     {
 568       indent ();
 569       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 570     }
 571   is_class_level = 0;
 572 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 573   {
 574     register struct binding_level *level = current_binding_level;
 575     current_binding_level = current_binding_level->level_chain;
 576     level->level_chain = free_binding_level;
 577 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 578     if (level->binding_depth != binding_depth)
 579       abort ();
 580 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 581     free_binding_level = level;
 582     find_class_binding_level ();
 583   }
 584 }
 585
 586 static void
 587 suspend_binding_level ()
 588 {
 589   if (class_binding_level)
 590     current_binding_level = class_binding_level;
 591
 592   if (global_binding_level)
 593     {
 594       /* Cannot suspend a level, if there are none left to suspend.  */
 595       if (current_binding_level == global_binding_level)
 596         abort ();
 597     }
 598   /* Suspend the current level.  */
 599 #if defined(DEBUG_CP_BINDING_LEVELS)
 600   binding_depth--;
 601   indent ();
 602   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 603           (is_class_level) ? "class" : "block",
 604           current_binding_level, lineno);
 605   if (is_class_level != (current_binding_level == class_binding_level))
 606     {
 607       indent ();
 608       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 609     }
 610   is_class_level = 0;
 611 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 612   current_binding_level = current_binding_level->level_chain;
 613   find_class_binding_level ();
 614 }
 615
 616 static void
 617 resume_binding_level (b)
 618      struct binding_level *b;
 619 {
 620   /* Resuming binding levels is meant only for namespaces,
 621      and those cannot nest into classes. */
 622   my_friendly_assert(!class_binding_level, 386);
 623   /* Also, resuming a non-directly nested namespace is a no-no.  */
 624   my_friendly_assert(b->level_chain == current_binding_level, 386);
 625   current_binding_level = b;
 626 #if defined(DEBUG_CP_BINDING_LEVELS)
 627   b->binding_depth = binding_depth;
 628   indent ();
 629   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 630            (is_class_level) ? "class" : "block", b, lineno);
 631   is_class_level = 0;
 632   binding_depth++;
 633 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 634 }
 635 \f
 636 /* Create a new `struct binding_level'.  */
 637
 638 static
 639 struct binding_level *
 640 make_binding_level ()
 641 {
 642   /* NOSTRICT */
 643   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 644 }
 645
 646 /* Nonzero if we are currently in the global binding level.  */
 647
 648 int
 649 global_bindings_p ()
 650 {
 651   return current_binding_level == global_binding_level;
 652 }
 653
 654 /* Return the innermost binding level that is not for a class scope.  */
 655
 656 static struct binding_level *
 657 innermost_nonclass_level ()
 658 {
 659   struct binding_level *b;
 660
 661   b = current_binding_level;
 662   while (b->parm_flag == 2)
 663     b = b->level_chain;
 664
 665   return b;
 666 }
 667
 668 /* Nonzero if we are currently in a toplevel binding level.  This
 669    means either the global binding level or a namespace in a toplevel
 670    binding level.  Since there are no non-toplevel namespace levels,
 671    this really means any namespace or template parameter level.  We
 672    also include a class whose context is toplevel.  */
 673
 674 int
 675 toplevel_bindings_p ()
 676 {
 677   struct binding_level *b = innermost_nonclass_level ();
 678
 679   return b->namespace_p || b->template_parms_p;
 680 }
 681
 682 /* Nonzero if this is a namespace scope, or if we are defining a class
 683    which is itself at namespace scope, or whose enclosing class is
 684    such a class, etc.  */
 685
 686 int
 687 namespace_bindings_p ()
 688 {
 689   struct binding_level *b = innermost_nonclass_level ();
 690
 691   return b->namespace_p;
 692 }
 693
 694 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 695    unconditionally.  Otherwise, use the normal logic to decide whether
 696    or not to create a BLOCK.  */
 697
 698 void
 699 keep_next_level (keep)
 700      int keep;
 701 {
 702   keep_next_level_flag = keep;
 703 }
 704
 705 /* Nonzero if the current level needs to have a BLOCK made.  */
 706
 707 int
 708 kept_level_p ()
 709 {
 710   return (current_binding_level->blocks != NULL_TREE
 711           || current_binding_level->keep
 712           || current_binding_level->names != NULL_TREE
 713           || (current_binding_level->tags != NULL_TREE
 714               && !current_binding_level->tag_transparent));
 715 }
 716
 717 static void
 718 declare_namespace_level ()
 719 {
 720   current_binding_level->namespace_p = 1;
 721 }
 722
 723 /* Returns non-zero if this scope was created to store template
 724    parameters.  */
 725
 726 int
 727 template_parm_scope_p ()
 728 {
 729   return current_binding_level->template_parms_p;
 730 }
 731
 732 /* Returns the kind of template specialization we are currently
 733    processing, given that it's declaration contained N_CLASS_SCOPES
 734    explicit scope qualifications.  */
 735
 736 tmpl_spec_kind
 737 current_tmpl_spec_kind (n_class_scopes)
 738      int n_class_scopes;
 739 {
 740   int n_template_parm_scopes = 0;
 741   int seen_specialization_p = 0;
 742   int innermost_specialization_p = 0;
 743   struct binding_level *b;
 744
 745   /* Scan through the template parameter scopes.  */
 746   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 747     {
 748       /* If we see a specialization scope inside a parameter scope,
 749          then something is wrong.  That corresponds to a declaration
 750          like:
 751
 752             template <class T> template <> ...
 753
 754          which is always illegal since [temp.expl.spec] forbids the
 755          specialization of a class member template if the enclosing
 756          class templates are not explicitly specialized as well.  */
 757       if (b->template_spec_p)
 758         {
 759           if (n_template_parm_scopes == 0)
 760             innermost_specialization_p = 1;
 761           else
 762             seen_specialization_p = 1;
 763         }
 764       else if (seen_specialization_p == 1)
 765         return tsk_invalid_member_spec;
 766
 767       ++n_template_parm_scopes;
 768     }
 769
 770   /* Handle explicit instantiations.  */
 771   if (processing_explicit_instantiation)
 772     {
 773       if (n_template_parm_scopes != 0)
 774         /* We've seen a template parameter list during an explicit
 775            instantiation.  For example:
 776
 777              template <class T> template void f(int);
 778
 779            This is erroneous.  */
 780         return tsk_invalid_expl_inst;
 781       else
 782         return tsk_expl_inst;
 783     }
 784
 785   if (n_template_parm_scopes < n_class_scopes)
 786     /* We've not seen enough template headers to match all the
 787        specialized classes present.  For example:
 788
 789          template <class T> void R<T>::S<T>::f(int);
 790
 791        This is illegal; there needs to be one set of template
 792        parameters for each class.  */
 793     return tsk_insufficient_parms;
 794   else if (n_template_parm_scopes == n_class_scopes)
 795     /* We're processing a non-template declaration (even though it may
 796        be a member of a template class.)  For example:
 797
 798          template <class T> void S<T>::f(int);
 799
 800        The `class T' maches the `S<T>', leaving no template headers
 801        corresponding to the `f'.  */
 802     return tsk_none;
 803   else if (n_template_parm_scopes > n_class_scopes + 1)
 804     /* We've got too many template headers.  For example:
 805
 806          template <> template <class T> void f (T);
 807
 808        There need to be more enclosing classes.  */
 809     return tsk_excessive_parms;
 810   else
 811     /* This must be a template.  It's of the form:
 812
 813          template <class T> template <class U> void S<T>::f(U);
 814
 815        This is a specialization if the innermost level was a
 816        specialization; otherwise it's just a definition of the
 817        template.  */
 818     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 819 }
 820
 821 void
 822 set_class_shadows (shadows)
 823      tree shadows;
 824 {
 825   class_binding_level->class_shadowed = shadows;
 826 }
 827
 828 /* Enter a new binding level.
 829    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 830    not for that of tags.  */
 831
 832 void
 833 pushlevel (tag_transparent)
 834      int tag_transparent;
 835 {
 836   struct binding_level *newlevel;
 837
 838   if (cfun && !doing_semantic_analysis_p ())
 839     return;
 840
 841   /* Reuse or create a struct for this binding level.  */
 842 #if defined(DEBUG_CP_BINDING_LEVELS)
 843   if (0)
 844 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 845   if (free_binding_level)
 846 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 847     {
 848       newlevel = free_binding_level;
 849       free_binding_level = free_binding_level->level_chain;
 850     }
 851   else
 852     newlevel = make_binding_level ();
 853
 854   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 855   keep_next_level_flag = 0;
 856 }
 857
 858 /* We're defining an object of type TYPE.  If it needs a cleanup, but
 859    we're not allowed to add any more objects with cleanups to the current
 860    scope, create a new binding level.  */
 861
 862 void
 863 maybe_push_cleanup_level (type)
 864      tree type;
 865 {
 866   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
 867       && current_binding_level->more_cleanups_ok == 0)
 868     {
 869       keep_next_level (2);
 870       pushlevel (1);
 871       clear_last_expr ();
 872       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
 873     }
 874 }
 875
 876 /* Enter a new scope.  The KIND indicates what kind of scope is being
 877    created.  */
 878
 879 void
 880 begin_scope (sk)
 881      scope_kind sk;
 882 {
 883   pushlevel (0);
 884
 885   switch (sk)
 886     {
 887     case sk_template_spec:
 888       current_binding_level->template_spec_p = 1;
 889       /* Fall through.  */
 890
 891     case sk_template_parms:
 892       current_binding_level->template_parms_p = 1;
 893       break;
 894
 895     default:
 896       abort ();
 897     }
 898 }
 899
 900 /* Exit the current scope.  */
 901
 902 void
 903 finish_scope ()
 904 {
 905   poplevel (0, 0, 0);
 906 }
 907
 908 void
 909 note_level_for_for ()
 910 {
 911   current_binding_level->is_for_scope = 1;
 912 }
 913
 914 /* Record that the current binding level represents a try block.  */
 915
 916 void
 917 note_level_for_try ()
 918 {
 919   current_binding_level->is_try_scope = 1;
 920 }
 921
 922 /* Record that the current binding level represents a catch block.  */
 923
 924 void
 925 note_level_for_catch ()
 926 {
 927   current_binding_level->is_catch_scope = 1;
 928 }
 929
 930 /* For a binding between a name and an entity at a block scope,
 931    this is the `struct binding_level' for the block.  */
 932 #define BINDING_LEVEL(NODE) \
 933   (((struct tree_binding*)(NODE))->scope.level)
 934
 935 /* A free list of CPLUS_BINDING nodes, connected by their
 936    TREE_CHAINs.  */
 937
 938 static tree free_bindings;
 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   if (free_bindings)
 952     {
 953       binding = free_bindings;
 954       free_bindings = TREE_CHAIN (binding);
 955     }
 956   else
 957     binding = make_node (CPLUS_BINDING);
 958
 959   /* Now, fill in the binding information.  */
 960   BINDING_VALUE (binding) = decl;
 961   BINDING_TYPE (binding) = NULL_TREE;
 962   BINDING_LEVEL (binding) = level;
 963   INHERITED_VALUE_BINDING_P (binding) = 0;
 964   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 965   BINDING_HAS_LEVEL_P (binding) = 1;
 966
 967   /* And put it on the front of the list of bindings for ID.  */
 968   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 969   IDENTIFIER_BINDING (id) = binding;
 970 }
 971
 972 /* ID is already bound in the current scope.  But, DECL is an
 973    additional binding for ID in the same scope.  This is the `struct
 974    stat' hack whereby a non-typedef class-name or enum-name can be
 975    bound at the same level as some other kind of entity.  It's the
 976    responsibility of the caller to check that inserting this name is
 977    legal here.  Returns nonzero if the new binding was successful.  */
 978 static int
 979 add_binding (id, decl)
 980      tree id;
 981      tree decl;
 982 {
 983   tree binding = IDENTIFIER_BINDING (id);
 984   int ok = 1;
 985
 986   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 987     /* The new name is the type name.  */
 988     BINDING_TYPE (binding) = decl;
 989   else if (!BINDING_VALUE (binding))
 990     /* This situation arises when push_class_level_binding moves an
 991        inherited type-binding out of the way to make room for a new
 992        value binding.  */
 993     BINDING_VALUE (binding) = decl;
 994   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 995            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 996     {
 997       /* The old binding was a type name.  It was placed in
 998          BINDING_VALUE because it was thought, at the point it was
 999          declared, to be the only entity with such a name.  Move the
1000          type name into the type slot; it is now hidden by the new
1001          binding.  */
1002       BINDING_TYPE (binding) = BINDING_VALUE (binding);
1003       BINDING_VALUE (binding) = decl;
1004       INHERITED_VALUE_BINDING_P (binding) = 0;
1005     }
1006   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1007            && TREE_CODE (decl) == TYPE_DECL
1008            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1009            && (same_type_p (TREE_TYPE (decl),
1010                             TREE_TYPE (BINDING_VALUE (binding)))
1011                /* If either type involves template parameters, we must
1012                   wait until instantiation.  */
1013                || uses_template_parms (TREE_TYPE (decl))
1014                || uses_template_parms (TREE_TYPE (BINDING_VALUE (binding)))))
1015     /* We have two typedef-names, both naming the same type to have
1016        the same name.  This is OK because of:
1017
1018          [dcl.typedef]
1019
1020          In a given scope, a typedef specifier can be used to redefine
1021          the name of any type declared in that scope to refer to the
1022          type to which it already refers.  */
1023     ok = 0;
1024   /* There can be two block-scope declarations of the same variable,
1025      so long as they are `extern' declarations.  */
1026   else if (TREE_CODE (decl) == VAR_DECL
1027            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1028            && DECL_EXTERNAL (decl)
1029            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1030     {
1031       duplicate_decls (decl, BINDING_VALUE (binding));
1032       ok = 0;
1033     }
1034   else
1035     {
1036       error ("declaration of `%#D'", decl);
1037       cp_error_at ("conflicts with previous declaration `%#D'",
1038                    BINDING_VALUE (binding));
1039       ok = 0;
1040     }
1041
1042   return ok;
1043 }
1044
1045 /* Add DECL to the list of things declared in B.  */
1046
1047 static void
1048 add_decl_to_level (decl, b)
1049      tree decl;
1050      struct binding_level *b;
1051 {
1052   /* We build up the list in reverse order, and reverse it later if
1053      necessary.  */
1054   TREE_CHAIN (decl) = b->names;
1055   b->names = decl;
1056 }
1057
1058 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1059    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1060    doesn't really belong to this binding level, that it got here
1061    through a using-declaration.  */
1062
1063 void
1064 push_local_binding (id, decl, flags)
1065      tree id;
1066      tree decl;
1067      int flags;
1068 {
1069   struct binding_level *b;
1070
1071   /* Skip over any local classes.  This makes sense if we call
1072      push_local_binding with a friend decl of a local class.  */
1073   b = current_binding_level;
1074   while (b->parm_flag == 2)
1075     b = b->level_chain;
1076
1077   if (lookup_name_current_level (id))
1078     {
1079       /* Supplement the existing binding.  */
1080       if (!add_binding (id, decl))
1081         /* It didn't work.  Something else must be bound at this
1082            level.  Do not add DECL to the list of things to pop
1083            later.  */
1084         return;
1085     }
1086   else
1087     /* Create a new binding.  */
1088     push_binding (id, decl, b);
1089
1090   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1091     /* We must put the OVERLOAD into a TREE_LIST since the
1092        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1093        decls that got here through a using-declaration.  */
1094     decl = build_tree_list (NULL_TREE, decl);
1095
1096   /* And put DECL on the list of things declared by the current
1097      binding level.  */
1098   add_decl_to_level (decl, b);
1099 }
1100
1101 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1102    binding was successful.  */
1103
1104 int
1105 push_class_binding (id, decl)
1106      tree id;
1107      tree decl;
1108 {
1109   int result = 1;
1110   tree binding = IDENTIFIER_BINDING (id);
1111   tree context;
1112
1113   /* Note that we declared this value so that we can issue an error if
1114      this an illegal redeclaration of a name already used for some
1115      other purpose.  */
1116   note_name_declared_in_class (id, decl);
1117
1118   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1119     /* Supplement the existing binding.  */
1120     result = add_binding (id, decl);
1121   else
1122     /* Create a new binding.  */
1123     push_binding (id, decl, class_binding_level);
1124
1125   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1126      class-level declaration.  Note that we do not use DECL here
1127      because of the possibility of the `struct stat' hack; if DECL is
1128      a class-name or enum-name we might prefer a field-name, or some
1129      such.  */
1130   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1131
1132   /* If this is a binding from a base class, mark it as such.  */
1133   binding = IDENTIFIER_BINDING (id);
1134   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1135     {
1136       /* Any implicit typename must be from a base-class.  The
1137          context for an implicit typename declaration is always
1138          the derived class in which the lookup was done, so the checks
1139          based on the context of DECL below will not trigger.  */
1140       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1141         INHERITED_VALUE_BINDING_P (binding) = 1;
1142       else
1143         {
1144           if (TREE_CODE (decl) == OVERLOAD)
1145             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1146           else
1147             {
1148               my_friendly_assert (DECL_P (decl), 0);
1149               context = context_for_name_lookup (decl);
1150             }
1151
1152           if (is_properly_derived_from (current_class_type, context))
1153             INHERITED_VALUE_BINDING_P (binding) = 1;
1154           else
1155             INHERITED_VALUE_BINDING_P (binding) = 0;
1156         }
1157     }
1158   else if (BINDING_VALUE (binding) == decl)
1159     /* We only encounter a TREE_LIST when push_class_decls detects an
1160        ambiguity.  Such an ambiguity can be overridden by a definition
1161        in this class.  */
1162     INHERITED_VALUE_BINDING_P (binding) = 1;
1163
1164   return result;
1165 }
1166
1167 /* Remove the binding for DECL which should be the innermost binding
1168    for ID.  */
1169
1170 static void
1171 pop_binding (id, decl)
1172      tree id;
1173      tree decl;
1174 {
1175   tree binding;
1176
1177   if (id == NULL_TREE)
1178     /* It's easiest to write the loops that call this function without
1179        checking whether or not the entities involved have names.  We
1180        get here for such an entity.  */
1181     return;
1182
1183   /* Get the innermost binding for ID.  */
1184   binding = IDENTIFIER_BINDING (id);
1185
1186   /* The name should be bound.  */
1187   my_friendly_assert (binding != NULL_TREE, 0);
1188
1189   /* The DECL will be either the ordinary binding or the type
1190      binding for this identifier.  Remove that binding.  */
1191   if (BINDING_VALUE (binding) == decl)
1192     BINDING_VALUE (binding) = NULL_TREE;
1193   else if (BINDING_TYPE (binding) == decl)
1194     BINDING_TYPE (binding) = NULL_TREE;
1195   else
1196     abort ();
1197
1198   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1199     {
1200       /* We're completely done with the innermost binding for this
1201          identifier.  Unhook it from the list of bindings.  */
1202       IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1203
1204       /* Add it to the free list.  */
1205       TREE_CHAIN (binding) = free_bindings;
1206       free_bindings = binding;
1207
1208       /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
1209          it.  */
1210       BINDING_LEVEL (binding) = NULL;
1211     }
1212 }
1213
1214 /* When a label goes out of scope, check to see if that label was used
1215    in a valid manner, and issue any appropriate warnings or errors.  */
1216
1217 static void
1218 pop_label (label, old_value)
1219      tree label;
1220      tree old_value;
1221 {
1222   if (!processing_template_decl && doing_semantic_analysis_p ())
1223     {
1224       if (DECL_INITIAL (label) == NULL_TREE)
1225         {
1226           cp_error_at ("label `%D' used but not defined", label);
1227           /* Avoid crashing later.  */
1228           define_label (input_filename, 1, DECL_NAME (label));
1229         }
1230       else if (warn_unused_label && !TREE_USED (label))
1231         cp_warning_at ("label `%D' defined but not used", label);
1232     }
1233
1234   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1235 }
1236
1237 /* At the end of a function, all labels declared within the function
1238    go out of scope.  BLOCK is the top-level block for the
1239    function.  */
1240
1241 static void
1242 pop_labels (block)
1243      tree block;
1244 {
1245   struct named_label_list *link;
1246
1247   /* Clear out the definitions of all label names, since their scopes
1248      end here.  */
1249   for (link = named_labels; link; link = link->next)
1250     {
1251       pop_label (link->label_decl, link->old_value);
1252       /* Put the labels into the "variables" of the top-level block,
1253          so debugger can see them.  */
1254       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1255       BLOCK_VARS (block) = link->label_decl;
1256     }
1257
1258   named_labels = NULL;
1259 }
1260
1261 /* Exit a binding level.
1262    Pop the level off, and restore the state of the identifier-decl mappings
1263    that were in effect when this level was entered.
1264
1265    If KEEP == 1, this level had explicit declarations, so
1266    and create a "block" (a BLOCK node) for the level
1267    to record its declarations and subblocks for symbol table output.
1268
1269    If FUNCTIONBODY is nonzero, this level is the body of a function,
1270    so create a block as if KEEP were set and also clear out all
1271    label names.
1272
1273    If REVERSE is nonzero, reverse the order of decls before putting
1274    them into the BLOCK.  */
1275
1276 tree
1277 poplevel (keep, reverse, functionbody)
1278      int keep;
1279      int reverse;
1280      int functionbody;
1281 {
1282   register tree link;
1283   /* The chain of decls was accumulated in reverse order.
1284      Put it into forward order, just for cleanliness.  */
1285   tree decls;
1286   int tmp = functionbody;
1287   int real_functionbody;
1288   tree tags;
1289   tree subblocks;
1290   tree block = NULL_TREE;
1291   tree decl;
1292   int leaving_for_scope;
1293
1294   if (cfun && !doing_semantic_analysis_p ())
1295     return NULL_TREE;
1296
1297   my_friendly_assert (current_binding_level->parm_flag != 2,
1298                       19990916);
1299
1300   real_functionbody = (current_binding_level->keep == 2
1301                        ? ((functionbody = 0), tmp) : functionbody);
1302   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1303   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1304
1305   my_friendly_assert (!current_binding_level->class_shadowed,
1306                       19990414);
1307
1308   /* We used to use KEEP == 2 to indicate that the new block should go
1309      at the beginning of the list of blocks at this binding level,
1310      rather than the end.  This hack is no longer used.  */
1311   my_friendly_assert (keep == 0 || keep == 1, 0);
1312
1313   if (current_binding_level->keep == 1)
1314     keep = 1;
1315
1316   /* Any uses of undefined labels, and any defined labels, now operate
1317      under constraints of next binding contour.  */
1318   if (cfun && !functionbody)
1319     {
1320       struct binding_level *level_chain;
1321       level_chain = current_binding_level->level_chain;
1322       if (level_chain)
1323         {
1324           struct named_label_use_list *uses;
1325           struct named_label_list *labels;
1326           for (labels = named_labels; labels; labels = labels->next)
1327             if (labels->binding_level == current_binding_level)
1328               {
1329                 tree decl;
1330                 if (current_binding_level->is_try_scope)
1331                   labels->in_try_scope = 1;
1332                 if (current_binding_level->is_catch_scope)
1333                   labels->in_catch_scope = 1;
1334                 for (decl = labels->names_in_scope; decl;
1335                      decl = TREE_CHAIN (decl))
1336                   if (decl_jump_unsafe (decl))
1337                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1338                                                    labels->bad_decls);
1339                 labels->binding_level = level_chain;
1340                 labels->names_in_scope = level_chain->names;
1341               }
1342
1343           for (uses = named_label_uses; uses; uses = uses->next)
1344             if (uses->binding_level == current_binding_level)
1345               {
1346                 uses->binding_level = level_chain;
1347                 uses->names_in_scope = level_chain->names;
1348               }
1349         }
1350     }
1351
1352   /* Get the decls in the order they were written.
1353      Usually current_binding_level->names is in reverse order.
1354      But parameter decls were previously put in forward order.  */
1355
1356   if (reverse)
1357     current_binding_level->names
1358       = decls = nreverse (current_binding_level->names);
1359   else
1360     decls = current_binding_level->names;
1361
1362   /* Output any nested inline functions within this block
1363      if they weren't already output.  */
1364   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1365     if (TREE_CODE (decl) == FUNCTION_DECL
1366         && ! TREE_ASM_WRITTEN (decl)
1367         && DECL_INITIAL (decl) != NULL_TREE
1368         && TREE_ADDRESSABLE (decl)
1369         && decl_function_context (decl) == current_function_decl)
1370       {
1371         /* If this decl was copied from a file-scope decl
1372            on account of a block-scope extern decl,
1373            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1374         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1375           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1376         else
1377           {
1378             push_function_context ();
1379             output_inline_function (decl);
1380             pop_function_context ();
1381           }
1382       }
1383
1384   /* When not in function-at-a-time mode, expand_end_bindings will
1385      warn about unused variables.  But, in function-at-a-time mode
1386      expand_end_bindings is not passed the list of variables in the
1387      current scope, and therefore no warning is emitted.  So, we
1388      explicitly warn here.  */
1389   if (!processing_template_decl)
1390     warn_about_unused_variables (getdecls ());
1391
1392   /* If there were any declarations or structure tags in that level,
1393      or if this level is a function body,
1394      create a BLOCK to record them for the life of this function.  */
1395   block = NULL_TREE;
1396   if (keep == 1 || functionbody)
1397     block = make_node (BLOCK);
1398   if (block != NULL_TREE)
1399     {
1400       BLOCK_VARS (block) = decls;
1401       BLOCK_SUBBLOCKS (block) = subblocks;
1402     }
1403
1404   /* In each subblock, record that this is its superior.  */
1405   if (keep >= 0)
1406     for (link = subblocks; link; link = TREE_CHAIN (link))
1407       BLOCK_SUPERCONTEXT (link) = block;
1408
1409   /* We still support the old for-scope rules, whereby the variables
1410      in a for-init statement were in scope after the for-statement
1411      ended.  We only use the new rules in flag_new_for_scope is
1412      nonzero.  */
1413   leaving_for_scope
1414     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1415
1416   /* Remove declarations for all the DECLs in this level.  */
1417   for (link = decls; link; link = TREE_CHAIN (link))
1418     {
1419       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1420           && DECL_NAME (link))
1421         {
1422           tree outer_binding
1423             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1424           tree ns_binding;
1425
1426           if (!outer_binding)
1427             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1428           else
1429             ns_binding = NULL_TREE;
1430
1431           if (outer_binding
1432               && (BINDING_LEVEL (outer_binding)
1433                   == current_binding_level->level_chain))
1434             /* We have something like:
1435
1436                  int i;
1437                  for (int i; ;);
1438
1439                and we are leaving the `for' scope.  There's no reason to
1440                keep the binding of the inner `i' in this case.  */
1441             pop_binding (DECL_NAME (link), link);
1442           else if ((outer_binding
1443                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1444                         == TYPE_DECL))
1445                    || (ns_binding
1446                        && TREE_CODE (ns_binding) == TYPE_DECL))
1447             /* Here, we have something like:
1448
1449                  typedef int I;
1450
1451                  void f () {
1452                    for (int I; ;);
1453                  }
1454
1455                We must pop the for-scope binding so we know what's a
1456                type and what isn't.  */
1457             pop_binding (DECL_NAME (link), link);
1458           else
1459             {
1460               /* Mark this VAR_DECL as dead so that we can tell we left it
1461                  there only for backward compatibility.  */
1462               DECL_DEAD_FOR_LOCAL (link) = 1;
1463
1464               /* Keep track of what should of have happenned when we
1465                  popped the binding.  */
1466               if (outer_binding && BINDING_VALUE (outer_binding))
1467                 DECL_SHADOWED_FOR_VAR (link)
1468                   = BINDING_VALUE (outer_binding);
1469
1470               /* Add it to the list of dead variables in the next
1471                  outermost binding to that we can remove these when we
1472                  leave that binding.  */
1473               current_binding_level->level_chain->dead_vars_from_for
1474                 = tree_cons (NULL_TREE, link,
1475                              current_binding_level->level_chain->
1476                              dead_vars_from_for);
1477
1478               /* Although we don't pop the CPLUS_BINDING, we do clear
1479                  its BINDING_LEVEL since the level is going away now.  */
1480               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1481                 = 0;
1482             }
1483         }
1484       else
1485         {
1486           /* Remove the binding.  */
1487           decl = link;
1488           if (TREE_CODE (decl) == TREE_LIST)
1489             decl = TREE_VALUE (decl);
1490           if (DECL_P (decl))
1491             pop_binding (DECL_NAME (decl), decl);
1492           else if (TREE_CODE (decl) == OVERLOAD)
1493             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1494           else
1495             abort ();
1496         }
1497     }
1498
1499   /* Remove declarations for any `for' variables from inner scopes
1500      that we kept around.  */
1501   for (link = current_binding_level->dead_vars_from_for;
1502        link; link = TREE_CHAIN (link))
1503     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1504
1505   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1506   for (link = current_binding_level->type_shadowed;
1507        link; link = TREE_CHAIN (link))
1508     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1509
1510   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1511   for (link = current_binding_level->shadowed_labels;
1512        link;
1513        link = TREE_CHAIN (link))
1514     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1515
1516   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1517      list if a `using' declaration put them there.  The debugging
1518      back-ends won't understand OVERLOAD, so we remove them here.
1519      Because the BLOCK_VARS are (temporarily) shared with
1520      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1521      popped all the bindings.  */
1522   if (block)
1523     {
1524       tree* d;
1525
1526       for (d = &BLOCK_VARS (block); *d; )
1527         {
1528           if (TREE_CODE (*d) == TREE_LIST)
1529             *d = TREE_CHAIN (*d);
1530           else
1531             d = &TREE_CHAIN (*d);
1532         }
1533     }
1534
1535   /* If the level being exited is the top level of a function,
1536      check over all the labels.  */
1537   if (functionbody)
1538     {
1539       /* Since this is the top level block of a function, the vars are
1540          the function's parameters.  Don't leave them in the BLOCK
1541          because they are found in the FUNCTION_DECL instead.  */
1542       BLOCK_VARS (block) = 0;
1543       pop_labels (block);
1544     }
1545
1546   tmp = current_binding_level->keep;
1547
1548   pop_binding_level ();
1549   if (functionbody)
1550     DECL_INITIAL (current_function_decl) = block;
1551   else if (block)
1552     current_binding_level->blocks
1553       = chainon (current_binding_level->blocks, block);
1554
1555   /* If we did not make a block for the level just exited,
1556      any blocks made for inner levels
1557      (since they cannot be recorded as subblocks in that level)
1558      must be carried forward so they will later become subblocks
1559      of something else.  */
1560   else if (subblocks)
1561     current_binding_level->blocks
1562       = chainon (current_binding_level->blocks, subblocks);
1563
1564   /* Each and every BLOCK node created here in `poplevel' is important
1565      (e.g. for proper debugging information) so if we created one
1566      earlier, mark it as "used".  */
1567   if (block)
1568     TREE_USED (block) = 1;
1569
1570   /* Take care of compiler's internal binding structures.  */
1571   if (tmp == 2)
1572     {
1573       tree scope_stmts;
1574
1575       scope_stmts
1576         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1577       if (block)
1578         {
1579           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1580           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1581         }
1582
1583       block = poplevel (keep, reverse, functionbody);
1584     }
1585
1586   return block;
1587 }
1588
1589 /* Delete the node BLOCK from the current binding level.
1590    This is used for the block inside a stmt expr ({...})
1591    so that the block can be reinserted where appropriate.  */
1592
1593 void
1594 delete_block (block)
1595      tree block;
1596 {
1597   tree t;
1598   if (current_binding_level->blocks == block)
1599     current_binding_level->blocks = TREE_CHAIN (block);
1600   for (t = current_binding_level->blocks; t;)
1601     {
1602       if (TREE_CHAIN (t) == block)
1603         TREE_CHAIN (t) = TREE_CHAIN (block);
1604       else
1605         t = TREE_CHAIN (t);
1606     }
1607   TREE_CHAIN (block) = NULL_TREE;
1608   /* Clear TREE_USED which is always set by poplevel.
1609      The flag is set again if insert_block is called.  */
1610   TREE_USED (block) = 0;
1611 }
1612
1613 /* Insert BLOCK at the end of the list of subblocks of the
1614    current binding level.  This is used when a BIND_EXPR is expanded,
1615    to handle the BLOCK node inside the BIND_EXPR.  */
1616
1617 void
1618 insert_block (block)
1619      tree block;
1620 {
1621   TREE_USED (block) = 1;
1622   current_binding_level->blocks
1623     = chainon (current_binding_level->blocks, block);
1624 }
1625
1626 /* Set the BLOCK node for the innermost scope
1627    (the one we are currently in).  */
1628
1629 void
1630 set_block (block)
1631     tree block ATTRIBUTE_UNUSED;
1632 {
1633   /* The RTL expansion machinery requires us to provide this callback,
1634      but it is not applicable in function-at-a-time mode.  */
1635   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1636 }
1637
1638 /* Do a pushlevel for class declarations.  */
1639
1640 void
1641 pushlevel_class ()
1642 {
1643   register struct binding_level *newlevel;
1644
1645   /* Reuse or create a struct for this binding level.  */
1646 #if defined(DEBUG_CP_BINDING_LEVELS)
1647   if (0)
1648 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1649   if (free_binding_level)
1650 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1651     {
1652       newlevel = free_binding_level;
1653       free_binding_level = free_binding_level->level_chain;
1654     }
1655   else
1656     newlevel = make_binding_level ();
1657
1658 #if defined(DEBUG_CP_BINDING_LEVELS)
1659   is_class_level = 1;
1660 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1661
1662   push_binding_level (newlevel, 0, 0);
1663
1664   class_binding_level = current_binding_level;
1665   class_binding_level->parm_flag = 2;
1666   class_binding_level->this_class = current_class_type;
1667 }
1668
1669 /* ...and a poplevel for class declarations.  */
1670
1671 void
1672 poplevel_class ()
1673 {
1674   register struct binding_level *level = class_binding_level;
1675   tree shadowed;
1676
1677   my_friendly_assert (level != 0, 354);
1678
1679   /* If we're leaving a toplevel class, don't bother to do the setting
1680      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1681      shouldn't even be used when current_class_type isn't set, and second,
1682      if we don't touch it here, we're able to use the cache effect if the
1683      next time we're entering a class scope, it is the same class.  */
1684   if (current_class_depth != 1)
1685     {
1686       struct binding_level* b;
1687
1688       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1689       for (shadowed = level->class_shadowed;
1690            shadowed;
1691            shadowed = TREE_CHAIN (shadowed))
1692         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1693
1694       /* Find the next enclosing class, and recreate
1695          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1696       b = level->level_chain;
1697       while (b && b->parm_flag != 2)
1698         b = b->level_chain;
1699
1700       if (b)
1701         for (shadowed = b->class_shadowed;
1702              shadowed;
1703              shadowed = TREE_CHAIN (shadowed))
1704           {
1705             tree t;
1706
1707             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1708             while (t && BINDING_LEVEL (t) != b)
1709               t = TREE_CHAIN (t);
1710
1711             if (t)
1712               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1713                 = BINDING_VALUE (t);
1714           }
1715     }
1716   else
1717     /* Remember to save what IDENTIFIER's were bound in this scope so we
1718        can recover from cache misses.  */
1719     {
1720       previous_class_type = current_class_type;
1721       previous_class_values = class_binding_level->class_shadowed;
1722     }
1723   for (shadowed = level->type_shadowed;
1724        shadowed;
1725        shadowed = TREE_CHAIN (shadowed))
1726     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1727
1728   /* Remove the bindings for all of the class-level declarations.  */
1729   for (shadowed = level->class_shadowed;
1730        shadowed;
1731        shadowed = TREE_CHAIN (shadowed))
1732     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1733
1734   /* Now, pop out of the binding level which we created up in the
1735      `pushlevel_class' routine.  */
1736 #if defined(DEBUG_CP_BINDING_LEVELS)
1737   is_class_level = 1;
1738 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1739
1740   pop_binding_level ();
1741 }
1742
1743 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1744    for any names in enclosing classes.  */
1745
1746 void
1747 clear_identifier_class_values ()
1748 {
1749   tree t;
1750
1751   if (!class_binding_level)
1752     return;
1753
1754   for (t = class_binding_level->class_shadowed;
1755        t;
1756        t = TREE_CHAIN (t))
1757     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1758 }
1759
1760 /* Returns non-zero if T is a virtual function table.  */
1761
1762 int
1763 vtable_decl_p (t, data)
1764      tree t;
1765      void *data ATTRIBUTE_UNUSED;
1766 {
1767   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1768 }
1769
1770 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1771    functions.  */
1772
1773 int
1774 vtype_decl_p (t, data)
1775      tree t;
1776      void *data ATTRIBUTE_UNUSED;
1777 {
1778   return (TREE_CODE (t) == TYPE_DECL
1779           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1780           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1781 }
1782
1783 /* Return the declarations that are members of the namespace NS.  */
1784
1785 tree
1786 cp_namespace_decls (ns)
1787      tree ns;
1788 {
1789   return NAMESPACE_LEVEL (ns)->names;
1790 }
1791
1792 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1793    itself, calling F for each.  The DATA is passed to F as well.  */
1794
1795 static int
1796 walk_namespaces_r (namespace, f, data)
1797      tree namespace;
1798      walk_namespaces_fn f;
1799      void *data;
1800 {
1801   tree current;
1802   int result = 0;
1803
1804   result |= (*f) (namespace, data);
1805
1806   for (current = cp_namespace_decls (namespace);
1807        current;
1808        current = TREE_CHAIN (current))
1809     {
1810       if (TREE_CODE (current) != NAMESPACE_DECL
1811           || DECL_NAMESPACE_ALIAS (current))
1812         continue;
1813
1814       /* We found a namespace.  */
1815       result |= walk_namespaces_r (current, f, data);
1816     }
1817
1818   return result;
1819 }
1820
1821 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1822    F as well.  */
1823
1824 int
1825 walk_namespaces (f, data)
1826      walk_namespaces_fn f;
1827      void *data;
1828 {
1829   return walk_namespaces_r (global_namespace, f, data);
1830 }
1831
1832 struct walk_globals_data {
1833   walk_globals_pred p;
1834   walk_globals_fn f;
1835   void *data;
1836 };
1837
1838 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1839    for which P returns non-zero, call F with its address.  If any call
1840    to F returns a non-zero value, return a non-zero value.  */
1841
1842 static int
1843 walk_globals_r (namespace, data)
1844      tree namespace;
1845      void *data;
1846 {
1847   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1848   walk_globals_pred p = wgd->p;
1849   walk_globals_fn f = wgd->f;
1850   void *d = wgd->data;
1851   tree *t;
1852   int result = 0;
1853
1854   t = &NAMESPACE_LEVEL (namespace)->names;
1855
1856   while (*t)
1857     {
1858       tree glbl = *t;
1859
1860       if ((*p) (glbl, d))
1861         result |= (*f) (t, d);
1862
1863       /* If F changed *T, then *T still points at the next item to
1864          examine.  */
1865       if (*t == glbl)
1866         t = &TREE_CHAIN (*t);
1867     }
1868
1869   return result;
1870 }
1871
1872 /* Walk the global declarations.  Whenever one is found for which P
1873    returns non-zero, call F with its address.  If any call to F
1874    returns a non-zero value, return a non-zero value.  */
1875
1876 int
1877 walk_globals (p, f, data)
1878      walk_globals_pred p;
1879      walk_globals_fn f;
1880      void *data;
1881 {
1882   struct walk_globals_data wgd;
1883   wgd.p = p;
1884   wgd.f = f;
1885   wgd.data = data;
1886
1887   return walk_namespaces (walk_globals_r, &wgd);
1888 }
1889
1890 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1891    DATA is non-NULL, this is the last time we will call
1892    wrapup_global_declarations for this NAMESPACE.  */
1893
1894 int
1895 wrapup_globals_for_namespace (namespace, data)
1896      tree namespace;
1897      void *data;
1898 {
1899   tree globals = cp_namespace_decls (namespace);
1900   int len = list_length (globals);
1901   tree *vec = (tree *) alloca (sizeof (tree) * len);
1902   int i;
1903   int result;
1904   tree decl;
1905   int last_time = (data != 0);
1906
1907   if (last_time && namespace == global_namespace)
1908     /* Let compile_file handle the global namespace.  */
1909     return 0;
1910
1911   /* Process the decls in reverse order--earliest first.
1912      Put them into VEC from back to front, then take out from front.  */
1913   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1914     vec[len - i - 1] = decl;
1915
1916   if (last_time)
1917     {
1918       check_global_declarations (vec, len);
1919       return 0;
1920     }
1921
1922   /* Temporarily mark vtables as external.  That prevents
1923      wrapup_global_declarations from writing them out; we must process
1924      them ourselves in finish_vtable_vardecl.  */
1925   for (i = 0; i < len; ++i)
1926     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1927       {
1928         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1929         DECL_EXTERNAL (vec[i]) = 1;
1930       }
1931
1932   /* Write out any globals that need to be output.  */
1933   result = wrapup_global_declarations (vec, len);
1934
1935   /* Undo the hack to DECL_EXTERNAL above.  */
1936   for (i = 0; i < len; ++i)
1937     if (vtable_decl_p (vec[i], /*data=*/0)
1938         && DECL_NOT_REALLY_EXTERN (vec[i]))
1939       {
1940         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1941         DECL_EXTERNAL (vec[i]) = 0;
1942       }
1943
1944   return result;
1945 }
1946
1947 \f
1948 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1949
1950 static void
1951 mark_binding_level (arg)
1952      void *arg;
1953 {
1954   struct binding_level *lvl = *(struct binding_level **)arg;
1955
1956   for (; lvl; lvl = lvl->level_chain)
1957     {
1958       ggc_mark_tree (lvl->names);
1959       ggc_mark_tree (lvl->tags);
1960       ggc_mark_tree (lvl->usings);
1961       ggc_mark_tree (lvl->using_directives);
1962       ggc_mark_tree (lvl->class_shadowed);
1963       ggc_mark_tree (lvl->type_shadowed);
1964       ggc_mark_tree (lvl->shadowed_labels);
1965       ggc_mark_tree (lvl->blocks);
1966       ggc_mark_tree (lvl->this_class);
1967       ggc_mark_tree (lvl->dead_vars_from_for);
1968     }
1969 }
1970
1971 static void
1972 mark_named_label_lists (labs, uses)
1973      void *labs;
1974      void *uses;
1975 {
1976   struct named_label_list *l = *(struct named_label_list **)labs;
1977   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
1978
1979   for (; l; l = l->next)
1980     {
1981       ggc_mark (l);
1982       mark_binding_level (l->binding_level);
1983       ggc_mark_tree (l->old_value);
1984       ggc_mark_tree (l->label_decl);
1985       ggc_mark_tree (l->bad_decls);
1986     }
1987
1988   for (; u; u = u->next)
1989     ggc_mark (u);
1990 }
1991 \f
1992 /* For debugging.  */
1993 static int no_print_functions = 0;
1994 static int no_print_builtins = 0;
1995
1996 void
1997 print_binding_level (lvl)
1998      struct binding_level *lvl;
1999 {
2000   tree t;
2001   int i = 0, len;
2002   fprintf (stderr, " blocks=");
2003   fprintf (stderr, HOST_PTR_PRINTF_FORMAT, HOST_PTR_PRINTF_TYPE lvl->blocks);
2004   if (lvl->tag_transparent)
2005     fprintf (stderr, " tag-transparent");
2006   if (lvl->more_cleanups_ok)
2007     fprintf (stderr, " more-cleanups-ok");
2008   if (lvl->have_cleanups)
2009     fprintf (stderr, " have-cleanups");
2010   fprintf (stderr, "\n");
2011   if (lvl->names)
2012     {
2013       fprintf (stderr, " names:\t");
2014       /* We can probably fit 3 names to a line?  */
2015       for (t = lvl->names; t; t = TREE_CHAIN (t))
2016         {
2017           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2018             continue;
2019           if (no_print_builtins
2020               && (TREE_CODE (t) == TYPE_DECL)
2021               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2022             continue;
2023
2024           /* Function decls tend to have longer names.  */
2025           if (TREE_CODE (t) == FUNCTION_DECL)
2026             len = 3;
2027           else
2028             len = 2;
2029           i += len;
2030           if (i > 6)
2031             {
2032               fprintf (stderr, "\n\t");
2033               i = len;
2034             }
2035           print_node_brief (stderr, "", t, 0);
2036           if (t == error_mark_node)
2037             break;
2038         }
2039       if (i)
2040         fprintf (stderr, "\n");
2041     }
2042   if (lvl->tags)
2043     {
2044       fprintf (stderr, " tags:\t");
2045       i = 0;
2046       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2047         {
2048           if (TREE_PURPOSE (t) == NULL_TREE)
2049             len = 3;
2050           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2051             len = 2;
2052           else
2053             len = 4;
2054           i += len;
2055           if (i > 5)
2056             {
2057               fprintf (stderr, "\n\t");
2058               i = len;
2059             }
2060           if (TREE_PURPOSE (t) == NULL_TREE)
2061             {
2062               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2063               fprintf (stderr, ">");
2064             }
2065           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2066             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2067           else
2068             {
2069               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2070               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2071               fprintf (stderr, ">");
2072             }
2073         }
2074       if (i)
2075         fprintf (stderr, "\n");
2076     }
2077   if (lvl->class_shadowed)
2078     {
2079       fprintf (stderr, " class-shadowed:");
2080       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2081         {
2082           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2083         }
2084       fprintf (stderr, "\n");
2085     }
2086   if (lvl->type_shadowed)
2087     {
2088       fprintf (stderr, " type-shadowed:");
2089       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2090         {
2091           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2092         }
2093       fprintf (stderr, "\n");
2094     }
2095 }
2096
2097 void
2098 print_other_binding_stack (stack)
2099      struct binding_level *stack;
2100 {
2101   struct binding_level *level;
2102   for (level = stack; level != global_binding_level; level = level->level_chain)
2103     {
2104       fprintf (stderr, "binding level ");
2105       fprintf (stderr, HOST_PTR_PRINTF_FORMAT, HOST_PTR_PRINTF_TYPE level);
2106       fprintf (stderr, "\n");
2107       print_binding_level (level);
2108     }
2109 }
2110
2111 void
2112 print_binding_stack ()
2113 {
2114   struct binding_level *b;
2115   fprintf (stderr, "current_binding_level=");
2116   fprintf (stderr, HOST_PTR_PRINTF_FORMAT, HOST_PTR_PRINTF_TYPE current_binding_level);
2117   fprintf (stderr, "\nclass_binding_level=");
2118   fprintf (stderr, HOST_PTR_PRINTF_FORMAT, HOST_PTR_PRINTF_TYPE class_binding_level);
2119   fprintf (stderr, "\nglobal_binding_level=");
2120   fprintf (stderr, HOST_PTR_PRINTF_FORMAT, HOST_PTR_PRINTF_TYPE global_binding_level);
2121   fprintf (stderr, "\n");
2122   if (class_binding_level)
2123     {
2124       for (b = class_binding_level; b; b = b->level_chain)
2125         if (b == current_binding_level)
2126           break;
2127       if (b)
2128         b = class_binding_level;
2129       else
2130         b = current_binding_level;
2131     }
2132   else
2133     b = current_binding_level;
2134   print_other_binding_stack (b);
2135   fprintf (stderr, "global:\n");
2136   print_binding_level (global_binding_level);
2137 }
2138
2139 /* Namespace binding access routines: The namespace_bindings field of
2140    the identifier is polymorphic, with three possible values:
2141    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2142    indicating the BINDING_VALUE of global_namespace. */
2143
2144 /* Check whether the a binding for the name to scope is known.
2145    Assumes that the bindings of the name are already a list
2146    of bindings. Returns the binding found, or NULL_TREE. */
2147
2148 static tree
2149 find_binding (name, scope)
2150      tree name;
2151      tree scope;
2152 {
2153   tree iter, prev = NULL_TREE;
2154
2155   scope = ORIGINAL_NAMESPACE (scope);
2156
2157   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2158        iter = TREE_CHAIN (iter))
2159     {
2160       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2161       if (BINDING_SCOPE (iter) == scope)
2162         {
2163           /* Move binding found to the front of the list, so
2164              subsequent lookups will find it faster. */
2165           if (prev)
2166             {
2167               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2168               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2169               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2170             }
2171           return iter;
2172         }
2173       prev = iter;
2174     }
2175   return NULL_TREE;
2176 }
2177
2178 /* Always returns a binding for name in scope. If the
2179    namespace_bindings is not a list, convert it to one first.
2180    If no binding is found, make a new one. */
2181
2182 tree
2183 binding_for_name (name, scope)
2184      tree name;
2185      tree scope;
2186 {
2187   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2188   tree result;
2189
2190   scope = ORIGINAL_NAMESPACE (scope);
2191
2192   if (b && TREE_CODE (b) != CPLUS_BINDING)
2193     {
2194       /* Get rid of optimization for global scope. */
2195       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2196       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2197       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2198     }
2199   if (b && (result = find_binding (name, scope)))
2200     return result;
2201   /* Not found, make a new one. */
2202   result = make_node (CPLUS_BINDING);
2203   TREE_CHAIN (result) = b;
2204   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2205   BINDING_SCOPE (result) = scope;
2206   BINDING_TYPE (result) = NULL_TREE;
2207   BINDING_VALUE (result) = NULL_TREE;
2208   return result;
2209 }
2210
2211 /* Return the binding value for name in scope, considering that
2212    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2213
2214 tree
2215 namespace_binding (name, scope)
2216      tree name;
2217      tree scope;
2218 {
2219   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2220   if (b == NULL_TREE)
2221     return NULL_TREE;
2222   if (scope == NULL_TREE)
2223     scope = global_namespace;
2224   if (TREE_CODE (b) != CPLUS_BINDING)
2225     return (scope == global_namespace) ? b : NULL_TREE;
2226   name = find_binding (name,scope);
2227   if (name == NULL_TREE)
2228     return name;
2229   return BINDING_VALUE (name);
2230 }
2231
2232 /* Set the binding value for name in scope. If modifying the binding
2233    of global_namespace is attempted, try to optimize it. */
2234
2235 void
2236 set_namespace_binding (name, scope, val)
2237      tree name;
2238      tree scope;
2239      tree val;
2240 {
2241   tree b;
2242
2243   if (scope == NULL_TREE)
2244     scope = global_namespace;
2245
2246   if (scope == global_namespace)
2247     {
2248       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2249       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2250         {
2251           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2252           return;
2253         }
2254     }
2255   b = binding_for_name (name, scope);
2256   BINDING_VALUE (b) = val;
2257 }
2258
2259 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2260    select a name that is unique to this compilation unit.  */
2261
2262 void
2263 push_namespace (name)
2264      tree name;
2265 {
2266   tree d = NULL_TREE;
2267   int need_new = 1;
2268   int implicit_use = 0;
2269   int global = 0;
2270   if (!global_namespace)
2271     {
2272       /* This must be ::. */
2273       my_friendly_assert (name == get_identifier ("::"), 377);
2274       global = 1;
2275     }
2276   else if (!name)
2277     {
2278       /* The name of anonymous namespace is unique for the translation
2279          unit.  */
2280       if (!anonymous_namespace_name)
2281         anonymous_namespace_name = get_file_function_name ('N');
2282       name = anonymous_namespace_name;
2283       d = IDENTIFIER_NAMESPACE_VALUE (name);
2284       if (d)
2285         /* Reopening anonymous namespace.  */
2286         need_new = 0;
2287       implicit_use = 1;
2288     }
2289   else
2290     {
2291       /* Check whether this is an extended namespace definition. */
2292       d = IDENTIFIER_NAMESPACE_VALUE (name);
2293       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2294         {
2295           need_new = 0;
2296           if (DECL_NAMESPACE_ALIAS (d))
2297             {
2298               error ("namespace alias `%D' not allowed here, assuming `%D'",
2299                         d, DECL_NAMESPACE_ALIAS (d));
2300               d = DECL_NAMESPACE_ALIAS (d);
2301             }
2302         }
2303     }
2304
2305   if (need_new)
2306     {
2307       /* Make a new namespace, binding the name to it. */
2308       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2309       /* The global namespace is not pushed, and the global binding
2310          level is set elsewhere.  */
2311       if (!global)
2312         {
2313           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2314           d = pushdecl (d);
2315           pushlevel (0);
2316           declare_namespace_level ();
2317           NAMESPACE_LEVEL (d) = current_binding_level;
2318         }
2319     }
2320   else
2321     resume_binding_level (NAMESPACE_LEVEL (d));
2322
2323   if (implicit_use)
2324     do_using_directive (d);
2325   /* Enter the name space. */
2326   current_namespace = d;
2327 }
2328
2329 /* Pop from the scope of the current namespace.  */
2330
2331 void
2332 pop_namespace ()
2333 {
2334   my_friendly_assert (current_namespace != global_namespace, 20010801);
2335   current_namespace = CP_DECL_CONTEXT (current_namespace);
2336   /* The binding level is not popped, as it might be re-opened later.  */
2337   suspend_binding_level ();
2338 }
2339
2340 /* Push into the scope of the namespace NS, even if it is deeply
2341    nested within another namespace.  */
2342
2343 void
2344 push_nested_namespace (ns)
2345      tree ns;
2346 {
2347   if (ns == global_namespace)
2348     push_to_top_level ();
2349   else
2350     {
2351       push_nested_namespace (CP_DECL_CONTEXT (ns));
2352       push_namespace (DECL_NAME (ns));
2353     }
2354 }
2355
2356 /* Pop back from the scope of the namespace NS, which was previously
2357    entered with push_nested_namespace.  */
2358
2359 void
2360 pop_nested_namespace (ns)
2361      tree ns;
2362 {
2363   while (ns != global_namespace)
2364     {
2365       pop_namespace ();
2366       ns = CP_DECL_CONTEXT (ns);
2367     }
2368
2369   pop_from_top_level ();
2370 }
2371
2372 \f
2373 /* Subroutines for reverting temporarily to top-level for instantiation
2374    of templates and such.  We actually need to clear out the class- and
2375    local-value slots of all identifiers, so that only the global values
2376    are at all visible.  Simply setting current_binding_level to the global
2377    scope isn't enough, because more binding levels may be pushed.  */
2378 struct saved_scope *scope_chain;
2379
2380 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2381
2382 static void
2383 mark_saved_scope (arg)
2384      void *arg;
2385 {
2386   struct saved_scope *t = *(struct saved_scope **)arg;
2387   while (t)
2388     {
2389       mark_binding_level (&t->class_bindings);
2390       ggc_mark_tree (t->old_bindings);
2391       ggc_mark_tree (t->old_namespace);
2392       ggc_mark_tree (t->decl_ns_list);
2393       ggc_mark_tree (t->class_name);
2394       ggc_mark_tree (t->class_type);
2395       ggc_mark_tree (t->access_specifier);
2396       ggc_mark_tree (t->function_decl);
2397       if (t->lang_base)
2398         ggc_mark_tree_varray (t->lang_base);
2399       ggc_mark_tree (t->lang_name);
2400       ggc_mark_tree (t->template_parms);
2401       ggc_mark_tree (t->x_previous_class_type);
2402       ggc_mark_tree (t->x_previous_class_values);
2403       ggc_mark_tree (t->x_saved_tree);
2404       ggc_mark_tree (t->lookups);
2405
2406       mark_stmt_tree (&t->x_stmt_tree);
2407       mark_binding_level (&t->bindings);
2408       t = t->prev;
2409     }
2410 }
2411
2412 static tree
2413 store_bindings (names, old_bindings)
2414      tree names, old_bindings;
2415 {
2416   tree t;
2417   tree search_bindings = old_bindings;
2418
2419   for (t = names; t; t = TREE_CHAIN (t))
2420     {
2421       tree binding, t1, id;
2422
2423       if (TREE_CODE (t) == TREE_LIST)
2424         id = TREE_PURPOSE (t);
2425       else
2426         id = DECL_NAME (t);
2427
2428       if (!id
2429           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2430              we have no IDENTIFIER_BINDING if we have left the class
2431              scope, but cached the class-level declarations.  */
2432           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2433         continue;
2434
2435       for (t1 = search_bindings; t1; t1 = TREE_CHAIN (t1))
2436         if (TREE_VEC_ELT (t1, 0) == id)
2437           goto skip_it;
2438
2439       my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2440       binding = make_tree_vec (4);
2441       TREE_VEC_ELT (binding, 0) = id;
2442       TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2443       TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2444       TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2445       IDENTIFIER_BINDING (id) = NULL_TREE;
2446       IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2447       TREE_CHAIN (binding) = old_bindings;
2448       old_bindings = binding;
2449     skip_it:
2450       ;
2451     }
2452   return old_bindings;
2453 }
2454
2455 void
2456 maybe_push_to_top_level (pseudo)
2457      int pseudo;
2458 {
2459   struct saved_scope *s;
2460   struct binding_level *b;
2461   tree old_bindings;
2462   int need_pop;
2463
2464   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2465
2466   b = scope_chain ? current_binding_level : 0;
2467
2468   /* If we're in the middle of some function, save our state.  */
2469   if (cfun)
2470     {
2471       need_pop = 1;
2472       push_function_context_to (NULL_TREE);
2473     }
2474   else
2475     need_pop = 0;
2476
2477   old_bindings = NULL_TREE;
2478   if (scope_chain && previous_class_type)
2479     old_bindings = store_bindings (previous_class_values, old_bindings);
2480
2481   /* Have to include global_binding_level, because class-level decls
2482      aren't listed anywhere useful.  */
2483   for (; b; b = b->level_chain)
2484     {
2485       tree t;
2486
2487       /* Template IDs are inserted into the global level. If they were
2488          inserted into namespace level, finish_file wouldn't find them
2489          when doing pending instantiations. Therefore, don't stop at
2490          namespace level, but continue until :: .  */
2491       if (b == global_binding_level || (pseudo && b->template_parms_p))
2492         break;
2493
2494       old_bindings = store_bindings (b->names, old_bindings);
2495       /* We also need to check class_shadowed to save class-level type
2496          bindings, since pushclass doesn't fill in b->names.  */
2497       if (b->parm_flag == 2)
2498         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2499
2500       /* Unwind type-value slots back to top level.  */
2501       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2502         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2503     }
2504   s->prev = scope_chain;
2505   s->old_bindings = old_bindings;
2506   s->bindings = b;
2507   s->need_pop_function_context = need_pop;
2508   s->function_decl = current_function_decl;
2509   s->last_parms = last_function_parms;
2510
2511   scope_chain = s;
2512   current_function_decl = NULL_TREE;
2513   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2514   current_lang_name = lang_name_cplusplus;
2515   current_namespace = global_namespace;
2516 }
2517
2518 void
2519 push_to_top_level ()
2520 {
2521   maybe_push_to_top_level (0);
2522 }
2523
2524 void
2525 pop_from_top_level ()
2526 {
2527   struct saved_scope *s = scope_chain;
2528   tree t;
2529
2530   /* Clear out class-level bindings cache.  */
2531   if (previous_class_type)
2532     invalidate_class_lookup_cache ();
2533
2534   VARRAY_FREE (current_lang_base);
2535
2536   scope_chain = s->prev;
2537   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2538     {
2539       tree id = TREE_VEC_ELT (t, 0);
2540
2541       SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2542       IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2543       IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2544     }
2545
2546   /* If we were in the middle of compiling a function, restore our
2547      state.  */
2548   if (s->need_pop_function_context)
2549     pop_function_context_from (NULL_TREE);
2550   current_function_decl = s->function_decl;
2551   last_function_parms = s->last_parms;
2552
2553   free (s);
2554 }
2555 \f
2556 /* Push a definition of struct, union or enum tag "name".
2557    into binding_level "b".   "type" should be the type node,
2558    We assume that the tag "name" is not already defined.
2559
2560    Note that the definition may really be just a forward reference.
2561    In that case, the TYPE_SIZE will be a NULL_TREE.
2562
2563    C++ gratuitously puts all these tags in the name space.  */
2564
2565 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2566    record the shadowed value for this binding contour.  TYPE is
2567    the type that ID maps to.  */
2568
2569 static void
2570 set_identifier_type_value_with_scope (id, type, b)
2571      tree id;
2572      tree type;
2573      struct binding_level *b;
2574 {
2575   if (!b->namespace_p)
2576     {
2577       /* Shadow the marker, not the real thing, so that the marker
2578          gets restored later. */
2579       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2580       b->type_shadowed
2581         = tree_cons (id, old_type_value, b->type_shadowed);
2582     }
2583   else
2584     {
2585       tree binding = binding_for_name (id, current_namespace);
2586       BINDING_TYPE (binding) = type;
2587       /* Store marker instead of real type. */
2588       type = global_type_node;
2589     }
2590   SET_IDENTIFIER_TYPE_VALUE (id, type);
2591 }
2592
2593 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2594
2595 void
2596 set_identifier_type_value (id, type)
2597      tree id;
2598      tree type;
2599 {
2600   set_identifier_type_value_with_scope (id, type, current_binding_level);
2601 }
2602
2603 /* Return the type associated with id. */
2604
2605 tree
2606 identifier_type_value (id)
2607      tree id;
2608 {
2609   /* There is no type with that name, anywhere. */
2610   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2611     return NULL_TREE;
2612   /* This is not the type marker, but the real thing. */
2613   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2614     return REAL_IDENTIFIER_TYPE_VALUE (id);
2615   /* Have to search for it. It must be on the global level, now.
2616      Ask lookup_name not to return non-types. */
2617   id = lookup_name_real (id, 2, 1, 0);
2618   if (id)
2619     return TREE_TYPE (id);
2620   return NULL_TREE;
2621 }
2622
2623 /* Pop off extraneous binding levels left over due to syntax errors.
2624
2625    We don't pop past namespaces, as they might be valid.  */
2626
2627 void
2628 pop_everything ()
2629 {
2630 #ifdef DEBUG_CP_BINDING_LEVELS
2631   fprintf (stderr, "XXX entering pop_everything ()\n");
2632 #endif
2633   while (!toplevel_bindings_p ())
2634     {
2635       if (current_binding_level->parm_flag == 2)
2636         pop_nested_class ();
2637       else
2638         poplevel (0, 0, 0);
2639     }
2640 #ifdef DEBUG_CP_BINDING_LEVELS
2641   fprintf (stderr, "XXX leaving pop_everything ()\n");
2642 #endif
2643 }
2644
2645 /* The type TYPE is being declared.  If it is a class template, or a
2646    specialization of a class template, do any processing required and
2647    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2648    being declared a friend.  B is the binding level at which this TYPE
2649    should be bound.
2650
2651    Returns the TYPE_DECL for TYPE, which may have been altered by this
2652    processing.  */
2653
2654 static tree
2655 maybe_process_template_type_declaration (type, globalize, b)
2656      tree type;
2657      int globalize;
2658      struct binding_level* b;
2659 {
2660   tree decl = TYPE_NAME (type);
2661
2662   if (processing_template_parmlist)
2663     /* You can't declare a new template type in a template parameter
2664        list.  But, you can declare a non-template type:
2665
2666          template <class A*> struct S;
2667
2668        is a forward-declaration of `A'.  */
2669     ;
2670   else
2671     {
2672       maybe_check_template_type (type);
2673
2674       my_friendly_assert (IS_AGGR_TYPE (type)
2675                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2676
2677
2678       if (processing_template_decl)
2679         {
2680           /* This may change after the call to
2681              push_template_decl_real, but we want the original value.  */
2682           tree name = DECL_NAME (decl);
2683
2684           decl = push_template_decl_real (decl, globalize);
2685           /* If the current binding level is the binding level for the
2686              template parameters (see the comment in
2687              begin_template_parm_list) and the enclosing level is a class
2688              scope, and we're not looking at a friend, push the
2689              declaration of the member class into the class scope.  In the
2690              friend case, push_template_decl will already have put the
2691              friend into global scope, if appropriate.  */
2692           if (TREE_CODE (type) != ENUMERAL_TYPE
2693               && !globalize && b->template_parms_p
2694               && b->level_chain->parm_flag == 2)
2695             {
2696               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2697               /* Put this tag on the list of tags for the class, since
2698                  that won't happen below because B is not the class
2699                  binding level, but is instead the pseudo-global level.  */
2700               b->level_chain->tags =
2701                 tree_cons (name, type, b->level_chain->tags);
2702               if (!COMPLETE_TYPE_P (current_class_type))
2703                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2704             }
2705         }
2706     }
2707
2708   return decl;
2709 }
2710
2711 /* In C++, you don't have to write `struct S' to refer to `S'; you
2712    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2713    if the user had written `typedef struct S S'.  Create and return
2714    the TYPE_DECL for TYPE.  */
2715
2716 tree
2717 create_implicit_typedef (name, type)
2718      tree name;
2719      tree type;
2720 {
2721   tree decl;
2722
2723   decl = build_decl (TYPE_DECL, name, type);
2724   DECL_ARTIFICIAL (decl) = 1;
2725   /* There are other implicit type declarations, like the one *within*
2726      a class that allows you to write `S::S'.  We must distinguish
2727      amongst these.  */
2728   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2729   TYPE_NAME (type) = decl;
2730
2731   return decl;
2732 }
2733
2734 /* Remember a local name for name-mangling purposes.  */
2735
2736 static void
2737 push_local_name (decl)
2738      tree decl;
2739 {
2740   size_t i, nelts;
2741   tree t, name;
2742
2743   if (!local_names)
2744     VARRAY_TREE_INIT (local_names, 8, "local_names");
2745
2746   name = DECL_NAME (decl);
2747
2748   nelts = VARRAY_ACTIVE_SIZE (local_names);
2749   for (i = 0; i < nelts; i++)
2750     {
2751       t = VARRAY_TREE (local_names, i);
2752       if (DECL_NAME (t) == name)
2753         {
2754           if (!DECL_LANG_SPECIFIC (decl))
2755             retrofit_lang_decl (decl);
2756           if (DECL_LANG_SPECIFIC (t))
2757             DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
2758           else
2759             DECL_DISCRIMINATOR (decl) = 1;
2760
2761           VARRAY_TREE (local_names, i) = decl;
2762           return;
2763         }
2764     }
2765
2766   VARRAY_PUSH_TREE (local_names, decl);
2767 }
2768
2769 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2770    Normally put it into the inner-most non-tag-transparent scope,
2771    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2772    The latter is needed for implicit declarations.  */
2773
2774 void
2775 pushtag (name, type, globalize)
2776      tree name, type;
2777      int globalize;
2778 {
2779   register struct binding_level *b;
2780
2781   b = current_binding_level;
2782   while (b->tag_transparent
2783          || (b->parm_flag == 2
2784              && (globalize
2785                  /* We may be defining a new type in the initializer
2786                     of a static member variable. We allow this when
2787                     not pedantic, and it is particularly useful for
2788                     type punning via an anonymous union. */
2789                  || COMPLETE_TYPE_P (b->this_class))))
2790     b = b->level_chain;
2791
2792   b->tags = tree_cons (name, type, b->tags);
2793
2794   if (name)
2795     {
2796       /* Do C++ gratuitous typedefing.  */
2797       if (IDENTIFIER_TYPE_VALUE (name) != type)
2798         {
2799           register tree d = NULL_TREE;
2800           int in_class = 0;
2801           tree context = TYPE_CONTEXT (type);
2802
2803           if (! context)
2804             {
2805               tree cs = current_scope ();
2806
2807               if (! globalize)
2808                 context = cs;
2809               else if (cs != NULL_TREE && TYPE_P (cs))
2810                 /* When declaring a friend class of a local class, we want
2811                    to inject the newly named class into the scope
2812                    containing the local class, not the namespace scope.  */
2813                 context = decl_function_context (get_type_decl (cs));
2814             }
2815           if (!context)
2816             context = current_namespace;
2817
2818           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2819               || b->parm_flag == 2)
2820             in_class = 1;
2821
2822           if (current_lang_name == lang_name_java)
2823             TYPE_FOR_JAVA (type) = 1;
2824
2825           d = create_implicit_typedef (name, type);
2826           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2827           if (! in_class)
2828             set_identifier_type_value_with_scope (name, type, b);
2829
2830           d = maybe_process_template_type_declaration (type,
2831                                                        globalize, b);
2832
2833           if (b->parm_flag == 2)
2834             {
2835               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2836                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2837                    class.  But if it's a member template class, we
2838                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2839                    is done later.  */
2840                 finish_member_declaration (d);
2841               else
2842                 pushdecl_class_level (d);
2843             }
2844           else
2845             d = pushdecl_with_scope (d, b);
2846
2847           /* FIXME what if it gets a name from typedef?  */
2848           if (ANON_AGGRNAME_P (name))
2849             DECL_IGNORED_P (d) = 1;
2850
2851           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2852
2853           /* If this is a local class, keep track of it.  We need this
2854              information for name-mangling, and so that it is possible to find
2855              all function definitions in a translation unit in a convenient
2856              way.  (It's otherwise tricky to find a member function definition
2857              it's only pointed to from within a local class.)  */
2858           if (TYPE_CONTEXT (type)
2859               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2860               && !processing_template_decl)
2861             VARRAY_PUSH_TREE (local_classes, type);
2862         }
2863       if (b->parm_flag == 2)
2864         {
2865           if (!COMPLETE_TYPE_P (current_class_type))
2866             CLASSTYPE_TAGS (current_class_type) = b->tags;
2867         }
2868     }
2869
2870   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2871     /* Use the canonical TYPE_DECL for this node.  */
2872     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2873   else
2874     {
2875       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2876          will be the tagged type we just added to the current
2877          binding level.  This fake NULL-named TYPE_DECL node helps
2878          dwarfout.c to know when it needs to output a
2879          representation of a tagged type, and it also gives us a
2880          convenient place to record the "scope start" address for
2881          the tagged type.  */
2882
2883       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2884       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2885     }
2886 }
2887
2888 /* Counter used to create anonymous type names.  */
2889
2890 static int anon_cnt = 0;
2891
2892 /* Return an IDENTIFIER which can be used as a name for
2893    anonymous structs and unions.  */
2894
2895 tree
2896 make_anon_name ()
2897 {
2898   char buf[32];
2899
2900   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2901   return get_identifier (buf);
2902 }
2903
2904 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2905    This keeps dbxout from getting confused.  */
2906
2907 void
2908 clear_anon_tags ()
2909 {
2910   register struct binding_level *b;
2911   register tree tags;
2912   static int last_cnt = 0;
2913
2914   /* Fast out if no new anon names were declared.  */
2915   if (last_cnt == anon_cnt)
2916     return;
2917
2918   b = current_binding_level;
2919   while (b->tag_transparent)
2920     b = b->level_chain;
2921   tags = b->tags;
2922   while (tags)
2923     {
2924       /* A NULL purpose means we have already processed all tags
2925          from here to the end of the list.  */
2926       if (TREE_PURPOSE (tags) == NULL_TREE)
2927         break;
2928       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2929         TREE_PURPOSE (tags) = NULL_TREE;
2930       tags = TREE_CHAIN (tags);
2931     }
2932   last_cnt = anon_cnt;
2933 }
2934 \f
2935 /* Subroutine of duplicate_decls: return truthvalue of whether
2936    or not types of these decls match.
2937
2938    For C++, we must compare the parameter list so that `int' can match
2939    `int&' in a parameter position, but `int&' is not confused with
2940    `const int&'.  */
2941
2942 int
2943 decls_match (newdecl, olddecl)
2944      tree newdecl, olddecl;
2945 {
2946   int types_match;
2947
2948   if (newdecl == olddecl)
2949     return 1;
2950
2951   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2952     /* If the two DECLs are not even the same kind of thing, we're not
2953        interested in their types.  */
2954     return 0;
2955
2956   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2957     {
2958       tree f1 = TREE_TYPE (newdecl);
2959       tree f2 = TREE_TYPE (olddecl);
2960       tree p1 = TYPE_ARG_TYPES (f1);
2961       tree p2 = TYPE_ARG_TYPES (f2);
2962
2963       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2964           && ! (DECL_EXTERN_C_P (newdecl)
2965                 && DECL_EXTERN_C_P (olddecl)))
2966         return 0;
2967
2968       if (TREE_CODE (f1) != TREE_CODE (f2))
2969         return 0;
2970
2971       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2972         {
2973           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
2974               && (DECL_BUILT_IN (olddecl)
2975 #ifndef NO_IMPLICIT_EXTERN_C
2976                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
2977                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
2978 #endif
2979               ))
2980             {
2981               types_match = self_promoting_args_p (p1);
2982               if (p1 == void_list_node)
2983                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2984             }
2985 #ifndef NO_IMPLICIT_EXTERN_C
2986           else if (p1 == NULL_TREE
2987                    && (DECL_EXTERN_C_P (olddecl)
2988                        && DECL_IN_SYSTEM_HEADER (olddecl)
2989                        && !DECL_CLASS_SCOPE_P (olddecl))
2990                    && (DECL_EXTERN_C_P (newdecl)
2991                        && DECL_IN_SYSTEM_HEADER (newdecl)
2992                        && !DECL_CLASS_SCOPE_P (newdecl)))
2993             {
2994               types_match = self_promoting_args_p (p2);
2995               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2996             }
2997 #endif
2998           else
2999             types_match = compparms (p1, p2);
3000         }
3001       else
3002         types_match = 0;
3003     }
3004   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3005     {
3006       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3007                                 DECL_TEMPLATE_PARMS (olddecl)))
3008         return 0;
3009
3010       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
3011           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
3012         return 0;
3013
3014       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3015         types_match = 1;
3016       else
3017         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3018                                    DECL_TEMPLATE_RESULT (newdecl));
3019     }
3020   else
3021     {
3022       if (TREE_TYPE (newdecl) == error_mark_node)
3023         types_match = TREE_TYPE (olddecl) == error_mark_node;
3024       else if (TREE_TYPE (olddecl) == NULL_TREE)
3025         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3026       else if (TREE_TYPE (newdecl) == NULL_TREE)
3027         types_match = 0;
3028       else
3029         types_match = comptypes (TREE_TYPE (newdecl),
3030                                  TREE_TYPE (olddecl),
3031                                  COMPARE_REDECLARATION);
3032     }
3033
3034   return types_match;
3035 }
3036
3037 /* If NEWDECL is `static' and an `extern' was seen previously,
3038    warn about it.  OLDDECL is the previous declaration.
3039
3040    Note that this does not apply to the C++ case of declaring
3041    a variable `extern const' and then later `const'.
3042
3043    Don't complain about built-in functions, since they are beyond
3044    the user's control.  */
3045
3046 static void
3047 warn_extern_redeclared_static (newdecl, olddecl)
3048      tree newdecl, olddecl;
3049 {
3050   static const char *const explicit_extern_static_warning
3051     = "`%D' was declared `extern' and later `static'";
3052   static const char *const implicit_extern_static_warning
3053     = "`%D' was declared implicitly `extern' and later `static'";
3054
3055   tree name;
3056
3057   if (TREE_CODE (newdecl) == TYPE_DECL
3058       || TREE_CODE (newdecl) == TEMPLATE_DECL
3059       || TREE_CODE (newdecl) == CONST_DECL)
3060     return;
3061
3062   /* Don't get confused by static member functions; that's a different
3063      use of `static'.  */
3064   if (TREE_CODE (newdecl) == FUNCTION_DECL
3065       && DECL_STATIC_FUNCTION_P (newdecl))
3066     return;
3067
3068   /* If the old declaration was `static', or the new one isn't, then
3069      then everything is OK.  */
3070   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3071     return;
3072
3073   /* It's OK to declare a builtin function as `static'.  */
3074   if (TREE_CODE (olddecl) == FUNCTION_DECL
3075       && DECL_ARTIFICIAL (olddecl))
3076     return;
3077
3078   name = DECL_ASSEMBLER_NAME (newdecl);
3079   pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3080               ? implicit_extern_static_warning
3081               : explicit_extern_static_warning, newdecl);
3082   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3083 }
3084
3085 /* Handle when a new declaration NEWDECL has the same name as an old
3086    one OLDDECL in the same binding contour.  Prints an error message
3087    if appropriate.
3088
3089    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3090    Otherwise, return 0.  */
3091
3092 int
3093 duplicate_decls (newdecl, olddecl)
3094      tree newdecl, olddecl;
3095 {
3096   unsigned olddecl_uid = DECL_UID (olddecl);
3097   int olddecl_friend = 0, types_match = 0;
3098   int new_defines_function = 0;
3099
3100   if (newdecl == olddecl)
3101     return 1;
3102
3103   types_match = decls_match (newdecl, olddecl);
3104
3105   /* If either the type of the new decl or the type of the old decl is an
3106      error_mark_node, then that implies that we have already issued an
3107      error (earlier) for some bogus type specification, and in that case,
3108      it is rather pointless to harass the user with yet more error message
3109      about the same declaration, so just pretend the types match here.  */
3110   if (TREE_TYPE (newdecl) == error_mark_node
3111       || TREE_TYPE (olddecl) == error_mark_node)
3112     types_match = 1;
3113
3114   if (DECL_P (olddecl)
3115       && TREE_CODE (newdecl) == FUNCTION_DECL
3116       && TREE_CODE (olddecl) == FUNCTION_DECL
3117       && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
3118     {
3119       if (DECL_DECLARED_INLINE_P (newdecl)
3120           && DECL_UNINLINABLE (newdecl)
3121           && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
3122         /* Already warned elsewhere.  */;
3123       else if (DECL_DECLARED_INLINE_P (olddecl)
3124                && DECL_UNINLINABLE (olddecl)
3125                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
3126         /* Already warned.  */;
3127       else if (DECL_DECLARED_INLINE_P (newdecl)
3128                && DECL_UNINLINABLE (olddecl)
3129                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
3130         {
3131           warning_with_decl (newdecl,
3132                              "function `%s' redeclared as inline");
3133           warning_with_decl (olddecl,
3134                              "previous declaration of function `%s' with attribute noinline");
3135         }
3136       else if (DECL_DECLARED_INLINE_P (olddecl)
3137                && DECL_UNINLINABLE (newdecl)
3138                && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
3139         {
3140           warning_with_decl (newdecl,
3141                              "function `%s' redeclared with attribute noinline");
3142           warning_with_decl (olddecl,
3143                              "previous declaration of function `%s' was inline");
3144         }
3145     }
3146
3147   /* Check for redeclaration and other discrepancies. */
3148   if (TREE_CODE (olddecl) == FUNCTION_DECL
3149       && DECL_ARTIFICIAL (olddecl))
3150     {
3151       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3152         {
3153           /* Avoid warnings redeclaring anticipated built-ins.  */
3154           if (DECL_ANTICIPATED (olddecl))
3155             return 0;
3156
3157           /* If you declare a built-in or predefined function name as static,
3158              the old definition is overridden, but optionally warn this was a
3159              bad choice of name.  */
3160           if (! TREE_PUBLIC (newdecl))
3161             {
3162               if (warn_shadow)
3163                 warning ("shadowing %s function `%#D'",
3164                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3165                             olddecl);
3166               /* Discard the old built-in function.  */
3167               return 0;
3168             }
3169           /* If the built-in is not ansi, then programs can override
3170              it even globally without an error.  */
3171           else if (! DECL_BUILT_IN (olddecl))
3172             warning ("library function `%#D' redeclared as non-function `%#D'",
3173                         olddecl, newdecl);
3174           else
3175             {
3176               error ("declaration of `%#D'", newdecl);
3177               error ("conflicts with built-in declaration `%#D'",
3178                         olddecl);
3179             }
3180           return 0;
3181         }
3182       else if (!types_match)
3183         {
3184           /* Avoid warnings redeclaring anticipated built-ins.  */
3185           if (DECL_ANTICIPATED (olddecl))
3186             ;  /* Do nothing yet.  */
3187           else if ((DECL_EXTERN_C_P (newdecl)
3188                && DECL_EXTERN_C_P (olddecl))
3189               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3190                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3191             {
3192               /* A near match; override the builtin.  */
3193
3194               if (TREE_PUBLIC (newdecl))
3195                 {
3196                   warning ("new declaration `%#D'", newdecl);
3197                   warning ("ambiguates built-in declaration `%#D'",
3198                               olddecl);
3199                 }
3200               else if (warn_shadow)
3201                 warning ("shadowing %s function `%#D'",
3202                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3203                             olddecl);
3204             }
3205           else
3206             /* Discard the old built-in function.  */
3207             return 0;
3208
3209           /* Replace the old RTL to avoid problems with inlining.  */
3210           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3211         }
3212
3213       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3214         {
3215           /* If a builtin function is redeclared as `static', merge
3216              the declarations, but make the original one static.  */
3217           DECL_THIS_STATIC (olddecl) = 1;
3218           TREE_PUBLIC (olddecl) = 0;
3219
3220           /* Make the old declaration consistent with the new one so
3221              that all remnants of the builtin-ness of this function
3222              will be banished.  */
3223           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3224           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3225         }
3226     }
3227   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3228     {
3229       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3230            && TREE_CODE (newdecl) != TYPE_DECL
3231            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3232                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3233           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3234               && TREE_CODE (olddecl) != TYPE_DECL
3235               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3236                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3237                         == TYPE_DECL))))
3238         {
3239           /* We do nothing special here, because C++ does such nasty
3240              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3241              get shadowed, and know that if we need to find a TYPE_DECL
3242              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3243              slot of the identifier.  */
3244           return 0;
3245         }
3246
3247       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3248            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3249           || (TREE_CODE (olddecl) == FUNCTION_DECL
3250               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3251         return 0;
3252
3253       error ("`%#D' redeclared as different kind of symbol", newdecl);
3254       if (TREE_CODE (olddecl) == TREE_LIST)
3255         olddecl = TREE_VALUE (olddecl);
3256       cp_error_at ("previous declaration of `%#D'", olddecl);
3257
3258       /* New decl is completely inconsistent with the old one =>
3259          tell caller to replace the old one.  */
3260
3261       return 0;
3262     }
3263   else if (!types_match)
3264     {
3265       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3266         /* These are certainly not duplicate declarations; they're
3267            from different scopes.  */
3268         return 0;
3269
3270       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3271         {
3272           /* The name of a class template may not be declared to refer to
3273              any other template, class, function, object, namespace, value,
3274              or type in the same scope.  */
3275           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3276               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3277             {
3278               error ("declaration of template `%#D'", newdecl);
3279               cp_error_at ("conflicts with previous declaration `%#D'",
3280                            olddecl);
3281             }
3282           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3283                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3284                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3285                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3286                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3287                                            DECL_TEMPLATE_PARMS (olddecl)))
3288             {
3289               error ("new declaration `%#D'", newdecl);
3290               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3291             }
3292           return 0;
3293         }
3294       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3295         {
3296           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3297             {
3298               error ("declaration of C function `%#D' conflicts with",
3299                         newdecl);
3300               cp_error_at ("previous declaration `%#D' here", olddecl);
3301             }
3302           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3303                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3304             {
3305               error ("new declaration `%#D'", newdecl);
3306               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3307             }
3308           else
3309             return 0;
3310         }
3311
3312       /* Already complained about this, so don't do so again.  */
3313       else if (current_class_type == NULL_TREE
3314           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3315         {
3316           error ("conflicting types for `%#D'", newdecl);
3317           cp_error_at ("previous declaration as `%#D'", olddecl);
3318         }
3319     }
3320   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3321             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3322                  && (!DECL_TEMPLATE_INFO (newdecl)
3323                      || (DECL_TI_TEMPLATE (newdecl)
3324                          != DECL_TI_TEMPLATE (olddecl))))
3325                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3326                     && (!DECL_TEMPLATE_INFO (olddecl)
3327                         || (DECL_TI_TEMPLATE (olddecl)
3328                             != DECL_TI_TEMPLATE (newdecl))))))
3329     /* It's OK to have a template specialization and a non-template
3330        with the same type, or to have specializations of two
3331        different templates with the same type.  Note that if one is a
3332        specialization, and the other is an instantiation of the same
3333        template, that we do not exit at this point.  That situation
3334        can occur if we instantiate a template class, and then
3335        specialize one of its methods.  This situation is legal, but
3336        the declarations must be merged in the usual way.  */
3337     return 0;
3338   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3339            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3340                 && !DECL_USE_TEMPLATE (newdecl))
3341                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3342                    && !DECL_USE_TEMPLATE (olddecl))))
3343     /* One of the declarations is a template instantiation, and the
3344        other is not a template at all.  That's OK.  */
3345     return 0;
3346   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3347            && DECL_NAMESPACE_ALIAS (newdecl)
3348            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3349     /* Redeclaration of namespace alias, ignore it. */
3350     return 1;
3351   else
3352     {
3353       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3354       if (errmsg)
3355         {
3356           error (errmsg, newdecl);
3357           if (DECL_NAME (olddecl) != NULL_TREE)
3358             cp_error_at ((DECL_INITIAL (olddecl)
3359                           && namespace_bindings_p ())
3360                          ? "`%#D' previously defined here"
3361                          : "`%#D' previously declared here", olddecl);
3362           return 0;
3363         }
3364       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3365                && DECL_INITIAL (olddecl) != NULL_TREE
3366                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3367                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3368         {
3369           /* Prototype decl follows defn w/o prototype.  */
3370           cp_warning_at ("prototype for `%#D'", newdecl);
3371           cp_warning_at ("follows non-prototype definition here", olddecl);
3372         }
3373       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3374                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3375         {
3376           /* extern "C" int foo ();
3377              int foo () { bar (); }
3378              is OK.  */
3379           if (current_lang_depth () == 0)
3380             SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3381           else
3382             {
3383               cp_error_at ("previous declaration of `%#D' with %L linkage",
3384                            olddecl, DECL_LANGUAGE (olddecl));
3385               error ("conflicts with new declaration with %L linkage",
3386                         DECL_LANGUAGE (newdecl));
3387             }
3388         }
3389
3390       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3391         ;
3392       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3393         {
3394           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3395           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3396           int i = 1;
3397
3398           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3399             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3400
3401           for (; t1 && t1 != void_list_node;
3402                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3403             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3404               {
3405                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3406                                            TREE_PURPOSE (t2)))
3407                   {
3408                     pedwarn ("default argument given for parameter %d of `%#D'",
3409                              i, newdecl);
3410                     cp_pedwarn_at ("after previous specification in `%#D'",
3411                                    olddecl);
3412                   }
3413                 else
3414                   {
3415                     error ("default argument given for parameter %d of `%#D'",
3416                               i, newdecl);
3417                     cp_error_at ("after previous specification in `%#D'",
3418                                  olddecl);
3419                   }
3420               }
3421
3422           if (DECL_DECLARED_INLINE_P (newdecl)
3423               && ! DECL_DECLARED_INLINE_P (olddecl)
3424               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3425             {
3426               warning ("`%#D' was used before it was declared inline",
3427                           newdecl);
3428               cp_warning_at ("previous non-inline declaration here",
3429                              olddecl);
3430             }
3431         }
3432     }
3433
3434   /* Do not merge an implicit typedef with an explicit one.  In:
3435
3436        class A;
3437        ...
3438        typedef class A A __attribute__ ((foo));
3439
3440      the attribute should apply only to the typedef.  */
3441   if (TREE_CODE (olddecl) == TYPE_DECL
3442       && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
3443           || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
3444     return 0;
3445
3446   /* If new decl is `static' and an `extern' was seen previously,
3447      warn about it.  */
3448   warn_extern_redeclared_static (newdecl, olddecl);
3449
3450   /* We have committed to returning 1 at this point.  */
3451   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3452     {
3453       /* Now that functions must hold information normally held
3454          by field decls, there is extra work to do so that
3455          declaration information does not get destroyed during
3456          definition.  */
3457       if (DECL_VINDEX (olddecl))
3458         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3459       if (DECL_VIRTUAL_CONTEXT (olddecl))
3460         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3461       if (DECL_CONTEXT (olddecl))
3462         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3463       if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3464         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3465       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3466       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3467       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3468       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3469       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3470       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3471       if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
3472         SET_OVERLOADED_OPERATOR_CODE
3473           (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
3474       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3475
3476       /* Optionally warn about more than one declaration for the same
3477          name, but don't warn about a function declaration followed by a
3478          definition.  */
3479       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3480           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3481           /* Don't warn about extern decl followed by definition. */
3482           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3483           /* Don't warn about friends, let add_friend take care of it. */
3484           && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
3485         {
3486           warning ("redundant redeclaration of `%D' in same scope", newdecl);
3487           cp_warning_at ("previous declaration of `%D'", olddecl);
3488         }
3489     }
3490
3491   /* Deal with C++: must preserve virtual function table size.  */
3492   if (TREE_CODE (olddecl) == TYPE_DECL)
3493     {
3494       register tree newtype = TREE_TYPE (newdecl);
3495       register tree oldtype = TREE_TYPE (olddecl);
3496
3497       if (newtype != error_mark_node && oldtype != error_mark_node
3498           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3499         {
3500           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3501           CLASSTYPE_FRIEND_CLASSES (newtype)
3502             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3503         }
3504
3505       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3506     }
3507
3508   /* Copy all the DECL_... slots specified in the new decl
3509      except for any that we copy here from the old type.  */
3510   DECL_ATTRIBUTES (newdecl)
3511     = (*targetm.merge_decl_attributes) (olddecl, newdecl);
3512   decl_attributes (&newdecl, DECL_ATTRIBUTES (newdecl), 0);
3513
3514   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3515     {
3516       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3517       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3518         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3519                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3520
3521       /* If the new declaration is a definition, update the file and
3522          line information on the declaration.  */
3523       if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
3524           && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
3525         {
3526           DECL_SOURCE_LINE (olddecl)
3527             = DECL_SOURCE_LINE (DECL_TEMPLATE_RESULT (olddecl))
3528             = DECL_SOURCE_LINE (newdecl);
3529           DECL_SOURCE_FILE (olddecl)
3530             = DECL_SOURCE_FILE (DECL_TEMPLATE_RESULT (olddecl))
3531             = DECL_SOURCE_FILE (newdecl);
3532         }
3533
3534       return 1;
3535     }
3536
3537   if (types_match)
3538     {
3539       /* Automatically handles default parameters.  */
3540       tree oldtype = TREE_TYPE (olddecl);
3541       tree newtype;
3542
3543       /* Merge the data types specified in the two decls.  */
3544       newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3545
3546       /* If merge_types produces a non-typedef type, just use the old type.  */
3547       if (TREE_CODE (newdecl) == TYPE_DECL
3548           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3549         newtype = oldtype;
3550
3551       if (TREE_CODE (newdecl) == VAR_DECL)
3552         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3553       /* Do this after calling `merge_types' so that default
3554          parameters don't confuse us.  */
3555       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3556           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3557               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3558         {
3559           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3560                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3561           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3562                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3563
3564           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3565               && DECL_SOURCE_LINE (olddecl) != 0
3566               && flag_exceptions
3567               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3568                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3569             {
3570               error ("declaration of `%F' throws different exceptions",
3571                         newdecl);
3572               cp_error_at ("than previous declaration `%F'", olddecl);
3573             }
3574         }
3575       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3576
3577       /* Lay the type out, unless already done.  */
3578       if (! same_type_p (newtype, oldtype)
3579           && TREE_TYPE (newdecl) != error_mark_node
3580           && !(processing_template_decl && uses_template_parms (newdecl)))
3581         layout_type (TREE_TYPE (newdecl));
3582
3583       if ((TREE_CODE (newdecl) == VAR_DECL
3584            || TREE_CODE (newdecl) == PARM_DECL
3585            || TREE_CODE (newdecl) == RESULT_DECL
3586            || TREE_CODE (newdecl) == FIELD_DECL
3587            || TREE_CODE (newdecl) == TYPE_DECL)
3588           && !(processing_template_decl && uses_template_parms (newdecl)))
3589         layout_decl (newdecl, 0);
3590
3591       /* Merge the type qualifiers.  */
3592       if (TREE_READONLY (newdecl))
3593         TREE_READONLY (olddecl) = 1;
3594       if (TREE_THIS_VOLATILE (newdecl))
3595         TREE_THIS_VOLATILE (olddecl) = 1;
3596
3597       /* Merge the initialization information.  */
3598       if (DECL_INITIAL (newdecl) == NULL_TREE
3599           && DECL_INITIAL (olddecl) != NULL_TREE)
3600         {
3601           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3602           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3603           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3604           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3605               && DECL_LANG_SPECIFIC (newdecl)
3606               && DECL_LANG_SPECIFIC (olddecl))
3607             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3608         }
3609
3610       /* Merge the section attribute.
3611          We want to issue an error if the sections conflict but that must be
3612          done later in decl_attributes since we are called before attributes
3613          are assigned.  */
3614       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3615         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3616
3617       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3618         {
3619           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3620             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3621           DECL_NO_LIMIT_STACK (newdecl)
3622             |= DECL_NO_LIMIT_STACK (olddecl);
3623           /* Keep the old RTL.  */
3624           COPY_DECL_RTL (olddecl, newdecl);
3625         }
3626       else if (TREE_CODE (newdecl) == VAR_DECL
3627                && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
3628         {
3629           /* Keep the old RTL.  We cannot keep the old RTL if the old
3630              declaration was for an incomplete object and the new
3631              declaration is not since many attributes of the RTL will
3632              change.  */
3633           COPY_DECL_RTL (olddecl, newdecl);
3634         }
3635     }
3636   /* If cannot merge, then use the new type and qualifiers,
3637      and don't preserve the old rtl.  */
3638   else
3639     {
3640       /* Clean out any memory we had of the old declaration.  */
3641       tree oldstatic = value_member (olddecl, static_aggregates);
3642       if (oldstatic)
3643         TREE_VALUE (oldstatic) = error_mark_node;
3644
3645       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3646       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3647       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3648       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3649     }
3650
3651   /* Merge the storage class information.  */
3652   merge_weak (newdecl, olddecl);
3653
3654   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3655   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3656   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3657   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3658   if (! DECL_EXTERNAL (olddecl))
3659     DECL_EXTERNAL (newdecl) = 0;
3660
3661   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3662     {
3663       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3664       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3665       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3666       DECL_TEMPLATE_INSTANTIATED (newdecl)
3667         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3668       /* Don't really know how much of the language-specific
3669          values we should copy from old to new.  */
3670       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3671       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3672       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3673       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3674       DECL_INITIALIZED_IN_CLASS_P (newdecl)
3675         |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
3676       olddecl_friend = DECL_FRIEND_P (olddecl);
3677
3678       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3679       if (TREE_CODE (newdecl) == FUNCTION_DECL
3680           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3681         DECL_BEFRIENDING_CLASSES (newdecl)
3682           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3683                      DECL_BEFRIENDING_CLASSES (olddecl));
3684     }
3685
3686   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3687     {
3688       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3689           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3690         {
3691           /* If newdecl is not a specialization, then it is not a
3692              template-related function at all.  And that means that we
3693              shoud have exited above, returning 0.  */
3694           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3695                               0);
3696
3697           if (TREE_USED (olddecl))
3698             /* From [temp.expl.spec]:
3699
3700                If a template, a member template or the member of a class
3701                template is explicitly specialized then that
3702                specialization shall be declared before the first use of
3703                that specialization that would cause an implicit
3704                instantiation to take place, in every translation unit in
3705                which such a use occurs.  */
3706             error ("explicit specialization of %D after first use",
3707                       olddecl);
3708
3709           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3710         }
3711       DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
3712
3713       /* If either decl says `inline', this fn is inline, unless its
3714          definition was passed already.  */
3715       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3716         DECL_INLINE (olddecl) = 1;
3717       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3718
3719       DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
3720         = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
3721
3722       /* Preserve abstractness on cloned [cd]tors.  */
3723       DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
3724
3725       if (! types_match)
3726         {
3727           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3728           COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
3729           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3730         }
3731       if (! types_match || new_defines_function)
3732         {
3733           /* These need to be copied so that the names are available.
3734              Note that if the types do match, we'll preserve inline
3735              info and other bits, but if not, we won't.  */
3736           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3737           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3738         }
3739       if (new_defines_function)
3740         /* If defining a function declared with other language
3741            linkage, use the previously declared language linkage.  */
3742         SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3743       else if (types_match)
3744         {
3745           /* If redeclaring a builtin function, and not a definition,
3746              it stays built in.  */
3747           if (DECL_BUILT_IN (olddecl))
3748             {
3749               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3750               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3751               /* If we're keeping the built-in definition, keep the rtl,
3752                  regardless of declaration matches.  */
3753               SET_DECL_RTL (newdecl, DECL_RTL (olddecl));
3754             }
3755           else
3756             DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
3757
3758           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3759           /* Don't clear out the arguments if we're redefining a function.  */
3760           if (DECL_ARGUMENTS (olddecl))
3761             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3762         }
3763     }
3764   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3765     NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3766
3767   /* Now preserve various other info from the definition.  */
3768   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3769   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3770   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3771   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3772
3773   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3774     {
3775       int function_size;
3776
3777       function_size = sizeof (struct tree_decl);
3778
3779       memcpy ((char *) olddecl + sizeof (struct tree_common),
3780               (char *) newdecl + sizeof (struct tree_common),
3781               function_size - sizeof (struct tree_common));
3782
3783       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3784         {
3785           /* If newdecl is a template instantiation, it is possible that
3786              the following sequence of events has occurred:
3787
3788              o A friend function was declared in a class template.  The
3789              class template was instantiated.
3790
3791              o The instantiation of the friend declaration was
3792              recorded on the instantiation list, and is newdecl.
3793
3794              o Later, however, instantiate_class_template called pushdecl
3795              on the newdecl to perform name injection.  But, pushdecl in
3796              turn called duplicate_decls when it discovered that another
3797              declaration of a global function with the same name already
3798              existed.
3799
3800              o Here, in duplicate_decls, we decided to clobber newdecl.
3801
3802              If we're going to do that, we'd better make sure that
3803              olddecl, and not newdecl, is on the list of
3804              instantiations so that if we try to do the instantiation
3805              again we won't get the clobbered declaration.  */
3806
3807           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3808           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3809
3810           for (; decls; decls = TREE_CHAIN (decls))
3811             if (TREE_VALUE (decls) == newdecl)
3812               TREE_VALUE (decls) = olddecl;
3813         }
3814     }
3815   else
3816     {
3817       memcpy ((char *) olddecl + sizeof (struct tree_common),
3818               (char *) newdecl + sizeof (struct tree_common),
3819               sizeof (struct tree_decl) - sizeof (struct tree_common)
3820               + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3821     }
3822
3823   DECL_UID (olddecl) = olddecl_uid;
3824   if (olddecl_friend)
3825     DECL_FRIEND_P (olddecl) = 1;
3826
3827   /* NEWDECL contains the merged attribute lists.
3828      Update OLDDECL to be the same.  */
3829   DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
3830
3831   return 1;
3832 }
3833
3834 /* Record a decl-node X as belonging to the current lexical scope.
3835    Check for errors (such as an incompatible declaration for the same
3836    name already seen in the same scope).
3837
3838    Returns either X or an old decl for the same name.
3839    If an old decl is returned, it may have been smashed
3840    to agree with what X says.  */
3841
3842 tree
3843 pushdecl (x)
3844      tree x;
3845 {
3846   register tree t;
3847   register tree name;
3848   int need_new_binding;
3849
3850   /* We shouldn't be calling pushdecl when we're generating RTL for a
3851      function that we already did semantic analysis on previously.  */
3852   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3853                       19990913);
3854
3855   need_new_binding = 1;
3856
3857   if (DECL_TEMPLATE_PARM_P (x))
3858     /* Template parameters have no context; they are not X::T even
3859        when declared within a class or namespace.  */
3860     ;
3861   else
3862     {
3863       if (current_function_decl && x != current_function_decl
3864           /* A local declaration for a function doesn't constitute
3865              nesting.  */
3866           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3867           /* A local declaration for an `extern' variable is in the
3868              scope of the current namespace, not the current
3869              function.  */
3870           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3871           && !DECL_CONTEXT (x))
3872         DECL_CONTEXT (x) = current_function_decl;
3873
3874       /* If this is the declaration for a namespace-scope function,
3875          but the declaration itself is in a local scope, mark the
3876          declaration.  */
3877       if (TREE_CODE (x) == FUNCTION_DECL
3878           && DECL_NAMESPACE_SCOPE_P (x)
3879           && current_function_decl
3880           && x != current_function_decl)
3881         DECL_LOCAL_FUNCTION_P (x) = 1;
3882     }
3883
3884   name = DECL_NAME (x);
3885   if (name)
3886     {
3887       int different_binding_level = 0;
3888
3889       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3890         name = TREE_OPERAND (name, 0);
3891
3892       /* In case this decl was explicitly namespace-qualified, look it
3893          up in its namespace context.  */
3894       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3895           && namespace_bindings_p ())
3896         t = namespace_binding (name, DECL_CONTEXT (x));
3897       else
3898         t = lookup_name_current_level (name);
3899
3900       /* [basic.link] If there is a visible declaration of an entity
3901          with linkage having the same name and type, ignoring entities
3902          declared outside the innermost enclosing namespace scope, the
3903          block scope declaration declares that same entity and
3904          receives the linkage of the previous declaration.  */
3905       if (! t && current_function_decl && x != current_function_decl
3906           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3907           && DECL_EXTERNAL (x))
3908         {
3909           /* Look in block scope.  */
3910           t = IDENTIFIER_VALUE (name);
3911           /* Or in the innermost namespace.  */
3912           if (! t)
3913             t = namespace_binding (name, DECL_CONTEXT (x));
3914           /* Does it have linkage?  Note that if this isn't a DECL, it's an
3915              OVERLOAD, which is OK.  */
3916           if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3917             t = NULL_TREE;
3918           if (t)
3919             different_binding_level = 1;
3920         }
3921
3922       /* If we are declaring a function, and the result of name-lookup
3923          was an OVERLOAD, look for an overloaded instance that is
3924          actually the same as the function we are declaring.  (If
3925          there is one, we have to merge our declaration with the
3926          previous declaration.)  */
3927       if (t && TREE_CODE (t) == OVERLOAD)
3928         {
3929           tree match;
3930
3931           if (TREE_CODE (x) == FUNCTION_DECL)
3932             for (match = t; match; match = OVL_NEXT (match))
3933               {
3934                 if (decls_match (OVL_CURRENT (match), x))
3935                   break;
3936               }
3937           else
3938             /* Just choose one.  */
3939             match = t;
3940
3941           if (match)
3942             t = OVL_CURRENT (match);
3943           else
3944             t = NULL_TREE;
3945         }
3946
3947       if (t == error_mark_node)
3948         {
3949           /* error_mark_node is 0 for a while during initialization!  */
3950           t = NULL_TREE;
3951           cp_error_at ("`%#D' used prior to declaration", x);
3952         }
3953       else if (t != NULL_TREE)
3954         {
3955           if (different_binding_level)
3956             {
3957               if (decls_match (x, t))
3958                 /* The standard only says that the local extern
3959                    inherits linkage from the previous decl; in
3960                    particular, default args are not shared.  It would
3961                    be nice to propagate inlining info, though.  FIXME.  */
3962                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3963             }
3964           else if (TREE_CODE (t) == PARM_DECL)
3965             {
3966               if (DECL_CONTEXT (t) == NULL_TREE)
3967                 /* This is probaby caused by too many errors, but calling
3968                    abort will say that if errors have occurred.  */
3969                 abort ();
3970
3971               /* Check for duplicate params.  */
3972               if (duplicate_decls (x, t))
3973                 return t;
3974             }
3975           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3976                     || DECL_FUNCTION_TEMPLATE_P (x))
3977                    && is_overloaded_fn (t))
3978             /* Don't do anything just yet. */;
3979           else if (t == wchar_decl_node)
3980             {
3981               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3982                 pedwarn ("redeclaration of `wchar_t' as `%T'",
3983                             TREE_TYPE (x));
3984
3985               /* Throw away the redeclaration.  */
3986               return t;
3987             }
3988           else if (TREE_CODE (t) != TREE_CODE (x))
3989             {
3990               if (duplicate_decls (x, t))
3991                 return t;
3992             }
3993           else if (duplicate_decls (x, t))
3994             {
3995               if (TREE_CODE (t) == TYPE_DECL)
3996                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3997               else if (TREE_CODE (t) == FUNCTION_DECL)
3998                 check_default_args (t);
3999
4000               return t;
4001             }
4002           else if (DECL_MAIN_P (x))
4003             {
4004               /* A redeclaration of main, but not a duplicate of the
4005                  previous one.
4006
4007                  [basic.start.main]
4008
4009                  This function shall not be overloaded.  */
4010               cp_error_at ("invalid redeclaration of `%D'", t);
4011               error ("as `%D'", x);
4012               /* We don't try to push this declaration since that
4013                  causes a crash.  */
4014               return x;
4015             }
4016         }
4017
4018       check_template_shadow (x);
4019
4020       /* If this is a function conjured up by the backend, massage it
4021          so it looks friendly.  */
4022       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
4023         {
4024           retrofit_lang_decl (x);
4025           SET_DECL_LANGUAGE (x, lang_c);
4026         }
4027
4028       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
4029         {
4030           t = push_overloaded_decl (x, PUSH_LOCAL);
4031           if (t != x)
4032             return t;
4033           if (!namespace_bindings_p ())
4034             /* We do not need to create a binding for this name;
4035                push_overloaded_decl will have already done so if
4036                necessary.  */
4037             need_new_binding = 0;
4038         }
4039       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
4040         {
4041           t = push_overloaded_decl (x, PUSH_GLOBAL);
4042           if (t == x)
4043             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
4044           return t;
4045         }
4046
4047       /* If declaring a type as a typedef, copy the type (unless we're
4048          at line 0), and install this TYPE_DECL as the new type's typedef
4049          name.  See the extensive comment in ../c-decl.c (pushdecl). */
4050       if (TREE_CODE (x) == TYPE_DECL)
4051         {
4052           tree type = TREE_TYPE (x);
4053           if (DECL_SOURCE_LINE (x) == 0)
4054             {
4055               if (TYPE_NAME (type) == 0)
4056                 TYPE_NAME (type) = x;
4057             }
4058           else if (type != error_mark_node && TYPE_NAME (type) != x
4059                    /* We don't want to copy the type when all we're
4060                       doing is making a TYPE_DECL for the purposes of
4061                       inlining.  */
4062                    && (!TYPE_NAME (type)
4063                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
4064             {
4065               DECL_ORIGINAL_TYPE (x) = type;
4066               type = build_type_copy (type);
4067               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4068               TYPE_NAME (type) = x;
4069               TREE_TYPE (x) = type;
4070             }
4071
4072           if (type != error_mark_node
4073               && TYPE_NAME (type)
4074               && TYPE_IDENTIFIER (type))
4075             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4076                                                   current_binding_level);
4077
4078         }
4079
4080       /* Multiple external decls of the same identifier ought to match.
4081
4082          We get warnings about inline functions where they are defined.
4083          We get warnings about other functions from push_overloaded_decl.
4084
4085          Avoid duplicate warnings where they are used.  */
4086       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4087         {
4088           tree decl;
4089
4090           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4091           if (decl && TREE_CODE (decl) == OVERLOAD)
4092             decl = OVL_FUNCTION (decl);
4093
4094           if (decl && decl != error_mark_node
4095               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4096               /* If different sort of thing, we already gave an error.  */
4097               && TREE_CODE (decl) == TREE_CODE (x)
4098               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4099             {
4100               pedwarn ("type mismatch with previous external decl", x);
4101               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4102             }
4103         }
4104
4105       /* This name is new in its binding level.
4106          Install the new declaration and return it.  */
4107       if (namespace_bindings_p ())
4108         {
4109           /* Install a global value.  */
4110
4111           /* If the first global decl has external linkage,
4112              warn if we later see static one.  */
4113           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4114             TREE_PUBLIC (name) = 1;
4115
4116           /* Bind the name for the entity.  */
4117           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4118                 && t != NULL_TREE)
4119               && (TREE_CODE (x) == TYPE_DECL
4120                   || TREE_CODE (x) == VAR_DECL
4121                   || TREE_CODE (x) == NAMESPACE_DECL
4122                   || TREE_CODE (x) == CONST_DECL
4123                   || TREE_CODE (x) == TEMPLATE_DECL))
4124             SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
4125
4126           /* Don't forget if the function was used via an implicit decl.  */
4127           if (IDENTIFIER_IMPLICIT_DECL (name)
4128               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4129             TREE_USED (x) = 1;
4130
4131           /* Don't forget if its address was taken in that way.  */
4132           if (IDENTIFIER_IMPLICIT_DECL (name)
4133               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4134             TREE_ADDRESSABLE (x) = 1;
4135
4136           /* Warn about mismatches against previous implicit decl.  */
4137           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4138               /* If this real decl matches the implicit, don't complain.  */
4139               && ! (TREE_CODE (x) == FUNCTION_DECL
4140                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4141             warning
4142               ("`%D' was previously implicitly declared to return `int'", x);
4143
4144           /* If new decl is `static' and an `extern' was seen previously,
4145              warn about it.  */
4146           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4147             warn_extern_redeclared_static (x, t);
4148         }
4149       else
4150         {
4151           /* Here to install a non-global value.  */
4152           tree oldlocal = IDENTIFIER_VALUE (name);
4153           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4154
4155           if (need_new_binding)
4156             {
4157               push_local_binding (name, x, 0);
4158               /* Because push_local_binding will hook X on to the
4159                  current_binding_level's name list, we don't want to
4160                  do that again below.  */
4161               need_new_binding = 0;
4162             }
4163
4164           /* If this is a TYPE_DECL, push it into the type value slot.  */
4165           if (TREE_CODE (x) == TYPE_DECL)
4166             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4167                                                   current_binding_level);
4168
4169           /* Clear out any TYPE_DECL shadowed by a namespace so that
4170              we won't think this is a type.  The C struct hack doesn't
4171              go through namespaces.  */
4172           if (TREE_CODE (x) == NAMESPACE_DECL)
4173             set_identifier_type_value_with_scope (name, NULL_TREE,
4174                                                   current_binding_level);
4175
4176           if (oldlocal)
4177             {
4178               tree d = oldlocal;
4179
4180               while (oldlocal
4181                      && TREE_CODE (oldlocal) == VAR_DECL
4182                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4183                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4184
4185               if (oldlocal == NULL_TREE)
4186                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4187             }
4188
4189           /* If this is an extern function declaration, see if we
4190              have a global definition or declaration for the function.  */
4191           if (oldlocal == NULL_TREE
4192               && DECL_EXTERNAL (x)
4193               && oldglobal != NULL_TREE
4194               && TREE_CODE (x) == FUNCTION_DECL
4195               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4196             {
4197               /* We have one.  Their types must agree.  */
4198               if (decls_match (x, oldglobal))
4199                 /* OK */;
4200               else
4201                 {
4202                   warning ("extern declaration of `%#D' doesn't match", x);
4203                   cp_warning_at ("global declaration `%#D'", oldglobal);
4204                 }
4205             }
4206           /* If we have a local external declaration,
4207              and no file-scope declaration has yet been seen,
4208              then if we later have a file-scope decl it must not be static.  */
4209           if (oldlocal == NULL_TREE
4210               && oldglobal == NULL_TREE
4211               && DECL_EXTERNAL (x)
4212               && TREE_PUBLIC (x))
4213             TREE_PUBLIC (name) = 1;
4214
4215           /* Warn if shadowing an argument at the top level of the body.  */
4216           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4217               /* Inline decls shadow nothing.  */
4218               && !DECL_FROM_INLINE (x)
4219               && TREE_CODE (oldlocal) == PARM_DECL)
4220             {
4221               bool err = false;
4222
4223               /* Don't complain if it's from an enclosing function.  */
4224               if (DECL_CONTEXT (oldlocal) == current_function_decl
4225                   && TREE_CODE (x) != PARM_DECL)
4226                 {
4227                   /* Go to where the parms should be and see if we find
4228                      them there.  */
4229                   struct binding_level *b = current_binding_level->level_chain;
4230
4231                   /* ARM $8.3 */
4232                   if (b->parm_flag == 1)
4233                     {
4234                       error ("declaration of `%#D' shadows a parameter",
4235                                 name);
4236                       err = true;
4237                     }
4238                 }
4239
4240               if (warn_shadow && !err)
4241                 shadow_warning ("a parameter", name, oldlocal);
4242             }
4243
4244           /* Maybe warn if shadowing something else.  */
4245           else if (warn_shadow && !DECL_EXTERNAL (x)
4246               /* No shadow warnings for internally generated vars.  */
4247               && ! DECL_ARTIFICIAL (x)
4248               /* No shadow warnings for vars made for inlining.  */
4249               && ! DECL_FROM_INLINE (x))
4250             {
4251               if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4252                        && current_class_ptr
4253                        && !TREE_STATIC (name))
4254                 warning ("declaration of `%s' shadows a member of `this'",
4255                             IDENTIFIER_POINTER (name));
4256               else if (oldlocal != NULL_TREE
4257                        && TREE_CODE (oldlocal) == VAR_DECL)
4258                 shadow_warning ("a previous local", name, oldlocal);
4259               else if (oldglobal != NULL_TREE
4260                        && TREE_CODE (oldglobal) == VAR_DECL)
4261                 /* XXX shadow warnings in outer-more namespaces */
4262                 shadow_warning ("a global declaration", name, oldglobal);
4263             }
4264         }
4265
4266       if (TREE_CODE (x) == FUNCTION_DECL)
4267         check_default_args (x);
4268
4269       if (TREE_CODE (x) == VAR_DECL)
4270         maybe_register_incomplete_var (x);
4271     }
4272
4273   if (need_new_binding)
4274     add_decl_to_level (x,
4275                        DECL_NAMESPACE_SCOPE_P (x)
4276                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4277                        : current_binding_level);
4278
4279   return x;
4280 }
4281
4282 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4283    caller to set DECL_CONTEXT properly.  */
4284
4285 static tree
4286 pushdecl_with_scope (x, level)
4287      tree x;
4288      struct binding_level *level;
4289 {
4290   register struct binding_level *b;
4291   tree function_decl = current_function_decl;
4292
4293   current_function_decl = NULL_TREE;
4294   if (level->parm_flag == 2)
4295     {
4296       b = class_binding_level;
4297       class_binding_level = level;
4298       pushdecl_class_level (x);
4299       class_binding_level = b;
4300     }
4301   else
4302     {
4303       b = current_binding_level;
4304       current_binding_level = level;
4305       x = pushdecl (x);
4306       current_binding_level = b;
4307     }
4308   current_function_decl = function_decl;
4309   return x;
4310 }
4311
4312 /* Like pushdecl, only it places X in the current namespace,
4313    if appropriate.  */
4314
4315 tree
4316 pushdecl_namespace_level (x)
4317      tree x;
4318 {
4319   register struct binding_level *b = current_binding_level;
4320   register tree t;
4321
4322   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4323
4324   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4325      what we want.  */
4326   if (TREE_CODE (x) == TYPE_DECL)
4327     {
4328       tree name = DECL_NAME (x);
4329       tree newval;
4330       tree *ptr = (tree *)0;
4331       for (; b != global_binding_level; b = b->level_chain)
4332         {
4333           tree shadowed = b->type_shadowed;
4334           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4335             if (TREE_PURPOSE (shadowed) == name)
4336               {
4337                 ptr = &TREE_VALUE (shadowed);
4338                 /* Can't break out of the loop here because sometimes
4339                    a binding level will have duplicate bindings for
4340                    PT names.  It's gross, but I haven't time to fix it.  */
4341               }
4342         }
4343       newval = TREE_TYPE (x);
4344       if (ptr == (tree *)0)
4345         {
4346           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4347              up here if this is changed to an assertion.  --KR  */
4348           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4349         }
4350       else
4351         {
4352           *ptr = newval;
4353         }
4354     }
4355   return t;
4356 }
4357
4358 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4359    if appropriate.  */
4360
4361 tree
4362 pushdecl_top_level (x)
4363      tree x;
4364 {
4365   push_to_top_level ();
4366   x = pushdecl_namespace_level (x);
4367   pop_from_top_level ();
4368   return x;
4369 }
4370
4371 /* Make the declaration of X appear in CLASS scope.  */
4372
4373 void
4374 pushdecl_class_level (x)
4375      tree x;
4376 {
4377   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4378      scope looks for the pre-mangled name.  */
4379   register tree name;
4380
4381   if (TREE_CODE (x) == OVERLOAD)
4382     x = OVL_CURRENT (x);
4383   name = DECL_NAME (x);
4384
4385   if (name)
4386     {
4387       push_class_level_binding (name, x);
4388       if (TREE_CODE (x) == TYPE_DECL)
4389         set_identifier_type_value (name, TREE_TYPE (x));
4390     }
4391   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4392     {
4393       tree f;
4394
4395       for (f = TYPE_FIELDS (TREE_TYPE (x));
4396            f;
4397            f = TREE_CHAIN (f))
4398         pushdecl_class_level (f);
4399     }
4400 }
4401
4402 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4403    DECL, or a modified version thereof.  */
4404
4405 tree
4406 maybe_push_decl (decl)
4407      tree decl;
4408 {
4409   tree type = TREE_TYPE (decl);
4410
4411   /* Add this decl to the current binding level, but not if it comes
4412      from another scope, e.g. a static member variable.  TEM may equal
4413      DECL or it may be a previous decl of the same name.  */
4414   if (decl == error_mark_node
4415       || (TREE_CODE (decl) != PARM_DECL
4416           && DECL_CONTEXT (decl) != NULL_TREE
4417           /* Definitions of namespace members outside their namespace are
4418              possible. */
4419           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4420       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4421       || TREE_CODE (type) == UNKNOWN_TYPE
4422       /* The declaration of a template specialization does not affect
4423          the functions available for overload resolution, so we do not
4424          call pushdecl.  */
4425       || (TREE_CODE (decl) == FUNCTION_DECL
4426           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4427     return decl;
4428   else
4429     return pushdecl (decl);
4430 }
4431
4432 /* Make the declaration(s) of X appear in CLASS scope
4433    under the name NAME.  */
4434
4435 void
4436 push_class_level_binding (name, x)
4437      tree name;
4438      tree x;
4439 {
4440   tree binding;
4441   /* The class_binding_level will be NULL if x is a template
4442      parameter name in a member template.  */
4443   if (!class_binding_level)
4444     return;
4445
4446   /* Make sure that this new member does not have the same name
4447      as a template parameter.  */
4448   if (TYPE_BEING_DEFINED (current_class_type))
4449     check_template_shadow (x);
4450
4451   /* If this declaration shadows a declaration from an enclosing
4452      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4453      we leave this class.  Record the shadowed declaration here.  */
4454   binding = IDENTIFIER_BINDING (name);
4455   if (binding
4456       && ((TREE_CODE (x) == OVERLOAD
4457            && BINDING_VALUE (binding)
4458            && is_overloaded_fn (BINDING_VALUE (binding)))
4459           || INHERITED_VALUE_BINDING_P (binding)))
4460     {
4461       tree shadow;
4462       tree old_decl;
4463
4464       /* If the old binding was from a base class, and was for a tag
4465          name, slide it over to make room for the new binding.  The
4466          old binding is still visible if explicitly qualified with a
4467          class-key.  */
4468       if (INHERITED_VALUE_BINDING_P (binding)
4469           && BINDING_VALUE (binding)
4470           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4471           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4472           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4473         {
4474           old_decl = BINDING_TYPE (binding);
4475           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4476           BINDING_VALUE (binding) = NULL_TREE;
4477           INHERITED_VALUE_BINDING_P (binding) = 0;
4478         }
4479       else
4480         old_decl = BINDING_VALUE (binding);
4481
4482       /* Find the previous binding of name on the class-shadowed
4483          list, and update it.  */
4484       for (shadow = class_binding_level->class_shadowed;
4485            shadow;
4486            shadow = TREE_CHAIN (shadow))
4487         if (TREE_PURPOSE (shadow) == name
4488             && TREE_TYPE (shadow) == old_decl)
4489           {
4490             BINDING_VALUE (binding) = x;
4491             INHERITED_VALUE_BINDING_P (binding) = 0;
4492             TREE_TYPE (shadow) = x;
4493             IDENTIFIER_CLASS_VALUE (name) = x;
4494             return;
4495           }
4496     }
4497
4498   /* If we didn't replace an existing binding, put the binding on the
4499      stack of bindings for the identifier, and update the shadowed list.  */
4500   if (push_class_binding (name, x))
4501     {
4502       class_binding_level->class_shadowed
4503         = tree_cons (name, NULL,
4504                      class_binding_level->class_shadowed);
4505       /* Record the value we are binding NAME to so that we can know
4506          what to pop later.  */
4507       TREE_TYPE (class_binding_level->class_shadowed) = x;
4508     }
4509 }
4510
4511 /* Insert another USING_DECL into the current binding level, returning
4512    this declaration. If this is a redeclaration, do nothing, and
4513    return NULL_TREE if this not in namespace scope (in namespace
4514    scope, a using decl might extend any previous bindings).  */
4515
4516 tree
4517 push_using_decl (scope, name)
4518      tree scope;
4519      tree name;
4520 {
4521   tree decl;
4522
4523   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4524   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4525   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4526     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4527       break;
4528   if (decl)
4529     return namespace_bindings_p () ? decl : NULL_TREE;
4530   decl = build_lang_decl (USING_DECL, name, void_type_node);
4531   DECL_INITIAL (decl) = scope;
4532   TREE_CHAIN (decl) = current_binding_level->usings;
4533   current_binding_level->usings = decl;
4534   return decl;
4535 }
4536
4537 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4538    changed (i.e. there was already a directive), or the fresh
4539    TREE_LIST otherwise.  */
4540
4541 tree
4542 push_using_directive (used)
4543      tree used;
4544 {
4545   tree ud = current_binding_level->using_directives;
4546   tree iter, ancestor;
4547
4548   /* Check if we already have this. */
4549   if (purpose_member (used, ud) != NULL_TREE)
4550     return NULL_TREE;
4551
4552   /* Recursively add all namespaces used. */
4553   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4554     push_using_directive (TREE_PURPOSE (iter));
4555
4556   ancestor = namespace_ancestor (current_decl_namespace (), used);
4557   ud = current_binding_level->using_directives;
4558   ud = tree_cons (used, ancestor, ud);
4559   current_binding_level->using_directives = ud;
4560   return ud;
4561 }
4562
4563 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4564    other definitions already in place.  We get around this by making
4565    the value of the identifier point to a list of all the things that
4566    want to be referenced by that name.  It is then up to the users of
4567    that name to decide what to do with that list.
4568
4569    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4570    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4571
4572    FLAGS is a bitwise-or of the following values:
4573      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4574                  namespace scope.
4575      PUSH_USING: DECL is being pushed as the result of a using
4576                  declaration.
4577
4578    The value returned may be a previous declaration if we guessed wrong
4579    about what language DECL should belong to (C or C++).  Otherwise,
4580    it's always DECL (and never something that's not a _DECL).  */
4581
4582 tree
4583 push_overloaded_decl (decl, flags)
4584      tree decl;
4585      int flags;
4586 {
4587   tree name = DECL_NAME (decl);
4588   tree old;
4589   tree new_binding;
4590   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4591
4592   if (doing_global)
4593     old = namespace_binding (name, DECL_CONTEXT (decl));
4594   else
4595     old = lookup_name_current_level (name);
4596
4597   if (old)
4598     {
4599       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4600         {
4601           tree t = TREE_TYPE (old);
4602           if (IS_AGGR_TYPE (t) && warn_shadow
4603               && (! DECL_IN_SYSTEM_HEADER (decl)
4604                   || ! DECL_IN_SYSTEM_HEADER (old)))
4605             warning ("`%#D' hides constructor for `%#T'", decl, t);
4606           old = NULL_TREE;
4607         }
4608       else if (is_overloaded_fn (old))
4609         {
4610           tree tmp;
4611
4612           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4613             {
4614               tree fn = OVL_CURRENT (tmp);
4615
4616               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4617                   && !(flags & PUSH_USING)
4618                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4619                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4620                 error ("`%#D' conflicts with previous using declaration `%#D'",
4621                           decl, fn);
4622
4623               if (duplicate_decls (decl, fn))
4624                 return fn;
4625             }
4626         }
4627       else if (old == error_mark_node)
4628         /* Ignore the undefined symbol marker.  */
4629         old = NULL_TREE;
4630       else
4631         {
4632           cp_error_at ("previous non-function declaration `%#D'", old);
4633           error ("conflicts with function declaration `%#D'", decl);
4634           return decl;
4635         }
4636     }
4637
4638   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4639     {
4640       if (old && TREE_CODE (old) != OVERLOAD)
4641         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4642       else
4643         new_binding = ovl_cons (decl, old);
4644       if (flags & PUSH_USING)
4645         OVL_USED (new_binding) = 1;
4646     }
4647   else
4648     /* NAME is not ambiguous.  */
4649     new_binding = decl;
4650
4651   if (doing_global)
4652     set_namespace_binding (name, current_namespace, new_binding);
4653   else
4654     {
4655       /* We only create an OVERLOAD if there was a previous binding at
4656          this level, or if decl is a template. In the former case, we
4657          need to remove the old binding and replace it with the new
4658          binding.  We must also run through the NAMES on the binding
4659          level where the name was bound to update the chain.  */
4660
4661       if (TREE_CODE (new_binding) == OVERLOAD && old)
4662         {
4663           tree *d;
4664
4665           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4666                *d;
4667                d = &TREE_CHAIN (*d))
4668             if (*d == old
4669                 || (TREE_CODE (*d) == TREE_LIST
4670                     && TREE_VALUE (*d) == old))
4671               {
4672                 if (TREE_CODE (*d) == TREE_LIST)
4673                   /* Just replace the old binding with the new.  */
4674                   TREE_VALUE (*d) = new_binding;
4675                 else
4676                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4677                   *d = tree_cons (NULL_TREE, new_binding,
4678                                   TREE_CHAIN (*d));
4679
4680                 /* And update the CPLUS_BINDING node.  */
4681                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4682                   = new_binding;
4683                 return decl;
4684               }
4685
4686           /* We should always find a previous binding in this case.  */
4687           abort ();
4688         }
4689
4690       /* Install the new binding.  */
4691       push_local_binding (name, new_binding, flags);
4692     }
4693
4694   return decl;
4695 }
4696 \f
4697 /* Generate an implicit declaration for identifier FUNCTIONID
4698    as a function of type int ().  Print a warning if appropriate.  */
4699
4700 tree
4701 implicitly_declare (functionid)
4702      tree functionid;
4703 {
4704   register tree decl;
4705
4706   /* We used to reuse an old implicit decl here,
4707      but this loses with inline functions because it can clobber
4708      the saved decl chains.  */
4709   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4710
4711   DECL_EXTERNAL (decl) = 1;
4712   TREE_PUBLIC (decl) = 1;
4713
4714   /* ISO standard says implicit declarations are in the innermost block.
4715      So we record the decl in the standard fashion.  */
4716   pushdecl (decl);
4717   rest_of_decl_compilation (decl, NULL, 0, 0);
4718
4719   if (warn_implicit
4720       /* Only one warning per identifier.  */
4721       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4722     {
4723       pedwarn ("implicit declaration of function `%#D'", decl);
4724     }
4725
4726   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4727
4728   return decl;
4729 }
4730
4731 /* Return zero if the declaration NEWDECL is valid
4732    when the declaration OLDDECL (assumed to be for the same name)
4733    has already been seen.
4734    Otherwise return an error message format string with a %s
4735    where the identifier should go.  */
4736
4737 static const char *
4738 redeclaration_error_message (newdecl, olddecl)
4739      tree newdecl, olddecl;
4740 {
4741   if (TREE_CODE (newdecl) == TYPE_DECL)
4742     {
4743       /* Because C++ can put things into name space for free,
4744          constructs like "typedef struct foo { ... } foo"
4745          would look like an erroneous redeclaration.  */
4746       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4747         return 0;
4748       else
4749         return "redefinition of `%#D'";
4750     }
4751   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4752     {
4753       /* If this is a pure function, its olddecl will actually be
4754          the original initialization to `0' (which we force to call
4755          abort()).  Don't complain about redefinition in this case.  */
4756       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4757         return 0;
4758
4759       /* If both functions come from different namespaces, this is not
4760          a redeclaration - this is a conflict with a used function. */
4761       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4762           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4763         return "`%D' conflicts with used function";
4764
4765       /* We'll complain about linkage mismatches in
4766          warn_extern_redeclared_static.  */
4767
4768       /* Defining the same name twice is no good.  */
4769       if (DECL_INITIAL (olddecl) != NULL_TREE
4770           && DECL_INITIAL (newdecl) != NULL_TREE)
4771         {
4772           if (DECL_NAME (olddecl) == NULL_TREE)
4773             return "`%#D' not declared in class";
4774           else
4775             return "redefinition of `%#D'";
4776         }
4777       return 0;
4778     }
4779   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4780     {
4781       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4782            && (DECL_TEMPLATE_RESULT (newdecl)
4783                != DECL_TEMPLATE_RESULT (olddecl))
4784            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4785            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4786           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4787               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4788               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4789         return "redefinition of `%#D'";
4790       return 0;
4791     }
4792   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4793     {
4794       /* Objects declared at top level:  */
4795       /* If at least one is a reference, it's ok.  */
4796       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4797         return 0;
4798       /* Reject two definitions.  */
4799       return "redefinition of `%#D'";
4800     }
4801   else
4802     {
4803       /* Objects declared with block scope:  */
4804       /* Reject two definitions, and reject a definition
4805          together with an external reference.  */
4806       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4807         return "redeclaration of `%#D'";
4808       return 0;
4809     }
4810 }
4811 \f
4812 /* Create a new label, named ID.  */
4813
4814 static tree
4815 make_label_decl (id, local_p)
4816      tree id;
4817      int local_p;
4818 {
4819   tree decl;
4820
4821   decl = build_decl (LABEL_DECL, id, void_type_node);
4822   if (expanding_p)
4823     /* Make sure every label has an rtx.  */
4824     label_rtx (decl);
4825
4826   DECL_CONTEXT (decl) = current_function_decl;
4827   DECL_MODE (decl) = VOIDmode;
4828   C_DECLARED_LABEL_FLAG (decl) = local_p;
4829
4830   /* Say where one reference is to the label, for the sake of the
4831      error if it is not defined.  */
4832   DECL_SOURCE_LINE (decl) = lineno;
4833   DECL_SOURCE_FILE (decl) = input_filename;
4834
4835   /* Record the fact that this identifier is bound to this label.  */
4836   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4837
4838   return decl;
4839 }
4840
4841 /* Record this label on the list of used labels so that we can check
4842    at the end of the function to see whether or not the label was
4843    actually defined, and so we can check when the label is defined whether
4844    this use is valid.  */
4845
4846 static void
4847 use_label (decl)
4848      tree decl;
4849 {
4850   if (named_label_uses == NULL
4851       || named_label_uses->names_in_scope != current_binding_level->names
4852       || named_label_uses->label_decl != decl)
4853     {
4854       struct named_label_use_list *new_ent;
4855       new_ent = ((struct named_label_use_list *)
4856                  ggc_alloc (sizeof (struct named_label_use_list)));
4857       new_ent->label_decl = decl;
4858       new_ent->names_in_scope = current_binding_level->names;
4859       new_ent->binding_level = current_binding_level;
4860       new_ent->lineno_o_goto = lineno;
4861       new_ent->filename_o_goto = input_filename;
4862       new_ent->next = named_label_uses;
4863       named_label_uses = new_ent;
4864     }
4865 }
4866
4867 /* Look for a label named ID in the current function.  If one cannot
4868    be found, create one.  (We keep track of used, but undefined,
4869    labels, and complain about them at the end of a function.)  */
4870
4871 tree
4872 lookup_label (id)
4873      tree id;
4874 {
4875   tree decl;
4876   struct named_label_list *ent;
4877
4878   /* You can't use labels at global scope.  */
4879   if (current_function_decl == NULL_TREE)
4880     {
4881       error ("label `%s' referenced outside of any function",
4882              IDENTIFIER_POINTER (id));
4883       return NULL_TREE;
4884     }
4885
4886   /* See if we've already got this label.  */
4887   decl = IDENTIFIER_LABEL_VALUE (id);
4888   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4889     return decl;
4890
4891   /* Record this label on the list of labels used in this function.
4892      We do this before calling make_label_decl so that we get the
4893      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4894   ent = ((struct named_label_list *)
4895          ggc_alloc_cleared (sizeof (struct named_label_list)));
4896   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4897   ent->next = named_labels;
4898   named_labels = ent;
4899
4900   /* We need a new label.  */
4901   decl = make_label_decl (id, /*local_p=*/0);
4902
4903   /* Now fill in the information we didn't have before.  */
4904   ent->label_decl = decl;
4905
4906   return decl;
4907 }
4908
4909 /* Declare a local label named ID.  */
4910
4911 tree
4912 declare_local_label (id)
4913      tree id;
4914 {
4915   tree decl;
4916
4917   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4918      this scope we can restore the old value of
4919      IDENTIFIER_TYPE_VALUE.  */
4920   current_binding_level->shadowed_labels
4921     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4922                  current_binding_level->shadowed_labels);
4923   /* Look for the label.  */
4924   decl = make_label_decl (id, /*local_p=*/1);
4925   /* Now fill in the information we didn't have before.  */
4926   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4927
4928   return decl;
4929 }
4930
4931 /* Returns nonzero if it is ill-formed to jump past the declaration of
4932    DECL.  Returns 2 if it's also a real problem.  */
4933
4934 static int
4935 decl_jump_unsafe (decl)
4936      tree decl;
4937 {
4938   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4939     return 0;
4940
4941   if (DECL_INITIAL (decl) == NULL_TREE
4942       && pod_type_p (TREE_TYPE (decl)))
4943     return 0;
4944
4945   /* This is really only important if we're crossing an initialization.
4946      The POD stuff is just pedantry; why should it matter if the class
4947      contains a field of pointer to member type?  */
4948   if (DECL_INITIAL (decl)
4949       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4950     return 2;
4951   return 1;
4952 }
4953
4954 /* Check that a single previously seen jump to a newly defined label
4955    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4956    the jump context; NAMES are the names in scope in LEVEL at the jump
4957    context; FILE and LINE are the source position of the jump or 0.  */
4958
4959 static void
4960 check_previous_goto_1 (decl, level, names, file, line)
4961      tree decl;
4962      struct binding_level *level;
4963      tree names;
4964      const char *file;
4965      int line;
4966 {
4967   int identified = 0;
4968   int saw_eh = 0;
4969   struct binding_level *b = current_binding_level;
4970   for (; b; b = b->level_chain)
4971     {
4972       tree new_decls = b->names;
4973       tree old_decls = (b == level ? names : NULL_TREE);
4974       for (; new_decls != old_decls;
4975            new_decls = TREE_CHAIN (new_decls))
4976         {
4977           int problem = decl_jump_unsafe (new_decls);
4978           if (! problem)
4979             continue;
4980
4981           if (! identified)
4982             {
4983               if (decl)
4984                 pedwarn ("jump to label `%D'", decl);
4985               else
4986                 pedwarn ("jump to case label");
4987
4988               if (file)
4989                 pedwarn_with_file_and_line (file, line, "  from here");
4990               identified = 1;
4991             }
4992
4993           if (problem > 1)
4994             cp_error_at ("  crosses initialization of `%#D'",
4995                          new_decls);
4996           else
4997             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4998                            new_decls);
4999         }
5000
5001       if (b == level)
5002         break;
5003       if ((b->is_try_scope || b->is_catch_scope) && ! saw_eh)
5004         {
5005           if (! identified)
5006             {
5007               if (decl)
5008                 pedwarn ("jump to label `%D'", decl);
5009               else
5010                 pedwarn ("jump to case label");
5011
5012               if (file)
5013                 pedwarn_with_file_and_line (file, line, "  from here");
5014               identified = 1;
5015             }
5016           if (b->is_try_scope)
5017             error ("  enters try block");
5018           else
5019             error ("  enters catch block");
5020           saw_eh = 1;
5021         }
5022     }
5023 }
5024
5025 static void
5026 check_previous_goto (use)
5027      struct named_label_use_list *use;
5028 {
5029   check_previous_goto_1 (use->label_decl, use->binding_level,
5030                          use->names_in_scope, use->filename_o_goto,
5031                          use->lineno_o_goto);
5032 }
5033
5034 static void
5035 check_switch_goto (level)
5036      struct binding_level *level;
5037 {
5038   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
5039 }
5040
5041 /* Check that any previously seen jumps to a newly defined label DECL
5042    are OK.  Called by define_label.  */
5043
5044 static void
5045 check_previous_gotos (decl)
5046      tree decl;
5047 {
5048   struct named_label_use_list **usep;
5049
5050   if (! TREE_USED (decl))
5051     return;
5052
5053   for (usep = &named_label_uses; *usep; )
5054     {
5055       struct named_label_use_list *use = *usep;
5056       if (use->label_decl == decl)
5057         {
5058           check_previous_goto (use);
5059           *usep = use->next;
5060         }
5061       else
5062         usep = &(use->next);
5063     }
5064 }
5065
5066 /* Check that a new jump to a label DECL is OK.  Called by
5067    finish_goto_stmt.  */
5068
5069 void
5070 check_goto (decl)
5071      tree decl;
5072 {
5073   int identified = 0;
5074   tree bad;
5075   struct named_label_list *lab;
5076
5077   /* We can't know where a computed goto is jumping.  So we assume
5078      that it's OK.  */
5079   if (! DECL_P (decl))
5080     return;
5081
5082   /* If the label hasn't been defined yet, defer checking.  */
5083   if (! DECL_INITIAL (decl))
5084     {
5085       use_label (decl);
5086       return;
5087     }
5088
5089   for (lab = named_labels; lab; lab = lab->next)
5090     if (decl == lab->label_decl)
5091       break;
5092
5093   /* If the label is not on named_labels it's a gcc local label, so
5094      it must be in an outer scope, so jumping to it is always OK.  */
5095   if (lab == 0)
5096     return;
5097
5098   if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
5099       && !identified)
5100     {
5101       cp_pedwarn_at ("jump to label `%D'", decl);
5102       pedwarn ("  from here");
5103       identified = 1;
5104     }
5105
5106   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5107     {
5108       tree b = TREE_VALUE (bad);
5109       int u = decl_jump_unsafe (b);
5110
5111       if (u > 1 && DECL_ARTIFICIAL (b))
5112         /* Can't skip init of __exception_info.  */
5113         cp_error_at ("  enters catch block", b);
5114       else if (u > 1)
5115         cp_error_at ("  skips initialization of `%#D'", b);
5116       else
5117         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5118     }
5119
5120   if (lab->in_try_scope)
5121     error ("  enters try block");
5122   else if (lab->in_catch_scope)
5123     error ("  enters catch block");
5124 }
5125
5126 /* Define a label, specifying the location in the source file.
5127    Return the LABEL_DECL node for the label, if the definition is valid.
5128    Otherwise return 0.  */
5129
5130 tree
5131 define_label (filename, line, name)
5132      const char *filename;
5133      int line;
5134      tree name;
5135 {
5136   tree decl = lookup_label (name);
5137   struct named_label_list *ent;
5138   register struct binding_level *p;
5139
5140   for (ent = named_labels; ent; ent = ent->next)
5141     if (ent->label_decl == decl)
5142       break;
5143
5144   /* After labels, make any new cleanups in the function go into their
5145      own new (temporary) binding contour.  */
5146   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5147     p->more_cleanups_ok = 0;
5148
5149   if (name == get_identifier ("wchar_t"))
5150     pedwarn ("label named wchar_t");
5151
5152   if (DECL_INITIAL (decl) != NULL_TREE)
5153     {
5154       error ("duplicate label `%D'", decl);
5155       return 0;
5156     }
5157   else
5158     {
5159       /* Mark label as having been defined.  */
5160       DECL_INITIAL (decl) = error_mark_node;
5161       /* Say where in the source.  */
5162       DECL_SOURCE_FILE (decl) = filename;
5163       DECL_SOURCE_LINE (decl) = line;
5164       if (ent)
5165         {
5166           ent->names_in_scope = current_binding_level->names;
5167           ent->binding_level = current_binding_level;
5168         }
5169       check_previous_gotos (decl);
5170       return decl;
5171     }
5172 }
5173
5174 struct cp_switch
5175 {
5176   struct binding_level *level;
5177   struct cp_switch *next;
5178   /* The SWITCH_STMT being built.  */
5179   tree switch_stmt;
5180   /* A splay-tree mapping the low element of a case range to the high
5181      element, or NULL_TREE if there is no high element.  Used to
5182      determine whether or not a new case label duplicates an old case
5183      label.  We need a tree, rather than simply a hash table, because
5184      of the GNU case range extension.  */
5185   splay_tree cases;
5186 };
5187
5188 /* A stack of the currently active switch statements.  The innermost
5189    switch statement is on the top of the stack.  There is no need to
5190    mark the stack for garbage collection because it is only active
5191    during the processing of the body of a function, and we never
5192    collect at that point.  */
5193
5194 static struct cp_switch *switch_stack;
5195
5196 /* Called right after a switch-statement condition is parsed.
5197    SWITCH_STMT is the switch statement being parsed.  */
5198
5199 void
5200 push_switch (switch_stmt)
5201      tree switch_stmt;
5202 {
5203   struct cp_switch *p
5204     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5205   p->level = current_binding_level;
5206   p->next = switch_stack;
5207   p->switch_stmt = switch_stmt;
5208   p->cases = splay_tree_new (case_compare, NULL, NULL);
5209   switch_stack = p;
5210 }
5211
5212 void
5213 pop_switch ()
5214 {
5215   struct cp_switch *cs;
5216
5217   cs = switch_stack;
5218   splay_tree_delete (cs->cases);
5219   switch_stack = switch_stack->next;
5220   free (cs);
5221 }
5222
5223 /* Note that we've seen a definition of a case label, and complain if this
5224    is a bad place for one.  */
5225
5226 tree
5227 finish_case_label (low_value, high_value)
5228      tree low_value;
5229      tree high_value;
5230 {
5231   tree cond, r;
5232   register struct binding_level *p;
5233
5234   if (! switch_stack)
5235     {
5236       if (high_value)
5237         error ("case label not within a switch statement");
5238       else if (low_value)
5239         error ("case label `%E' not within a switch statement",
5240                   low_value);
5241       else
5242         error ("`default' label not within a switch statement");
5243       return NULL_TREE;
5244     }
5245
5246   if (processing_template_decl)
5247     {
5248       tree label;
5249
5250       /* For templates, just add the case label; we'll do semantic
5251          analysis at instantiation-time.  */
5252       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5253       return add_stmt (build_case_label (low_value, high_value, label));
5254     }
5255
5256   /* Find the condition on which this switch statement depends.  */
5257   cond = SWITCH_COND (switch_stack->switch_stmt);
5258   if (cond && TREE_CODE (cond) == TREE_LIST)
5259     cond = TREE_VALUE (cond);
5260
5261   r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5262   if (r == error_mark_node)
5263     r = NULL_TREE;
5264
5265   check_switch_goto (switch_stack->level);
5266
5267   /* After labels, make any new cleanups in the function go into their
5268      own new (temporary) binding contour.  */
5269   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5270     p->more_cleanups_ok = 0;
5271
5272   return r;
5273 }
5274 \f
5275 /* Return the list of declarations of the current level.
5276    Note that this list is in reverse order unless/until
5277    you nreverse it; and when you do nreverse it, you must
5278    store the result back using `storedecls' or you will lose.  */
5279
5280 tree
5281 getdecls ()
5282 {
5283   return current_binding_level->names;
5284 }
5285
5286 /* Return the list of type-tags (for structs, etc) of the current level.  */
5287
5288 tree
5289 gettags ()
5290 {
5291   return current_binding_level->tags;
5292 }
5293
5294 /* Store the list of declarations of the current level.
5295    This is done for the parameter declarations of a function being defined,
5296    after they are modified in the light of any missing parameters.  */
5297
5298 static void
5299 storedecls (decls)
5300      tree decls;
5301 {
5302   current_binding_level->names = decls;
5303 }
5304
5305 /* Similarly, store the list of tags of the current level.  */
5306
5307 void
5308 storetags (tags)
5309      tree tags;
5310 {
5311   current_binding_level->tags = tags;
5312 }
5313 \f
5314 /* Return the type that should be used when TYPE's name is preceded
5315    by a tag such as 'struct' or 'union', or null if the name cannot
5316    be used in this way.
5317
5318    For example, when processing the third line of:
5319
5320         struct A;
5321         typedef struct A A;
5322         struct A;
5323
5324    lookup of A will find the typedef.  Given A's typedef, this function
5325    will return the type associated with "struct A".  For the tag to be
5326    anything other than TYPE, TYPE must be a typedef whose original type
5327    has the same name and context as TYPE itself.
5328
5329    It is not valid for a typedef of an anonymous type to be used with
5330    an explicit tag:
5331
5332        typedef struct { ... } B;
5333        struct B;
5334
5335    Return null for this case.  */
5336
5337 static tree
5338 follow_tag_typedef (type)
5339      tree type;
5340 {
5341   tree original;
5342
5343   original = original_type (type);
5344   if (! TYPE_NAME (original))
5345     return NULL_TREE;
5346   if (TYPE_IDENTIFIER (original) == TYPE_IDENTIFIER (type)
5347       && (CP_DECL_CONTEXT (TYPE_NAME (original))
5348           == CP_DECL_CONTEXT (TYPE_NAME (type)))
5349       && !(CLASS_TYPE_P (original) && TYPE_WAS_ANONYMOUS (original)))
5350     return original;
5351   else
5352     return NULL_TREE;
5353 }
5354
5355 /* Given NAME, an IDENTIFIER_NODE,
5356    return the structure (or union or enum) definition for that name.
5357    Searches binding levels from BINDING_LEVEL up to the global level.
5358    If THISLEVEL_ONLY is nonzero, searches only the specified context
5359    (but skips any tag-transparent contexts to find one that is
5360    meaningful for tags).
5361    FORM says which kind of type the caller wants;
5362    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5363    If the wrong kind of type is found, and it's not a template, an error is
5364    reported.  */
5365
5366 static tree
5367 lookup_tag (form, name, binding_level, thislevel_only)
5368      enum tree_code form;
5369      tree name;
5370      struct binding_level *binding_level;
5371      int thislevel_only;
5372 {
5373   register struct binding_level *level;
5374   /* Non-zero if, we should look past a template parameter level, even
5375      if THISLEVEL_ONLY.  */
5376   int allow_template_parms_p = 1;
5377
5378   for (level = binding_level; level; level = level->level_chain)
5379     {
5380       register tree tail;
5381       if (ANON_AGGRNAME_P (name))
5382         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5383           {
5384             /* There's no need for error checking here, because
5385                anon names are unique throughout the compilation.  */
5386             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5387               return TREE_VALUE (tail);
5388           }
5389       else if (level->namespace_p)
5390         /* Do namespace lookup. */
5391         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5392           {
5393             tree old = binding_for_name (name, tail);
5394
5395             /* If we just skipped past a template parameter level,
5396                even though THISLEVEL_ONLY, and we find a template
5397                class declaration, then we use the _TYPE node for the
5398                template.  See the example below.  */
5399             if (thislevel_only && !allow_template_parms_p
5400                 && old && BINDING_VALUE (old)
5401                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5402               old = TREE_TYPE (BINDING_VALUE (old));
5403             else
5404               old = BINDING_TYPE (old);
5405
5406             if (old)
5407               {
5408                 /* We've found something at this binding level.  If it is
5409                    a typedef, extract the tag it refers to.  Lookup fails
5410                    if the typedef doesn't refer to a taggable type.  */
5411                 old = follow_tag_typedef (old);
5412                 if (!old)
5413                   return NULL_TREE;
5414                 if (TREE_CODE (old) != form
5415                     && (form == ENUMERAL_TYPE
5416                         || TREE_CODE (old) == ENUMERAL_TYPE))
5417                   {
5418                     error ("`%#D' redeclared as %C", old, form);
5419                     return NULL_TREE;
5420                   }
5421                 return old;
5422               }
5423             if (thislevel_only || tail == global_namespace)
5424               return NULL_TREE;
5425           }
5426       else
5427         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5428           {
5429             if (TREE_PURPOSE (tail) == name)
5430               {
5431                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5432
5433                 if (code != form
5434                     && (form == ENUMERAL_TYPE || code == ENUMERAL_TYPE))
5435                   {
5436                     /* Definition isn't the kind we were looking for.  */
5437                     error ("`%#D' redeclared as %C", TREE_VALUE (tail), form);
5438                     return NULL_TREE;
5439                   }
5440                 return TREE_VALUE (tail);
5441               }
5442           }
5443       if (thislevel_only && ! level->tag_transparent)
5444         {
5445           if (level->template_parms_p && allow_template_parms_p)
5446             {
5447               /* We must deal with cases like this:
5448
5449                    template <class T> struct S;
5450                    template <class T> struct S {};
5451
5452                  When looking up `S', for the second declaration, we
5453                  would like to find the first declaration.  But, we
5454                  are in the pseudo-global level created for the
5455                  template parameters, rather than the (surrounding)
5456                  namespace level.  Thus, we keep going one more level,
5457                  even though THISLEVEL_ONLY is non-zero.  */
5458               allow_template_parms_p = 0;
5459               continue;
5460             }
5461           else
5462             return NULL_TREE;
5463         }
5464     }
5465   return NULL_TREE;
5466 }
5467
5468 #if 0
5469 void
5470 set_current_level_tags_transparency (tags_transparent)
5471      int tags_transparent;
5472 {
5473   current_binding_level->tag_transparent = tags_transparent;
5474 }
5475 #endif
5476
5477 /* Given a type, find the tag that was defined for it and return the tag name.
5478    Otherwise return 0.  However, the value can never be 0
5479    in the cases in which this is used.
5480
5481    C++: If NAME is non-zero, this is the new name to install.  This is
5482    done when replacing anonymous tags with real tag names.  */
5483
5484 static tree
5485 lookup_tag_reverse (type, name)
5486      tree type;
5487      tree name;
5488 {
5489   register struct binding_level *level;
5490
5491   for (level = current_binding_level; level; level = level->level_chain)
5492     {
5493       register tree tail;
5494       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5495         {
5496           if (TREE_VALUE (tail) == type)
5497             {
5498               if (name)
5499                 TREE_PURPOSE (tail) = name;
5500               return TREE_PURPOSE (tail);
5501             }
5502         }
5503     }
5504   return NULL_TREE;
5505 }
5506 \f
5507 /* Look up NAME in the NAMESPACE.  */
5508
5509 tree
5510 lookup_namespace_name (namespace, name)
5511      tree namespace, name;
5512 {
5513   tree val;
5514   tree template_id = NULL_TREE;
5515
5516   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5517
5518   if (TREE_CODE (name) == NAMESPACE_DECL)
5519     /* This happens for A::B<int> when B is a namespace. */
5520     return name;
5521   else if (TREE_CODE (name) == TEMPLATE_DECL)
5522     {
5523       /* This happens for A::B where B is a template, and there are no
5524          template arguments.  */
5525       error ("invalid use of `%D'", name);
5526       return error_mark_node;
5527     }
5528
5529   namespace = ORIGINAL_NAMESPACE (namespace);
5530
5531   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5532     {
5533       template_id = name;
5534       name = TREE_OPERAND (name, 0);
5535       if (TREE_CODE (name) == OVERLOAD)
5536         name = DECL_NAME (OVL_CURRENT (name));
5537       else if (DECL_P (name))
5538         name = DECL_NAME (name);
5539     }
5540
5541   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5542
5543   val = make_node (CPLUS_BINDING);
5544   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5545     return error_mark_node;
5546
5547   if (BINDING_VALUE (val))
5548     {
5549       val = BINDING_VALUE (val);
5550
5551       if (template_id)
5552         {
5553           if (DECL_CLASS_TEMPLATE_P (val))
5554             val = lookup_template_class (val,
5555                                          TREE_OPERAND (template_id, 1),
5556                                          /*in_decl=*/NULL_TREE,
5557                                          /*context=*/NULL_TREE,
5558                                          /*entering_scope=*/0,
5559                                          tf_error | tf_warning);
5560           else if (DECL_FUNCTION_TEMPLATE_P (val)
5561                    || TREE_CODE (val) == OVERLOAD)
5562             val = lookup_template_function (val,
5563                                             TREE_OPERAND (template_id, 1));
5564           else
5565             {
5566               error ("`%D::%D' is not a template",
5567                         namespace, name);
5568               return error_mark_node;
5569             }
5570         }
5571
5572       /* If we have a single function from a using decl, pull it out.  */
5573       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5574         val = OVL_FUNCTION (val);
5575
5576       /* Ignore built-in functions that haven't been prototyped yet.  */
5577       if (!val || !DECL_P(val)
5578           || !DECL_LANG_SPECIFIC(val)
5579           || !DECL_ANTICIPATED (val))
5580         return val;
5581     }
5582
5583   error ("`%D' undeclared in namespace `%D'", name, namespace);
5584   return error_mark_node;
5585 }
5586
5587 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5588
5589 static unsigned long
5590 typename_hash (k)
5591      hash_table_key k;
5592 {
5593   unsigned long hash;
5594   tree t;
5595
5596   t = (tree) k;
5597   hash = (((unsigned long) TYPE_CONTEXT (t))
5598           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5599
5600   return hash;
5601 }
5602
5603 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5604
5605 static bool
5606 typename_compare (k1, k2)
5607      hash_table_key k1;
5608      hash_table_key k2;
5609 {
5610   tree t1;
5611   tree t2;
5612   tree d1;
5613   tree d2;
5614
5615   t1 = (tree) k1;
5616   t2 = (tree) k2;
5617   d1 = TYPE_NAME (t1);
5618   d2 = TYPE_NAME (t2);
5619
5620   return (DECL_NAME (d1) == DECL_NAME (d2)
5621           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5622           && ((TREE_TYPE (t1) != NULL_TREE)
5623               == (TREE_TYPE (t2) != NULL_TREE))
5624           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5625           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5626 }
5627
5628 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5629    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5630    is non-NULL, this type is being created by the implicit typename
5631    extension, and BASE_TYPE is a type named `t' in some base class of
5632    `T' which depends on template parameters.
5633
5634    Returns the new TYPENAME_TYPE.  */
5635
5636 tree
5637 build_typename_type (context, name, fullname, base_type)
5638      tree context;
5639      tree name;
5640      tree fullname;
5641      tree base_type;
5642 {
5643   tree t;
5644   tree d;
5645   struct hash_entry *e;
5646
5647   static struct hash_table ht;
5648
5649   if (!ht.table)
5650     {
5651       static struct hash_table *h = &ht;
5652
5653       hash_table_init (&ht, &hash_newfunc, &typename_hash, &typename_compare);
5654       ggc_add_tree_hash_table_root (&h, 1);
5655     }
5656
5657   /* Build the TYPENAME_TYPE.  */
5658   t = make_aggr_type (TYPENAME_TYPE);
5659   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5660   TYPENAME_TYPE_FULLNAME (t) = fullname;
5661   TREE_TYPE (t) = base_type;
5662
5663   /* Build the corresponding TYPE_DECL.  */
5664   d = build_decl (TYPE_DECL, name, t);
5665   TYPE_NAME (TREE_TYPE (d)) = d;
5666   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5667   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5668   DECL_ARTIFICIAL (d) = 1;
5669
5670   /* See if we already have this type.  */
5671   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5672   if (e)
5673     t = (tree) e->key;
5674   else
5675     /* Insert the type into the table.  */
5676     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5677
5678   return t;
5679 }
5680
5681 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5682    unless an error occurs, in which case error_mark_node is returned.
5683    If we locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is
5684    set, we return that, rather than the _TYPE it corresponds to, in
5685    other cases we look through the type decl.  If TF_ERROR is set,
5686    complain about errors, otherwise be quiet.  */
5687
5688 tree
5689 make_typename_type (context, name, complain)
5690      tree context, name;
5691      tsubst_flags_t complain;
5692 {
5693   tree fullname;
5694
5695   if (TYPE_P (name))
5696     {
5697       if (!(TYPE_LANG_SPECIFIC (name)
5698             && (CLASSTYPE_IS_TEMPLATE (name)
5699                 || CLASSTYPE_USE_TEMPLATE (name))))
5700         name = TYPE_IDENTIFIER (name);
5701       else
5702         /* Create a TEMPLATE_ID_EXPR for the type.  */
5703         name = build_nt (TEMPLATE_ID_EXPR,
5704                          CLASSTYPE_TI_TEMPLATE (name),
5705                          CLASSTYPE_TI_ARGS (name));
5706     }
5707   else if (TREE_CODE (name) == TYPE_DECL)
5708     name = DECL_NAME (name);
5709
5710   fullname = name;
5711
5712   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5713     {
5714       name = TREE_OPERAND (name, 0);
5715       if (TREE_CODE (name) == TEMPLATE_DECL)
5716         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5717     }
5718   if (TREE_CODE (name) == TEMPLATE_DECL)
5719     {
5720       error ("`%D' used without template parameters", name);
5721       return error_mark_node;
5722     }
5723   if (TREE_CODE (name) != IDENTIFIER_NODE)
5724     abort ();
5725
5726   if (TREE_CODE (context) == NAMESPACE_DECL)
5727     {
5728       /* We can get here from typename_sub0 in the explicit_template_type
5729          expansion.  Just fail.  */
5730       if (complain & tf_error)
5731         error ("no class template named `%#T' in `%#T'",
5732                   name, context);
5733       return error_mark_node;
5734     }
5735
5736   if (! uses_template_parms (context)
5737       || currently_open_class (context))
5738     {
5739       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5740         {
5741           tree tmpl = NULL_TREE;
5742           if (IS_AGGR_TYPE (context))
5743             tmpl = lookup_field (context, name, 0, 0);
5744           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5745             {
5746               if (complain & tf_error)
5747                 error ("no class template named `%#T' in `%#T'",
5748                           name, context);
5749               return error_mark_node;
5750             }
5751
5752           return lookup_template_class (tmpl,
5753                                         TREE_OPERAND (fullname, 1),
5754                                         NULL_TREE, context,
5755                                         /*entering_scope=*/0,
5756                                         tf_error | tf_warning);
5757         }
5758       else
5759         {
5760           tree t;
5761
5762           if (!IS_AGGR_TYPE (context))
5763             {
5764               if (complain & tf_error)
5765                 error ("no type named `%#T' in `%#T'", name, context);
5766               return error_mark_node;
5767             }
5768
5769           t = lookup_field (context, name, 0, 1);
5770           if (t)
5771             {
5772               if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
5773                 t = TREE_TYPE (t);
5774               if (IMPLICIT_TYPENAME_P (t))
5775                 {
5776                   /* Lookup found an implicit typename that we had
5777                      injected into the current scope. Doing things
5778                      properly would have located the exact same type,
5779                      so there is no error here.  We must remove the
5780                      implicitness so that we do not warn about it.  */
5781                   t = copy_node (t);
5782                   TREE_TYPE (t) = NULL_TREE;
5783                 }
5784
5785               return t;
5786             }
5787         }
5788     }
5789
5790   /* If the CONTEXT is not a template type, then either the field is
5791      there now or its never going to be.  */
5792   if (!uses_template_parms (context))
5793     {
5794       if (complain & tf_error)
5795         error ("no type named `%#T' in `%#T'", name, context);
5796       return error_mark_node;
5797     }
5798
5799
5800   return build_typename_type (context, name, fullname,  NULL_TREE);
5801 }
5802
5803 /* Resolve `CONTEXT::template NAME'.  Returns an appropriate type,
5804    unless an error occurs, in which case error_mark_node is returned.
5805    If we locate a TYPE_DECL, we return that, rather than the _TYPE it
5806    corresponds to.  If COMPLAIN zero, don't complain about any errors
5807    that occur.  */
5808
5809 tree
5810 make_unbound_class_template (context, name, complain)
5811      tree context, name;
5812      int complain;
5813 {
5814   tree t;
5815   tree d;
5816
5817   if (TYPE_P (name))
5818     name = TYPE_IDENTIFIER (name);
5819   else if (DECL_P (name))
5820     name = DECL_NAME (name);
5821   if (TREE_CODE (name) != IDENTIFIER_NODE)
5822     abort ();
5823
5824   if (!uses_template_parms (context)
5825       || currently_open_class (context))
5826     {
5827       tree tmpl = NULL_TREE;
5828
5829       if (IS_AGGR_TYPE (context))
5830         tmpl = lookup_field (context, name, 0, 0);
5831
5832       if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5833         {
5834           if (complain)
5835             error ("no class template named `%#T' in `%#T'", name, context);
5836           return error_mark_node;
5837         }
5838
5839       if (!enforce_access (context, tmpl))
5840         return error_mark_node;
5841
5842       return tmpl;
5843     }
5844
5845   /* Build the UNBOUND_CLASS_TEMPLATE.  */
5846   t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
5847   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5848   TREE_TYPE (t) = NULL_TREE;
5849
5850   /* Build the corresponding TEMPLATE_DECL.  */
5851   d = build_decl (TEMPLATE_DECL, name, t);
5852   TYPE_NAME (TREE_TYPE (d)) = d;
5853   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5854   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5855   DECL_ARTIFICIAL (d) = 1;
5856
5857   return t;
5858 }
5859
5860 /* Select the right _DECL from multiple choices. */
5861
5862 static tree
5863 select_decl (binding, flags)
5864      tree binding;
5865      int flags;
5866 {
5867   tree val;
5868   val = BINDING_VALUE (binding);
5869
5870   if (LOOKUP_NAMESPACES_ONLY (flags))
5871     {
5872       /* We are not interested in types. */
5873       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5874         return val;
5875       return NULL_TREE;
5876     }
5877
5878   /* If we could have a type and
5879      we have nothing or we need a type and have none.  */
5880   if (BINDING_TYPE (binding)
5881       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5882                    && TREE_CODE (val) != TYPE_DECL)))
5883     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5884   /* Don't return non-types if we really prefer types. */
5885   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5886            && (TREE_CODE (val) != TEMPLATE_DECL
5887                || !DECL_CLASS_TEMPLATE_P (val)))
5888     val = NULL_TREE;
5889
5890   return val;
5891 }
5892
5893 /* Unscoped lookup of a global: iterate over current namespaces,
5894    considering using-directives.  If SPACESP is non-NULL, store a list
5895    of the namespaces we've considered in it.  */
5896
5897 tree
5898 unqualified_namespace_lookup (name, flags, spacesp)
5899      tree name;
5900      int flags;
5901      tree *spacesp;
5902 {
5903   tree b = make_node (CPLUS_BINDING);
5904   tree initial = current_decl_namespace ();
5905   tree scope = initial;
5906   tree siter;
5907   struct binding_level *level;
5908   tree val = NULL_TREE;
5909
5910   if (spacesp)
5911     *spacesp = NULL_TREE;
5912
5913   for (; !val; scope = CP_DECL_CONTEXT (scope))
5914     {
5915       if (spacesp)
5916         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5917       val = binding_for_name (name, scope);
5918
5919       /* Ignore anticipated built-in functions.  */
5920       if (val && BINDING_VALUE (val)
5921           && DECL_P (BINDING_VALUE (val))
5922           && DECL_LANG_SPECIFIC (BINDING_VALUE (val))
5923           && DECL_ANTICIPATED (BINDING_VALUE (val)))
5924         {
5925           BINDING_VALUE (b) = NULL_TREE;
5926           BINDING_TYPE (b) = NULL_TREE;
5927         }
5928       else
5929         {
5930           /* Initialize binding for this context. */
5931           BINDING_VALUE (b) = BINDING_VALUE (val);
5932           BINDING_TYPE (b) = BINDING_TYPE (val);
5933         }
5934
5935       /* Add all _DECLs seen through local using-directives. */
5936       for (level = current_binding_level;
5937            !level->namespace_p;
5938            level = level->level_chain)
5939         if (!lookup_using_namespace (name, b, level->using_directives,
5940                                      scope, flags, spacesp))
5941           /* Give up because of error. */
5942           return error_mark_node;
5943
5944       /* Add all _DECLs seen through global using-directives. */
5945       /* XXX local and global using lists should work equally. */
5946       siter = initial;
5947       while (1)
5948         {
5949           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5950                                        scope, flags, spacesp))
5951             /* Give up because of error. */
5952             return error_mark_node;
5953           if (siter == scope) break;
5954           siter = CP_DECL_CONTEXT (siter);
5955         }
5956
5957       val = select_decl (b, flags);
5958       if (scope == global_namespace)
5959         break;
5960     }
5961   return val;
5962 }
5963
5964 /* Combine prefer_type and namespaces_only into flags.  */
5965
5966 static int
5967 lookup_flags (prefer_type, namespaces_only)
5968   int prefer_type, namespaces_only;
5969 {
5970   if (namespaces_only)
5971     return LOOKUP_PREFER_NAMESPACES;
5972   if (prefer_type > 1)
5973     return LOOKUP_PREFER_TYPES;
5974   if (prefer_type > 0)
5975     return LOOKUP_PREFER_BOTH;
5976   return 0;
5977 }
5978
5979 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5980    ignore it or not.  Subroutine of lookup_name_real.  */
5981
5982 static tree
5983 qualify_lookup (val, flags)
5984      tree val;
5985      int flags;
5986 {
5987   if (val == NULL_TREE)
5988     return val;
5989   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5990     return val;
5991   if ((flags & LOOKUP_PREFER_TYPES)
5992       && (TREE_CODE (val) == TYPE_DECL
5993           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5994               && DECL_CLASS_TEMPLATE_P (val))))
5995     return val;
5996   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5997     return NULL_TREE;
5998   return val;
5999 }
6000
6001 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
6002    that.  */
6003
6004 static void
6005 warn_about_implicit_typename_lookup (typename, binding)
6006      tree typename;
6007      tree binding;
6008 {
6009   tree subtype = TREE_TYPE (TREE_TYPE (typename));
6010   tree name = DECL_NAME (typename);
6011
6012   if (! (TREE_CODE (binding) == TEMPLATE_DECL
6013          && CLASSTYPE_TEMPLATE_INFO (subtype)
6014          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
6015       && ! (TREE_CODE (binding) == TYPE_DECL
6016             && same_type_p (TREE_TYPE (binding), subtype)))
6017     {
6018       warning ("lookup of `%D' finds `%#D'",
6019                   name, binding);
6020       warning ("  instead of `%D' from dependent base class",
6021                   typename);
6022       warning ("  (use `typename %T::%D' if that's what you meant)",
6023                   constructor_name (current_class_type), name);
6024     }
6025 }
6026
6027 /* Look up NAME in the current binding level and its superiors in the
6028    namespace of variables, functions and typedefs.  Return a ..._DECL
6029    node of some kind representing its definition if there is only one
6030    such declaration, or return a TREE_LIST with all the overloaded
6031    definitions if there are many, or return 0 if it is undefined.
6032
6033    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
6034    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
6035    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
6036    Otherwise we prefer non-TYPE_DECLs.
6037
6038    If NONCLASS is non-zero, we don't look for the NAME in class scope,
6039    using IDENTIFIER_CLASS_VALUE.  */
6040
6041 static tree
6042 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
6043      tree name;
6044      int prefer_type, nonclass, namespaces_only;
6045 {
6046   tree t;
6047   tree val = NULL_TREE;
6048   int yylex = 0;
6049   tree from_obj = NULL_TREE;
6050   int flags;
6051   int val_is_implicit_typename = 0;
6052
6053   /* Hack: copy flag set by parser, if set. */
6054   if (only_namespace_names)
6055     namespaces_only = 1;
6056
6057   if (prefer_type == -2)
6058     {
6059       extern int looking_for_typename;
6060       tree type = NULL_TREE;
6061
6062       yylex = 1;
6063       prefer_type = looking_for_typename;
6064
6065       flags = lookup_flags (prefer_type, namespaces_only);
6066       /* If the next thing is '<', class templates are types. */
6067       if (looking_for_template)
6068         flags |= LOOKUP_TEMPLATES_EXPECTED;
6069
6070       if (got_scope)
6071         type = got_scope;
6072       else if (got_object != error_mark_node)
6073         type = got_object;
6074
6075       if (type)
6076         {
6077           if (type == error_mark_node)
6078             return error_mark_node;
6079           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
6080             type = TREE_TYPE (type);
6081
6082           if (TYPE_P (type))
6083             type = complete_type (type);
6084
6085           if (TREE_CODE (type) == VOID_TYPE)
6086             type = global_namespace;
6087           if (TREE_CODE (type) == NAMESPACE_DECL)
6088             {
6089               val = make_node (CPLUS_BINDING);
6090               flags |= LOOKUP_COMPLAIN;
6091               if (!qualified_lookup_using_namespace (name, type, val, flags))
6092                 return NULL_TREE;
6093               val = select_decl (val, flags);
6094             }
6095           else if (! IS_AGGR_TYPE (type)
6096                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
6097                    || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
6098                    || TREE_CODE (type) == TYPENAME_TYPE)
6099             /* Someone else will give an error about this if needed.  */
6100             val = NULL_TREE;
6101           else if (type == current_class_type)
6102             val = IDENTIFIER_CLASS_VALUE (name);
6103           else
6104             {
6105               val = lookup_member (type, name, 0, prefer_type);
6106               type_access_control (type, val);
6107
6108               /* Restore the containing TYPENAME_TYPE if we looked
6109                  through it before.  */
6110               if (got_scope && got_scope != type
6111                   && val && TREE_CODE (val) == TYPE_DECL
6112                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
6113                 TYPE_CONTEXT (TREE_TYPE (val)) = got_scope;
6114             }
6115         }
6116       else
6117         val = NULL_TREE;
6118
6119       if (got_scope)
6120         goto done;
6121       else if (got_object && val)
6122         {
6123           from_obj = val;
6124           val = NULL_TREE;
6125         }
6126     }
6127   else
6128     {
6129       flags = lookup_flags (prefer_type, namespaces_only);
6130       /* If we're not parsing, we need to complain. */
6131       flags |= LOOKUP_COMPLAIN;
6132     }
6133
6134   /* First, look in non-namespace scopes.  */
6135
6136   if (current_class_type == NULL_TREE)
6137     nonclass = 1;
6138
6139   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
6140     {
6141       tree binding;
6142
6143       if (!LOCAL_BINDING_P (t) && nonclass)
6144         /* We're not looking for class-scoped bindings, so keep going.  */
6145         continue;
6146
6147       /* If this is the kind of thing we're looking for, we're done.  */
6148       if (qualify_lookup (BINDING_VALUE (t), flags))
6149         binding = BINDING_VALUE (t);
6150       else if ((flags & LOOKUP_PREFER_TYPES)
6151                && qualify_lookup (BINDING_TYPE (t), flags))
6152         binding = BINDING_TYPE (t);
6153       else
6154         binding = NULL_TREE;
6155
6156       /* Handle access control on types from enclosing or base classes.  */
6157       if (binding && ! yylex
6158           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
6159         type_access_control (BINDING_LEVEL (t)->this_class, binding);
6160
6161       if (binding
6162           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
6163         {
6164           if (val_is_implicit_typename && !yylex)
6165             warn_about_implicit_typename_lookup (val, binding);
6166           val = binding;
6167           val_is_implicit_typename
6168             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
6169           if (!val_is_implicit_typename)
6170             break;
6171         }
6172     }
6173
6174   /* Now lookup in namespace scopes.  */
6175   if (!val || val_is_implicit_typename)
6176     {
6177       t = unqualified_namespace_lookup (name, flags, 0);
6178       if (t)
6179         {
6180           if (val_is_implicit_typename && !yylex)
6181             warn_about_implicit_typename_lookup (val, t);
6182           val = t;
6183         }
6184     }
6185
6186  done:
6187   if (val)
6188     {
6189       /* This should only warn about types used in qualified-ids.  */
6190       if (from_obj && from_obj != val)
6191         {
6192           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
6193               && TREE_CODE (val) == TYPE_DECL
6194               && ! same_type_p (TREE_TYPE (from_obj), TREE_TYPE (val)))
6195             pedwarn ("\
6196 lookup of `%D' in the scope of `%#T' (`%#D') \
6197 does not match lookup in the current scope (`%#D')",
6198                         name, got_object, from_obj, val);
6199
6200           /* We don't change val to from_obj if got_object depends on
6201              template parms because that breaks implicit typename for
6202              destructor calls.  */
6203           if (! uses_template_parms (got_object))
6204             val = from_obj;
6205         }
6206
6207       /* If we have a single function from a using decl, pull it out.  */
6208       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6209         val = OVL_FUNCTION (val);
6210     }
6211   else if (from_obj)
6212     val = from_obj;
6213
6214   return val;
6215 }
6216
6217 tree
6218 lookup_name_nonclass (name)
6219      tree name;
6220 {
6221   return lookup_name_real (name, 0, 1, 0);
6222 }
6223
6224 tree
6225 lookup_function_nonclass (name, args)
6226      tree name;
6227      tree args;
6228 {
6229   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6230 }
6231
6232 tree
6233 lookup_name_namespace_only (name)
6234      tree name;
6235 {
6236   /* type-or-namespace, nonclass, namespace_only */
6237   return lookup_name_real (name, 1, 1, 1);
6238 }
6239
6240 tree
6241 lookup_name (name, prefer_type)
6242      tree name;
6243      int prefer_type;
6244 {
6245   return lookup_name_real (name, prefer_type, 0, 0);
6246 }
6247
6248 /* Similar to `lookup_name' but look only in the innermost non-class
6249    binding level.  */
6250
6251 tree
6252 lookup_name_current_level (name)
6253      tree name;
6254 {
6255   struct binding_level *b;
6256   tree t = NULL_TREE;
6257
6258   b = current_binding_level;
6259   while (b->parm_flag == 2)
6260     b = b->level_chain;
6261
6262   if (b->namespace_p)
6263     {
6264       t = IDENTIFIER_NAMESPACE_VALUE (name);
6265
6266       /* extern "C" function() */
6267       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6268         t = TREE_VALUE (t);
6269     }
6270   else if (IDENTIFIER_BINDING (name)
6271            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6272     {
6273       while (1)
6274         {
6275           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6276             return IDENTIFIER_VALUE (name);
6277
6278           if (b->keep == 2)
6279             b = b->level_chain;
6280           else
6281             break;
6282         }
6283     }
6284
6285   return t;
6286 }
6287
6288 /* Like lookup_name_current_level, but for types.  */
6289
6290 tree
6291 lookup_type_current_level (name)
6292      tree name;
6293 {
6294   register tree t = NULL_TREE;
6295
6296   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6297
6298   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6299       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6300     {
6301       struct binding_level *b = current_binding_level;
6302       while (1)
6303         {
6304           if (purpose_member (name, b->type_shadowed))
6305             return REAL_IDENTIFIER_TYPE_VALUE (name);
6306           if (b->keep == 2)
6307             b = b->level_chain;
6308           else
6309             break;
6310         }
6311     }
6312
6313   return t;
6314 }
6315
6316 void
6317 begin_only_namespace_names ()
6318 {
6319   only_namespace_names = 1;
6320 }
6321
6322 void
6323 end_only_namespace_names ()
6324 {
6325   only_namespace_names = 0;
6326 }
6327 \f
6328 /* Push the declarations of builtin types into the namespace.
6329    RID_INDEX is the index of the builtin type
6330    in the array RID_POINTERS.  NAME is the name used when looking
6331    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6332
6333 void
6334 record_builtin_type (rid_index, name, type)
6335      enum rid rid_index;
6336      const char *name;
6337      tree type;
6338 {
6339   tree rname = NULL_TREE, tname = NULL_TREE;
6340   tree tdecl = NULL_TREE;
6341
6342   if ((int) rid_index < (int) RID_MAX)
6343     rname = ridpointers[(int) rid_index];
6344   if (name)
6345     tname = get_identifier (name);
6346
6347   TYPE_BUILT_IN (type) = 1;
6348
6349   if (tname)
6350     {
6351       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6352       set_identifier_type_value (tname, NULL_TREE);
6353       if ((int) rid_index < (int) RID_MAX)
6354         /* Built-in types live in the global namespace. */
6355         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6356     }
6357   if (rname != NULL_TREE)
6358     {
6359       if (tname != NULL_TREE)
6360         {
6361           set_identifier_type_value (rname, NULL_TREE);
6362           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6363         }
6364       else
6365         {
6366           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6367           set_identifier_type_value (rname, NULL_TREE);
6368         }
6369     }
6370 }
6371
6372 /* Record one of the standard Java types.
6373  * Declare it as having the given NAME.
6374  * If SIZE > 0, it is the size of one of the integral types;
6375  * otherwise it is the negative of the size of one of the other types.  */
6376
6377 static tree
6378 record_builtin_java_type (name, size)
6379      const char *name;
6380      int size;
6381 {
6382   tree type, decl;
6383   if (size > 0)
6384     type = make_signed_type (size);
6385   else if (size > -32)
6386     { /* "__java_char" or ""__java_boolean". */
6387       type = make_unsigned_type (-size);
6388       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6389     }
6390   else
6391     { /* "__java_float" or ""__java_double". */
6392       type = make_node (REAL_TYPE);
6393       TYPE_PRECISION (type) = - size;
6394       layout_type (type);
6395     }
6396   record_builtin_type (RID_MAX, name, type);
6397   decl = TYPE_NAME (type);
6398
6399   /* Suppress generate debug symbol entries for these types,
6400      since for normal C++ they are just clutter.
6401      However, push_lang_context undoes this if extern "Java" is seen. */
6402   DECL_IGNORED_P (decl) = 1;
6403
6404   TYPE_FOR_JAVA (type) = 1;
6405   return type;
6406 }
6407
6408 /* Push a type into the namespace so that the back-ends ignore it. */
6409
6410 static void
6411 record_unknown_type (type, name)
6412      tree type;
6413      const char *name;
6414 {
6415   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6416   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6417   DECL_IGNORED_P (decl) = 1;
6418   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6419   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6420   TYPE_ALIGN (type) = 1;
6421   TYPE_USER_ALIGN (type) = 0;
6422   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6423 }
6424
6425 /* An string for which we should create an IDENTIFIER_NODE at
6426    startup.  */
6427
6428 typedef struct predefined_identifier
6429 {
6430   /* The name of the identifier.  */
6431   const char *const name;
6432   /* The place where the IDENTIFIER_NODE should be stored.  */
6433   tree *const node;
6434   /* Non-zero if this is the name of a constructor or destructor.  */
6435   const int ctor_or_dtor_p;
6436 } predefined_identifier;
6437
6438 /* Create all the predefined identifiers.  */
6439
6440 static void
6441 initialize_predefined_identifiers ()
6442 {
6443   const predefined_identifier *pid;
6444
6445   /* A table of identifiers to create at startup.  */
6446   static const predefined_identifier predefined_identifiers[] = {
6447     { "C++", &lang_name_cplusplus, 0 },
6448     { "C", &lang_name_c, 0 },
6449     { "Java", &lang_name_java, 0 },
6450     { CTOR_NAME, &ctor_identifier, 1 },
6451     { "__base_ctor", &base_ctor_identifier, 1 },
6452     { "__comp_ctor", &complete_ctor_identifier, 1 },
6453     { DTOR_NAME, &dtor_identifier, 1 },
6454     { "__comp_dtor", &complete_dtor_identifier, 1 },
6455     { "__base_dtor", &base_dtor_identifier, 1 },
6456     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6457     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6458     { "nelts", &nelts_identifier, 0 },
6459     { THIS_NAME, &this_identifier, 0 },
6460     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6461     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6462     { "_vptr", &vptr_identifier, 0 },
6463     { "__vtt_parm", &vtt_parm_identifier, 0 },
6464     { "std", &std_identifier, 0 },
6465     { NULL, NULL, 0 }
6466   };
6467
6468   for (pid = predefined_identifiers; pid->name; ++pid)
6469     {
6470       *pid->node = get_identifier (pid->name);
6471       if (pid->ctor_or_dtor_p)
6472         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6473     }
6474 }
6475
6476 /* Create the predefined scalar types of C,
6477    and some nodes representing standard constants (0, 1, (void *)0).
6478    Initialize the global binding level.
6479    Make definitions for built-in primitive functions.  */
6480
6481 void
6482 cxx_init_decl_processing ()
6483 {
6484   tree void_ftype;
6485   tree void_ftype_ptr;
6486
6487   /* Create all the identifiers we need.  */
6488   initialize_predefined_identifiers ();
6489
6490   /* Fill in back-end hooks.  */
6491   init_lang_status = &push_cp_function_context;
6492   free_lang_status = &pop_cp_function_context;
6493   mark_lang_status = &mark_cp_function_context;
6494   lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
6495
6496   cp_parse_init ();
6497   init_decl2 ();
6498   init_pt ();
6499
6500   /* Create the global variables.  */
6501   push_to_top_level ();
6502
6503   /* Enter the global namespace. */
6504   my_friendly_assert (global_namespace == NULL_TREE, 375);
6505   push_namespace (get_identifier ("::"));
6506   global_namespace = current_namespace;
6507   current_lang_name = NULL_TREE;
6508
6509   /* Adjust various flags based on command-line settings.  */
6510   if (! flag_permissive && ! pedantic)
6511     flag_pedantic_errors = 1;
6512   if (!flag_no_inline)
6513     {
6514       flag_inline_trees = 1;
6515       flag_no_inline = 1;
6516     }
6517   if (flag_inline_functions)
6518     {
6519       flag_inline_trees = 2;
6520       flag_inline_functions = 0;
6521     }
6522
6523   /* Initially, C.  */
6524   current_lang_name = lang_name_c;
6525
6526   current_function_decl = NULL_TREE;
6527   current_binding_level = NULL_BINDING_LEVEL;
6528   free_binding_level = NULL_BINDING_LEVEL;
6529
6530   build_common_tree_nodes (flag_signed_char);
6531
6532   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6533   TREE_TYPE (error_mark_list) = error_mark_node;
6534
6535   /* Make the binding_level structure for global names.  */
6536   pushlevel (0);
6537   global_binding_level = current_binding_level;
6538   /* The global level is the namespace level of ::.  */
6539   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6540   declare_namespace_level ();
6541
6542   /* Create the `std' namespace.  */
6543   push_namespace (std_identifier);
6544   std_node = current_namespace;
6545   pop_namespace ();
6546
6547   lang_attribute_table = cp_attribute_table;
6548
6549   c_common_nodes_and_builtins ();
6550
6551   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6552   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6553   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6554   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6555   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6556   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6557   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6558   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6559
6560   integer_two_node = build_int_2 (2, 0);
6561   TREE_TYPE (integer_two_node) = integer_type_node;
6562   integer_three_node = build_int_2 (3, 0);
6563   TREE_TYPE (integer_three_node) = integer_type_node;
6564
6565   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6566   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6567   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6568   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6569   TYPE_PRECISION (boolean_type_node) = 1;
6570   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6571   boolean_false_node = build_int_2 (0, 0);
6572   TREE_TYPE (boolean_false_node) = boolean_type_node;
6573   boolean_true_node = build_int_2 (1, 0);
6574   TREE_TYPE (boolean_true_node) = boolean_type_node;
6575
6576   signed_size_zero_node = build_int_2 (0, 0);
6577   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6578
6579   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6580
6581 #if 0
6582   record_builtin_type (RID_MAX, NULL, string_type_node);
6583 #endif
6584
6585   delta_type_node = ptrdiff_type_node;
6586   vtable_index_type = ptrdiff_type_node;
6587
6588   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6589   lang_type_promotes_to = convert_type_from_ellipsis;
6590
6591   void_ftype = build_function_type (void_type_node, void_list_node);
6592   void_ftype_ptr = build_function_type (void_type_node,
6593                                         tree_cons (NULL_TREE,
6594                                                    ptr_type_node,
6595                                                    void_list_node));
6596   void_ftype_ptr
6597     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6598
6599   /* C++ extensions */
6600
6601   unknown_type_node = make_node (UNKNOWN_TYPE);
6602   record_unknown_type (unknown_type_node, "unknown type");
6603
6604   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6605   TREE_TYPE (unknown_type_node) = unknown_type_node;
6606
6607   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6608      result.  */
6609   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6610   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6611
6612   {
6613     /* Make sure we get a unique function type, so we can give
6614        its pointer type a name.  (This wins for gdb.) */
6615     tree vfunc_type = make_node (FUNCTION_TYPE);
6616     TREE_TYPE (vfunc_type) = integer_type_node;
6617     TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6618     layout_type (vfunc_type);
6619
6620     vtable_entry_type = build_pointer_type (vfunc_type);
6621   }
6622   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6623
6624   vtbl_type_node
6625     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6626   layout_type (vtbl_type_node);
6627   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6628   record_builtin_type (RID_MAX, NULL, vtbl_type_node);
6629   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6630   layout_type (vtbl_ptr_type_node);
6631   record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
6632
6633   push_namespace (get_identifier ("__cxxabiv1"));
6634   abi_node = current_namespace;
6635   pop_namespace ();
6636
6637   global_type_node = make_node (LANG_TYPE);
6638   record_unknown_type (global_type_node, "global type");
6639
6640   /* Now, C++.  */
6641   current_lang_name = lang_name_cplusplus;
6642
6643   {
6644     tree bad_alloc_type_node, newtype, deltype;
6645     tree ptr_ftype_sizetype;
6646
6647     push_namespace (std_identifier);
6648     bad_alloc_type_node = xref_tag
6649       (class_type_node, get_identifier ("bad_alloc"), 1);
6650     pop_namespace ();
6651     ptr_ftype_sizetype
6652       = build_function_type (ptr_type_node,
6653                              tree_cons (NULL_TREE,
6654                                         c_size_type_node,
6655                                         void_list_node));
6656     newtype = build_exception_variant
6657       (ptr_ftype_sizetype, add_exception_specifier
6658        (NULL_TREE, bad_alloc_type_node, -1));
6659     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6660     push_cp_library_fn (NEW_EXPR, newtype);
6661     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6662     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6663     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6664   }
6665
6666   abort_fndecl
6667     = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
6668
6669   /* Perform other language dependent initializations.  */
6670   init_class_processing ();
6671   init_init_processing ();
6672   init_search_processing ();
6673   init_rtti_processing ();
6674
6675   if (flag_exceptions)
6676     init_exception_processing ();
6677
6678   if (! supports_one_only ())
6679     flag_weak = 0;
6680
6681   make_fname_decl = cp_make_fname_decl;
6682   start_fname_decls ();
6683
6684   /* Show we use EH for cleanups.  */
6685   using_eh_for_cleanups ();
6686
6687   /* Maintain consistency.  Perhaps we should just complain if they
6688      say -fwritable-strings?  */
6689   if (flag_writable_strings)
6690     flag_const_strings = 0;
6691
6692   /* Add GC roots for all of our global variables.  */
6693   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6694   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6695   ggc_add_tree_root (&integer_three_node, 1);
6696   ggc_add_tree_root (&integer_two_node, 1);
6697   ggc_add_tree_root (&signed_size_zero_node, 1);
6698   ggc_add_tree_root (&size_one_node, 1);
6699   ggc_add_tree_root (&size_zero_node, 1);
6700   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6701                 mark_binding_level);
6702   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6703   ggc_add_tree_root (&static_ctors, 1);
6704   ggc_add_tree_root (&static_dtors, 1);
6705   ggc_add_tree_root (&lastiddecl, 1);
6706
6707   ggc_add_tree_root (&last_function_parms, 1);
6708   ggc_add_tree_root (&error_mark_list, 1);
6709
6710   ggc_add_tree_root (&global_namespace, 1);
6711   ggc_add_tree_root (&global_type_node, 1);
6712   ggc_add_tree_root (&anonymous_namespace_name, 1);
6713
6714   ggc_add_tree_root (&got_object, 1);
6715   ggc_add_tree_root (&got_scope, 1);
6716
6717   ggc_add_tree_root (&current_lang_name, 1);
6718   ggc_add_tree_root (&static_aggregates, 1);
6719   ggc_add_tree_root (&free_bindings, 1);
6720   ggc_add_tree_root (&incomplete_vars, 1);
6721 }
6722
6723 /* Generate an initializer for a function naming variable from
6724    NAME. NAME may be NULL, in which case we generate a special
6725    ERROR_MARK node which should be replaced later. */
6726
6727 tree
6728 cp_fname_init (name)
6729      const char *name;
6730 {
6731   tree domain = NULL_TREE;
6732   tree type;
6733   tree init = NULL_TREE;
6734   size_t length = 0;
6735
6736   if (name)
6737     {
6738       length = strlen (name);
6739       domain = build_index_type (size_int (length));
6740       init = build_string (length + 1, name);
6741     }
6742
6743   type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
6744   type = build_cplus_array_type (type, domain);
6745
6746   if (init)
6747     TREE_TYPE (init) = type;
6748   else
6749     /* We don't know the value until instantiation time. Make
6750        something which will be digested now, but replaced later. */
6751     init = build (ERROR_MARK, type);
6752
6753   return init;
6754 }
6755
6756 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6757    decl, NAME is the initialization string and TYPE_DEP indicates whether
6758    NAME depended on the type of the function. We make use of that to detect
6759    __PRETTY_FUNCTION__ inside a template fn. This is being done
6760    lazily at the point of first use, so we musn't push the decl now.  */
6761
6762 static tree
6763 cp_make_fname_decl (id, type_dep)
6764      tree id;
6765      int type_dep;
6766 {
6767   const char *const name = (type_dep && processing_template_decl
6768                       ? NULL : fname_as_string (type_dep));
6769   tree init = cp_fname_init (name);
6770   tree decl = build_decl (VAR_DECL, id, TREE_TYPE (init));
6771
6772   /* As we don't push the decl here, we must set the context. */
6773   DECL_CONTEXT (decl) = current_function_decl;
6774   DECL_PRETTY_FUNCTION_P (decl) = type_dep;
6775
6776   TREE_STATIC (decl) = 1;
6777   TREE_READONLY (decl) = 1;
6778   DECL_ARTIFICIAL (decl) = 1;
6779   DECL_INITIAL (decl) = init;
6780
6781   TREE_USED (decl) = 1;
6782
6783   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6784
6785   return decl;
6786 }
6787
6788 /* Make a definition for a builtin function named NAME in the current
6789    namespace, whose data type is TYPE and whose context is CONTEXT.
6790    TYPE should be a function type with argument types.
6791
6792    CLASS and CODE tell later passes how to compile calls to this function.
6793    See tree.h for possible values.
6794
6795    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6796    the name to be called if we can't opencode the function.  */
6797
6798 static tree
6799 builtin_function_1 (name, type, context, code, class, libname)
6800      const char *name;
6801      tree type;
6802      tree context;
6803      int code;
6804      enum built_in_class class;
6805      const char *libname;
6806 {
6807   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6808   DECL_BUILT_IN_CLASS (decl) = class;
6809   DECL_FUNCTION_CODE (decl) = code;
6810   DECL_CONTEXT (decl) = context;
6811
6812   /* The return builtins leave the current function.  */
6813   if (code == BUILT_IN_RETURN || code == BUILT_IN_EH_RETURN)
6814     TREE_THIS_VOLATILE (decl) = 1;
6815
6816   pushdecl (decl);
6817
6818   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6819      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6820      function in the namespace.  */
6821   if (libname)
6822     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
6823   make_decl_rtl (decl, NULL);
6824
6825   /* Warn if a function in the namespace for users
6826      is used without an occasion to consider it declared.  */
6827   if (name[0] != '_' || name[1] != '_')
6828     DECL_ANTICIPATED (decl) = 1;
6829
6830   /* Possibly apply some default attributes to this built-in function.  */
6831   decl_attributes (&decl, NULL_TREE, 0);
6832
6833   return decl;
6834 }
6835
6836 /* Entry point for the benefit of c_common_nodes_and_builtins.
6837
6838    Make a defintion for a builtin function named NAME and whose data type
6839    is TYPE.  TYPE should be a function type with argument types.  This
6840    function places the anticipated declaration in the global namespace
6841    and additionally in the std namespace if appropriate.
6842
6843    CLASS and CODE tell later passes how to compile calls to this function.
6844    See tree.h for possible values.
6845
6846    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6847    the name to be called if we can't opencode the function.  */
6848
6849 tree
6850 builtin_function (name, type, code, class, libname)
6851      const char *name;
6852      tree type;
6853      int code;
6854      enum built_in_class class;
6855      const char *libname;
6856 {
6857   /* All builtins that don't begin with an '_' should additionally
6858      go in the 'std' namespace.  */
6859   if (name[0] != '_')
6860     {
6861       push_namespace (std_identifier);
6862       builtin_function_1 (name, type, std_node, code, class, libname);
6863       pop_namespace ();
6864     }
6865
6866   return builtin_function_1 (name, type, NULL_TREE, code, class, libname);
6867 }
6868
6869 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6870    function.  Not called directly.  */
6871
6872 static tree
6873 build_library_fn_1 (name, operator_code, type)
6874      tree name;
6875      enum tree_code operator_code;
6876      tree type;
6877 {
6878   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6879   DECL_EXTERNAL (fn) = 1;
6880   TREE_PUBLIC (fn) = 1;
6881   DECL_ARTIFICIAL (fn) = 1;
6882   TREE_NOTHROW (fn) = 1;
6883   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6884   SET_DECL_LANGUAGE (fn, lang_c);
6885   return fn;
6886 }
6887
6888 /* Returns the _DECL for a library function with C linkage.
6889    We assume that such functions never throw; if this is incorrect,
6890    callers should unset TREE_NOTHROW.  */
6891
6892 tree
6893 build_library_fn (name, type)
6894      tree name;
6895      tree type;
6896 {
6897   return build_library_fn_1 (name, ERROR_MARK, type);
6898 }
6899
6900 /* Returns the _DECL for a library function with C++ linkage.  */
6901
6902 static tree
6903 build_cp_library_fn (name, operator_code, type)
6904      tree name;
6905      enum tree_code operator_code;
6906      tree type;
6907 {
6908   tree fn = build_library_fn_1 (name, operator_code, type);
6909   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6910   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6911   SET_DECL_LANGUAGE (fn, lang_cplusplus);
6912   set_mangled_name_for_decl (fn);
6913   return fn;
6914 }
6915
6916 /* Like build_library_fn, but takes a C string instead of an
6917    IDENTIFIER_NODE.  */
6918
6919 tree
6920 build_library_fn_ptr (name, type)
6921      const char *name;
6922      tree type;
6923 {
6924   return build_library_fn (get_identifier (name), type);
6925 }
6926
6927 /* Like build_cp_library_fn, but takes a C string instead of an
6928    IDENTIFIER_NODE.  */
6929
6930 tree
6931 build_cp_library_fn_ptr (name, type)
6932      const char *name;
6933      tree type;
6934 {
6935   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6936 }
6937
6938 /* Like build_library_fn, but also pushes the function so that we will
6939    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6940
6941 tree
6942 push_library_fn (name, type)
6943      tree name, type;
6944 {
6945   tree fn = build_library_fn (name, type);
6946   pushdecl_top_level (fn);
6947   return fn;
6948 }
6949
6950 /* Like build_cp_library_fn, but also pushes the function so that it
6951    will be found by normal lookup.  */
6952
6953 static tree
6954 push_cp_library_fn (operator_code, type)
6955      enum tree_code operator_code;
6956      tree type;
6957 {
6958   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6959                                  operator_code,
6960                                  type);
6961   pushdecl (fn);
6962   return fn;
6963 }
6964
6965 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6966    a FUNCTION_TYPE.  */
6967
6968 tree
6969 push_void_library_fn (name, parmtypes)
6970      tree name, parmtypes;
6971 {
6972   tree type = build_function_type (void_type_node, parmtypes);
6973   return push_library_fn (name, type);
6974 }
6975
6976 /* Like push_library_fn, but also note that this function throws
6977    and does not return.  Used for __throw_foo and the like.  */
6978
6979 tree
6980 push_throw_library_fn (name, type)
6981      tree name, type;
6982 {
6983   tree fn = push_library_fn (name, type);
6984   TREE_THIS_VOLATILE (fn) = 1;
6985   TREE_NOTHROW (fn) = 0;
6986   return fn;
6987 }
6988
6989 /* Apply default attributes to a function, if a system function with default
6990    attributes.  */
6991
6992 void
6993 insert_default_attributes (decl)
6994      tree decl;
6995 {
6996   if (!DECL_EXTERN_C_FUNCTION_P (decl))
6997     return;
6998   if (!TREE_PUBLIC (decl))
6999     return;
7000   c_common_insert_default_attributes (decl);
7001 }
7002 \f
7003 /* When we call finish_struct for an anonymous union, we create
7004    default copy constructors and such.  But, an anonymous union
7005    shouldn't have such things; this function undoes the damage to the
7006    anonymous union type T.
7007
7008    (The reason that we create the synthesized methods is that we don't
7009    distinguish `union { int i; }' from `typedef union { int i; } U'.
7010    The first is an anonymous union; the second is just an ordinary
7011    union type.)  */
7012
7013 void
7014 fixup_anonymous_aggr (t)
7015      tree t;
7016 {
7017   tree *q;
7018
7019   /* Wipe out memory of synthesized methods */
7020   TYPE_HAS_CONSTRUCTOR (t) = 0;
7021   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
7022   TYPE_HAS_INIT_REF (t) = 0;
7023   TYPE_HAS_CONST_INIT_REF (t) = 0;
7024   TYPE_HAS_ASSIGN_REF (t) = 0;
7025   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
7026
7027   /* Splice the implicitly generated functions out of the TYPE_METHODS
7028      list.  */
7029   q = &TYPE_METHODS (t);
7030   while (*q)
7031     {
7032       if (DECL_ARTIFICIAL (*q))
7033         *q = TREE_CHAIN (*q);
7034       else
7035         q = &TREE_CHAIN (*q);
7036     }
7037
7038   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
7039   if (TYPE_METHODS (t))
7040     cp_error_at ("an anonymous union cannot have function members", t);
7041
7042   /* Anonymous aggregates cannot have fields with ctors, dtors or complex
7043      assignment operators (because they cannot have these methods themselves).
7044      For anonymous unions this is already checked because they are not allowed
7045      in any union, otherwise we have to check it.  */
7046   if (TREE_CODE (t) != UNION_TYPE)
7047     {
7048       tree field, type;
7049
7050       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
7051         if (TREE_CODE (field) == FIELD_DECL)
7052           {
7053             type = TREE_TYPE (field);
7054             if (CLASS_TYPE_P (type))
7055               {
7056                 if (TYPE_NEEDS_CONSTRUCTING (type))
7057                   cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
7058                                field);
7059                 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7060                   cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
7061                                field);
7062                 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
7063                   cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
7064                                field);
7065               }
7066           }
7067     }
7068 }
7069
7070 /* Make sure that a declaration with no declarator is well-formed, i.e.
7071    just defines a tagged type or anonymous union.
7072
7073    Returns the type defined, if any.  */
7074
7075 tree
7076 check_tag_decl (declspecs)
7077      tree declspecs;
7078 {
7079   int found_type = 0;
7080   int saw_friend = 0;
7081   int saw_typedef = 0;
7082   tree ob_modifier = NULL_TREE;
7083   register tree link;
7084   register tree t = NULL_TREE;
7085
7086   for (link = declspecs; link; link = TREE_CHAIN (link))
7087     {
7088       register tree value = TREE_VALUE (link);
7089
7090       if (TYPE_P (value)
7091           || TREE_CODE (value) == TYPE_DECL
7092           || (TREE_CODE (value) == IDENTIFIER_NODE
7093               && IDENTIFIER_GLOBAL_VALUE (value)
7094               && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value)) == TYPE_DECL))
7095         {
7096           ++found_type;
7097
7098           if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
7099             {
7100               if (! in_system_header)
7101                 pedwarn ("redeclaration of C++ built-in type `%T'", value);
7102               return NULL_TREE;
7103             }
7104
7105           if (TYPE_P (value)
7106               && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
7107                   || TREE_CODE (value) == ENUMERAL_TYPE))
7108             {
7109               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
7110               t = value;
7111             }
7112         }
7113       else if (value == ridpointers[(int) RID_TYPEDEF])
7114         saw_typedef = 1;
7115       else if (value == ridpointers[(int) RID_FRIEND])
7116         {
7117           if (current_class_type == NULL_TREE
7118               || current_scope () != current_class_type)
7119             ob_modifier = value;
7120           else
7121             saw_friend = 1;
7122         }
7123       else if (value == ridpointers[(int) RID_STATIC]
7124                || value == ridpointers[(int) RID_EXTERN]
7125                || value == ridpointers[(int) RID_AUTO]
7126                || value == ridpointers[(int) RID_REGISTER]
7127                || value == ridpointers[(int) RID_INLINE]
7128                || value == ridpointers[(int) RID_VIRTUAL]
7129                || value == ridpointers[(int) RID_CONST]
7130                || value == ridpointers[(int) RID_VOLATILE]
7131                || value == ridpointers[(int) RID_EXPLICIT])
7132         ob_modifier = value;
7133     }
7134
7135   if (found_type > 1)
7136     error ("multiple types in one declaration");
7137
7138   if (t == NULL_TREE && ! saw_friend)
7139     pedwarn ("declaration does not declare anything");
7140
7141   /* Check for an anonymous union.  */
7142   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7143            && TYPE_ANONYMOUS_P (t))
7144     {
7145       /* 7/3 In a simple-declaration, the optional init-declarator-list
7146          can be omitted only when declaring a class (clause 9) or
7147          enumeration (7.2), that is, when the decl-specifier-seq contains
7148          either a class-specifier, an elaborated-type-specifier with
7149          a class-key (9.1), or an enum-specifier.  In these cases and
7150          whenever a class-specifier or enum-specifier is present in the
7151          decl-specifier-seq, the identifiers in these specifiers are among
7152          the names being declared by the declaration (as class-name,
7153          enum-names, or enumerators, depending on the syntax).  In such
7154          cases, and except for the declaration of an unnamed bit-field (9.6),
7155          the decl-specifier-seq shall introduce one or more names into the
7156          program, or shall redeclare a name introduced by a previous
7157          declaration.  [Example:
7158              enum { };            // ill-formed
7159              typedef class { };   // ill-formed
7160          --end example]  */
7161       if (saw_typedef)
7162         {
7163           error ("missing type-name in typedef-declaration");
7164           return NULL_TREE;
7165         }
7166       /* Anonymous unions are objects, so they can have specifiers.  */;
7167       SET_ANON_AGGR_TYPE_P (t);
7168
7169       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7170         pedwarn ("ISO C++ prohibits anonymous structs");
7171     }
7172
7173   else if (ob_modifier)
7174     {
7175       if (ob_modifier == ridpointers[(int) RID_INLINE]
7176           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7177         error ("`%D' can only be specified for functions", ob_modifier);
7178       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7179         error ("`%D' can only be specified inside a class", ob_modifier);
7180       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7181         error ("`%D' can only be specified for constructors",
7182                   ob_modifier);
7183       else
7184         error ("`%D' can only be specified for objects and functions",
7185                   ob_modifier);
7186     }
7187
7188   return t;
7189 }
7190
7191 /* Called when a declaration is seen that contains no names to declare.
7192    If its type is a reference to a structure, union or enum inherited
7193    from a containing scope, shadow that tag name for the current scope
7194    with a forward reference.
7195    If its type defines a new named structure or union
7196    or defines an enum, it is valid but we need not do anything here.
7197    Otherwise, it is an error.
7198
7199    C++: may have to grok the declspecs to learn about static,
7200    complain for anonymous unions.  */
7201
7202 void
7203 shadow_tag (declspecs)
7204      tree declspecs;
7205 {
7206   tree t = check_tag_decl (declspecs);
7207
7208   if (t)
7209     maybe_process_partial_specialization (t);
7210
7211   /* This is where the variables in an anonymous union are
7212      declared.  An anonymous union declaration looks like:
7213      union { ... } ;
7214      because there is no declarator after the union, the parser
7215      sends that declaration here.  */
7216   if (t && ANON_AGGR_TYPE_P (t))
7217     {
7218       fixup_anonymous_aggr (t);
7219
7220       if (TYPE_FIELDS (t))
7221         {
7222           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7223                                       NULL);
7224           finish_anon_union (decl);
7225         }
7226     }
7227 }
7228 \f
7229 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7230
7231 tree
7232 groktypename (typename)
7233      tree typename;
7234 {
7235   tree specs, attrs;
7236   tree type;
7237   if (TREE_CODE (typename) != TREE_LIST)
7238     return typename;
7239   split_specs_attrs (TREE_PURPOSE (typename), &specs, &attrs);
7240   type = grokdeclarator (TREE_VALUE (typename), specs,
7241                          TYPENAME, 0, &attrs);
7242   if (attrs)
7243     cplus_decl_attributes (&type, attrs, 0);
7244   return type;
7245 }
7246
7247 /* Decode a declarator in an ordinary declaration or data definition.
7248    This is called as soon as the type information and variable name
7249    have been parsed, before parsing the initializer if any.
7250    Here we create the ..._DECL node, fill in its type,
7251    and put it on the list of decls for the current context.
7252    The ..._DECL node is returned as the value.
7253
7254    Exception: for arrays where the length is not specified,
7255    the type is left null, to be filled in by `cp_finish_decl'.
7256
7257    Function definitions do not come here; they go to start_function
7258    instead.  However, external and forward declarations of functions
7259    do go through here.  Structure field declarations are done by
7260    grokfield and not through here.  */
7261
7262 tree
7263 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7264      tree declarator, declspecs;
7265      int initialized;
7266      tree attributes, prefix_attributes;
7267 {
7268   tree decl;
7269   register tree type, tem;
7270   tree context;
7271   extern int have_extern_spec;
7272   extern int used_extern_spec;
7273
7274 #if 0
7275   /* See code below that used this.  */
7276   int init_written = initialized;
7277 #endif
7278
7279   /* This should only be done once on the top most decl.  */
7280   if (have_extern_spec && !used_extern_spec)
7281     {
7282       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7283                              declspecs);
7284       used_extern_spec = 1;
7285     }
7286
7287   /* An object declared as __attribute__((deprecated)) suppresses
7288      warnings of uses of other deprecated items.  */
7289   if (lookup_attribute ("deprecated", attributes))
7290     deprecated_state = DEPRECATED_SUPPRESS;
7291
7292   attributes = chainon (attributes, prefix_attributes);
7293
7294   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7295                          &attributes);
7296
7297   deprecated_state = DEPRECATED_NORMAL;
7298
7299   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7300     return NULL_TREE;
7301
7302   type = TREE_TYPE (decl);
7303
7304   if (type == error_mark_node)
7305     return NULL_TREE;
7306
7307   context = DECL_CONTEXT (decl);
7308
7309   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7310       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7311     {
7312       /* When parsing the initializer, lookup should use the object's
7313          namespace. */
7314       push_decl_namespace (context);
7315     }
7316
7317   /* We are only interested in class contexts, later. */
7318   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7319     context = NULL_TREE;
7320
7321   if (initialized)
7322     /* Is it valid for this decl to have an initializer at all?
7323        If not, set INITIALIZED to zero, which will indirectly
7324        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7325     switch (TREE_CODE (decl))
7326       {
7327       case TYPE_DECL:
7328         /* typedef foo = bar  means give foo the same type as bar.
7329            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7330            Any other case of an initialization in a TYPE_DECL is an error.  */
7331         if (pedantic || list_length (declspecs) > 1)
7332           {
7333             error ("typedef `%D' is initialized", decl);
7334             initialized = 0;
7335           }
7336         break;
7337
7338       case FUNCTION_DECL:
7339         error ("function `%#D' is initialized like a variable", decl);
7340         initialized = 0;
7341         break;
7342
7343       default:
7344         break;
7345       }
7346
7347   if (initialized)
7348     {
7349       if (! toplevel_bindings_p ()
7350           && DECL_EXTERNAL (decl))
7351         warning ("declaration of `%#D' has `extern' and is initialized",
7352                     decl);
7353       DECL_EXTERNAL (decl) = 0;
7354       if (toplevel_bindings_p ())
7355         TREE_STATIC (decl) = 1;
7356
7357       /* Tell `pushdecl' this is an initialized decl
7358          even though we don't yet have the initializer expression.
7359          Also tell `cp_finish_decl' it may store the real initializer.  */
7360       DECL_INITIAL (decl) = error_mark_node;
7361     }
7362
7363   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7364   cplus_decl_attributes (&decl, attributes, 0);
7365
7366   /* If #pragma weak was used, mark the decl weak now.  */
7367   if (current_binding_level == global_binding_level)
7368     maybe_apply_pragma_weak (decl);
7369
7370   if (TREE_CODE (decl) == FUNCTION_DECL
7371       && DECL_DECLARED_INLINE_P (decl)
7372       && DECL_UNINLINABLE (decl)
7373       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
7374     warning_with_decl (decl,
7375                        "inline function `%s' given attribute noinline");
7376
7377   if (context && COMPLETE_TYPE_P (complete_type (context)))
7378     {
7379       push_nested_class (context, 2);
7380
7381       if (TREE_CODE (decl) == VAR_DECL)
7382         {
7383           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7384           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7385             error ("`%#D' is not a static member of `%#T'", decl, context);
7386           else
7387             {
7388               if (DECL_CONTEXT (field) != context)
7389                 {
7390                   pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7391                               DECL_CONTEXT (field), DECL_NAME (decl),
7392                               context, DECL_NAME (decl));
7393                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7394                 }
7395               /* Static data member are tricky; an in-class initialization
7396                  still doesn't provide a definition, so the in-class
7397                  declaration will have DECL_EXTERNAL set, but will have an
7398                  initialization.  Thus, duplicate_decls won't warn
7399                  about this situation, and so we check here.  */
7400               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7401                 error ("duplicate initialization of %D", decl);
7402               if (duplicate_decls (decl, field))
7403                 decl = field;
7404             }
7405         }
7406       else
7407         {
7408           tree field = check_classfn (context, decl);
7409           if (field && duplicate_decls (decl, field))
7410             decl = field;
7411         }
7412
7413       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7414       DECL_IN_AGGR_P (decl) = 0;
7415       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7416           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7417         {
7418           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7419           /* [temp.expl.spec] An explicit specialization of a static data
7420              member of a template is a definition if the declaration
7421              includes an initializer; otherwise, it is a declaration.
7422
7423              We check for processing_specialization so this only applies
7424              to the new specialization syntax.  */
7425           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7426             DECL_EXTERNAL (decl) = 1;
7427         }
7428
7429       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7430         pedwarn ("declaration of `%#D' outside of class is not definition",
7431                     decl);
7432     }
7433
7434   /* Enter this declaration into the symbol table.  */
7435   tem = maybe_push_decl (decl);
7436
7437   if (processing_template_decl)
7438     tem = push_template_decl (tem);
7439
7440 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7441   /* Tell the back-end to use or not use .common as appropriate.  If we say
7442      -fconserve-space, we want this to save .data space, at the expense of
7443      wrong semantics.  If we say -fno-conserve-space, we want this to
7444      produce errors about redefs; to do this we force variables into the
7445      data segment.  */
7446   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7447 #endif
7448
7449   if (! processing_template_decl)
7450     start_decl_1 (tem);
7451
7452   return tem;
7453 }
7454
7455 void
7456 start_decl_1 (decl)
7457      tree decl;
7458 {
7459   tree type = TREE_TYPE (decl);
7460   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7461
7462   if (type == error_mark_node)
7463     return;
7464
7465   maybe_push_cleanup_level (type);
7466
7467   if (initialized)
7468     /* Is it valid for this decl to have an initializer at all?
7469        If not, set INITIALIZED to zero, which will indirectly
7470        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7471     {
7472       /* Don't allow initializations for incomplete types except for
7473          arrays which might be completed by the initialization.  */
7474       if (COMPLETE_TYPE_P (complete_type (type)))
7475         ;                       /* A complete type is ok.  */
7476       else if (TREE_CODE (type) != ARRAY_TYPE)
7477         {
7478           error ("variable `%#D' has initializer but incomplete type",
7479                     decl);
7480           initialized = 0;
7481           type = TREE_TYPE (decl) = error_mark_node;
7482         }
7483       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7484         {
7485           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7486             error ("elements of array `%#D' have incomplete type", decl);
7487           /* else we already gave an error in start_decl.  */
7488           initialized = 0;
7489         }
7490     }
7491
7492   if (!initialized
7493       && TREE_CODE (decl) != TYPE_DECL
7494       && TREE_CODE (decl) != TEMPLATE_DECL
7495       && type != error_mark_node
7496       && IS_AGGR_TYPE (type)
7497       && ! DECL_EXTERNAL (decl))
7498     {
7499       if ((! processing_template_decl || ! uses_template_parms (type))
7500           && !COMPLETE_TYPE_P (complete_type (type)))
7501         {
7502           error ("aggregate `%#D' has incomplete type and cannot be defined",
7503                  decl);
7504           /* Change the type so that assemble_variable will give
7505              DECL an rtl we can live with: (mem (const_int 0)).  */
7506           type = TREE_TYPE (decl) = error_mark_node;
7507         }
7508       else
7509         {
7510           /* If any base type in the hierarchy of TYPE needs a constructor,
7511              then we set initialized to 1.  This way any nodes which are
7512              created for the purposes of initializing this aggregate
7513              will live as long as it does.  This is necessary for global
7514              aggregates which do not have their initializers processed until
7515              the end of the file.  */
7516           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7517         }
7518     }
7519
7520   if (! initialized)
7521     DECL_INITIAL (decl) = NULL_TREE;
7522 }
7523
7524 /* Handle initialization of references.
7525    These three arguments are from `cp_finish_decl', and have the
7526    same meaning here that they do there.
7527
7528    Quotes on semantics can be found in ARM 8.4.3.  */
7529
7530 static tree
7531 grok_reference_init (decl, type, init)
7532      tree decl, type, init;
7533 {
7534   tree tmp;
7535
7536   if (init == NULL_TREE)
7537     {
7538       if ((DECL_LANG_SPECIFIC (decl) == 0
7539            || DECL_IN_AGGR_P (decl) == 0)
7540           && ! DECL_THIS_EXTERN (decl))
7541         error ("`%D' declared as reference but not initialized", decl);
7542       return NULL_TREE;
7543     }
7544
7545   if (init == error_mark_node)
7546     return NULL_TREE;
7547
7548   if (TREE_CODE (init) == CONSTRUCTOR)
7549     {
7550       error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7551       return NULL_TREE;
7552     }
7553
7554   if (TREE_CODE (init) == TREE_LIST)
7555     init = build_compound_expr (init);
7556
7557   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7558     init = convert_from_reference (init);
7559
7560   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7561       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7562     {
7563       /* Note: default conversion is only called in very special cases.  */
7564       init = default_conversion (init);
7565     }
7566
7567   /* Convert INIT to the reference type TYPE.  This may involve the
7568      creation of a temporary, whose lifetime must be the same as that
7569      of the reference.  If so, a DECL_STMT for the temporary will be
7570      added just after the DECL_STMT for DECL.  That's why we don't set
7571      DECL_INITIAL for local references (instead assigning to them
7572      explicitly); we need to allow the temporary to be initialized
7573      first.  */
7574   tmp = convert_to_reference
7575     (type, init, CONV_IMPLICIT,
7576      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7577      decl);
7578
7579   if (tmp == error_mark_node)
7580     return NULL_TREE;
7581   else if (tmp == NULL_TREE)
7582     {
7583       error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7584       return NULL_TREE;
7585     }
7586
7587   if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
7588     return tmp;
7589
7590   DECL_INITIAL (decl) = tmp;
7591
7592   return NULL_TREE;
7593 }
7594
7595 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7596    mucking with forces it does not comprehend (i.e. initialization with a
7597    constructor).  If we are at global scope and won't go into COMMON, fill
7598    it in with a dummy CONSTRUCTOR to force the variable into .data;
7599    otherwise we can use error_mark_node.  */
7600
7601 static tree
7602 obscure_complex_init (decl, init)
7603      tree decl, init;
7604 {
7605   if (! flag_no_inline && TREE_STATIC (decl))
7606     {
7607       if (extract_init (decl, init))
7608         return NULL_TREE;
7609     }
7610
7611 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7612   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7613     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7614                                  NULL_TREE);
7615   else
7616 #endif
7617     DECL_INITIAL (decl) = error_mark_node;
7618
7619   return init;
7620 }
7621
7622 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7623    array until we finish parsing the initializer.  If that's the
7624    situation we're in, update DECL accordingly.  */
7625
7626 static void
7627 maybe_deduce_size_from_array_init (decl, init)
7628      tree decl;
7629      tree init;
7630 {
7631   tree type = TREE_TYPE (decl);
7632
7633   if (TREE_CODE (type) == ARRAY_TYPE
7634       && TYPE_DOMAIN (type) == NULL_TREE
7635       && TREE_CODE (decl) != TYPE_DECL)
7636     {
7637       /* do_default is really a C-ism to deal with tentative definitions.
7638          But let's leave it here to ease the eventual merge.  */
7639       int do_default = !DECL_EXTERNAL (decl);
7640       tree initializer = init ? init : DECL_INITIAL (decl);
7641       int failure = complete_array_type (type, initializer, do_default);
7642
7643       if (failure == 1)
7644         error ("initializer fails to determine size of `%D'", decl);
7645
7646       if (failure == 2)
7647         {
7648           if (do_default)
7649             error ("array size missing in `%D'", decl);
7650           /* If a `static' var's size isn't known, make it extern as
7651              well as static, so it does not get allocated.  If it's not
7652              `static', then don't mark it extern; finish_incomplete_decl
7653              will give it a default size and it will get allocated.  */
7654           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7655             DECL_EXTERNAL (decl) = 1;
7656         }
7657
7658       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7659           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7660                               integer_zero_node))
7661         error ("zero-size array `%D'", decl);
7662
7663       layout_decl (decl, 0);
7664     }
7665 }
7666
7667 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7668    any appropriate error messages regarding the layout.  */
7669
7670 static void
7671 layout_var_decl (decl)
7672      tree decl;
7673 {
7674   tree type = TREE_TYPE (decl);
7675 #if 0
7676   tree ttype = target_type (type);
7677 #endif
7678
7679   /* If we haven't already layed out this declaration, do so now.
7680      Note that we must not call complete type for an external object
7681      because it's type might involve templates that we are not
7682      supposed to isntantiate yet.  (And it's perfectly legal to say
7683      `extern X x' for some incomplete type `X'.)  */
7684   if (!DECL_EXTERNAL (decl))
7685     complete_type (type);
7686   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7687     layout_decl (decl, 0);
7688
7689   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7690     {
7691       /* An automatic variable with an incomplete type: that is an error.
7692          Don't talk about array types here, since we took care of that
7693          message in grokdeclarator.  */
7694       error ("storage size of `%D' isn't known", decl);
7695       TREE_TYPE (decl) = error_mark_node;
7696     }
7697 #if 0
7698   /* Keep this code around in case we later want to control debug info
7699      based on whether a type is "used".  (jason 1999-11-11) */
7700
7701   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7702     /* Let debugger know it should output info for this type.  */
7703     note_debug_info_needed (ttype);
7704
7705   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7706     note_debug_info_needed (DECL_CONTEXT (decl));
7707 #endif
7708
7709   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7710       && DECL_SIZE (decl) != NULL_TREE
7711       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7712     {
7713       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7714         constant_expression_warning (DECL_SIZE (decl));
7715       else
7716         error ("storage size of `%D' isn't constant", decl);
7717     }
7718
7719   if (TREE_STATIC (decl)
7720       && !DECL_ARTIFICIAL (decl)
7721       && current_function_decl
7722       && DECL_CONTEXT (decl) == current_function_decl)
7723     push_local_name (decl);
7724 }
7725
7726 /* If a local static variable is declared in an inline function, or if
7727    we have a weak definition, we must endeavor to create only one
7728    instance of the variable at link-time.  */
7729
7730 static void
7731 maybe_commonize_var (decl)
7732      tree decl;
7733 {
7734   /* Static data in a function with comdat linkage also has comdat
7735      linkage.  */
7736   if (TREE_STATIC (decl)
7737       /* Don't mess with __FUNCTION__.  */
7738       && ! DECL_ARTIFICIAL (decl)
7739       && current_function_decl
7740       && DECL_CONTEXT (decl) == current_function_decl
7741       && (DECL_DECLARED_INLINE_P (current_function_decl)
7742           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7743       && TREE_PUBLIC (current_function_decl))
7744     {
7745       /* If flag_weak, we don't need to mess with this, as we can just
7746          make the function weak, and let it refer to its unique local
7747          copy.  This works because we don't allow the function to be
7748          inlined.  */
7749       if (! flag_weak)
7750         {
7751           if (DECL_INTERFACE_KNOWN (current_function_decl))
7752             {
7753               TREE_PUBLIC (decl) = 1;
7754               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7755             }
7756           else if (DECL_INITIAL (decl) == NULL_TREE
7757                    || DECL_INITIAL (decl) == error_mark_node)
7758             {
7759               TREE_PUBLIC (decl) = 1;
7760               DECL_COMMON (decl) = 1;
7761             }
7762           /* else we lose. We can only do this if we can use common,
7763              which we can't if it has been initialized.  */
7764
7765           if (!TREE_PUBLIC (decl))
7766             {
7767               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7768               cp_warning_at ("  you can work around this by removing the initializer", decl);
7769             }
7770         }
7771       else
7772         comdat_linkage (decl);
7773     }
7774   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7775     /* Set it up again; we might have set DECL_INITIAL since the last
7776        time.  */
7777     comdat_linkage (decl);
7778 }
7779
7780 /* Issue an error message if DECL is an uninitialized const variable.  */
7781
7782 static void
7783 check_for_uninitialized_const_var (decl)
7784      tree decl;
7785 {
7786   tree type = TREE_TYPE (decl);
7787
7788   /* ``Unless explicitly declared extern, a const object does not have
7789      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7790      7.1.6 */
7791   if (TREE_CODE (decl) == VAR_DECL
7792       && TREE_CODE (type) != REFERENCE_TYPE
7793       && CP_TYPE_CONST_P (type)
7794       && !TYPE_NEEDS_CONSTRUCTING (type)
7795       && !DECL_INITIAL (decl))
7796     error ("uninitialized const `%D'", decl);
7797 }
7798
7799 /* Verify INIT (the initializer for DECL), and record the
7800    initialization in DECL_INITIAL, if appropriate.  Returns a new
7801    value for INIT.  */
7802
7803 static tree
7804 check_initializer (decl, init)
7805      tree decl;
7806      tree init;
7807 {
7808   tree type;
7809
7810   if (TREE_CODE (decl) == FIELD_DECL)
7811     return init;
7812
7813   type = TREE_TYPE (decl);
7814
7815   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7816   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7817     init = NULL_TREE;
7818
7819   /* Check the initializer.  */
7820   if (init)
7821     {
7822       /* Things that are going to be initialized need to have complete
7823          type.  */
7824       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7825
7826       if (type == error_mark_node)
7827         /* We will have already complained.  */
7828         init = NULL_TREE;
7829       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7830         {
7831           error ("variable-sized object `%D' may not be initialized", decl);
7832           init = NULL_TREE;
7833         }
7834       else if (TREE_CODE (type) == ARRAY_TYPE
7835                && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7836         {
7837           error ("elements of array `%#D' have incomplete type", decl);
7838           init = NULL_TREE;
7839         }
7840       else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
7841         {
7842           error ("`%D' has incomplete type", decl);
7843           TREE_TYPE (decl) = error_mark_node;
7844           init = NULL_TREE;
7845         }
7846     }
7847
7848   if (TREE_CODE (decl) == CONST_DECL)
7849     {
7850       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7851
7852       DECL_INITIAL (decl) = init;
7853
7854       my_friendly_assert (init != NULL_TREE, 149);
7855       init = NULL_TREE;
7856     }
7857   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7858     {
7859       init = grok_reference_init (decl, type, init);
7860       if (init)
7861         init = obscure_complex_init (decl, init);
7862     }
7863   else if (init)
7864     {
7865       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7866         {
7867           if (TREE_CODE (type) == ARRAY_TYPE)
7868             init = digest_init (type, init, (tree *) 0);
7869           else if (TREE_CODE (init) == CONSTRUCTOR
7870                    && TREE_HAS_CONSTRUCTOR (init))
7871             {
7872               if (TYPE_NON_AGGREGATE_CLASS (type))
7873                 {
7874                   error ("`%D' must be initialized by constructor, not by `{...}'",
7875                             decl);
7876                   init = error_mark_node;
7877                 }
7878               else
7879                 goto dont_use_constructor;
7880             }
7881         }
7882       else
7883         {
7884         dont_use_constructor:
7885           if (TREE_CODE (init) != TREE_VEC)
7886             init = store_init_value (decl, init);
7887         }
7888
7889       if (init)
7890         /* We must hide the initializer so that expand_decl
7891            won't try to do something it does not understand.  */
7892         init = obscure_complex_init (decl, init);
7893     }
7894   else if (DECL_EXTERNAL (decl))
7895     ;
7896   else if (TYPE_P (type)
7897            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7898     {
7899       tree core_type = strip_array_types (type);
7900
7901       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7902         {
7903           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7904             error ("structure `%D' with uninitialized const members", decl);
7905           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7906             error ("structure `%D' with uninitialized reference members",
7907                       decl);
7908         }
7909
7910       check_for_uninitialized_const_var (decl);
7911
7912       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7913         init = obscure_complex_init (decl, NULL_TREE);
7914
7915     }
7916   else
7917     check_for_uninitialized_const_var (decl);
7918
7919   return init;
7920 }
7921
7922 /* If DECL is not a local variable, give it RTL.  */
7923
7924 static void
7925 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7926      tree decl;
7927      tree init;
7928      const char *asmspec;
7929 {
7930   int toplev = toplevel_bindings_p ();
7931   int defer_p;
7932
7933   /* Handle non-variables up front.  */
7934   if (TREE_CODE (decl) != VAR_DECL)
7935     {
7936       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7937       return;
7938     }
7939
7940   /* If we see a class member here, it should be a static data
7941      member.  */
7942   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7943     {
7944       my_friendly_assert (TREE_STATIC (decl), 19990828);
7945       /* An in-class declaration of a static data member should be
7946          external; it is only a declaration, and not a definition.  */
7947       if (init == NULL_TREE)
7948         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7949     }
7950
7951   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7952   if (asmspec)
7953     {
7954       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
7955       /* The `register' keyword, when used together with an
7956          asm-specification, indicates that the variable should be
7957          placed in a particular register.  */
7958       if (DECL_REGISTER (decl))
7959         DECL_C_HARD_REGISTER (decl) = 1;
7960     }
7961
7962   /* We don't create any RTL for local variables.  */
7963   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7964     return;
7965
7966   /* We defer emission of local statics until the corresponding
7967      DECL_STMT is expanded.  */
7968   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7969
7970   /* We try to defer namespace-scope static constants so that they are
7971      not emitted into the object file unnecessarily.  */
7972   if (!DECL_VIRTUAL_P (decl)
7973       && TREE_READONLY (decl)
7974       && DECL_INITIAL (decl) != NULL_TREE
7975       && DECL_INITIAL (decl) != error_mark_node
7976       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7977       && toplev
7978       && !TREE_PUBLIC (decl))
7979     {
7980       /* Fool with the linkage of static consts according to #pragma
7981          interface.  */
7982       if (!interface_unknown && !TREE_PUBLIC (decl))
7983         {
7984           TREE_PUBLIC (decl) = 1;
7985           DECL_EXTERNAL (decl) = interface_only;
7986         }
7987
7988       defer_p = 1;
7989     }
7990   /* Likewise for template instantiations.  */
7991   else if (DECL_COMDAT (decl))
7992     defer_p = 1;
7993
7994   /* If we're deferring the variable, we only need to make RTL if
7995      there's an ASMSPEC.  Otherwise, we'll lazily create it later when
7996      we need it.  (There's no way to lazily create RTL for things that
7997      have assembly specs because the information about the specifier
7998      isn't stored in the tree, yet)  */
7999   if (defer_p && asmspec)
8000     make_decl_rtl (decl, asmspec);
8001   /* If we're not deferring, go ahead and assemble the variable.  */
8002   else if (!defer_p)
8003     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
8004 }
8005
8006 /* The old ARM scoping rules injected variables declared in the
8007    initialization statement of a for-statement into the surrounding
8008    scope.  We support this usage, in order to be backward-compatible.
8009    DECL is a just-declared VAR_DECL; if necessary inject its
8010    declaration into the surrounding scope.  */
8011
8012 void
8013 maybe_inject_for_scope_var (decl)
8014      tree decl;
8015 {
8016   if (!DECL_NAME (decl))
8017     return;
8018
8019   if (current_binding_level->is_for_scope)
8020     {
8021       struct binding_level *outer
8022         = current_binding_level->level_chain;
8023
8024       /* Check to see if the same name is already bound at the outer
8025          level, either because it was directly declared, or because a
8026          dead for-decl got preserved.  In either case, the code would
8027          not have been valid under the ARM scope rules, so clear
8028          is_for_scope for the current_binding_level.
8029
8030          Otherwise, we need to preserve the temp slot for decl to last
8031          into the outer binding level.  */
8032
8033       tree outer_binding
8034         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
8035
8036       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
8037           && (TREE_CODE (BINDING_VALUE (outer_binding))
8038               == VAR_DECL)
8039           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
8040         {
8041           BINDING_VALUE (outer_binding)
8042             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
8043           current_binding_level->is_for_scope = 0;
8044         }
8045       else if (DECL_IN_MEMORY_P (decl))
8046         preserve_temp_slots (DECL_RTL (decl));
8047     }
8048 }
8049
8050 /* Generate code to initialize DECL (a local variable).  */
8051
8052 void
8053 initialize_local_var (decl, init, flags)
8054      tree decl;
8055      tree init;
8056      int flags;
8057 {
8058   tree type = TREE_TYPE (decl);
8059
8060   /* If the type is bogus, don't bother initializing the variable.  */
8061   if (type == error_mark_node)
8062     return;
8063
8064   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
8065     {
8066       /* If we used it already as memory, it must stay in memory.  */
8067       DECL_INITIAL (decl) = NULL_TREE;
8068       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
8069     }
8070
8071   /* Local statics are handled differently from ordinary automatic
8072      variables.  */
8073   if (TREE_STATIC (decl))
8074     {
8075       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8076           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8077         expand_static_init (decl, init);
8078       return;
8079     }
8080
8081   if (DECL_SIZE (decl) && type != error_mark_node)
8082     {
8083       int already_used;
8084
8085       /* Compute and store the initial value.  */
8086       already_used = TREE_USED (decl) || TREE_USED (type);
8087
8088       if (init || TYPE_NEEDS_CONSTRUCTING (type))
8089         {
8090           int saved_stmts_are_full_exprs_p;
8091
8092           my_friendly_assert (building_stmt_tree (), 20000906);
8093           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
8094           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
8095           finish_expr_stmt (build_aggr_init (decl, init, flags));
8096           current_stmt_tree ()->stmts_are_full_exprs_p =
8097             saved_stmts_are_full_exprs_p;
8098         }
8099
8100       /* Set this to 0 so we can tell whether an aggregate which was
8101          initialized was ever used.  Don't do this if it has a
8102          destructor, so we don't complain about the 'resource
8103          allocation is initialization' idiom.  Now set
8104          attribute((unused)) on types so decls of that type will be
8105          marked used. (see TREE_USED, above.)  */
8106       if (TYPE_NEEDS_CONSTRUCTING (type)
8107           && ! already_used
8108           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
8109           && DECL_NAME (decl))
8110         TREE_USED (decl) = 0;
8111       else if (already_used)
8112         TREE_USED (decl) = 1;
8113     }
8114 }
8115
8116 /* Generate code to destroy DECL (a local variable).  */
8117
8118 static void
8119 destroy_local_var (decl)
8120      tree decl;
8121 {
8122   tree type = TREE_TYPE (decl);
8123   tree cleanup;
8124
8125   /* Only variables get cleaned up.  */
8126   if (TREE_CODE (decl) != VAR_DECL)
8127     return;
8128
8129   /* And only things with destructors need cleaning up.  */
8130   if (type == error_mark_node
8131       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
8132     return;
8133
8134   if (TREE_CODE (decl) == VAR_DECL &&
8135       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
8136     /* We don't clean up things that aren't defined in this
8137        translation unit, or that need a static cleanup.  The latter
8138        are handled by finish_file.  */
8139     return;
8140
8141   /* Compute the cleanup.  */
8142   cleanup = maybe_build_cleanup (decl);
8143
8144   /* Record the cleanup required for this declaration.  */
8145   if (DECL_SIZE (decl) && cleanup)
8146     finish_decl_cleanup (decl, cleanup);
8147 }
8148
8149 /* Finish processing of a declaration;
8150    install its line number and initial value.
8151    If the length of an array type is not known before,
8152    it must be determined now, from the initial value, or it is an error.
8153
8154    INIT holds the value of an initializer that should be allowed to escape
8155    the normal rules.
8156
8157    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8158    if the (init) syntax was used.  */
8159
8160 void
8161 cp_finish_decl (decl, init, asmspec_tree, flags)
8162      tree decl, init;
8163      tree asmspec_tree;
8164      int flags;
8165 {
8166   register tree type;
8167   tree ttype = NULL_TREE;
8168   const char *asmspec = NULL;
8169   int was_readonly = 0;
8170
8171   if (! decl)
8172     {
8173       if (init)
8174         error ("assignment (not initialization) in declaration");
8175       return;
8176     }
8177
8178   /* If a name was specified, get the string.  */
8179   if (current_binding_level == global_binding_level)
8180     asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
8181   if (asmspec_tree)
8182     asmspec = TREE_STRING_POINTER (asmspec_tree);
8183
8184   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8185     {
8186       error ("cannot initialize `%D' to namespace `%D'",
8187                 decl, init);
8188       init = NULL_TREE;
8189     }
8190
8191   if (current_class_type
8192       && CP_DECL_CONTEXT (decl) == current_class_type
8193       && TYPE_BEING_DEFINED (current_class_type)
8194       && (DECL_INITIAL (decl) || init))
8195     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
8196
8197   if (TREE_CODE (decl) == VAR_DECL
8198       && DECL_CONTEXT (decl)
8199       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8200       && DECL_CONTEXT (decl) != current_namespace
8201       && init)
8202     {
8203       /* Leave the namespace of the object. */
8204       pop_decl_namespace ();
8205     }
8206
8207   type = TREE_TYPE (decl);
8208
8209   if (type == error_mark_node)
8210     return;
8211
8212   if (TYPE_HAS_MUTABLE_P (type))
8213     TREE_READONLY (decl) = 0;
8214
8215   if (processing_template_decl)
8216     {
8217       /* Add this declaration to the statement-tree.  */
8218       if (at_function_scope_p ()
8219           && TREE_CODE (decl) != RESULT_DECL)
8220         add_decl_stmt (decl);
8221
8222       if (init && DECL_INITIAL (decl))
8223         DECL_INITIAL (decl) = init;
8224       goto finish_end0;
8225     }
8226
8227   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8228   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8229
8230   /* Take care of TYPE_DECLs up front.  */
8231   if (TREE_CODE (decl) == TYPE_DECL)
8232     {
8233       if (init && DECL_INITIAL (decl))
8234         {
8235           /* typedef foo = bar; store the type of bar as the type of foo.  */
8236           TREE_TYPE (decl) = type = TREE_TYPE (init);
8237           DECL_INITIAL (decl) = init = NULL_TREE;
8238         }
8239       if (type != error_mark_node
8240           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8241         {
8242           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8243             warning ("shadowing previous type declaration of `%#D'", decl);
8244           set_identifier_type_value (DECL_NAME (decl), type);
8245           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8246         }
8247
8248       /* If we have installed this as the canonical typedef for this
8249          type, and that type has not been defined yet, delay emitting
8250          the debug information for it, as we will emit it later.  */
8251       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8252           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8253         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8254
8255       rest_of_decl_compilation (decl, NULL,
8256                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8257       goto finish_end;
8258     }
8259
8260   if (TREE_CODE (decl) != FUNCTION_DECL)
8261     ttype = target_type (type);
8262
8263   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8264       && TYPE_NEEDS_CONSTRUCTING (type))
8265     {
8266       /* Currently, GNU C++ puts constants in text space, making them
8267          impossible to initialize.  In the future, one would hope for
8268          an operating system which understood the difference between
8269          initialization and the running of a program.  */
8270       was_readonly = 1;
8271       TREE_READONLY (decl) = 0;
8272     }
8273
8274   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8275     {
8276       /* This must override the asm specifier which was placed by
8277          grokclassfn.  Lay this out fresh.  */
8278       SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
8279       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8280       make_decl_rtl (decl, asmspec);
8281     }
8282
8283   /* Deduce size of array from initialization, if not already known.  */
8284   init = check_initializer (decl, init);
8285   maybe_deduce_size_from_array_init (decl, init);
8286
8287   /* Add this declaration to the statement-tree.  This needs to happen
8288      after the call to check_initializer so that the DECL_STMT for a
8289      reference temp is added before the DECL_STMT for the reference itself.  */
8290   if (building_stmt_tree ()
8291       && at_function_scope_p ()
8292       && TREE_CODE (decl) != RESULT_DECL)
8293     add_decl_stmt (decl);
8294
8295   if (TREE_CODE (decl) == VAR_DECL)
8296     layout_var_decl (decl);
8297
8298   /* Output the assembler code and/or RTL code for variables and functions,
8299      unless the type is an undefined structure or union.
8300      If not, it will get done when the type is completed.  */
8301   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8302       || TREE_CODE (decl) == RESULT_DECL)
8303     {
8304       if (TREE_CODE (decl) == VAR_DECL)
8305         maybe_commonize_var (decl);
8306
8307       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8308
8309       if (TREE_CODE (type) == FUNCTION_TYPE
8310           || TREE_CODE (type) == METHOD_TYPE)
8311         abstract_virtuals_error (decl,
8312                                  strip_array_types (TREE_TYPE (type)));
8313       else
8314         abstract_virtuals_error (decl, strip_array_types (type));
8315
8316       if (TREE_CODE (decl) == FUNCTION_DECL)
8317         ;
8318       else if (DECL_EXTERNAL (decl)
8319                && ! (DECL_LANG_SPECIFIC (decl)
8320                      && DECL_NOT_REALLY_EXTERN (decl)))
8321         {
8322           if (init)
8323             DECL_INITIAL (decl) = init;
8324         }
8325       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8326         {
8327           /* This is a local declaration.  */
8328           if (doing_semantic_analysis_p ())
8329             maybe_inject_for_scope_var (decl);
8330           /* Initialize the local variable.  But, if we're building a
8331              statement-tree, we'll do the initialization when we
8332              expand the tree.  */
8333           if (processing_template_decl)
8334             {
8335               if (init || DECL_INITIAL (decl) == error_mark_node)
8336                 DECL_INITIAL (decl) = init;
8337             }
8338           else
8339             {
8340               /* If we're not building RTL, then we need to do so
8341                  now.  */
8342               my_friendly_assert (building_stmt_tree (), 20000906);
8343               /* Initialize the variable.  */
8344               initialize_local_var (decl, init, flags);
8345               /* Clean up the variable.  */
8346               destroy_local_var (decl);
8347             }
8348         }
8349       else if (TREE_STATIC (decl) && type != error_mark_node)
8350         {
8351           /* Cleanups for static variables are handled by `finish_file'.  */
8352           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8353               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8354             expand_static_init (decl, init);
8355         }
8356     finish_end0:
8357
8358       /* Undo call to `pushclass' that was done in `start_decl'
8359          due to initialization of qualified member variable.
8360          I.e., Foo::x = 10;  */
8361       {
8362         tree context = CP_DECL_CONTEXT (decl);
8363         if (context
8364             && TYPE_P (context)
8365             && (TREE_CODE (decl) == VAR_DECL
8366                 /* We also have a pushclass done that we need to undo here
8367                    if we're at top level and declare a method.  */
8368                 || TREE_CODE (decl) == FUNCTION_DECL)
8369             /* If size hasn't been set, we're still defining it,
8370                and therefore inside the class body; don't pop
8371                the binding level..  */
8372             && COMPLETE_TYPE_P (context)
8373             && context == current_class_type)
8374           pop_nested_class ();
8375       }
8376     }
8377
8378  finish_end:
8379
8380   if (was_readonly)
8381     TREE_READONLY (decl) = 1;
8382 }
8383
8384 /* This is here for a midend callback from c-common.c */
8385
8386 void
8387 finish_decl (decl, init, asmspec_tree)
8388      tree decl, init;
8389      tree asmspec_tree;
8390 {
8391   cp_finish_decl (decl, init, asmspec_tree, 0);
8392 }
8393
8394 /* Returns a declaration for a VAR_DECL as if:
8395
8396      extern "C" TYPE NAME;
8397
8398    had been seen.  Used to create compiler-generated global
8399    variables.  */
8400
8401 tree
8402 declare_global_var (name, type)
8403      tree name;
8404      tree type;
8405 {
8406   tree decl;
8407
8408   push_to_top_level ();
8409   decl = build_decl (VAR_DECL, name, type);
8410   TREE_PUBLIC (decl) = 1;
8411   DECL_EXTERNAL (decl) = 1;
8412   DECL_ARTIFICIAL (decl) = 1;
8413   pushdecl (decl);
8414   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8415   pop_from_top_level ();
8416
8417   return decl;
8418 }
8419
8420 /* Returns a pointer to the `atexit' function.  Note that if
8421    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8422    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8423
8424 static tree
8425 get_atexit_node ()
8426 {
8427   tree atexit_fndecl;
8428   tree arg_types;
8429   tree fn_type;
8430   tree fn_ptr_type;
8431   const char *name;
8432
8433   if (atexit_node)
8434     return atexit_node;
8435
8436   if (flag_use_cxa_atexit)
8437     {
8438       /* The declaration for `__cxa_atexit' is:
8439
8440            int __cxa_atexit (void (*)(void *), void *, void *)
8441
8442          We build up the argument types and then then function type
8443          itself.  */
8444
8445       /* First, build the pointer-to-function type for the first
8446          argument.  */
8447       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8448       fn_type = build_function_type (void_type_node, arg_types);
8449       fn_ptr_type = build_pointer_type (fn_type);
8450       /* Then, build the rest of the argument types.  */
8451       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8452       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8453       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8454       /* And the final __cxa_atexit type.  */
8455       fn_type = build_function_type (integer_type_node, arg_types);
8456       fn_ptr_type = build_pointer_type (fn_type);
8457       name = "__cxa_atexit";
8458     }
8459   else
8460     {
8461       /* The declaration for `atexit' is:
8462
8463            int atexit (void (*)());
8464
8465          We build up the argument types and then then function type
8466          itself.  */
8467       fn_type = build_function_type (void_type_node, void_list_node);
8468       fn_ptr_type = build_pointer_type (fn_type);
8469       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8470       /* Build the final atexit type.  */
8471       fn_type = build_function_type (integer_type_node, arg_types);
8472       name = "atexit";
8473     }
8474
8475   /* Now, build the function declaration.  */
8476   push_lang_context (lang_name_c);
8477   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8478   mark_used (atexit_fndecl);
8479   pop_lang_context ();
8480   atexit_node = default_conversion (atexit_fndecl);
8481
8482   return atexit_node;
8483 }
8484
8485 /* Returns the __dso_handle VAR_DECL.  */
8486
8487 static tree
8488 get_dso_handle_node ()
8489 {
8490   if (dso_handle_node)
8491     return dso_handle_node;
8492
8493   /* Declare the variable.  */
8494   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8495                                         ptr_type_node);
8496
8497   return dso_handle_node;
8498 }
8499
8500 /* Begin a new function with internal linkage whose job will be simply
8501    to destroy some particular variable.  */
8502
8503 static tree
8504 start_cleanup_fn ()
8505 {
8506   static int counter = 0;
8507   int old_interface_unknown = interface_unknown;
8508   char name[32];
8509   tree parmtypes;
8510   tree fntype;
8511   tree fndecl;
8512
8513   push_to_top_level ();
8514
8515   /* No need to mangle this.  */
8516   push_lang_context (lang_name_c);
8517
8518   interface_unknown = 1;
8519
8520   /* Build the parameter-types.  */
8521   parmtypes = void_list_node;
8522   /* Functions passed to __cxa_atexit take an additional parameter.
8523      We'll just ignore it.  After we implement the new calling
8524      convention for destructors, we can eliminate the use of
8525      additional cleanup functions entirely in the -fnew-abi case.  */
8526   if (flag_use_cxa_atexit)
8527     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8528   /* Build the function type itself.  */
8529   fntype = build_function_type (void_type_node, parmtypes);
8530   /* Build the name of the function.  */
8531   sprintf (name, "__tcf_%d", counter++);
8532   /* Build the function declaration.  */
8533   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8534   /* It's a function with internal linkage, generated by the
8535      compiler.  */
8536   TREE_PUBLIC (fndecl) = 0;
8537   DECL_ARTIFICIAL (fndecl) = 1;
8538   /* Make the function `inline' so that it is only emitted if it is
8539      actually needed.  It is unlikely that it will be inlined, since
8540      it is only called via a function pointer, but we avoid unnecessary
8541      emissions this way.  */
8542   DECL_INLINE (fndecl) = 1;
8543   /* Build the parameter.  */
8544   if (flag_use_cxa_atexit)
8545     {
8546       tree parmdecl;
8547
8548       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8549       DECL_CONTEXT (parmdecl) = fndecl;
8550       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8551       TREE_USED (parmdecl) = 1;
8552       DECL_ARGUMENTS (fndecl) = parmdecl;
8553     }
8554
8555   pushdecl (fndecl);
8556   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8557
8558   interface_unknown = old_interface_unknown;
8559
8560   pop_lang_context ();
8561
8562   return current_function_decl;
8563 }
8564
8565 /* Finish the cleanup function begun by start_cleanup_fn.  */
8566
8567 static void
8568 end_cleanup_fn ()
8569 {
8570   expand_body (finish_function (0));
8571
8572   pop_from_top_level ();
8573 }
8574
8575 /* Generate code to handle the destruction of DECL, an object with
8576    static storage duration.  */
8577
8578 void
8579 register_dtor_fn (decl)
8580      tree decl;
8581 {
8582   tree cleanup;
8583   tree compound_stmt;
8584   tree args;
8585   tree fcall;
8586
8587   int saved_flag_access_control;
8588
8589   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8590     return;
8591
8592   /* Call build_cleanup before we enter the anonymous function so that
8593      any access checks will be done relative to the current scope,
8594      rather than the scope of the anonymous function.  */
8595   build_cleanup (decl);
8596
8597   /* Now start the function.  */
8598   cleanup = start_cleanup_fn ();
8599
8600   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8601      to the original function, rather than the anonymous one.  That
8602      will make the back-end think that nested functions are in use,
8603      which causes confusion.  */
8604   saved_flag_access_control = flag_access_control;
8605   flag_access_control = 0;
8606   fcall = build_cleanup (decl);
8607   flag_access_control = saved_flag_access_control;
8608
8609   /* Create the body of the anonymous function.  */
8610   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8611   finish_expr_stmt (fcall);
8612   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8613   end_cleanup_fn ();
8614
8615   /* Call atexit with the cleanup function.  */
8616   mark_addressable (cleanup);
8617   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8618   if (flag_use_cxa_atexit)
8619     {
8620       args = tree_cons (NULL_TREE,
8621                         build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
8622                         NULL_TREE);
8623       args = tree_cons (NULL_TREE, null_pointer_node, args);
8624       args = tree_cons (NULL_TREE, cleanup, args);
8625     }
8626   else
8627     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8628   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8629 }
8630
8631 void
8632 expand_static_init (decl, init)
8633      tree decl;
8634      tree init;
8635 {
8636   tree oldstatic = value_member (decl, static_aggregates);
8637
8638   if (oldstatic)
8639     {
8640       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8641         error ("multiple initializations given for `%D'", decl);
8642     }
8643   else if (! toplevel_bindings_p ())
8644     {
8645       /* Emit code to perform this initialization but once.  */
8646       tree if_stmt;
8647       tree then_clause;
8648       tree assignment;
8649       tree guard;
8650       tree guard_init;
8651
8652       /* Emit code to perform this initialization but once.  This code
8653          looks like:
8654
8655            static int guard = 0;
8656            if (!guard) {
8657              // Do initialization.
8658              guard = 1;
8659              // Register variable for destruction at end of program.
8660            }
8661
8662          Note that the `temp' variable is only set to 1 *after* the
8663          initialization is complete.  This ensures that an exception,
8664          thrown during the construction, will cause the variable to
8665          reinitialized when we pass through this code again, as per:
8666
8667            [stmt.dcl]
8668
8669            If the initialization exits by throwing an exception, the
8670            initialization is not complete, so it will be tried again
8671            the next time control enters the declaration.
8672
8673          In theory, this process should be thread-safe, too; multiple
8674          threads should not be able to initialize the variable more
8675          than once.  We don't yet attempt to ensure thread-safety.  */
8676
8677       /* Create the guard variable.  */
8678       guard = get_guard (decl);
8679
8680       /* Begin the conditional initialization.  */
8681       if_stmt = begin_if_stmt ();
8682       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8683       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8684
8685       /* Do the initialization itself.  */
8686       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8687           || (init && TREE_CODE (init) == TREE_LIST))
8688         assignment = build_aggr_init (decl, init, 0);
8689       else if (init)
8690         /* The initialization we're doing here is just a bitwise
8691            copy.  */
8692         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8693       else
8694         assignment = NULL_TREE;
8695
8696       /* Once the assignment is complete, set TEMP to 1.  Since the
8697          construction of the static object is complete at this point,
8698          we want to make sure TEMP is set to 1 even if a temporary
8699          constructed during the initialization throws an exception
8700          when it is destroyed.  So, we combine the initialization and
8701          the assignment to TEMP into a single expression, ensuring
8702          that when we call finish_expr_stmt the cleanups will not be
8703          run until after TEMP is set to 1.  */
8704       guard_init = set_guard (guard);
8705       if (assignment)
8706         {
8707           assignment = tree_cons (NULL_TREE, assignment,
8708                                   build_tree_list (NULL_TREE,
8709                                                    guard_init));
8710           assignment = build_compound_expr (assignment);
8711         }
8712       else
8713         assignment = guard_init;
8714       finish_expr_stmt (assignment);
8715
8716       /* Use atexit to register a function for destroying this static
8717          variable.  */
8718       register_dtor_fn (decl);
8719
8720       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8721       finish_then_clause (if_stmt);
8722       finish_if_stmt ();
8723     }
8724   else
8725     static_aggregates = tree_cons (init, decl, static_aggregates);
8726 }
8727
8728 /* Finish the declaration of a catch-parameter.  */
8729
8730 tree
8731 start_handler_parms (declspecs, declarator)
8732      tree declspecs;
8733      tree declarator;
8734 {
8735   tree decl;
8736   if (declspecs)
8737     {
8738       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8739                              1, NULL);
8740       if (decl == NULL_TREE)
8741         error ("invalid catch parameter");
8742     }
8743   else
8744     decl = NULL_TREE;
8745
8746   return decl;
8747 }
8748
8749 \f
8750 /* Make TYPE a complete type based on INITIAL_VALUE.
8751    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8752    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8753
8754 int
8755 complete_array_type (type, initial_value, do_default)
8756      tree type, initial_value;
8757      int do_default;
8758 {
8759   register tree maxindex = NULL_TREE;
8760   int value = 0;
8761
8762   if (initial_value)
8763     {
8764       /* An array of character type can be initialized from a
8765          brace-enclosed string constant.  */
8766       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8767           && TREE_CODE (initial_value) == CONSTRUCTOR
8768           && CONSTRUCTOR_ELTS (initial_value)
8769           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8770               == STRING_CST)
8771           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8772         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8773
8774       /* Note MAXINDEX is really the maximum index, one less than the
8775          size.  */
8776       if (TREE_CODE (initial_value) == STRING_CST)
8777         {
8778           int eltsize
8779             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8780           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8781                                    / eltsize) - 1, 0);
8782         }
8783       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8784         {
8785           tree elts = CONSTRUCTOR_ELTS (initial_value);
8786
8787           maxindex = ssize_int (-1);
8788           for (; elts; elts = TREE_CHAIN (elts))
8789             {
8790               if (TREE_PURPOSE (elts))
8791                 maxindex = TREE_PURPOSE (elts);
8792               else
8793                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8794             }
8795           maxindex = copy_node (maxindex);
8796         }
8797       else
8798         {
8799           /* Make an error message unless that happened already.  */
8800           if (initial_value != error_mark_node)
8801             value = 1;
8802           else
8803             initial_value = NULL_TREE;
8804
8805           /* Prevent further error messages.  */
8806           maxindex = build_int_2 (0, 0);
8807         }
8808     }
8809
8810   if (!maxindex)
8811     {
8812       if (do_default)
8813         maxindex = build_int_2 (0, 0);
8814       value = 2;
8815     }
8816
8817   if (maxindex)
8818     {
8819       tree itype;
8820       tree domain;
8821
8822       domain = build_index_type (maxindex);
8823       TYPE_DOMAIN (type) = domain;
8824
8825       if (! TREE_TYPE (maxindex))
8826         TREE_TYPE (maxindex) = domain;
8827       if (initial_value)
8828         itype = TREE_TYPE (initial_value);
8829       else
8830         itype = NULL;
8831       if (itype && !TYPE_DOMAIN (itype))
8832         TYPE_DOMAIN (itype) = domain;
8833       /* The type of the main variant should never be used for arrays
8834          of different sizes.  It should only ever be completed with the
8835          size of the array.  */
8836       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8837         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8838     }
8839
8840   /* Lay out the type now that we can get the real answer.  */
8841
8842   layout_type (type);
8843
8844   return value;
8845 }
8846 \f
8847 /* Return zero if something is declared to be a member of type
8848    CTYPE when in the context of CUR_TYPE.  STRING is the error
8849    message to print in that case.  Otherwise, quietly return 1.  */
8850
8851 static int
8852 member_function_or_else (ctype, cur_type, flags)
8853      tree ctype, cur_type;
8854      enum overload_flags flags;
8855 {
8856   if (ctype && ctype != cur_type)
8857     {
8858       if (flags == DTOR_FLAG)
8859         error ("destructor for alien class `%T' cannot be a member",
8860                   ctype);
8861       else
8862         error ("constructor for alien class `%T' cannot be a member",
8863                   ctype);
8864       return 0;
8865     }
8866   return 1;
8867 }
8868 \f
8869 /* Subroutine of `grokdeclarator'.  */
8870
8871 /* Generate errors possibly applicable for a given set of specifiers.
8872    This is for ARM $7.1.2.  */
8873
8874 static void
8875 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8876      tree object;
8877      const char *type;
8878      int virtualp, quals, friendp, raises, inlinep;
8879 {
8880   if (virtualp)
8881     error ("`%D' declared as a `virtual' %s", object, type);
8882   if (inlinep)
8883     error ("`%D' declared as an `inline' %s", object, type);
8884   if (quals)
8885     error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8886               object, type);
8887   if (friendp)
8888     cp_error_at ("`%D' declared as a friend", object);
8889   if (raises
8890       && (TREE_CODE (object) == TYPE_DECL
8891           || (!TYPE_PTRFN_P (TREE_TYPE (object))
8892               && !TYPE_REFFN_P (TREE_TYPE (object))
8893               && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
8894     cp_error_at ("`%D' declared with an exception specification", object);
8895 }
8896
8897 /* CTYPE is class type, or null if non-class.
8898    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8899    or METHOD_TYPE.
8900    DECLARATOR is the function's name.
8901    VIRTUALP is truthvalue of whether the function is virtual or not.
8902    FLAGS are to be passed through to `grokclassfn'.
8903    QUALS are qualifiers indicating whether the function is `const'
8904    or `volatile'.
8905    RAISES is a list of exceptions that this function can raise.
8906    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8907    not look, and -1 if we should not call `grokclassfn' at all.
8908
8909    Returns `NULL_TREE' if something goes wrong, after issuing
8910    applicable error messages.  */
8911
8912 static tree
8913 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8914             raises, check, friendp, publicp, inlinep, funcdef_flag,
8915             template_count, in_namespace)
8916      tree ctype, type;
8917      tree declarator;
8918      tree orig_declarator;
8919      int virtualp;
8920      enum overload_flags flags;
8921      tree quals, raises;
8922      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8923      tree in_namespace;
8924 {
8925   tree decl;
8926   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8927   int has_default_arg = 0;
8928   tree t;
8929
8930   if (raises)
8931     type = build_exception_variant (type, raises);
8932
8933   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8934   /* Propagate volatile out from type to decl. */
8935   if (TYPE_VOLATILE (type))
8936     TREE_THIS_VOLATILE (decl) = 1;
8937
8938   /* If this decl has namespace scope, set that up.  */
8939   if (in_namespace)
8940     set_decl_namespace (decl, in_namespace, friendp);
8941   else if (!ctype)
8942     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8943
8944   /* `main' and builtins have implicit 'C' linkage.  */
8945   if ((MAIN_NAME_P (declarator)
8946        || (IDENTIFIER_LENGTH (declarator) > 10
8947            && IDENTIFIER_POINTER (declarator)[0] == '_'
8948            && IDENTIFIER_POINTER (declarator)[1] == '_'
8949            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8950       && current_lang_name == lang_name_cplusplus
8951       && ctype == NULL_TREE
8952       /* NULL_TREE means global namespace.  */
8953       && DECL_CONTEXT (decl) == NULL_TREE)
8954     SET_DECL_LANGUAGE (decl, lang_c);
8955
8956   /* Should probably propagate const out from type to decl I bet (mrs).  */
8957   if (staticp)
8958     {
8959       DECL_STATIC_FUNCTION_P (decl) = 1;
8960       DECL_CONTEXT (decl) = ctype;
8961     }
8962
8963   if (ctype)
8964     DECL_CONTEXT (decl) = ctype;
8965
8966   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8967     {
8968       if (processing_template_decl)
8969         error ("cannot declare `::main' to be a template");
8970       if (inlinep)
8971         error ("cannot declare `::main' to be inline");
8972       if (!publicp)
8973         error ("cannot declare `::main' to be static");
8974       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8975                         integer_type_node))
8976         error ("`main' must return `int'");
8977       inlinep = 0;
8978       publicp = 1;
8979     }
8980
8981   /* Members of anonymous types and local classes have no linkage; make
8982      them internal.  */
8983   /* FIXME what if it gets a name from typedef?  */
8984   if (ctype && (TYPE_ANONYMOUS_P (ctype)
8985                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8986     publicp = 0;
8987
8988   if (publicp)
8989     {
8990       /* [basic.link]: A name with no linkage (notably, the name of a class
8991          or enumeration declared in a local scope) shall not be used to
8992          declare an entity with linkage.
8993
8994          Only check this for public decls for now.  */
8995       t = no_linkage_check (TREE_TYPE (decl));
8996       if (t)
8997         {
8998           if (TYPE_ANONYMOUS_P (t))
8999             {
9000               if (DECL_EXTERN_C_P (decl))
9001                 /* Allow this; it's pretty common in C.  */;
9002               else
9003                 {
9004                   pedwarn ("non-local function `%#D' uses anonymous type",
9005                               decl);
9006                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
9007                     cp_pedwarn_at ("\
9008 `%#D' does not refer to the unqualified type, so it is not used for linkage",
9009                                 TYPE_NAME (t));
9010                 }
9011             }
9012           else
9013             pedwarn ("non-local function `%#D' uses local type `%T'",
9014                         decl, t);
9015         }
9016     }
9017
9018   TREE_PUBLIC (decl) = publicp;
9019   if (! publicp)
9020     {
9021       DECL_INTERFACE_KNOWN (decl) = 1;
9022       DECL_NOT_REALLY_EXTERN (decl) = 1;
9023     }
9024
9025   /* If the declaration was declared inline, mark it as such.  */
9026   if (inlinep)
9027     DECL_DECLARED_INLINE_P (decl) = 1;
9028   /* We inline functions that are explicitly declared inline, or, when
9029      the user explicitly asks us to, all functions.  */
9030   if (DECL_DECLARED_INLINE_P (decl) || flag_inline_trees == 2)
9031     DECL_INLINE (decl) = 1;
9032
9033   DECL_EXTERNAL (decl) = 1;
9034   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
9035     {
9036       error ("%smember function `%D' cannot have `%T' method qualifier",
9037                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
9038       quals = NULL_TREE;
9039     }
9040
9041   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
9042     grok_op_properties (decl, friendp);
9043
9044   if (ctype && decl_function_context (decl))
9045     DECL_NO_STATIC_CHAIN (decl) = 1;
9046
9047   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
9048     if (TREE_PURPOSE (t)
9049         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
9050       {
9051         has_default_arg = 1;
9052         break;
9053       }
9054
9055   if (friendp
9056       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
9057     {
9058       if (funcdef_flag)
9059         error
9060           ("defining explicit specialization `%D' in friend declaration",
9061            orig_declarator);
9062       else
9063         {
9064           tree fns = TREE_OPERAND (orig_declarator, 0);
9065           tree args = TREE_OPERAND (orig_declarator, 1);
9066
9067           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
9068             {
9069               /* Something like `template <class T> friend void f<T>()'.  */
9070               error ("invalid use of template-id `%D' in declaration of primary template",
9071                         orig_declarator);
9072               return NULL_TREE;
9073             }
9074
9075
9076           /* A friend declaration of the form friend void f<>().  Record
9077              the information in the TEMPLATE_ID_EXPR.  */
9078           SET_DECL_IMPLICIT_INSTANTIATION (decl);
9079
9080           if (TREE_CODE (fns) == COMPONENT_REF)
9081             {
9082               /* Due to bison parser ickiness, we will have already looked
9083                  up an operator_name or PFUNCNAME within the current class
9084                  (see template_id in parse.y). If the current class contains
9085                  such a name, we'll get a COMPONENT_REF here. Undo that. */
9086
9087               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
9088                                   == current_class_type, 20001120);
9089               fns = TREE_OPERAND (fns, 1);
9090             }
9091           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
9092                               || TREE_CODE (fns) == LOOKUP_EXPR
9093                               || TREE_CODE (fns) == OVERLOAD, 20001120);
9094           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
9095
9096           if (has_default_arg)
9097             {
9098               error ("default arguments are not allowed in declaration of friend template specialization `%D'",
9099                         decl);
9100               return NULL_TREE;
9101             }
9102
9103           if (inlinep)
9104             {
9105               error ("`inline' is not allowed in declaration of friend template specialization `%D'",
9106                         decl);
9107               return NULL_TREE;
9108             }
9109         }
9110     }
9111
9112   if (has_default_arg)
9113     add_defarg_fn (decl);
9114
9115   if (funcdef_flag)
9116     /* Make the init_value nonzero so pushdecl knows this is not
9117        tentative.  error_mark_node is replaced later with the BLOCK.  */
9118     DECL_INITIAL (decl) = error_mark_node;
9119
9120   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
9121     TREE_NOTHROW (decl) = 1;
9122
9123   /* Caller will do the rest of this.  */
9124   if (check < 0)
9125     return decl;
9126
9127   if (flags == NO_SPECIAL && ctype && constructor_name (ctype) == declarator)
9128     DECL_CONSTRUCTOR_P (decl) = 1;
9129
9130   /* Function gets the ugly name, field gets the nice one.  This call
9131      may change the type of the function (because of default
9132      parameters)!  */
9133   if (ctype != NULL_TREE)
9134     grokclassfn (ctype, decl, flags, quals);
9135
9136   decl = check_explicit_specialization (orig_declarator, decl,
9137                                         template_count,
9138                                         2 * (funcdef_flag != 0) +
9139                                         4 * (friendp != 0));
9140   if (decl == error_mark_node)
9141     return NULL_TREE;
9142
9143   if (ctype != NULL_TREE
9144       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9145       && check)
9146     {
9147       tree old_decl;
9148
9149       old_decl = check_classfn (ctype, decl);
9150
9151       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9152         /* Because grokfndecl is always supposed to return a
9153            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9154            here.  We depend on our callers to figure out that its
9155            really a template that's being returned.  */
9156         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9157
9158       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9159           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9160         {
9161           /* Remove the `this' parm added by grokclassfn.
9162              XXX Isn't this done in start_function, too?  */
9163           revert_static_member_fn (decl);
9164           last_function_parms = TREE_CHAIN (last_function_parms);
9165         }
9166       if (old_decl && DECL_ARTIFICIAL (old_decl))
9167         error ("definition of implicitly-declared `%D'", old_decl);
9168
9169       if (old_decl)
9170         {
9171           /* Since we've smashed OLD_DECL to its
9172              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9173           if (TREE_CODE (decl) == TEMPLATE_DECL)
9174             decl = DECL_TEMPLATE_RESULT (decl);
9175
9176           /* Attempt to merge the declarations.  This can fail, in
9177              the case of some illegal specialization declarations.  */
9178           if (!duplicate_decls (decl, old_decl))
9179             error ("no `%#D' member function declared in class `%T'",
9180                       decl, ctype);
9181           return old_decl;
9182         }
9183     }
9184
9185   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9186     return NULL_TREE;
9187
9188   if (ctype == NULL_TREE || check)
9189     return decl;
9190
9191   if (virtualp)
9192     DECL_VIRTUAL_P (decl) = 1;
9193
9194   return decl;
9195 }
9196
9197 static tree
9198 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9199      tree type;
9200      tree declarator;
9201      RID_BIT_TYPE *specbits_in;
9202      int initialized;
9203      int constp;
9204      tree in_namespace;
9205 {
9206   tree decl;
9207   RID_BIT_TYPE specbits;
9208
9209   specbits = *specbits_in;
9210
9211   if (TREE_CODE (type) == OFFSET_TYPE)
9212     {
9213       /* If you declare a static member so that it
9214          can be initialized, the code will reach here.  */
9215       tree basetype = TYPE_OFFSET_BASETYPE (type);
9216       type = TREE_TYPE (type);
9217       decl = build_lang_decl (VAR_DECL, declarator, type);
9218       DECL_CONTEXT (decl) = basetype;
9219     }
9220   else
9221     {
9222       tree context;
9223
9224       if (in_namespace)
9225         context = in_namespace;
9226       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9227         context = current_namespace;
9228       else
9229         context = NULL_TREE;
9230
9231       /* For namespace-scope variables, declared in a template, we
9232          need the full lang_decl.  The same is true for
9233          namespace-scope variables that do not have C++ language
9234          linkage.  */
9235       if (context
9236           && (processing_template_decl
9237               || current_lang_name != lang_name_cplusplus))
9238         decl = build_lang_decl (VAR_DECL, declarator, type);
9239       else
9240         decl = build_decl (VAR_DECL, declarator, type);
9241
9242       if (context)
9243         set_decl_namespace (decl, context, 0);
9244
9245       context = DECL_CONTEXT (decl);
9246       if (declarator && context && current_lang_name != lang_name_c)
9247         /* We can't mangle lazily here because we don't have any
9248            way to recover whether or not a variable was `extern
9249            "C"' later.  */
9250         mangle_decl (decl);
9251     }
9252
9253   if (in_namespace)
9254     set_decl_namespace (decl, in_namespace, 0);
9255
9256   if (RIDBIT_SETP (RID_EXTERN, specbits))
9257     {
9258       DECL_THIS_EXTERN (decl) = 1;
9259       DECL_EXTERNAL (decl) = !initialized;
9260     }
9261
9262   /* In class context, static means one per class,
9263      public access, and static storage.  */
9264   if (DECL_CLASS_SCOPE_P (decl))
9265     {
9266       TREE_PUBLIC (decl) = 1;
9267       TREE_STATIC (decl) = 1;
9268       DECL_EXTERNAL (decl) = 0;
9269     }
9270   /* At top level, either `static' or no s.c. makes a definition
9271      (perhaps tentative), and absence of `static' makes it public.  */
9272   else if (toplevel_bindings_p ())
9273     {
9274       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9275                             && (DECL_THIS_EXTERN (decl) || ! constp));
9276       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9277     }
9278   /* Not at top level, only `static' makes a static definition.  */
9279   else
9280     {
9281       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9282       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9283     }
9284
9285   if (TREE_PUBLIC (decl))
9286     {
9287       /* [basic.link]: A name with no linkage (notably, the name of a class
9288          or enumeration declared in a local scope) shall not be used to
9289          declare an entity with linkage.
9290
9291          Only check this for public decls for now.  */
9292       tree t = no_linkage_check (TREE_TYPE (decl));
9293       if (t)
9294         {
9295           if (TYPE_ANONYMOUS_P (t))
9296             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9297           else
9298             pedwarn ("non-local variable `%#D' uses local type `%T'",
9299                         decl, t);
9300         }
9301     }
9302
9303   return decl;
9304 }
9305
9306 /* Create and return a canonical pointer to member function type, for
9307    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9308
9309 tree
9310 build_ptrmemfunc_type (type)
9311      tree type;
9312 {
9313   tree fields[4];
9314   tree t;
9315   tree unqualified_variant = NULL_TREE;
9316
9317   if (type == error_mark_node)
9318     return type;
9319
9320   /* If a canonical type already exists for this type, use it.  We use
9321      this method instead of type_hash_canon, because it only does a
9322      simple equality check on the list of field members.  */
9323
9324   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9325     return t;
9326
9327   /* Make sure that we always have the unqualified pointer-to-member
9328      type first.  */
9329   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9330     unqualified_variant
9331       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9332
9333   t = make_aggr_type (RECORD_TYPE);
9334   /* Let the front-end know this is a pointer to member function...  */
9335   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9336   /* ... and not really an aggregate.  */
9337   SET_IS_AGGR_TYPE (t, 0);
9338
9339   fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9340   fields[1] = build_decl (FIELD_DECL, delta_identifier,
9341                           delta_type_node);
9342   finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9343
9344   /* Zap out the name so that the back-end will give us the debugging
9345      information for this anonymous RECORD_TYPE.  */
9346   TYPE_NAME (t) = NULL_TREE;
9347
9348   /* If this is not the unqualified form of this pointer-to-member
9349      type, set the TYPE_MAIN_VARIANT for this type to be the
9350      unqualified type.  Since they are actually RECORD_TYPEs that are
9351      not variants of each other, we must do this manually.  */
9352   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9353     {
9354       t = build_qualified_type (t, cp_type_quals (type));
9355       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9356       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9357       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9358     }
9359
9360   /* Cache this pointer-to-member type so that we can find it again
9361      later.  */
9362   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9363
9364   /* Seems to be wanted.  */
9365   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9366
9367   return t;
9368 }
9369
9370 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9371    Check to see that the definition is valid.  Issue appropriate error
9372    messages.  Return 1 if the definition is particularly bad, or 0
9373    otherwise.  */
9374
9375 int
9376 check_static_variable_definition (decl, type)
9377      tree decl;
9378      tree type;
9379 {
9380   /* Motion 10 at San Diego: If a static const integral data member is
9381      initialized with an integral constant expression, the initializer
9382      may appear either in the declaration (within the class), or in
9383      the definition, but not both.  If it appears in the class, the
9384      member is a member constant.  The file-scope definition is always
9385      required.  */
9386   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9387     {
9388       error ("invalid in-class initialization of static data member of non-integral type `%T'",
9389                 type);
9390       /* If we just return the declaration, crashes will sometimes
9391          occur.  We therefore return void_type_node, as if this was a
9392          friend declaration, to cause callers to completely ignore
9393          this declaration.  */
9394       return 1;
9395     }
9396   else if (!CP_TYPE_CONST_P (type))
9397     error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9398               decl);
9399   else if (pedantic && !INTEGRAL_TYPE_P (type))
9400     pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9401
9402   return 0;
9403 }
9404
9405 /* Given the SIZE (i.e., number of elements) in an array, compute an
9406    appropriate index type for the array.  If non-NULL, NAME is the
9407    name of the thing being declared.  */
9408
9409 tree
9410 compute_array_index_type (name, size)
9411      tree name;
9412      tree size;
9413 {
9414   tree itype;
9415
9416   /* If this involves a template parameter, it will be a constant at
9417      instantiation time, but we don't know what the value is yet.
9418      Even if no template parameters are involved, we may an expression
9419      that is not a constant; we don't even simplify `1 + 2' when
9420      processing a template.  */
9421   if (processing_template_decl)
9422     {
9423       /* Resolve a qualified reference to an enumerator or static
9424          const data member of ours.  */
9425       if (TREE_CODE (size) == SCOPE_REF
9426           && TREE_OPERAND (size, 0) == current_class_type)
9427         {
9428           tree t = lookup_field (current_class_type,
9429                                  TREE_OPERAND (size, 1), 0, 0);
9430           if (t)
9431             size = t;
9432         }
9433
9434       return build_index_type (build_min (MINUS_EXPR, sizetype,
9435                                           size, integer_one_node));
9436     }
9437
9438   /* The size might be the result of a cast. */
9439   STRIP_TYPE_NOPS (size);
9440
9441   /* It might be a const variable or enumeration constant.  */
9442   size = decl_constant_value (size);
9443
9444   /* The array bound must be an integer type.  */
9445   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9446       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9447       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9448     {
9449       if (name)
9450         error ("size of array `%D' has non-integer type", name);
9451       else
9452         error ("size of array has non-integer type");
9453       size = integer_one_node;
9454     }
9455
9456   /* Normally, the array-bound will be a constant.  */
9457   if (TREE_CODE (size) == INTEGER_CST)
9458     {
9459       /* Check to see if the array bound overflowed.  Make that an
9460          error, no matter how generous we're being.  */
9461       int old_flag_pedantic_errors = flag_pedantic_errors;
9462       int old_pedantic = pedantic;
9463       pedantic = flag_pedantic_errors = 1;
9464       constant_expression_warning (size);
9465       pedantic = old_pedantic;
9466       flag_pedantic_errors = old_flag_pedantic_errors;
9467
9468       /* An array must have a positive number of elements.  */
9469       if (INT_CST_LT (size, integer_zero_node))
9470         {
9471           if (name)
9472             error ("size of array `%D' is negative", name);
9473           else
9474             error ("size of array is negative");
9475           size = integer_one_node;
9476         }
9477       /* Except that an extension we allow zero-sized arrays.  We
9478          always allow them in system headers because glibc uses
9479          them.  */
9480       else if (integer_zerop (size) && pedantic && !in_system_header)
9481         {
9482           if (name)
9483             pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9484           else
9485             pedwarn ("ISO C++ forbids zero-size array");
9486         }
9487     }
9488   else if (TREE_CONSTANT (size))
9489     {
9490       /* `(int) &fn' is not a valid array bound.  */
9491       if (name)
9492         error ("size of array `%D' is not an integral constant-expression",
9493                   name);
9494       else
9495         error ("size of array is not an integral constant-expression");
9496     }
9497
9498   /* Compute the index of the largest element in the array.  It is
9499      one less than the number of elements in the array.  */
9500   itype
9501     = fold (cp_build_binary_op (MINUS_EXPR,
9502                                 cp_convert (ssizetype, size),
9503                                 cp_convert (ssizetype,
9504                                             integer_one_node)));
9505
9506   /* Check for variable-sized arrays.  We allow such things as an
9507      extension, even though they are not allowed in ANSI/ISO C++.  */
9508   if (!TREE_CONSTANT (itype))
9509     {
9510       if (pedantic)
9511         {
9512           if (name)
9513             pedwarn ("ISO C++ forbids variable-size array `%D'",
9514                         name);
9515           else
9516             pedwarn ("ISO C++ forbids variable-size array");
9517         }
9518
9519       /* Create a variable-sized array index type.  */
9520       itype = variable_size (itype);
9521     }
9522   /* Make sure that there was no overflow when creating to a signed
9523      index type.  (For example, on a 32-bit machine, an array with
9524      size 2^32 - 1 is too big.)  */
9525   else if (TREE_OVERFLOW (itype))
9526     {
9527       error ("overflow in array dimension");
9528       TREE_OVERFLOW (itype) = 0;
9529     }
9530
9531   /* Create and return the appropriate index type.  */
9532   return build_index_type (itype);
9533 }
9534
9535 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9536    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9537    with this type.  */
9538
9539 static tree
9540 create_array_type_for_decl (name, type, size)
9541      tree name;
9542      tree type;
9543      tree size;
9544 {
9545   tree itype = NULL_TREE;
9546   const char* error_msg;
9547
9548   /* If things have already gone awry, bail now.  */
9549   if (type == error_mark_node || size == error_mark_node)
9550     return error_mark_node;
9551
9552   /* Assume that everything will go OK.  */
9553   error_msg = NULL;
9554
9555   /* There are some types which cannot be array elements.  */
9556   switch (TREE_CODE (type))
9557     {
9558     case VOID_TYPE:
9559       error_msg = "array of void";
9560       break;
9561
9562     case FUNCTION_TYPE:
9563       error_msg = "array of functions";
9564       break;
9565
9566     case REFERENCE_TYPE:
9567       error_msg = "array of references";
9568       break;
9569
9570     case OFFSET_TYPE:
9571       error_msg = "array of data members";
9572       break;
9573
9574     case METHOD_TYPE:
9575       error_msg = "array of function members";
9576       break;
9577
9578     default:
9579       break;
9580     }
9581
9582   /* If something went wrong, issue an error-message and return.  */
9583   if (error_msg)
9584     {
9585       if (name)
9586         error ("declaration of `%D' as %s", name, error_msg);
9587       else
9588         error ("creating %s", error_msg);
9589
9590       return error_mark_node;
9591     }
9592
9593   /* [dcl.array]
9594
9595      The constant expressions that specify the bounds of the arrays
9596      can be omitted only for the first member of the sequence.  */
9597   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9598     {
9599       if (name)
9600         error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9601                   name);
9602       else
9603         error ("multidimensional array must have bounds for all dimensions except the first");
9604
9605       return error_mark_node;
9606     }
9607
9608   /* Figure out the index type for the array.  */
9609   if (size)
9610     itype = compute_array_index_type (name, size);
9611
9612   return build_cplus_array_type (type, itype);
9613 }
9614
9615 /* Check that it's OK to declare a function with the indicated TYPE.
9616    SFK indicates the kind of special function (if any) that this
9617    function is.  OPTYPE is the type given in a conversion operator
9618    declaration.  Returns the actual return type of the function; that
9619    may be different than TYPE if an error occurs, or for certain
9620    special functions.  */
9621
9622 static tree
9623 check_special_function_return_type (sfk, type, optype)
9624      special_function_kind sfk;
9625      tree type;
9626      tree optype;
9627 {
9628   switch (sfk)
9629     {
9630     case sfk_constructor:
9631       if (type)
9632         error ("return type specification for constructor invalid");
9633
9634       type = void_type_node;
9635       break;
9636
9637     case sfk_destructor:
9638       if (type)
9639         error ("return type specification for destructor invalid");
9640       type = void_type_node;
9641       break;
9642
9643     case sfk_conversion:
9644       if (type && !same_type_p (type, optype))
9645         error ("operator `%T' declared to return `%T'", optype, type);
9646       else if (type)
9647         pedwarn ("return type specified for `operator %T'",  optype);
9648       type = optype;
9649       break;
9650
9651     default:
9652       abort ();
9653       break;
9654     }
9655
9656   return type;
9657 }
9658
9659 /* Given declspecs and a declarator,
9660    determine the name and type of the object declared
9661    and construct a ..._DECL node for it.
9662    (In one case we can return a ..._TYPE node instead.
9663     For invalid input we sometimes return 0.)
9664
9665    DECLSPECS is a chain of tree_list nodes whose value fields
9666     are the storage classes and type specifiers.
9667
9668    DECL_CONTEXT says which syntactic context this declaration is in:
9669      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9670      FUNCDEF for a function definition.  Like NORMAL but a few different
9671       error messages in each case.  Return value may be zero meaning
9672       this definition is too screwy to try to parse.
9673      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9674       handle member functions (which have FIELD context).
9675       Return value may be zero meaning this definition is too screwy to
9676       try to parse.
9677      PARM for a parameter declaration (either within a function prototype
9678       or before a function body).  Make a PARM_DECL, or return void_type_node.
9679      CATCHPARM for a parameter declaration before a catch clause.
9680      TYPENAME if for a typename (in a cast or sizeof).
9681       Don't make a DECL node; just return the ..._TYPE node.
9682      FIELD for a struct or union field; make a FIELD_DECL.
9683      BITFIELD for a field with specified width.
9684    INITIALIZED is 1 if the decl has an initializer.
9685
9686    ATTRLIST is a pointer to the list of attributes, which may be NULL
9687    if there are none; *ATTRLIST may be modified if attributes from inside
9688    the declarator should be applied to the declaration.
9689
9690    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9691    It may also be so in the PARM case, for a prototype where the
9692    argument type is specified but not the name.
9693
9694    This function is where the complicated C meanings of `static'
9695    and `extern' are interpreted.
9696
9697    For C++, if there is any monkey business to do, the function which
9698    calls this one must do it, i.e., prepending instance variables,
9699    renaming overloaded function names, etc.
9700
9701    Note that for this C++, it is an error to define a method within a class
9702    which does not belong to that class.
9703
9704    Except in the case where SCOPE_REFs are implicitly known (such as
9705    methods within a class being redundantly qualified),
9706    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9707    (class_name::decl_name).  The caller must also deal with this.
9708
9709    If a constructor or destructor is seen, and the context is FIELD,
9710    then the type gains the attribute TREE_HAS_x.  If such a declaration
9711    is erroneous, NULL_TREE is returned.
9712
9713    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9714    function, these are the qualifiers to give to the `this' pointer. We
9715    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9716
9717    May return void_type_node if the declarator turned out to be a friend.
9718    See grokfield for details.  */
9719
9720 tree
9721 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9722      tree declspecs;
9723      tree declarator;
9724      enum decl_context decl_context;
9725      int initialized;
9726      tree *attrlist;
9727 {
9728   RID_BIT_TYPE specbits;
9729   int nclasses = 0;
9730   tree spec;
9731   tree type = NULL_TREE;
9732   int longlong = 0;
9733   int type_quals;
9734   int virtualp, explicitp, friendp, inlinep, staticp;
9735   int explicit_int = 0;
9736   int explicit_char = 0;
9737   int defaulted_int = 0;
9738   int extern_langp = 0;
9739   tree dependant_name = NULL_TREE;
9740
9741   tree typedef_decl = NULL_TREE;
9742   const char *name;
9743   tree typedef_type = NULL_TREE;
9744   int funcdef_flag = 0;
9745   enum tree_code innermost_code = ERROR_MARK;
9746   int bitfield = 0;
9747 #if 0
9748   /* See the code below that used this.  */
9749   tree decl_attr = NULL_TREE;
9750 #endif
9751   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9752      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9753   tree init = NULL_TREE;
9754
9755   /* Keep track of what sort of function is being processed
9756      so that we can warn about default return values, or explicit
9757      return values which do not match prescribed defaults.  */
9758   special_function_kind sfk = sfk_none;
9759
9760   tree dname = NULL_TREE;
9761   tree ctype = current_class_type;
9762   tree ctor_return_type = NULL_TREE;
9763   enum overload_flags flags = NO_SPECIAL;
9764   tree quals = NULL_TREE;
9765   tree raises = NULL_TREE;
9766   int template_count = 0;
9767   tree in_namespace = NULL_TREE;
9768   tree returned_attrs = NULL_TREE;
9769
9770   RIDBIT_RESET_ALL (specbits);
9771   if (decl_context == FUNCDEF)
9772     funcdef_flag = 1, decl_context = NORMAL;
9773   else if (decl_context == MEMFUNCDEF)
9774     funcdef_flag = -1, decl_context = FIELD;
9775   else if (decl_context == BITFIELD)
9776     bitfield = 1, decl_context = FIELD;
9777
9778   /* Look inside a declarator for the name being declared
9779      and get it as a string, for an error message.  */
9780   {
9781     tree *next = &declarator;
9782     register tree decl;
9783     name = NULL;
9784
9785     while (next && *next)
9786       {
9787         decl = *next;
9788         switch (TREE_CODE (decl))
9789           {
9790           case TREE_LIST:
9791             /* For attributes.  */
9792             next = &TREE_VALUE (decl);
9793             break;
9794
9795           case COND_EXPR:
9796             ctype = NULL_TREE;
9797             next = &TREE_OPERAND (decl, 0);
9798             break;
9799
9800           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9801             {
9802               tree name = TREE_OPERAND (decl, 0);
9803               tree rename = NULL_TREE;
9804
9805               my_friendly_assert (flags == NO_SPECIAL, 152);
9806               flags = DTOR_FLAG;
9807               sfk = sfk_destructor;
9808               if (TREE_CODE (name) == TYPE_DECL)
9809                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9810               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9811               if (ctype == NULL_TREE)
9812                 {
9813                   if (current_class_type == NULL_TREE)
9814                     {
9815                       error ("destructors must be member functions");
9816                       flags = NO_SPECIAL;
9817                     }
9818                   else
9819                     {
9820                       tree t = constructor_name (current_class_name);
9821                       if (t != name)
9822                         rename = t;
9823                     }
9824                 }
9825               else
9826                 {
9827                   tree t = constructor_name (ctype);
9828                   if (t != name)
9829                     rename = t;
9830                 }
9831
9832               if (rename)
9833                 {
9834                   error ("destructor `%T' must match class name `%T'",
9835                             name, rename);
9836                   TREE_OPERAND (decl, 0) = rename;
9837                 }
9838               next = &name;
9839             }
9840             break;
9841
9842           case ADDR_EXPR:       /* C++ reference declaration */
9843             /* Fall through. */
9844           case ARRAY_REF:
9845           case INDIRECT_REF:
9846             ctype = NULL_TREE;
9847             innermost_code = TREE_CODE (decl);
9848             next = &TREE_OPERAND (decl, 0);
9849             break;
9850
9851           case CALL_EXPR:
9852             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9853               {
9854                 /* This is actually a variable declaration using
9855                    constructor syntax.  We need to call start_decl and
9856                    cp_finish_decl so we can get the variable
9857                    initialized...  */
9858
9859                 tree attributes;
9860
9861                 *next = TREE_OPERAND (decl, 0);
9862                 init = CALL_DECLARATOR_PARMS (decl);
9863
9864                 if (attrlist)
9865                   {
9866                     attributes = *attrlist;
9867                   }
9868                 else
9869                   {
9870                     attributes = NULL_TREE;
9871                   }
9872
9873                 decl = start_decl (declarator, declspecs, 1,
9874                                    attributes, NULL_TREE);
9875                 decl_type_access_control (decl);
9876                 if (decl)
9877                   {
9878                     /* Look for __unused__ attribute */
9879                     if (TREE_USED (TREE_TYPE (decl)))
9880                       TREE_USED (decl) = 1;
9881                     finish_decl (decl, init, NULL_TREE);
9882                   }
9883                 else
9884                   error ("invalid declarator");
9885                 return 0;
9886               }
9887             innermost_code = TREE_CODE (decl);
9888             if (decl_context == FIELD && ctype == NULL_TREE)
9889               ctype = current_class_type;
9890             if (ctype
9891                 && TREE_OPERAND (decl, 0)
9892                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9893                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9894                          == constructor_name_full (ctype))
9895                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9896                             == constructor_name (ctype)))))
9897               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9898             next = &TREE_OPERAND (decl, 0);
9899             decl = *next;
9900             if (ctype != NULL_TREE
9901                 && decl != NULL_TREE && flags != DTOR_FLAG
9902                 && decl == constructor_name (ctype))
9903               {
9904                 sfk = sfk_constructor;
9905                 ctor_return_type = ctype;
9906               }
9907             ctype = NULL_TREE;
9908             break;
9909
9910           case TEMPLATE_ID_EXPR:
9911               {
9912                 tree fns = TREE_OPERAND (decl, 0);
9913
9914                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9915                   fns = TREE_OPERAND (fns, 0);
9916
9917                 dname = fns;
9918                 if (TREE_CODE (dname) == COMPONENT_REF)
9919                   dname = TREE_OPERAND (dname, 1);
9920                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9921                   {
9922                     my_friendly_assert (is_overloaded_fn (dname),
9923                                         19990331);
9924                     dname = DECL_NAME (get_first_fn (dname));
9925                   }
9926               }
9927           /* Fall through. */
9928
9929           case IDENTIFIER_NODE:
9930             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9931               dname = decl;
9932
9933             next = 0;
9934
9935             if (C_IS_RESERVED_WORD (dname))
9936               {
9937                 error ("declarator-id missing; using reserved word `%D'",
9938                           dname);
9939                 name = IDENTIFIER_POINTER (dname);
9940               }
9941             else if (!IDENTIFIER_TYPENAME_P (dname))
9942               name = IDENTIFIER_POINTER (dname);
9943             else
9944               {
9945                 my_friendly_assert (flags == NO_SPECIAL, 154);
9946                 flags = TYPENAME_FLAG;
9947                 ctor_return_type = TREE_TYPE (dname);
9948                 sfk = sfk_conversion;
9949                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9950                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9951                         == TYPE_DECL))
9952                   name = IDENTIFIER_POINTER (dname);
9953                 else
9954                   name = "<invalid operator>";
9955               }
9956             break;
9957
9958             /* C++ extension */
9959           case SCOPE_REF:
9960             {
9961               /* Perform error checking, and decide on a ctype.  */
9962               tree cname = TREE_OPERAND (decl, 0);
9963               if (cname == NULL_TREE)
9964                 ctype = NULL_TREE;
9965               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9966                 {
9967                   ctype = NULL_TREE;
9968                   in_namespace = TREE_OPERAND (decl, 0);
9969                   TREE_OPERAND (decl, 0) = NULL_TREE;
9970                 }
9971               else if (! is_aggr_type (cname, 1))
9972                 TREE_OPERAND (decl, 0) = NULL_TREE;
9973               /* Must test TREE_OPERAND (decl, 1), in case user gives
9974                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9975               else if (TREE_OPERAND (decl, 1)
9976                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9977                 ctype = cname;
9978               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9979                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9980                 {
9981                   /* This might be declaring a member of a template
9982                      parm to be a friend.  */
9983                   ctype = cname;
9984                   dependant_name = TREE_OPERAND (decl, 1);
9985                 }
9986               else if (ctype == NULL_TREE)
9987                 ctype = cname;
9988               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9989                 TREE_OPERAND (decl, 0) = ctype;
9990               else
9991                 {
9992                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9993                     {
9994                       error ("type `%T' is not derived from type `%T'",
9995                                 cname, ctype);
9996                       TREE_OPERAND (decl, 0) = NULL_TREE;
9997                     }
9998                   else
9999                     ctype = cname;
10000                 }
10001
10002               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
10003                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
10004                        == constructor_name_full (ctype))
10005                       || (DECL_NAME (TREE_OPERAND (decl, 1))
10006                           == constructor_name (ctype))))
10007                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
10008               next = &TREE_OPERAND (decl, 1);
10009               decl = *next;
10010               if (ctype)
10011                 {
10012                   if (TREE_CODE (decl) == IDENTIFIER_NODE
10013                       && constructor_name (ctype) == decl)
10014                     {
10015                       sfk = sfk_constructor;
10016                       ctor_return_type = ctype;
10017                     }
10018                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
10019                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
10020                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
10021                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
10022                     {
10023                       sfk = sfk_destructor;
10024                       ctor_return_type = ctype;
10025                       flags = DTOR_FLAG;
10026                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
10027                       next = &TREE_OPERAND (decl, 0);
10028                     }
10029                 }
10030             }
10031             break;
10032
10033           case ERROR_MARK:
10034             next = 0;
10035             break;
10036
10037           case TYPE_DECL:
10038             /* Parse error puts this typespec where
10039                a declarator should go.  */
10040             error ("`%T' specified as declarator-id", DECL_NAME (decl));
10041             if (TREE_TYPE (decl) == current_class_type)
10042               error ("  perhaps you want `%T' for a constructor",
10043                         current_class_name);
10044             dname = DECL_NAME (decl);
10045             name = IDENTIFIER_POINTER (dname);
10046
10047             /* Avoid giving two errors for this.  */
10048             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
10049
10050             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
10051             *next = dname;
10052             next = 0;
10053             break;
10054
10055           default:
10056             internal_error ("`%D' as declarator", decl);
10057           }
10058       }
10059   }
10060
10061   /* A function definition's declarator must have the form of
10062      a function declarator.  */
10063
10064   if (funcdef_flag && innermost_code != CALL_EXPR)
10065     return 0;
10066
10067   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
10068       && innermost_code != CALL_EXPR
10069       && ! (ctype && declspecs == NULL_TREE))
10070     {
10071       error ("declaration of `%D' as non-function", dname);
10072       return void_type_node;
10073     }
10074
10075   /* Anything declared one level down from the top level
10076      must be one of the parameters of a function
10077      (because the body is at least two levels down).  */
10078
10079   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10080      by not allowing C++ class definitions to specify their parameters
10081      with xdecls (must be spec.d in the parmlist).
10082
10083      Since we now wait to push a class scope until we are sure that
10084      we are in a legitimate method context, we must set oldcname
10085      explicitly (since current_class_name is not yet alive).
10086
10087      We also want to avoid calling this a PARM if it is in a namespace.  */
10088
10089   if (decl_context == NORMAL && !toplevel_bindings_p ())
10090     {
10091       struct binding_level *b = current_binding_level;
10092       current_binding_level = b->level_chain;
10093       if (current_binding_level != 0 && toplevel_bindings_p ())
10094         decl_context = PARM;
10095       current_binding_level = b;
10096     }
10097
10098   if (name == NULL)
10099     name = decl_context == PARM ? "parameter" : "type name";
10100
10101   /* Look through the decl specs and record which ones appear.
10102      Some typespecs are defined as built-in typenames.
10103      Others, the ones that are modifiers of other types,
10104      are represented by bits in SPECBITS: set the bits for
10105      the modifiers that appear.  Storage class keywords are also in SPECBITS.
10106
10107      If there is a typedef name or a type, store the type in TYPE.
10108      This includes builtin typedefs such as `int'.
10109
10110      Set EXPLICIT_INT if the type is `int' or `char' and did not
10111      come from a user typedef.
10112
10113      Set LONGLONG if `long' is mentioned twice.
10114
10115      For C++, constructors and destructors have their own fast treatment.  */
10116
10117   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10118     {
10119       register int i;
10120       register tree id;
10121
10122       /* Certain parse errors slip through.  For example,
10123          `int class;' is not caught by the parser. Try
10124          weakly to recover here.  */
10125       if (TREE_CODE (spec) != TREE_LIST)
10126         return 0;
10127
10128       id = TREE_VALUE (spec);
10129
10130       /* If the entire declaration is itself tagged as deprecated then
10131          suppress reports of deprecated items.  */
10132       if (!adding_implicit_members && id && TREE_DEPRECATED (id))
10133         {
10134           if (deprecated_state != DEPRECATED_SUPPRESS)
10135             warn_deprecated_use (id);
10136         }
10137
10138       if (TREE_CODE (id) == IDENTIFIER_NODE)
10139         {
10140           if (id == ridpointers[(int) RID_INT]
10141               || id == ridpointers[(int) RID_CHAR]
10142               || id == ridpointers[(int) RID_BOOL]
10143               || id == ridpointers[(int) RID_WCHAR])
10144             {
10145               if (type)
10146                 {
10147                   if (id == ridpointers[(int) RID_BOOL])
10148                     error ("`bool' is now a keyword");
10149                   else
10150                     error ("extraneous `%T' ignored", id);
10151                 }
10152               else
10153                 {
10154                   if (id == ridpointers[(int) RID_INT])
10155                     explicit_int = 1;
10156                   else if (id == ridpointers[(int) RID_CHAR])
10157                     explicit_char = 1;
10158                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10159                 }
10160               goto found;
10161             }
10162           /* C++ aggregate types.  */
10163           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10164             {
10165               if (type)
10166                 error ("multiple declarations `%T' and `%T'", type, id);
10167               else
10168                 type = IDENTIFIER_TYPE_VALUE (id);
10169               goto found;
10170             }
10171
10172           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10173             {
10174               if (ridpointers[i] == id)
10175                 {
10176                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10177                     {
10178                       if (pedantic && ! in_system_header && warn_long_long)
10179                         pedwarn ("ISO C++ does not support `long long'");
10180                       if (longlong)
10181                         error ("`long long long' is too long for GCC");
10182                       else
10183                         longlong = 1;
10184                     }
10185                   else if (RIDBIT_SETP (i, specbits))
10186                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10187                   if (i == (int)RID_EXTERN
10188                       && TREE_PURPOSE (spec) == error_mark_node)
10189                     /* This extern was part of a language linkage.  */
10190                     extern_langp = 1;
10191                   RIDBIT_SET (i, specbits);
10192                   goto found;
10193                 }
10194             }
10195         }
10196       else if (TREE_CODE (id) == TYPE_DECL)
10197         {
10198           if (type)
10199             error ("multiple declarations `%T' and `%T'", type,
10200                       TREE_TYPE (id));
10201           else
10202             {
10203               type = TREE_TYPE (id);
10204               TREE_VALUE (spec) = type;
10205               typedef_decl = id;
10206             }
10207           goto found;
10208         }
10209       if (type)
10210         error ("two or more data types in declaration of `%s'", name);
10211       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10212         {
10213           register tree t = lookup_name (id, 1);
10214           if (!t || TREE_CODE (t) != TYPE_DECL)
10215             error ("`%s' fails to be a typedef or built in type",
10216                    IDENTIFIER_POINTER (id));
10217           else
10218             {
10219               type = TREE_TYPE (t);
10220               typedef_decl = t;
10221             }
10222         }
10223       else if (id != error_mark_node)
10224         /* Can't change CLASS nodes into RECORD nodes here!  */
10225         type = id;
10226
10227     found: ;
10228     }
10229
10230 #if 0
10231   /* See the code below that used this.  */
10232   if (typedef_decl)
10233     decl_attr = DECL_ATTRIBUTES (typedef_decl);
10234 #endif
10235   typedef_type = type;
10236
10237   /* No type at all: default to `int', and set DEFAULTED_INT
10238      because it was not a user-defined typedef.  */
10239
10240   if (type == NULL_TREE
10241       && (RIDBIT_SETP (RID_SIGNED, specbits)
10242           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10243           || RIDBIT_SETP (RID_LONG, specbits)
10244           || RIDBIT_SETP (RID_SHORT, specbits)))
10245     {
10246       /* These imply 'int'.  */
10247       type = integer_type_node;
10248       defaulted_int = 1;
10249     }
10250
10251   if (sfk != sfk_none)
10252     type = check_special_function_return_type (sfk, type,
10253                                                ctor_return_type);
10254   else if (type == NULL_TREE)
10255     {
10256       int is_main;
10257
10258       explicit_int = -1;
10259
10260       /* We handle `main' specially here, because 'main () { }' is so
10261          common.  With no options, it is allowed.  With -Wreturn-type,
10262          it is a warning.  It is only an error with -pedantic-errors.  */
10263       is_main = (funcdef_flag
10264                  && dname && MAIN_NAME_P (dname)
10265                  && ctype == NULL_TREE
10266                  && in_namespace == NULL_TREE
10267                  && current_namespace == global_namespace);
10268
10269       if (in_system_header || flag_ms_extensions)
10270         /* Allow it, sigh.  */;
10271       else if (pedantic || ! is_main)
10272         pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10273                     name);
10274       else if (warn_return_type)
10275         warning ("ISO C++ forbids declaration of `%s' with no type",
10276                     name);
10277
10278       type = integer_type_node;
10279     }
10280
10281   if (type && IMPLICIT_TYPENAME_P (type))
10282     {
10283       /* The implicit typename extension is deprecated and will be
10284          removed.  Warn about its use now.  */
10285       warning ("`%T' is implicitly a typename", type);
10286       cp_deprecated ("implicit typename");
10287
10288       /* Now remove its implicitness, so that we don't warn again.
10289          For instance this might be a typedef, and we do not want to
10290          warn on uses of the typedef itself.  Simply clearing the
10291          TREE_TYPE is insufficient.  */
10292       type = copy_node (type);
10293       TREE_TYPE (type) = NULL_TREE;
10294     }
10295
10296   ctype = NULL_TREE;
10297
10298   /* Now process the modifiers that were specified
10299      and check for invalid combinations.  */
10300
10301   /* Long double is a special combination.  */
10302
10303   if (RIDBIT_SETP (RID_LONG, specbits)
10304       && TYPE_MAIN_VARIANT (type) == double_type_node)
10305     {
10306       RIDBIT_RESET (RID_LONG, specbits);
10307       type = build_qualified_type (long_double_type_node,
10308                                    cp_type_quals (type));
10309     }
10310
10311   /* Check all other uses of type modifiers.  */
10312
10313   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10314       || RIDBIT_SETP (RID_SIGNED, specbits)
10315       || RIDBIT_SETP (RID_LONG, specbits)
10316       || RIDBIT_SETP (RID_SHORT, specbits))
10317     {
10318       int ok = 0;
10319
10320       if (TREE_CODE (type) == REAL_TYPE)
10321         error ("short, signed or unsigned invalid for `%s'", name);
10322       else if (TREE_CODE (type) != INTEGER_TYPE)
10323         error ("long, short, signed or unsigned invalid for `%s'", name);
10324       else if (RIDBIT_SETP (RID_LONG, specbits)
10325                && RIDBIT_SETP (RID_SHORT, specbits))
10326         error ("long and short specified together for `%s'", name);
10327       else if ((RIDBIT_SETP (RID_LONG, specbits)
10328                 || RIDBIT_SETP (RID_SHORT, specbits))
10329                && explicit_char)
10330         error ("long or short specified with char for `%s'", name);
10331       else if ((RIDBIT_SETP (RID_LONG, specbits)
10332                 || RIDBIT_SETP (RID_SHORT, specbits))
10333                && TREE_CODE (type) == REAL_TYPE)
10334         error ("long or short specified with floating type for `%s'", name);
10335       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10336                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10337         error ("signed and unsigned given together for `%s'", name);
10338       else
10339         {
10340           ok = 1;
10341           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10342             {
10343               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10344                        name);
10345               if (flag_pedantic_errors)
10346                 ok = 0;
10347             }
10348         }
10349
10350       /* Discard the type modifiers if they are invalid.  */
10351       if (! ok)
10352         {
10353           RIDBIT_RESET (RID_UNSIGNED, specbits);
10354           RIDBIT_RESET (RID_SIGNED, specbits);
10355           RIDBIT_RESET (RID_LONG, specbits);
10356           RIDBIT_RESET (RID_SHORT, specbits);
10357           longlong = 0;
10358         }
10359     }
10360
10361   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10362       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10363     {
10364       error ("complex invalid for `%s'", name);
10365       RIDBIT_RESET (RID_COMPLEX, specbits);
10366     }
10367
10368   /* Decide whether an integer type is signed or not.
10369      Optionally treat bitfields as signed by default.  */
10370   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10371       /* [class.bit]
10372
10373          It is implementation-defined whether a plain (neither
10374          explicitly signed or unsigned) char, short, int, or long
10375          bit-field is signed or unsigned.
10376
10377          Naturally, we extend this to long long as well.  Note that
10378          this does not include wchar_t.  */
10379       || (bitfield && !flag_signed_bitfields
10380           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10381           /* A typedef for plain `int' without `signed' can be
10382              controlled just like plain `int', but a typedef for
10383              `signed int' cannot be so controlled.  */
10384           && !(typedef_decl
10385                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10386           && (TREE_CODE (type) == INTEGER_TYPE
10387               || TREE_CODE (type) == CHAR_TYPE)
10388           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10389     {
10390       if (longlong)
10391         type = long_long_unsigned_type_node;
10392       else if (RIDBIT_SETP (RID_LONG, specbits))
10393         type = long_unsigned_type_node;
10394       else if (RIDBIT_SETP (RID_SHORT, specbits))
10395         type = short_unsigned_type_node;
10396       else if (type == char_type_node)
10397         type = unsigned_char_type_node;
10398       else if (typedef_decl)
10399         type = unsigned_type (type);
10400       else
10401         type = unsigned_type_node;
10402     }
10403   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10404            && type == char_type_node)
10405     type = signed_char_type_node;
10406   else if (longlong)
10407     type = long_long_integer_type_node;
10408   else if (RIDBIT_SETP (RID_LONG, specbits))
10409     type = long_integer_type_node;
10410   else if (RIDBIT_SETP (RID_SHORT, specbits))
10411     type = short_integer_type_node;
10412
10413   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10414     {
10415       /* If we just have "complex", it is equivalent to
10416          "complex double", but if any modifiers at all are specified it is
10417          the complex form of TYPE.  E.g, "complex short" is
10418          "complex short int".  */
10419
10420       if (defaulted_int && ! longlong
10421           && ! (RIDBIT_SETP (RID_LONG, specbits)
10422                 || RIDBIT_SETP (RID_SHORT, specbits)
10423                 || RIDBIT_SETP (RID_SIGNED, specbits)
10424                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10425         type = complex_double_type_node;
10426       else if (type == integer_type_node)
10427         type = complex_integer_type_node;
10428       else if (type == float_type_node)
10429         type = complex_float_type_node;
10430       else if (type == double_type_node)
10431         type = complex_double_type_node;
10432       else if (type == long_double_type_node)
10433         type = complex_long_double_type_node;
10434       else
10435         type = build_complex_type (type);
10436     }
10437
10438   type_quals = TYPE_UNQUALIFIED;
10439   if (RIDBIT_SETP (RID_CONST, specbits))
10440     type_quals |= TYPE_QUAL_CONST;
10441   if (RIDBIT_SETP (RID_VOLATILE, specbits))
10442     type_quals |= TYPE_QUAL_VOLATILE;
10443   if (RIDBIT_SETP (RID_RESTRICT, specbits))
10444     type_quals |= TYPE_QUAL_RESTRICT;
10445   if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
10446     error ("qualifiers are not allowed on declaration of `operator %T'",
10447               ctor_return_type);
10448
10449   type_quals |= cp_type_quals (type);
10450   type = cp_build_qualified_type_real
10451     (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
10452                          ? tf_ignore_bad_quals : 0) | tf_error | tf_warning));
10453   /* We might have ignored or rejected some of the qualifiers.  */
10454   type_quals = cp_type_quals (type);
10455
10456   staticp = 0;
10457   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10458   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10459   RIDBIT_RESET (RID_VIRTUAL, specbits);
10460   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10461   RIDBIT_RESET (RID_EXPLICIT, specbits);
10462
10463   if (RIDBIT_SETP (RID_STATIC, specbits))
10464     staticp = 1 + (decl_context == FIELD);
10465
10466   if (virtualp && staticp == 2)
10467     {
10468       error ("member `%D' cannot be declared both virtual and static",
10469                 dname);
10470       staticp = 0;
10471     }
10472   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10473   RIDBIT_RESET (RID_FRIEND, specbits);
10474
10475   if (dependant_name && !friendp)
10476     {
10477       error ("`%T::%D' is not a valid declarator", ctype, dependant_name);
10478       return void_type_node;
10479     }
10480
10481   /* Warn if two storage classes are given. Default to `auto'.  */
10482
10483   if (RIDBIT_ANY_SET (specbits))
10484     {
10485       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10486       if (RIDBIT_SETP (RID_EXTERN, specbits) && !extern_langp) nclasses++;
10487       if (decl_context == PARM && nclasses > 0)
10488         error ("storage class specifiers invalid in parameter declarations");
10489       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10490         {
10491           if (decl_context == PARM)
10492             error ("typedef declaration invalid in parameter declaration");
10493           nclasses++;
10494         }
10495       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10496       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10497       if (!nclasses && !friendp && extern_langp)
10498         nclasses++;
10499     }
10500
10501   /* Give error if `virtual' is used outside of class declaration.  */
10502   if (virtualp
10503       && (current_class_name == NULL_TREE || decl_context != FIELD))
10504     {
10505       error ("virtual outside class declaration");
10506       virtualp = 0;
10507     }
10508
10509   /* Static anonymous unions are dealt with here.  */
10510   if (staticp && decl_context == TYPENAME
10511       && TREE_CODE (declspecs) == TREE_LIST
10512       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10513     decl_context = FIELD;
10514
10515   /* Warn about storage classes that are invalid for certain
10516      kinds of declarations (parameters, typenames, etc.).  */
10517
10518   if (nclasses > 1)
10519     error ("multiple storage classes in declaration of `%s'", name);
10520   else if (decl_context != NORMAL && nclasses > 0)
10521     {
10522       if ((decl_context == PARM || decl_context == CATCHPARM)
10523           && (RIDBIT_SETP (RID_REGISTER, specbits)
10524               || RIDBIT_SETP (RID_AUTO, specbits)))
10525         ;
10526       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10527         ;
10528       else if (decl_context == FIELD
10529                /* C++ allows static class elements  */
10530                && RIDBIT_SETP (RID_STATIC, specbits))
10531         /* C++ also allows inlines and signed and unsigned elements,
10532            but in those cases we don't come in here.  */
10533         ;
10534       else
10535         {
10536           if (decl_context == FIELD)
10537             {
10538               tree tmp = NULL_TREE;
10539               register int op = 0;
10540
10541               if (declarator)
10542                 {
10543                   /* Avoid trying to get an operand off an identifier node.  */
10544                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10545                     tmp = declarator;
10546                   else
10547                     tmp = TREE_OPERAND (declarator, 0);
10548                   op = IDENTIFIER_OPNAME_P (tmp);
10549                   if (IDENTIFIER_TYPENAME_P (tmp))
10550                     {
10551                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10552                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10553                               == TYPE_DECL))
10554                         name = IDENTIFIER_POINTER (tmp);
10555                       else
10556                         name = "<invalid operator>";
10557                     }
10558                 }
10559               error ("storage class specified for %s `%s'",
10560                      op ? "member operator" : "field",
10561                      name);
10562             }
10563           else
10564             {
10565               if (decl_context == PARM || decl_context == CATCHPARM)
10566                 error ("storage class specified for parameter `%s'", name);
10567               else
10568                 error ("storage class specified for typename");
10569             }
10570           RIDBIT_RESET (RID_REGISTER, specbits);
10571           RIDBIT_RESET (RID_AUTO, specbits);
10572           RIDBIT_RESET (RID_EXTERN, specbits);
10573         }
10574     }
10575   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10576     {
10577       if (toplevel_bindings_p ())
10578         {
10579           /* It's common practice (and completely valid) to have a const
10580              be initialized and declared extern.  */
10581           if (!(type_quals & TYPE_QUAL_CONST))
10582             warning ("`%s' initialized and declared `extern'", name);
10583         }
10584       else
10585         error ("`%s' has both `extern' and initializer", name);
10586     }
10587   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10588            && ! toplevel_bindings_p ())
10589     error ("nested function `%s' declared `extern'", name);
10590   else if (toplevel_bindings_p ())
10591     {
10592       if (RIDBIT_SETP (RID_AUTO, specbits))
10593         error ("top-level declaration of `%s' specifies `auto'", name);
10594     }
10595
10596   if (nclasses > 0 && friendp)
10597     error ("storage class specifiers invalid in friend function declarations");
10598
10599   /* Now figure out the structure of the declarator proper.
10600      Descend through it, creating more complex types, until we reach
10601      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10602
10603   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10604          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10605     {
10606       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10607          an INDIRECT_REF (for *...),
10608          a CALL_EXPR (for ...(...)),
10609          an identifier (for the name being declared)
10610          or a null pointer (for the place in an absolute declarator
10611          where the name was omitted).
10612          For the last two cases, we have just exited the loop.
10613
10614          For C++ it could also be
10615          a SCOPE_REF (for class :: ...).  In this case, we have converted
10616          sensible names to types, and those are the values we use to
10617          qualify the member name.
10618          an ADDR_EXPR (for &...),
10619          a BIT_NOT_EXPR (for destructors)
10620
10621          At this point, TYPE is the type of elements of an array,
10622          or for a function to return, or for a pointer to point to.
10623          After this sequence of ifs, TYPE is the type of the
10624          array or function or pointer, and DECLARATOR has had its
10625          outermost layer removed.  */
10626
10627       if (type == error_mark_node)
10628         {
10629           if (TREE_CODE (declarator) == SCOPE_REF)
10630             declarator = TREE_OPERAND (declarator, 1);
10631           else
10632             declarator = TREE_OPERAND (declarator, 0);
10633           continue;
10634         }
10635       if (quals != NULL_TREE
10636           && (declarator == NULL_TREE
10637               || TREE_CODE (declarator) != SCOPE_REF))
10638         {
10639           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10640             ctype = TYPE_METHOD_BASETYPE (type);
10641           if (ctype != NULL_TREE)
10642             {
10643               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10644               grok_method_quals (ctype, dummy, quals);
10645               type = TREE_TYPE (dummy);
10646               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10647               quals = NULL_TREE;
10648             }
10649         }
10650
10651       switch (TREE_CODE (declarator))
10652         {
10653         case TREE_LIST:
10654           {
10655             /* We encode a declarator with embedded attributes using
10656                a TREE_LIST.  */
10657             tree attrs = TREE_PURPOSE (declarator);
10658             tree inner_decl;
10659             int attr_flags;
10660
10661             declarator = TREE_VALUE (declarator);
10662             inner_decl = declarator;
10663             while (inner_decl != NULL_TREE
10664                    && TREE_CODE (inner_decl) == TREE_LIST)
10665               inner_decl = TREE_VALUE (inner_decl);
10666             attr_flags = 0;
10667             if (inner_decl == NULL_TREE
10668                 || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
10669               attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
10670             if (TREE_CODE (inner_decl) == CALL_EXPR)
10671               attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
10672             if (TREE_CODE (inner_decl) == ARRAY_REF)
10673               attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
10674             returned_attrs = decl_attributes (&type,
10675                                               chainon (returned_attrs, attrs),
10676                                               attr_flags);
10677           }
10678           break;
10679
10680         case ARRAY_REF:
10681           {
10682             register tree size;
10683
10684             size = TREE_OPERAND (declarator, 1);
10685
10686             /* VC++ spells a zero-sized array with [].  */
10687             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10688                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10689               size = integer_zero_node;
10690
10691             declarator = TREE_OPERAND (declarator, 0);
10692
10693             type = create_array_type_for_decl (dname, type, size);
10694
10695             /* VLAs never work as fields. */
10696             if (decl_context == FIELD && !processing_template_decl
10697                 && TREE_CODE (type) == ARRAY_TYPE
10698                 && TYPE_DOMAIN (type) != NULL_TREE
10699                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10700               {
10701                 error ("size of member `%D' is not constant", dname);
10702                 /* Proceed with arbitrary constant size, so that offset
10703                    computations don't get confused. */
10704                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10705                                                    integer_one_node);
10706               }
10707
10708             ctype = NULL_TREE;
10709           }
10710           break;
10711
10712         case CALL_EXPR:
10713           {
10714             tree arg_types;
10715             int funcdecl_p;
10716             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10717             tree inner_decl = TREE_OPERAND (declarator, 0);
10718
10719             /* Declaring a function type.
10720                Make sure we have a valid type for the function to return.  */
10721
10722             /* We now know that the TYPE_QUALS don't apply to the
10723                decl, but to its return type.  */
10724             type_quals = TYPE_UNQUALIFIED;
10725
10726             /* Warn about some types functions can't return.  */
10727
10728             if (TREE_CODE (type) == FUNCTION_TYPE)
10729               {
10730                 error ("`%s' declared as function returning a function", name);
10731                 type = integer_type_node;
10732               }
10733             if (TREE_CODE (type) == ARRAY_TYPE)
10734               {
10735                 error ("`%s' declared as function returning an array", name);
10736                 type = integer_type_node;
10737               }
10738
10739             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10740               inner_decl = TREE_OPERAND (inner_decl, 1);
10741
10742             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10743               inner_decl = dname;
10744
10745             /* Pick up type qualifiers which should be applied to `this'.  */
10746             quals = CALL_DECLARATOR_QUALS (declarator);
10747
10748             /* Pick up the exception specifications.  */
10749             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10750
10751             /* Say it's a definition only for the CALL_EXPR
10752                closest to the identifier.  */
10753             funcdecl_p
10754               = inner_decl
10755               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10756                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10757                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10758
10759             if (ctype == NULL_TREE
10760                 && decl_context == FIELD
10761                 && funcdecl_p
10762                 && (friendp == 0 || dname == current_class_name))
10763               ctype = current_class_type;
10764
10765             if (ctype && sfk == sfk_conversion)
10766               TYPE_HAS_CONVERSION (ctype) = 1;
10767             if (ctype && constructor_name (ctype) == dname)
10768               {
10769                 /* We are within a class's scope. If our declarator name
10770                    is the same as the class name, and we are defining
10771                    a function, then it is a constructor/destructor, and
10772                    therefore returns a void type.  */
10773
10774                 if (flags == DTOR_FLAG)
10775                   {
10776                     /* ISO C++ 12.4/2.  A destructor may not be
10777                        declared const or volatile.  A destructor may
10778                        not be static.  */
10779                     if (staticp == 2)
10780                       error ("destructor cannot be static member function");
10781                     if (quals)
10782                       {
10783                         error ("destructors may not be `%s'",
10784                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10785                         quals = NULL_TREE;
10786                       }
10787                     if (decl_context == FIELD)
10788                       {
10789                         if (! member_function_or_else (ctype,
10790                                                        current_class_type,
10791                                                        flags))
10792                           return void_type_node;
10793                       }
10794                   }
10795                 else            /* It's a constructor.  */
10796                   {
10797                     if (explicitp == 1)
10798                       explicitp = 2;
10799                     /* ISO C++ 12.1.  A constructor may not be
10800                        declared const or volatile.  A constructor may
10801                        not be virtual.  A constructor may not be
10802                        static.  */
10803                     if (staticp == 2)
10804                       error ("constructor cannot be static member function");
10805                     if (virtualp)
10806                       {
10807                         pedwarn ("constructors cannot be declared virtual");
10808                         virtualp = 0;
10809                       }
10810                     if (quals)
10811                       {
10812                         error ("constructors may not be `%s'",
10813                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10814                         quals = NULL_TREE;
10815                       }
10816                     {
10817                       RID_BIT_TYPE tmp_bits;
10818                       memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
10819                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10820                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10821                       if (RIDBIT_ANY_SET (tmp_bits))
10822                         error ("return value type specifier for constructor ignored");
10823                     }
10824                     if (decl_context == FIELD)
10825                       {
10826                         if (! member_function_or_else (ctype,
10827                                                        current_class_type,
10828                                                        flags))
10829                           return void_type_node;
10830                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10831                         if (sfk != sfk_constructor)
10832                           return NULL_TREE;
10833                       }
10834                   }
10835                 if (decl_context == FIELD)
10836                   staticp = 0;
10837               }
10838             else if (friendp)
10839               {
10840                 if (initialized)
10841                   error ("can't initialize friend function `%s'", name);
10842                 if (virtualp)
10843                   {
10844                     /* Cannot be both friend and virtual.  */
10845                     error ("virtual functions cannot be friends");
10846                     RIDBIT_RESET (RID_FRIEND, specbits);
10847                     friendp = 0;
10848                   }
10849                 if (decl_context == NORMAL)
10850                   error ("friend declaration not in class definition");
10851                 if (current_function_decl && funcdef_flag)
10852                   error ("can't define friend function `%s' in a local class definition",
10853                             name);
10854               }
10855
10856             /* Construct the function type and go to the next
10857                inner layer of declarator.  */
10858
10859             declarator = TREE_OPERAND (declarator, 0);
10860
10861             /* FIXME: This is where default args should be fully
10862                processed.  */
10863
10864             arg_types = grokparms (inner_parms);
10865
10866             if (declarator && flags == DTOR_FLAG)
10867               {
10868                 /* A destructor declared in the body of a class will
10869                    be represented as a BIT_NOT_EXPR.  But, we just
10870                    want the underlying IDENTIFIER.  */
10871                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10872                   declarator = TREE_OPERAND (declarator, 0);
10873
10874                 if (arg_types != void_list_node)
10875                   {
10876                     error ("destructors may not have parameters");
10877                     arg_types = void_list_node;
10878                     last_function_parms = NULL_TREE;
10879                   }
10880               }
10881
10882             /* ANSI says that `const int foo ();'
10883                does not make the function foo const.  */
10884             type = build_function_type (type, arg_types);
10885
10886             {
10887               tree t;
10888               for (t = arg_types; t; t = TREE_CHAIN (t))
10889                 if (TREE_PURPOSE (t)
10890                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10891                   {
10892                     add_defarg_fn (type);
10893                     break;
10894                   }
10895             }
10896           }
10897           break;
10898
10899         case ADDR_EXPR:
10900         case INDIRECT_REF:
10901           /* Filter out pointers-to-references and references-to-references.
10902              We can get these if a TYPE_DECL is used.  */
10903
10904           if (TREE_CODE (type) == REFERENCE_TYPE)
10905             {
10906               error ("cannot declare %s to references",
10907                      TREE_CODE (declarator) == ADDR_EXPR
10908                      ? "references" : "pointers");
10909               declarator = TREE_OPERAND (declarator, 0);
10910               continue;
10911             }
10912
10913           if (TREE_CODE (type) == OFFSET_TYPE
10914               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10915                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10916             {
10917               error ("cannot declare pointer to `%#T' member",
10918                         TREE_TYPE (type));
10919               type = TREE_TYPE (type);
10920             }
10921
10922           /* Merge any constancy or volatility into the target type
10923              for the pointer.  */
10924
10925           /* We now know that the TYPE_QUALS don't apply to the decl,
10926              but to the target of the pointer.  */
10927           type_quals = TYPE_UNQUALIFIED;
10928
10929           if (TREE_CODE (declarator) == ADDR_EXPR)
10930             {
10931               if (TREE_CODE (type) == VOID_TYPE)
10932                 error ("invalid type: `void &'");
10933               else
10934                 type = build_reference_type (type);
10935             }
10936           else if (TREE_CODE (type) == METHOD_TYPE)
10937             type = build_ptrmemfunc_type (build_pointer_type (type));
10938           else
10939             type = build_pointer_type (type);
10940
10941           /* Process a list of type modifier keywords (such as
10942              const or volatile) that were given inside the `*' or `&'.  */
10943
10944           if (TREE_TYPE (declarator))
10945             {
10946               register tree typemodlist;
10947               int erred = 0;
10948               int constp = 0;
10949               int volatilep = 0;
10950               int restrictp = 0;
10951
10952               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10953                    typemodlist = TREE_CHAIN (typemodlist))
10954                 {
10955                   tree qualifier = TREE_VALUE (typemodlist);
10956
10957                   if (qualifier == ridpointers[(int) RID_CONST])
10958                     {
10959                       constp++;
10960                       type_quals |= TYPE_QUAL_CONST;
10961                     }
10962                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10963                     {
10964                       volatilep++;
10965                       type_quals |= TYPE_QUAL_VOLATILE;
10966                     }
10967                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10968                     {
10969                       restrictp++;
10970                       type_quals |= TYPE_QUAL_RESTRICT;
10971                     }
10972                   else if (!erred)
10973                     {
10974                       erred = 1;
10975                       error ("invalid type modifier within pointer declarator");
10976                     }
10977                 }
10978               if (constp > 1)
10979                 pedwarn ("duplicate `const'");
10980               if (volatilep > 1)
10981                 pedwarn ("duplicate `volatile'");
10982               if (restrictp > 1)
10983                 pedwarn ("duplicate `restrict'");
10984               type = cp_build_qualified_type (type, type_quals);
10985               type_quals = cp_type_quals (type);
10986             }
10987           declarator = TREE_OPERAND (declarator, 0);
10988           ctype = NULL_TREE;
10989           break;
10990
10991         case SCOPE_REF:
10992           {
10993             /* We have converted type names to NULL_TREE if the
10994                name was bogus, or to a _TYPE node, if not.
10995
10996                The variable CTYPE holds the type we will ultimately
10997                resolve to.  The code here just needs to build
10998                up appropriate member types.  */
10999             tree sname = TREE_OPERAND (declarator, 1);
11000             tree t;
11001
11002             /* Destructors can have their visibilities changed as well.  */
11003             if (TREE_CODE (sname) == BIT_NOT_EXPR)
11004               sname = TREE_OPERAND (sname, 0);
11005
11006             if (TREE_COMPLEXITY (declarator) == 0)
11007               /* This needs to be here, in case we are called
11008                  multiple times.  */ ;
11009             else if (TREE_COMPLEXITY (declarator) == -1)
11010               /* Namespace member. */
11011               pop_decl_namespace ();
11012             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
11013               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
11014             else if (! IS_AGGR_TYPE_CODE
11015                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
11016               ;
11017             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
11018               {
11019                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
11020                    that refer to ctype.  They couldn't be resolved earlier
11021                    because we hadn't pushed into the class yet.
11022                    Example: resolve 'B<T>::type' in
11023                    'B<typename B<T>::type> B<T>::f () { }'.  */
11024                 if (current_template_parms
11025                     && uses_template_parms (type)
11026                     && uses_template_parms (current_class_type))
11027                   {
11028                     tree args = current_template_args ();
11029                     type = tsubst (type, args, tf_error | tf_warning,
11030                                    NULL_TREE);
11031                   }
11032
11033                 /* This pop_nested_class corresponds to the
11034                    push_nested_class used to push into class scope for
11035                    parsing the argument list of a function decl, in
11036                    qualified_id.  */
11037                 pop_nested_class ();
11038                 TREE_COMPLEXITY (declarator) = current_class_depth;
11039               }
11040             else
11041               abort ();
11042
11043             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
11044               {
11045                 /* We had a reference to a global decl, or
11046                    perhaps we were given a non-aggregate typedef,
11047                    in which case we cleared this out, and should just
11048                    keep going as though it wasn't there.  */
11049                 declarator = sname;
11050                 continue;
11051               }
11052             ctype = TREE_OPERAND (declarator, 0);
11053
11054             t = ctype;
11055             while (t != NULL_TREE && CLASS_TYPE_P (t))
11056               {
11057                 /* You're supposed to have one `template <...>'
11058                    for every template class, but you don't need one
11059                    for a full specialization.  For example:
11060
11061                      template <class T> struct S{};
11062                      template <> struct S<int> { void f(); };
11063                      void S<int>::f () {}
11064
11065                    is correct; there shouldn't be a `template <>' for
11066                    the definition of `S<int>::f'.  */
11067                 if (CLASSTYPE_TEMPLATE_INFO (t)
11068                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
11069                         || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
11070                     && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
11071                   template_count += 1;
11072
11073                 t = TYPE_MAIN_DECL (t);
11074                 t = DECL_CONTEXT (t);
11075               }
11076
11077             if (sname == NULL_TREE)
11078               goto done_scoping;
11079
11080             if (TREE_CODE (sname) == IDENTIFIER_NODE)
11081               {
11082                 /* This is the `standard' use of the scoping operator:
11083                    basetype :: member .  */
11084
11085                 if (ctype == current_class_type)
11086                   {
11087                     /* class A {
11088                          void A::f ();
11089                        };
11090
11091                        Is this ill-formed?  */
11092
11093                     if (pedantic)
11094                       pedwarn ("extra qualification `%T::' on member `%s' ignored",
11095                                   ctype, name);
11096                   }
11097                 else if (TREE_CODE (type) == FUNCTION_TYPE)
11098                   {
11099                     if (current_class_type == NULL_TREE || friendp)
11100                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11101                                                       TYPE_ARG_TYPES (type));
11102                     else
11103                       {
11104                         error ("cannot declare member function `%T::%s' within `%T'",
11105                                   ctype, name, current_class_type);
11106                         return void_type_node;
11107                       }
11108                   }
11109                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
11110                          || COMPLETE_TYPE_P (complete_type (ctype)))
11111                   {
11112                     /* Have to move this code elsewhere in this function.
11113                        this code is used for i.e., typedef int A::M; M *pm;
11114
11115                        It is?  How? jason 10/2/94 */
11116
11117                     if (current_class_type)
11118                       {
11119                         error ("cannot declare member `%T::%s' within `%T'",
11120                                   ctype, name, current_class_type);
11121                         return void_type_node;
11122                       }
11123                     type = build_offset_type (ctype, type);
11124                   }
11125                 else
11126                   {
11127                     incomplete_type_error (NULL_TREE, ctype);
11128                     return error_mark_node;
11129                   }
11130
11131                 declarator = sname;
11132               }
11133             else if (TREE_CODE (sname) == SCOPE_REF)
11134               abort ();
11135             else
11136               {
11137               done_scoping:
11138                 declarator = TREE_OPERAND (declarator, 1);
11139                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
11140                   /* In this case, we will deal with it later.  */
11141                   ;
11142                 else
11143                   {
11144                     if (TREE_CODE (type) == FUNCTION_TYPE)
11145                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11146                                                       TYPE_ARG_TYPES (type));
11147                     else
11148                       type = build_offset_type (ctype, type);
11149                   }
11150               }
11151           }
11152           break;
11153
11154         case BIT_NOT_EXPR:
11155           declarator = TREE_OPERAND (declarator, 0);
11156           break;
11157
11158         case RECORD_TYPE:
11159         case UNION_TYPE:
11160         case ENUMERAL_TYPE:
11161           declarator = NULL_TREE;
11162           break;
11163
11164         case ERROR_MARK:
11165           declarator = NULL_TREE;
11166           break;
11167
11168         default:
11169           abort ();
11170         }
11171     }
11172
11173   if (returned_attrs)
11174     {
11175       if (attrlist)
11176         *attrlist = chainon (returned_attrs, *attrlist);
11177       else
11178         attrlist = &returned_attrs;
11179     }
11180
11181   /* Now TYPE has the actual type.  */
11182
11183   /* Did array size calculations overflow?  */
11184
11185   if (TREE_CODE (type) == ARRAY_TYPE
11186       && COMPLETE_TYPE_P (type)
11187       && TREE_OVERFLOW (TYPE_SIZE (type)))
11188     {
11189       error ("size of array `%s' is too large", name);
11190       /* If we proceed with the array type as it is, we'll eventually
11191          crash in tree_low_cst().  */
11192       type = error_mark_node;
11193     }
11194
11195   if (explicitp == 1 || (explicitp && friendp))
11196     {
11197       /* [dcl.fct.spec] The explicit specifier shall only be used in
11198          declarations of constructors within a class definition.  */
11199       error ("only declarations of constructors can be `explicit'");
11200       explicitp = 0;
11201     }
11202
11203   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11204     {
11205       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11206         {
11207           error ("non-member `%s' cannot be declared `mutable'", name);
11208           RIDBIT_RESET (RID_MUTABLE, specbits);
11209         }
11210       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11211         {
11212           error ("non-object member `%s' cannot be declared `mutable'", name);
11213           RIDBIT_RESET (RID_MUTABLE, specbits);
11214         }
11215       else if (TREE_CODE (type) == FUNCTION_TYPE
11216                || TREE_CODE (type) == METHOD_TYPE)
11217         {
11218           error ("function `%s' cannot be declared `mutable'", name);
11219           RIDBIT_RESET (RID_MUTABLE, specbits);
11220         }
11221       else if (staticp)
11222         {
11223           error ("static `%s' cannot be declared `mutable'", name);
11224           RIDBIT_RESET (RID_MUTABLE, specbits);
11225         }
11226       else if (type_quals & TYPE_QUAL_CONST)
11227         {
11228           error ("const `%s' cannot be declared `mutable'", name);
11229           RIDBIT_RESET (RID_MUTABLE, specbits);
11230         }
11231     }
11232
11233   if (declarator == NULL_TREE
11234       || TREE_CODE (declarator) == IDENTIFIER_NODE
11235       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11236           && (TREE_CODE (type) == FUNCTION_TYPE
11237               || TREE_CODE (type) == METHOD_TYPE)))
11238     /* OK */;
11239   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11240     {
11241       error ("template-id `%D' used as a declarator", declarator);
11242       declarator = dname;
11243     }
11244   else
11245     /* Unexpected declarator format.  */
11246     abort ();
11247
11248   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11249
11250   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11251     {
11252       tree decl;
11253
11254       /* Note that the grammar rejects storage classes
11255          in typenames, fields or parameters.  */
11256       if (current_lang_name == lang_name_java)
11257         TYPE_FOR_JAVA (type) = 1;
11258
11259       if (decl_context == FIELD)
11260         {
11261           if (declarator == constructor_name (current_class_type))
11262             pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11263                         declarator);
11264           decl = build_lang_decl (TYPE_DECL, declarator, type);
11265         }
11266       else
11267         {
11268           decl = build_decl (TYPE_DECL, declarator, type);
11269           if (!current_function_decl)
11270             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11271         }
11272
11273       /* If the user declares "typedef struct {...} foo" then the
11274          struct will have an anonymous name.  Fill that name in now.
11275          Nothing can refer to it, so nothing needs know about the name
11276          change.  */
11277       if (type != error_mark_node
11278           && declarator
11279           && TYPE_NAME (type)
11280           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11281           && TYPE_ANONYMOUS_P (type)
11282           /* Don't do this if there are attributes.  */
11283           && (!attrlist || !*attrlist)
11284           && cp_type_quals (type) == TYPE_UNQUALIFIED)
11285         {
11286           tree oldname = TYPE_NAME (type);
11287           tree t;
11288
11289           /* Replace the anonymous name with the real name everywhere.  */
11290           lookup_tag_reverse (type, declarator);
11291           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11292             if (TYPE_NAME (t) == oldname)
11293               TYPE_NAME (t) = decl;
11294
11295           if (TYPE_LANG_SPECIFIC (type))
11296             TYPE_WAS_ANONYMOUS (type) = 1;
11297
11298           /* If this is a typedef within a template class, the nested
11299              type is a (non-primary) template.  The name for the
11300              template needs updating as well.  */
11301           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11302             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11303               = TYPE_IDENTIFIER (type);
11304
11305           /* FIXME remangle member functions; member functions of a
11306              type with external linkage have external linkage.  */
11307         }
11308
11309       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11310         {
11311           cp_error_at ("typedef name may not be class-qualified", decl);
11312           return NULL_TREE;
11313         }
11314       else if (quals)
11315         {
11316           if (ctype == NULL_TREE)
11317             {
11318               if (TREE_CODE (type) != METHOD_TYPE)
11319                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11320               else
11321                 ctype = TYPE_METHOD_BASETYPE (type);
11322             }
11323           if (ctype != NULL_TREE)
11324             grok_method_quals (ctype, decl, quals);
11325         }
11326
11327       if (RIDBIT_SETP (RID_SIGNED, specbits)
11328           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11329         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11330
11331       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11332                       inlinep, friendp, raises != NULL_TREE);
11333
11334       if (initialized)
11335         error ("typedef declaration includes an initializer");
11336
11337       return decl;
11338     }
11339
11340   /* Detect the case of an array type of unspecified size
11341      which came, as such, direct from a typedef name.
11342      We must copy the type, so that the array's domain can be
11343      individually set by the object's initializer.  */
11344
11345   if (type && typedef_type
11346       && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
11347       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
11348     type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
11349
11350   /* Detect where we're using a typedef of function type to declare a
11351      function. last_function_parms will not be set, so we must create
11352      it now.  */
11353
11354   if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
11355     {
11356       tree decls = NULL_TREE;
11357       tree args;
11358
11359       for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
11360         {
11361           tree decl = build_decl (PARM_DECL, NULL_TREE, TREE_VALUE (args));
11362
11363           TREE_CHAIN (decl) = decls;
11364           decls = decl;
11365         }
11366
11367       last_function_parms = nreverse (decls);
11368     }
11369
11370   /* If this is a type name (such as, in a cast or sizeof),
11371      compute the type and return it now.  */
11372
11373   if (decl_context == TYPENAME)
11374     {
11375       /* Note that the grammar rejects storage classes
11376          in typenames, fields or parameters.  */
11377       if (type_quals != TYPE_UNQUALIFIED)
11378         type_quals = TYPE_UNQUALIFIED;
11379
11380       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11381       if (friendp)
11382         {
11383           if (type_quals != TYPE_UNQUALIFIED)
11384             {
11385               error ("type qualifiers specified for friend class declaration");
11386               type_quals = TYPE_UNQUALIFIED;
11387             }
11388           if (inlinep)
11389             {
11390               error ("`inline' specified for friend class declaration");
11391               inlinep = 0;
11392             }
11393
11394           /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11395              But don't allow implicit typenames except with a class-key.  */
11396           if (!current_aggr && (TREE_CODE (type) != TYPENAME_TYPE
11397                                 || IMPLICIT_TYPENAME_P (type)))
11398             {
11399               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11400                 pedwarn ("template parameters cannot be friends");
11401               else if (TREE_CODE (type) == TYPENAME_TYPE)
11402                 pedwarn ("\
11403 friend declaration requires class-key, i.e. `friend class %T::%T'",
11404                             constructor_name (current_class_type),
11405                             TYPE_IDENTIFIER (type));
11406               else
11407                 pedwarn ("\
11408 friend declaration requires class-key, i.e. `friend %#T'",
11409                             type);
11410             }
11411
11412           /* Only try to do this stuff if we didn't already give up.  */
11413           if (type != integer_type_node)
11414             {
11415               decl_type_access_control (TYPE_NAME (type));
11416
11417               /* A friendly class?  */
11418               if (current_class_type)
11419                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11420               else
11421                 error ("trying to make class `%T' a friend of global scope",
11422                           type);
11423
11424               type = void_type_node;
11425             }
11426         }
11427       else if (quals)
11428         {
11429           if (ctype == NULL_TREE)
11430             {
11431               if (TREE_CODE (type) != METHOD_TYPE)
11432                 error ("invalid qualifiers on non-member function type");
11433               else
11434                 ctype = TYPE_METHOD_BASETYPE (type);
11435             }
11436           if (ctype)
11437             {
11438               tree dummy = build_decl (TYPE_DECL, declarator, type);
11439               grok_method_quals (ctype, dummy, quals);
11440               type = TREE_TYPE (dummy);
11441             }
11442         }
11443
11444       return type;
11445     }
11446   else if (declarator == NULL_TREE && decl_context != PARM
11447            && decl_context != CATCHPARM
11448            && TREE_CODE (type) != UNION_TYPE
11449            && ! bitfield)
11450     {
11451       error ("abstract declarator `%T' used as declaration", type);
11452       declarator = make_anon_name ();
11453     }
11454
11455   /* `void' at top level (not within pointer)
11456      is allowed only in typedefs or type names.
11457      We don't complain about parms either, but that is because
11458      a better error message can be made later.  */
11459
11460   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11461     {
11462       if (! declarator)
11463         error ("unnamed variable or field declared void");
11464       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11465         {
11466           if (IDENTIFIER_OPNAME_P (declarator))
11467             abort ();
11468           else
11469             error ("variable or field `%s' declared void", name);
11470         }
11471       else
11472         error ("variable or field declared void");
11473       type = integer_type_node;
11474     }
11475
11476   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11477      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11478
11479   if (decl_context == PARM || decl_context == CATCHPARM)
11480     {
11481       if (ctype || in_namespace)
11482         error ("cannot use `::' in parameter declaration");
11483
11484       /* A parameter declared as an array of T is really a pointer to T.
11485          One declared as a function is really a pointer to a function.
11486          One declared as a member is really a pointer to member.  */
11487
11488       if (TREE_CODE (type) == ARRAY_TYPE)
11489         {
11490           /* Transfer const-ness of array into that of type pointed to.  */
11491           type = build_pointer_type (TREE_TYPE (type));
11492           type_quals = TYPE_UNQUALIFIED;
11493         }
11494       else if (TREE_CODE (type) == FUNCTION_TYPE)
11495         type = build_pointer_type (type);
11496       else if (TREE_CODE (type) == OFFSET_TYPE)
11497         type = build_pointer_type (type);
11498     }
11499
11500   {
11501     register tree decl;
11502
11503     if (decl_context == PARM)
11504       {
11505         decl = build_decl (PARM_DECL, declarator, type);
11506
11507         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11508                         inlinep, friendp, raises != NULL_TREE);
11509
11510         /* Compute the type actually passed in the parmlist,
11511            for the case where there is no prototype.
11512            (For example, shorts and chars are passed as ints.)
11513            When there is a prototype, this is overridden later.  */
11514
11515         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11516       }
11517     else if (decl_context == FIELD)
11518       {
11519         if (type == error_mark_node)
11520           {
11521             /* Happens when declaring arrays of sizes which
11522                are error_mark_node, for example.  */
11523             decl = NULL_TREE;
11524           }
11525         else if (in_namespace && !friendp)
11526           {
11527             /* Something like struct S { int N::j; };  */
11528             error ("invalid use of `::'");
11529             decl = NULL_TREE;
11530           }
11531         else if (TREE_CODE (type) == FUNCTION_TYPE)
11532           {
11533             int publicp = 0;
11534             tree function_context;
11535
11536             /* We catch the others as conflicts with the builtin
11537                typedefs.  */
11538             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11539               {
11540                 error ("function `%D' cannot be declared friend",
11541                           declarator);
11542                 friendp = 0;
11543               }
11544
11545             if (friendp == 0)
11546               {
11547                 if (ctype == NULL_TREE)
11548                   ctype = current_class_type;
11549
11550                 if (ctype == NULL_TREE)
11551                   {
11552                     error ("can't make `%D' into a method -- not in a class",
11553                               declarator);
11554                     return void_type_node;
11555                   }
11556
11557                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11558                    ARM 9.5 */
11559                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11560                   {
11561                     error ("function `%D' declared virtual inside a union",
11562                               declarator);
11563                     return void_type_node;
11564                   }
11565
11566                 if (declarator == ansi_opname (NEW_EXPR)
11567                     || declarator == ansi_opname (VEC_NEW_EXPR)
11568                     || declarator == ansi_opname (DELETE_EXPR)
11569                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11570                   {
11571                     if (virtualp)
11572                       {
11573                         error ("`%D' cannot be declared virtual, since it is always static",
11574                                   declarator);
11575                         virtualp = 0;
11576                       }
11577                   }
11578                 else if (staticp < 2)
11579                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11580                                                   TYPE_ARG_TYPES (type));
11581               }
11582
11583             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11584             function_context = (ctype != NULL_TREE) ?
11585               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11586             publicp = (! friendp || ! staticp)
11587               && function_context == NULL_TREE;
11588             decl = grokfndecl (ctype, type,
11589                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11590                                ? declarator : dname,
11591                                declarator,
11592                                virtualp, flags, quals, raises,
11593                                friendp ? -1 : 0, friendp, publicp, inlinep,
11594                                funcdef_flag, template_count, in_namespace);
11595             if (decl == NULL_TREE)
11596               return decl;
11597 #if 0
11598             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11599             /* The decl and setting of decl_attr is also turned off.  */
11600             decl = build_decl_attribute_variant (decl, decl_attr);
11601 #endif
11602
11603             /* [class.conv.ctor]
11604
11605                A constructor declared without the function-specifier
11606                explicit that can be called with a single parameter
11607                specifies a conversion from the type of its first
11608                parameter to the type of its class.  Such a constructor
11609                is called a converting constructor.  */
11610             if (explicitp == 2)
11611               DECL_NONCONVERTING_P (decl) = 1;
11612             else if (DECL_CONSTRUCTOR_P (decl))
11613               {
11614                 /* The constructor can be called with exactly one
11615                    parameter if there is at least one parameter, and
11616                    any subsequent parameters have default arguments.
11617                    Ignore any compiler-added parms.  */
11618                 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
11619
11620                 if (arg_types == void_list_node
11621                     || (arg_types
11622                         && TREE_CHAIN (arg_types)
11623                         && TREE_CHAIN (arg_types) != void_list_node
11624                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11625                   DECL_NONCONVERTING_P (decl) = 1;
11626               }
11627           }
11628         else if (TREE_CODE (type) == METHOD_TYPE)
11629           {
11630             /* We only get here for friend declarations of
11631                members of other classes.  */
11632             /* All method decls are public, so tell grokfndecl to set
11633                TREE_PUBLIC, also.  */
11634             decl = grokfndecl (ctype, type, declarator, declarator,
11635                                virtualp, flags, quals, raises,
11636                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11637                                template_count, in_namespace);
11638             if (decl == NULL_TREE)
11639               return NULL_TREE;
11640           }
11641         else if (!staticp && ! processing_template_decl
11642                  && !COMPLETE_TYPE_P (complete_type (type))
11643                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11644           {
11645             if (declarator)
11646               error ("field `%D' has incomplete type", declarator);
11647             else
11648               error ("name `%T' has incomplete type", type);
11649
11650             /* If we're instantiating a template, tell them which
11651                instantiation made the field's type be incomplete.  */
11652             if (current_class_type
11653                 && TYPE_NAME (current_class_type)
11654                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11655                 && declspecs && TREE_VALUE (declspecs)
11656                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11657               error ("  in instantiation of template `%T'",
11658                         current_class_type);
11659
11660             type = error_mark_node;
11661             decl = NULL_TREE;
11662           }
11663         else
11664           {
11665             if (friendp)
11666               {
11667                 error ("`%s' is neither function nor member function; cannot be declared friend",
11668                        IDENTIFIER_POINTER (declarator));
11669                 friendp = 0;
11670               }
11671             decl = NULL_TREE;
11672           }
11673
11674         if (friendp)
11675           {
11676             /* Friends are treated specially.  */
11677             if (ctype == current_class_type)
11678               warning ("member functions are implicitly friends of their class");
11679             else
11680               {
11681                 tree t = NULL_TREE;
11682                 if (decl && DECL_NAME (decl))
11683                   {
11684                     if (template_class_depth (current_class_type) == 0)
11685                       {
11686                         decl
11687                           = check_explicit_specialization
11688                           (declarator, decl,
11689                            template_count, 2 * (funcdef_flag != 0) + 4);
11690                         if (decl == error_mark_node)
11691                           return error_mark_node;
11692                       }
11693
11694                     t = do_friend (ctype, declarator, decl,
11695                                    last_function_parms, *attrlist,
11696                                    flags, quals, funcdef_flag);
11697                   }
11698                 if (t && funcdef_flag)
11699                   return t;
11700
11701                 return void_type_node;
11702               }
11703           }
11704
11705         /* Structure field.  It may not be a function, except for C++ */
11706
11707         if (decl == NULL_TREE)
11708           {
11709             if (initialized)
11710               {
11711                 if (!staticp)
11712                   {
11713                     /* An attempt is being made to initialize a non-static
11714                        member.  But, from [class.mem]:
11715
11716                        4 A member-declarator can contain a
11717                        constant-initializer only if it declares a static
11718                        member (_class.static_) of integral or enumeration
11719                        type, see _class.static.data_.
11720
11721                        This used to be relatively common practice, but
11722                        the rest of the compiler does not correctly
11723                        handle the initialization unless the member is
11724                        static so we make it static below.  */
11725                     pedwarn ("ISO C++ forbids initialization of member `%D'",
11726                                 declarator);
11727                     pedwarn ("making `%D' static", declarator);
11728                     staticp = 1;
11729                   }
11730
11731                 if (uses_template_parms (type))
11732                   /* We'll check at instantiation time.  */
11733                   ;
11734                 else if (check_static_variable_definition (declarator,
11735                                                            type))
11736                   /* If we just return the declaration, crashes
11737                      will sometimes occur.  We therefore return
11738                      void_type_node, as if this was a friend
11739                      declaration, to cause callers to completely
11740                      ignore this declaration.  */
11741                   return void_type_node;
11742               }
11743
11744             /* 9.2p13 [class.mem] */
11745             if (declarator == constructor_name (current_class_type)
11746                 /* The standard does not allow non-static data members
11747                    here either, but we agreed at the 10/99 meeting
11748                    to change that in TC 1 so that they are allowed in
11749                    classes with no user-defined constructors.  */
11750                 && staticp)
11751               pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11752                           declarator);
11753
11754             if (staticp)
11755               {
11756                 /* C++ allows static class members.  All other work
11757                    for this is done by grokfield.  */
11758                 decl = build_lang_decl (VAR_DECL, declarator, type);
11759                 TREE_STATIC (decl) = 1;
11760                 /* In class context, 'static' means public access.  */
11761                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11762               }
11763             else
11764               {
11765                 decl = build_decl (FIELD_DECL, declarator, type);
11766                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11767                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11768                   {
11769                     DECL_MUTABLE_P (decl) = 1;
11770                     RIDBIT_RESET (RID_MUTABLE, specbits);
11771                   }
11772               }
11773
11774             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11775                             inlinep, friendp, raises != NULL_TREE);
11776           }
11777       }
11778     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11779       {
11780         tree original_name;
11781         int publicp = 0;
11782
11783         if (! declarator)
11784           return NULL_TREE;
11785
11786         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11787           original_name = dname;
11788         else
11789           original_name = declarator;
11790
11791         if (RIDBIT_SETP (RID_AUTO, specbits))
11792           error ("storage class `auto' invalid for function `%s'", name);
11793         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11794           error ("storage class `register' invalid for function `%s'", name);
11795
11796         /* Function declaration not at top level.
11797            Storage classes other than `extern' are not allowed
11798            and `extern' makes no difference.  */
11799         if (! toplevel_bindings_p ()
11800             && (RIDBIT_SETP (RID_STATIC, specbits)
11801                 || RIDBIT_SETP (RID_INLINE, specbits))
11802             && pedantic)
11803           {
11804             if (RIDBIT_SETP (RID_STATIC, specbits))
11805               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11806             else
11807               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11808           }
11809
11810         if (ctype == NULL_TREE)
11811           {
11812             if (virtualp)
11813               {
11814                 error ("virtual non-class function `%s'", name);
11815                 virtualp = 0;
11816               }
11817           }
11818         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11819           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11820                                           TYPE_ARG_TYPES (type));
11821
11822         /* Record presence of `static'.  */
11823         publicp = (ctype != NULL_TREE
11824                    || RIDBIT_SETP (RID_EXTERN, specbits)
11825                    || !RIDBIT_SETP (RID_STATIC, specbits));
11826
11827         decl = grokfndecl (ctype, type, original_name, declarator,
11828                            virtualp, flags, quals, raises,
11829                            1, friendp,
11830                            publicp, inlinep, funcdef_flag,
11831                            template_count, in_namespace);
11832         if (decl == NULL_TREE)
11833           return NULL_TREE;
11834
11835         if (staticp == 1)
11836           {
11837             int illegal_static = 0;
11838
11839             /* Don't allow a static member function in a class, and forbid
11840                declaring main to be static.  */
11841             if (TREE_CODE (type) == METHOD_TYPE)
11842               {
11843                 pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11844                 illegal_static = 1;
11845               }
11846             else if (current_function_decl)
11847               {
11848                 /* FIXME need arm citation */
11849                 error ("cannot declare static function inside another function");
11850                 illegal_static = 1;
11851               }
11852
11853             if (illegal_static)
11854               {
11855                 staticp = 0;
11856                 RIDBIT_RESET (RID_STATIC, specbits);
11857               }
11858           }
11859       }
11860     else
11861       {
11862         /* It's a variable.  */
11863
11864         /* An uninitialized decl with `extern' is a reference.  */
11865         decl = grokvardecl (type, declarator, &specbits,
11866                             initialized,
11867                             (type_quals & TYPE_QUAL_CONST) != 0,
11868                             in_namespace);
11869         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11870                         inlinep, friendp, raises != NULL_TREE);
11871
11872         if (ctype)
11873           {
11874             DECL_CONTEXT (decl) = ctype;
11875             if (staticp == 1)
11876               {
11877                 pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
11878                 staticp = 0;
11879                 RIDBIT_RESET (RID_STATIC, specbits);
11880               }
11881             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11882               {
11883                 error ("static member `%D' declared `register'", decl);
11884                 RIDBIT_RESET (RID_REGISTER, specbits);
11885               }
11886             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11887               {
11888                 pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11889                             decl);
11890                 RIDBIT_RESET (RID_EXTERN, specbits);
11891               }
11892           }
11893       }
11894
11895     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11896
11897     /* Record `register' declaration for warnings on &
11898        and in case doing stupid register allocation.  */
11899
11900     if (RIDBIT_SETP (RID_REGISTER, specbits))
11901       DECL_REGISTER (decl) = 1;
11902
11903     if (RIDBIT_SETP (RID_EXTERN, specbits))
11904       DECL_THIS_EXTERN (decl) = 1;
11905
11906     if (RIDBIT_SETP (RID_STATIC, specbits))
11907       DECL_THIS_STATIC (decl) = 1;
11908
11909     /* Record constancy and volatility.  There's no need to do this
11910        when processing a template; we'll do this for the instantiated
11911        declaration based on the type of DECL.  */
11912     if (!processing_template_decl)
11913       c_apply_type_quals_to_decl (type_quals, decl);
11914
11915     return decl;
11916   }
11917 }
11918 \f
11919 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11920    An empty exprlist is a parmlist.  An exprlist which
11921    contains only identifiers at the global level
11922    is a parmlist.  Otherwise, it is an exprlist.  */
11923
11924 int
11925 parmlist_is_exprlist (exprs)
11926      tree exprs;
11927 {
11928   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11929     return 0;
11930
11931   if (toplevel_bindings_p ())
11932     {
11933       /* At the global level, if these are all identifiers,
11934          then it is a parmlist.  */
11935       while (exprs)
11936         {
11937           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11938             return 1;
11939           exprs = TREE_CHAIN (exprs);
11940         }
11941       return 0;
11942     }
11943   return 1;
11944 }
11945
11946 /* Subroutine of start_function.  Ensure that each of the parameter
11947    types (as listed in PARMS) is complete, as is required for a
11948    function definition.  */
11949
11950 static void
11951 require_complete_types_for_parms (parms)
11952      tree parms;
11953 {
11954   for (; parms; parms = TREE_CHAIN (parms))
11955     {
11956       if (VOID_TYPE_P (TREE_TYPE (parms)))
11957         /* grokparms will have already issued an error */
11958         TREE_TYPE (parms) = error_mark_node;
11959       else if (complete_type_or_else (TREE_TYPE (parms), parms))
11960         layout_decl (parms, 0);
11961       else
11962         TREE_TYPE (parms) = error_mark_node;
11963     }
11964 }
11965
11966 /* Returns non-zero if T is a local variable.  */
11967
11968 int
11969 local_variable_p (t)
11970      tree t;
11971 {
11972   if ((TREE_CODE (t) == VAR_DECL
11973        /* A VAR_DECL with a context that is a _TYPE is a static data
11974           member.  */
11975        && !TYPE_P (CP_DECL_CONTEXT (t))
11976        /* Any other non-local variable must be at namespace scope.  */
11977        && !DECL_NAMESPACE_SCOPE_P (t))
11978       || (TREE_CODE (t) == PARM_DECL))
11979     return 1;
11980
11981   return 0;
11982 }
11983
11984 /* Returns non-zero if T is an automatic local variable or a label.
11985    (These are the declarations that need to be remapped when the code
11986    containing them is duplicated.)  */
11987
11988 int
11989 nonstatic_local_decl_p (t)
11990      tree t;
11991 {
11992   return ((local_variable_p (t) && !TREE_STATIC (t))
11993           || TREE_CODE (t) == LABEL_DECL
11994           || TREE_CODE (t) == RESULT_DECL);
11995 }
11996
11997 /* Like local_variable_p, but suitable for use as a tree-walking
11998    function.  */
11999
12000 static tree
12001 local_variable_p_walkfn (tp, walk_subtrees, data)
12002      tree *tp;
12003      int *walk_subtrees ATTRIBUTE_UNUSED;
12004      void *data ATTRIBUTE_UNUSED;
12005 {
12006   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
12007           ? *tp : NULL_TREE);
12008 }
12009
12010 /* Check that ARG, which is a default-argument expression for a
12011    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
12012    something goes wrong.  DECL may also be a _TYPE node, rather than a
12013    DECL, if there is no DECL available.  */
12014
12015 tree
12016 check_default_argument (decl, arg)
12017      tree decl;
12018      tree arg;
12019 {
12020   tree var;
12021   tree decl_type;
12022
12023   if (TREE_CODE (arg) == DEFAULT_ARG)
12024     /* We get a DEFAULT_ARG when looking at an in-class declaration
12025        with a default argument.  Ignore the argument for now; we'll
12026        deal with it after the class is complete.  */
12027     return arg;
12028
12029   if (processing_template_decl || uses_template_parms (arg))
12030     /* We don't do anything checking until instantiation-time.  Note
12031        that there may be uninstantiated arguments even for an
12032        instantiated function, since default arguments are not
12033        instantiated until they are needed.  */
12034     return arg;
12035
12036   if (TYPE_P (decl))
12037     {
12038       decl_type = decl;
12039       decl = NULL_TREE;
12040     }
12041   else
12042     decl_type = TREE_TYPE (decl);
12043
12044   if (arg == error_mark_node
12045       || decl == error_mark_node
12046       || TREE_TYPE (arg) == error_mark_node
12047       || decl_type == error_mark_node)
12048     /* Something already went wrong.  There's no need to check
12049        further.  */
12050     return error_mark_node;
12051
12052   /* [dcl.fct.default]
12053
12054      A default argument expression is implicitly converted to the
12055      parameter type.  */
12056   if (!TREE_TYPE (arg)
12057       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
12058     {
12059       if (decl)
12060         error ("default argument for `%#D' has type `%T'",
12061                   decl, TREE_TYPE (arg));
12062       else
12063         error ("default argument for parameter of type `%T' has type `%T'",
12064                   decl_type, TREE_TYPE (arg));
12065
12066       return error_mark_node;
12067     }
12068
12069   /* [dcl.fct.default]
12070
12071      Local variables shall not be used in default argument
12072      expressions.
12073
12074      The keyword `this' shall not be used in a default argument of a
12075      member function.  */
12076   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
12077                                       NULL);
12078   if (var)
12079     {
12080       error ("default argument `%E' uses local variable `%D'",
12081                 arg, var);
12082       return error_mark_node;
12083     }
12084
12085   /* All is well.  */
12086   return arg;
12087 }
12088
12089 /* Decode the list of parameter types for a function type.
12090    Given the list of things declared inside the parens,
12091    return a list of types.
12092
12093    We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
12094    flag. If unset, we append void_list_node. A parmlist declared
12095    as `(void)' is accepted as the empty parmlist.
12096
12097    Also set last_function_parms to the chain of PARM_DECLs.  */
12098
12099 static tree
12100 grokparms (first_parm)
12101      tree first_parm;
12102 {
12103   tree result = NULL_TREE;
12104   tree decls = NULL_TREE;
12105   int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
12106   tree parm, chain;
12107   int any_error = 0;
12108
12109   my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
12110
12111   for (parm = first_parm; parm != NULL_TREE; parm = chain)
12112     {
12113       tree type = NULL_TREE;
12114       tree decl = TREE_VALUE (parm);
12115       tree init = TREE_PURPOSE (parm);
12116       tree specs, attrs;
12117
12118       chain = TREE_CHAIN (parm);
12119       /* @@ weak defense against parse errors.  */
12120       if (TREE_CODE (decl) != VOID_TYPE
12121           && TREE_CODE (decl) != TREE_LIST)
12122         {
12123           /* Give various messages as the need arises.  */
12124           if (TREE_CODE (decl) == STRING_CST)
12125             error ("invalid string constant `%E'", decl);
12126           else if (TREE_CODE (decl) == INTEGER_CST)
12127             error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12128           continue;
12129         }
12130
12131       if (parm == void_list_node)
12132         break;
12133
12134       split_specs_attrs (TREE_PURPOSE (decl), &specs, &attrs);
12135       decl = grokdeclarator (TREE_VALUE (decl), specs,
12136                              PARM, init != NULL_TREE, &attrs);
12137       if (! decl || TREE_TYPE (decl) == error_mark_node)
12138         continue;
12139
12140       if (attrs)
12141         cplus_decl_attributes (&decl, attrs, 0);
12142
12143       type = TREE_TYPE (decl);
12144       if (VOID_TYPE_P (type))
12145         {
12146           if (same_type_p (type, void_type_node)
12147               && !DECL_NAME (decl) && !result && !chain && !ellipsis)
12148             /* this is a parmlist of `(void)', which is ok.  */
12149             break;
12150           incomplete_type_error (decl, type);
12151           /* It's not a good idea to actually create parameters of
12152              type `void'; other parts of the compiler assume that a
12153              void type terminates the parameter list.  */
12154           type = error_mark_node;
12155           TREE_TYPE (decl) = error_mark_node;
12156         }
12157
12158       if (type != error_mark_node)
12159         {
12160           /* Top-level qualifiers on the parameters are
12161              ignored for function types.  */
12162           type = TYPE_MAIN_VARIANT (type);
12163           if (TREE_CODE (type) == METHOD_TYPE)
12164             {
12165               error ("parameter `%D' invalidly declared method type", decl);
12166               type = build_pointer_type (type);
12167               TREE_TYPE (decl) = type;
12168             }
12169           else if (TREE_CODE (type) == OFFSET_TYPE)
12170             {
12171               error ("parameter `%D' invalidly declared offset type", decl);
12172               type = build_pointer_type (type);
12173               TREE_TYPE (decl) = type;
12174             }
12175           else if (abstract_virtuals_error (decl, type))
12176             any_error = 1;  /* Seems like a good idea. */
12177           else if (POINTER_TYPE_P (type))
12178             {
12179               /* [dcl.fct]/6, parameter types cannot contain pointers
12180                  (references) to arrays of unknown bound.  */
12181               tree t = TREE_TYPE (type);
12182               int ptr = TYPE_PTR_P (type);
12183
12184               while (1)
12185                 {
12186                   if (TYPE_PTR_P (t))
12187                     ptr = 1;
12188                   else if (TREE_CODE (t) != ARRAY_TYPE)
12189                     break;
12190                   else if (!TYPE_DOMAIN (t))
12191                     break;
12192                   t = TREE_TYPE (t);
12193                 }
12194               if (TREE_CODE (t) == ARRAY_TYPE)
12195                 error ("parameter `%D' includes %s to array of unknown bound `%T'",
12196                           decl, ptr ? "pointer" : "reference", t);
12197             }
12198
12199           DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12200           if (PROMOTE_PROTOTYPES
12201               && INTEGRAL_TYPE_P (type)
12202               && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12203             DECL_ARG_TYPE (decl) = integer_type_node;
12204           if (!any_error && init)
12205             init = check_default_argument (decl, init);
12206           else
12207             init = NULL_TREE;
12208         }
12209
12210       TREE_CHAIN (decl) = decls;
12211       decls = decl;
12212       result = tree_cons (init, type, result);
12213     }
12214   decls = nreverse (decls);
12215   result = nreverse (result);
12216   if (!ellipsis)
12217     result = chainon (result, void_list_node);
12218   last_function_parms = decls;
12219
12220   return result;
12221 }
12222
12223 \f
12224 /* D is a constructor or overloaded `operator='.
12225
12226    Let T be the class in which D is declared. Then, this function
12227    returns:
12228
12229    -1 if D's is an ill-formed constructor or copy assignment operator
12230       whose first parameter is of type `T'.
12231    0  if D is not a copy constructor or copy assignment
12232       operator.
12233    1  if D is a copy constructor or copy assignment operator whose
12234       first parameter is a reference to const qualified T.
12235    2  if D is a copy constructor or copy assignment operator whose
12236       first parameter is a reference to non-const qualified T.
12237
12238    This function can be used as a predicate. Positive values indicate
12239    a copy constructor and non-zero values indicate a copy assignment
12240    operator.  */
12241
12242 int
12243 copy_fn_p (d)
12244      tree d;
12245 {
12246   tree args;
12247   tree arg_type;
12248   int result = 1;
12249
12250   my_friendly_assert (DECL_FUNCTION_MEMBER_P (d), 20011208);
12251
12252   if (DECL_TEMPLATE_INFO (d) && is_member_template (DECL_TI_TEMPLATE (d)))
12253     /* Instantiations of template member functions are never copy
12254        functions.  Note that member functions of templated classes are
12255        represented as template functions internally, and we must
12256        accept those as copy functions.  */
12257     return 0;
12258
12259   args = FUNCTION_FIRST_USER_PARMTYPE (d);
12260   if (!args)
12261     return 0;
12262
12263   arg_type = TREE_VALUE (args);
12264
12265   if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
12266     {
12267       /* Pass by value copy assignment operator.  */
12268       result = -1;
12269     }
12270   else if (TREE_CODE (arg_type) == REFERENCE_TYPE
12271            && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
12272     {
12273       if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
12274         result = 2;
12275     }
12276   else
12277     return 0;
12278
12279   args = TREE_CHAIN (args);
12280
12281   if (args && args != void_list_node && !TREE_PURPOSE (args))
12282     /* There are more non-optional args.  */
12283     return 0;
12284
12285   return result;
12286 }
12287
12288 /* Remember any special properties of member function DECL.  */
12289
12290 void grok_special_member_properties (decl)
12291      tree decl;
12292 {
12293   if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl))
12294     ; /* Not special.  */
12295   else if (DECL_CONSTRUCTOR_P (decl))
12296     {
12297       int ctor = copy_fn_p (decl);
12298
12299       if (ctor > 0)
12300         {
12301           /* [class.copy]
12302
12303              A non-template constructor for class X is a copy
12304              constructor if its first parameter is of type X&, const
12305              X&, volatile X& or const volatile X&, and either there
12306              are no other parameters or else all other parameters have
12307              default arguments.  */
12308           TYPE_HAS_INIT_REF (DECL_CONTEXT (decl)) = 1;
12309           if (ctor > 1)
12310             TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl)) = 1;
12311         }
12312       else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
12313         TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl)) = 1;
12314     }
12315   else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
12316     {
12317       /* [class.copy]
12318
12319          A non-template assignment operator for class X is a copy
12320          assignment operator if its parameter is of type X, X&, const
12321          X&, volatile X& or const volatile X&.  */
12322
12323       int assop = copy_fn_p (decl);
12324
12325       if (assop)
12326         {
12327           TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12328           if (assop != 1)
12329             TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12330           if (DECL_PURE_VIRTUAL_P (decl))
12331             TYPE_HAS_ABSTRACT_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12332         }
12333     }
12334 }
12335
12336 /* Check a constructor DECL has the correct form.  Complains
12337    if the class has a constructor of the form X(X).  */
12338
12339 int
12340 grok_ctor_properties (ctype, decl)
12341      tree ctype, decl;
12342 {
12343   int ctor_parm = copy_fn_p (decl);
12344
12345   if (ctor_parm < 0)
12346     {
12347       /* [class.copy]
12348
12349          A declaration of a constructor for a class X is ill-formed if
12350          its first parameter is of type (optionally cv-qualified) X
12351          and either there are no other parameters or else all other
12352          parameters have default arguments.
12353
12354          We *don't* complain about member template instantiations that
12355          have this form, though; they can occur as we try to decide
12356          what constructor to use during overload resolution.  Since
12357          overload resolution will never prefer such a constructor to
12358          the non-template copy constructor (which is either explicitly
12359          or implicitly defined), there's no need to worry about their
12360          existence.  Theoretically, they should never even be
12361          instantiated, but that's hard to forestall.  */
12362       error ("invalid constructor; you probably meant `%T (const %T&)'",
12363                 ctype, ctype);
12364       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12365       return 0;
12366     }
12367
12368   return 1;
12369 }
12370
12371 /* An operator with this code is unary, but can also be binary.  */
12372
12373 static int
12374 ambi_op_p (code)
12375      enum tree_code code;
12376 {
12377   return (code == INDIRECT_REF
12378           || code == ADDR_EXPR
12379           || code == CONVERT_EXPR
12380           || code == NEGATE_EXPR
12381           || code == PREINCREMENT_EXPR
12382           || code == PREDECREMENT_EXPR);
12383 }
12384
12385 /* An operator with this name can only be unary.  */
12386
12387 static int
12388 unary_op_p (code)
12389      enum tree_code code;
12390 {
12391   return (code == TRUTH_NOT_EXPR
12392           || code == BIT_NOT_EXPR
12393           || code == COMPONENT_REF
12394           || code == TYPE_EXPR);
12395 }
12396
12397 /* Do a little sanity-checking on how they declared their operator.  */
12398
12399 void
12400 grok_op_properties (decl, friendp)
12401      tree decl;
12402      int friendp;
12403 {
12404   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12405   tree argtype;
12406   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12407   tree name = DECL_NAME (decl);
12408   enum tree_code operator_code;
12409   int arity;
12410
12411   /* Count the number of arguments.  */
12412   for (argtype = argtypes, arity = 0;
12413        argtype && argtype != void_list_node;
12414        argtype = TREE_CHAIN (argtype))
12415     ++arity;
12416
12417   if (current_class_type == NULL_TREE)
12418     friendp = 1;
12419
12420   if (DECL_CONV_FN_P (decl))
12421     operator_code = TYPE_EXPR;
12422   else
12423     do
12424       {
12425 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)       \
12426         if (ansi_opname (CODE) == name)                         \
12427           {                                                     \
12428             operator_code = (CODE);                             \
12429             break;                                              \
12430           }                                                     \
12431         else if (ansi_assopname (CODE) == name)                 \
12432           {                                                     \
12433             operator_code = (CODE);                             \
12434             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;              \
12435             break;                                              \
12436           }
12437
12438 #include "operators.def"
12439 #undef DEF_OPERATOR
12440
12441         abort ();
12442       }
12443     while (0);
12444   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12445   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12446
12447   if (! friendp)
12448     {
12449       switch (operator_code)
12450         {
12451         case CALL_EXPR:
12452           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12453           break;
12454
12455         case ARRAY_REF:
12456           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12457           break;
12458
12459         case COMPONENT_REF:
12460         case MEMBER_REF:
12461           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12462           break;
12463
12464         case NEW_EXPR:
12465           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12466           break;
12467
12468         case DELETE_EXPR:
12469           TYPE_GETS_DELETE (current_class_type) |= 1;
12470           break;
12471
12472         case VEC_NEW_EXPR:
12473           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12474           break;
12475
12476         case VEC_DELETE_EXPR:
12477           TYPE_GETS_DELETE (current_class_type) |= 2;
12478           break;
12479
12480         default:
12481           break;
12482         }
12483     }
12484
12485   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12486     {
12487       /* When the compiler encounters the definition of A::operator new, it
12488          doesn't look at the class declaration to find out if it's static.  */
12489       if (methodp)
12490         revert_static_member_fn (decl);
12491
12492       TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12493     }
12494   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12495     {
12496       if (methodp)
12497         revert_static_member_fn (decl);
12498
12499       TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12500     }
12501   else
12502     {
12503       /* An operator function must either be a non-static member function
12504          or have at least one parameter of a class, a reference to a class,
12505          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12506       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12507         {
12508           if (operator_code == TYPE_EXPR
12509               || operator_code == CALL_EXPR
12510               || operator_code == COMPONENT_REF
12511               || operator_code == ARRAY_REF
12512               || operator_code == NOP_EXPR)
12513             error ("`%D' must be a nonstatic member function", decl);
12514           else
12515             {
12516               tree p = argtypes;
12517
12518               if (DECL_STATIC_FUNCTION_P (decl))
12519                 error ("`%D' must be either a non-static member function or a non-member function", decl);
12520
12521               if (p)
12522                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12523                   {
12524                     tree arg = TREE_VALUE (p);
12525                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12526                       arg = TREE_TYPE (arg);
12527
12528                     /* This lets bad template code slip through.  */
12529                     if (IS_AGGR_TYPE (arg)
12530                         || TREE_CODE (arg) == ENUMERAL_TYPE
12531                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12532                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12533                       goto foundaggr;
12534                   }
12535               error
12536                 ("`%D' must have an argument of class or enumerated type",
12537                  decl);
12538             foundaggr:
12539               ;
12540             }
12541         }
12542
12543       if (operator_code == CALL_EXPR)
12544         return;                 /* No restrictions on args. */
12545
12546       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12547         {
12548           tree t = TREE_TYPE (name);
12549           if (! friendp)
12550             {
12551               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12552               const char *what = 0;
12553
12554               if (ref)
12555                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12556
12557               if (TREE_CODE (t) == VOID_TYPE)
12558                 what = "void";
12559               else if (t == current_class_type)
12560                 what = "the same type";
12561               /* Don't force t to be complete here.  */
12562               else if (IS_AGGR_TYPE (t)
12563                        && COMPLETE_TYPE_P (t)
12564                        && DERIVED_FROM_P (t, current_class_type))
12565                 what = "a base class";
12566
12567               if (what)
12568                 warning ("conversion to %s%s will never use a type conversion operator",
12569                          ref ? "a reference to " : "", what);
12570             }
12571         }
12572       if (operator_code == COND_EXPR)
12573         {
12574           /* 13.4.0.3 */
12575           error ("ISO C++ prohibits overloading operator ?:");
12576         }
12577       else if (ambi_op_p (operator_code))
12578         {
12579           if (arity == 1)
12580             /* We pick the one-argument operator codes by default, so
12581                we don't have to change anything.  */
12582             ;
12583           else if (arity == 2)
12584             {
12585               /* If we thought this was a unary operator, we now know
12586                  it to be a binary operator.  */
12587               switch (operator_code)
12588                 {
12589                 case INDIRECT_REF:
12590                   operator_code = MULT_EXPR;
12591                   break;
12592
12593                 case ADDR_EXPR:
12594                   operator_code = BIT_AND_EXPR;
12595                   break;
12596
12597                 case CONVERT_EXPR:
12598                   operator_code = PLUS_EXPR;
12599                   break;
12600
12601                 case NEGATE_EXPR:
12602                   operator_code = MINUS_EXPR;
12603                   break;
12604
12605                 case PREINCREMENT_EXPR:
12606                   operator_code = POSTINCREMENT_EXPR;
12607                   break;
12608
12609                 case PREDECREMENT_EXPR:
12610                   operator_code = POSTDECREMENT_EXPR;
12611                   break;
12612
12613                 default:
12614                   abort ();
12615                 }
12616
12617               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12618
12619               if ((operator_code == POSTINCREMENT_EXPR
12620                    || operator_code == POSTDECREMENT_EXPR)
12621                   && ! processing_template_decl
12622                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12623                 {
12624                   if (methodp)
12625                     error ("postfix `%D' must take `int' as its argument",
12626                               decl);
12627                   else
12628                     error
12629                       ("postfix `%D' must take `int' as its second argument",
12630                        decl);
12631                 }
12632             }
12633           else
12634             {
12635               if (methodp)
12636                 error ("`%D' must take either zero or one argument", decl);
12637               else
12638                 error ("`%D' must take either one or two arguments", decl);
12639             }
12640
12641           /* More Effective C++ rule 6.  */
12642           if (warn_ecpp
12643               && (operator_code == POSTINCREMENT_EXPR
12644                   || operator_code == POSTDECREMENT_EXPR
12645                   || operator_code == PREINCREMENT_EXPR
12646                   || operator_code == PREDECREMENT_EXPR))
12647             {
12648               tree arg = TREE_VALUE (argtypes);
12649               tree ret = TREE_TYPE (TREE_TYPE (decl));
12650               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12651                 arg = TREE_TYPE (arg);
12652               arg = TYPE_MAIN_VARIANT (arg);
12653               if (operator_code == PREINCREMENT_EXPR
12654                   || operator_code == PREDECREMENT_EXPR)
12655                 {
12656                   if (TREE_CODE (ret) != REFERENCE_TYPE
12657                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12658                                        arg))
12659                     warning ("prefix `%D' should return `%T'", decl,
12660                                 build_reference_type (arg));
12661                 }
12662               else
12663                 {
12664                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12665                     warning ("postfix `%D' should return `%T'", decl, arg);
12666                 }
12667             }
12668         }
12669       else if (unary_op_p (operator_code))
12670         {
12671           if (arity != 1)
12672             {
12673               if (methodp)
12674                 error ("`%D' must take `void'", decl);
12675               else
12676                 error ("`%D' must take exactly one argument", decl);
12677             }
12678         }
12679       else /* if (binary_op_p (operator_code)) */
12680         {
12681           if (arity != 2)
12682             {
12683               if (methodp)
12684                 error ("`%D' must take exactly one argument", decl);
12685               else
12686                 error ("`%D' must take exactly two arguments", decl);
12687             }
12688
12689           /* More Effective C++ rule 7.  */
12690           if (warn_ecpp
12691               && (operator_code == TRUTH_ANDIF_EXPR
12692                   || operator_code == TRUTH_ORIF_EXPR
12693                   || operator_code == COMPOUND_EXPR))
12694             warning ("user-defined `%D' always evaluates both arguments",
12695                         decl);
12696         }
12697
12698       /* Effective C++ rule 23.  */
12699       if (warn_ecpp
12700           && arity == 2
12701           && !DECL_ASSIGNMENT_OPERATOR_P (decl)
12702           && (operator_code == PLUS_EXPR
12703               || operator_code == MINUS_EXPR
12704               || operator_code == TRUNC_DIV_EXPR
12705               || operator_code == MULT_EXPR
12706               || operator_code == TRUNC_MOD_EXPR)
12707           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12708         warning ("`%D' should return by value", decl);
12709
12710       /* [over.oper]/8 */
12711       for (; argtypes && argtypes != void_list_node;
12712           argtypes = TREE_CHAIN (argtypes))
12713         if (TREE_PURPOSE (argtypes))
12714           {
12715             TREE_PURPOSE (argtypes) = NULL_TREE;
12716             if (operator_code == POSTINCREMENT_EXPR
12717                 || operator_code == POSTDECREMENT_EXPR)
12718               {
12719                 if (pedantic)
12720                   pedwarn ("`%D' cannot have default arguments", decl);
12721               }
12722             else
12723               error ("`%D' cannot have default arguments", decl);
12724           }
12725
12726     }
12727 }
12728 \f
12729 static const char *
12730 tag_name (code)
12731      enum tag_types code;
12732 {
12733   switch (code)
12734     {
12735     case record_type:
12736       return "struct";
12737     case class_type:
12738       return "class";
12739     case union_type:
12740       return "union ";
12741     case enum_type:
12742       return "enum";
12743     default:
12744       abort ();
12745     }
12746 }
12747
12748 /* Get the struct, enum or union (CODE says which) with tag NAME.
12749    Define the tag as a forward-reference if it is not defined.
12750
12751    C++: If a class derivation is given, process it here, and report
12752    an error if multiple derivation declarations are not identical.
12753
12754    If this is a definition, come in through xref_tag and only look in
12755    the current frame for the name (since C++ allows new names in any
12756    scope.)  */
12757
12758 tree
12759 xref_tag (code_type_node, name, globalize)
12760      tree code_type_node;
12761      tree name;
12762      int globalize;
12763 {
12764   enum tag_types tag_code;
12765   enum tree_code code;
12766   register tree ref, t;
12767   struct binding_level *b = current_binding_level;
12768   tree attributes = NULL_TREE;
12769   tree context = NULL_TREE;
12770
12771   /* If we are called from the parser, code_type_node will sometimes be a
12772      TREE_LIST.  This indicates that the user wrote
12773      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12774      use them later.  */
12775   if (TREE_CODE (code_type_node) == TREE_LIST)
12776     {
12777       attributes = TREE_PURPOSE (code_type_node);
12778       code_type_node = TREE_VALUE (code_type_node);
12779     }
12780
12781   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12782   switch (tag_code)
12783     {
12784     case record_type:
12785     case class_type:
12786       code = RECORD_TYPE;
12787       break;
12788     case union_type:
12789       code = UNION_TYPE;
12790       break;
12791     case enum_type:
12792       code = ENUMERAL_TYPE;
12793       break;
12794     default:
12795       abort ();
12796     }
12797
12798   /* If a cross reference is requested, look up the type
12799      already defined for this tag and return it.  */
12800   if (TYPE_P (name))
12801     {
12802       t = name;
12803       name = TYPE_IDENTIFIER (t);
12804     }
12805   else
12806     t = IDENTIFIER_TYPE_VALUE (name);
12807
12808   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12809   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12810     {
12811       static int explained;
12812       tree shadowed;
12813
12814       warning ("`%s %T' declares a new type at namespace scope",
12815                   tag_name (tag_code), name);
12816       if (!explained++)
12817         warning ("  names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'",
12818                     tag_name (tag_code),
12819                     constructor_name (current_class_type),
12820                     TYPE_IDENTIFIER (t));
12821
12822       /* We need to remove the class scope binding for the
12823          TYPENAME_TYPE as otherwise poplevel_class gets confused. */
12824       for (shadowed = b->class_shadowed;
12825            shadowed;
12826            shadowed = TREE_CHAIN (shadowed))
12827         if (TREE_TYPE (shadowed) == TYPE_NAME (t))
12828           {
12829             TREE_PURPOSE (shadowed) = NULL_TREE;
12830             break;
12831           }
12832     }
12833
12834   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12835       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12836     t = NULL_TREE;
12837
12838   if (! globalize)
12839     {
12840       /* If we know we are defining this tag, only look it up in
12841          this scope and don't try to find it as a type.  */
12842       ref = lookup_tag (code, name, b, 1);
12843     }
12844   else
12845     {
12846       if (t)
12847         {
12848           ref = follow_tag_typedef (t);
12849
12850           /* [dcl.type.elab] If the identifier resolves to a
12851              typedef-name or a template type-parameter, the
12852              elaborated-type-specifier is ill-formed.  */
12853           if (!ref)
12854             {
12855               pedwarn ("using typedef-name `%D' after `%s'",
12856                        TYPE_NAME (t), tag_name (tag_code));
12857               ref = t;
12858             }
12859           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12860             error ("using template type parameter `%T' after `%s'",
12861                    t, tag_name (tag_code));
12862         }
12863       else
12864         ref = lookup_tag (code, name, b, 0);
12865
12866       if (! ref)
12867         {
12868           /* Try finding it as a type declaration.  If that wins,
12869              use it.  */
12870           ref = lookup_name (name, 1);
12871
12872           if (ref != NULL_TREE
12873               && processing_template_decl
12874               && DECL_CLASS_TEMPLATE_P (ref)
12875               && template_class_depth (current_class_type) == 0)
12876             /* Since GLOBALIZE is true, we're declaring a global
12877                template, so we want this type.  */
12878             ref = DECL_TEMPLATE_RESULT (ref);
12879
12880           if (ref && TREE_CODE (ref) == TYPE_DECL
12881               && TREE_CODE (TREE_TYPE (ref)) == code)
12882             ref = TREE_TYPE (ref);
12883           else
12884             ref = NULL_TREE;
12885         }
12886
12887       if (ref && current_class_type
12888           && template_class_depth (current_class_type)
12889           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12890         {
12891           /* Since GLOBALIZE is non-zero, we are not looking at a
12892              definition of this tag.  Since, in addition, we are currently
12893              processing a (member) template declaration of a template
12894              class, we must be very careful; consider:
12895
12896                template <class X>
12897                struct S1
12898
12899                template <class U>
12900                struct S2
12901                { template <class V>
12902                friend struct S1; };
12903
12904              Here, the S2::S1 declaration should not be confused with the
12905              outer declaration.  In particular, the inner version should
12906              have a template parameter of level 2, not level 1.  This
12907              would be particularly important if the member declaration
12908              were instead:
12909
12910                template <class V = U> friend struct S1;
12911
12912              say, when we should tsubst into `U' when instantiating
12913              S2.  On the other hand, when presented with:
12914
12915                  template <class T>
12916                  struct S1 {
12917                    template <class U>
12918                    struct S2 {};
12919                    template <class U>
12920                    friend struct S2;
12921                  };
12922
12923               we must find the inner binding eventually.  We
12924               accomplish this by making sure that the new type we
12925               create to represent this declaration has the right
12926               TYPE_CONTEXT.  */
12927           context = TYPE_CONTEXT (ref);
12928           ref = NULL_TREE;
12929         }
12930     }
12931
12932   if (! ref)
12933     {
12934       /* If no such tag is yet defined, create a forward-reference node
12935          and record it as the "definition".
12936          When a real declaration of this type is found,
12937          the forward-reference will be altered into a real type.  */
12938       if (code == ENUMERAL_TYPE)
12939         {
12940           error ("use of enum `%#D' without previous declaration", name);
12941
12942           ref = make_node (ENUMERAL_TYPE);
12943
12944           /* Give the type a default layout like unsigned int
12945              to avoid crashing if it does not get defined.  */
12946           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12947           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12948           TYPE_USER_ALIGN (ref) = 0;
12949           TREE_UNSIGNED (ref) = 1;
12950           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12951           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12952           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12953
12954           /* Enable us to recognize when a type is created in class context.
12955              To do nested classes correctly, this should probably be cleared
12956              out when we leave this classes scope.  Currently this in only
12957              done in `start_enum'.  */
12958
12959           pushtag (name, ref, globalize);
12960         }
12961       else
12962         {
12963           struct binding_level *old_b = class_binding_level;
12964
12965           ref = make_aggr_type (code);
12966           TYPE_CONTEXT (ref) = context;
12967
12968 #ifdef NONNESTED_CLASSES
12969           /* Class types don't nest the way enums do.  */
12970           class_binding_level = (struct binding_level *)0;
12971 #endif
12972           pushtag (name, ref, globalize);
12973           class_binding_level = old_b;
12974         }
12975     }
12976   else
12977     {
12978       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12979         redeclare_class_template (ref, current_template_parms);
12980     }
12981
12982   TYPE_ATTRIBUTES (ref) = attributes;
12983
12984   return ref;
12985 }
12986
12987 tree
12988 xref_tag_from_type (old, id, globalize)
12989      tree old, id;
12990      int globalize;
12991 {
12992   tree code_type_node;
12993
12994   if (TREE_CODE (old) == RECORD_TYPE)
12995     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12996                       ? class_type_node : record_type_node);
12997   else
12998     code_type_node = union_type_node;
12999
13000   if (id == NULL_TREE)
13001     id = TYPE_IDENTIFIER (old);
13002
13003   return xref_tag (code_type_node, id, globalize);
13004 }
13005
13006 /* REF is a type (named NAME), for which we have just seen some
13007    baseclasses.  BINFO is a list of those baseclasses; the
13008    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
13009    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
13010    struct, or union.  */
13011
13012 void
13013 xref_basetypes (code_type_node, name, ref, binfo)
13014      tree code_type_node;
13015      tree name ATTRIBUTE_UNUSED;
13016      tree ref;
13017      tree binfo;
13018 {
13019   /* In the declaration `A : X, Y, ... Z' we mark all the types
13020      (A, X, Y, ..., Z) so we can check for duplicates.  */
13021   tree binfos;
13022   tree base;
13023
13024   int i, len;
13025   enum tag_types tag_code;
13026
13027   /* If we are called from the parser, code_type_node will sometimes be a
13028      TREE_LIST.  This indicates that the user wrote
13029      "class __attribute__ ((foo)) bar".  Extract the attributes so that
13030      tree_low_cst doesn't crash.  */
13031   if (TREE_CODE (code_type_node) == TREE_LIST)
13032     code_type_node = TREE_VALUE (code_type_node);
13033
13034   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
13035
13036   if (tag_code == union_type)
13037     {
13038       error ("derived union `%T' invalid", ref);
13039       return;
13040     }
13041
13042   len = list_length (binfo);
13043
13044   /* First, make sure that any templates in base-classes are
13045      instantiated.  This ensures that if we call ourselves recursively
13046      we do not get confused about which classes are marked and which
13047      are not.  */
13048   for (base = binfo; base; base = TREE_CHAIN (base))
13049     complete_type (TREE_VALUE (base));
13050
13051   SET_CLASSTYPE_MARKED (ref);
13052   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
13053
13054   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
13055     {
13056       /* The base of a derived struct is public by default.  */
13057       int via_public
13058         = (TREE_PURPOSE (binfo) == access_public_node
13059            || TREE_PURPOSE (binfo) == access_public_virtual_node
13060            || (tag_code != class_type
13061                && (TREE_PURPOSE (binfo) == access_default_node
13062                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
13063       int via_protected
13064         = (TREE_PURPOSE (binfo) == access_protected_node
13065            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
13066       int via_virtual
13067         = (TREE_PURPOSE (binfo) == access_private_virtual_node
13068            || TREE_PURPOSE (binfo) == access_protected_virtual_node
13069            || TREE_PURPOSE (binfo) == access_public_virtual_node
13070            || TREE_PURPOSE (binfo) == access_default_virtual_node);
13071       tree basetype = TREE_VALUE (binfo);
13072       tree base_binfo;
13073
13074       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
13075         basetype = TREE_TYPE (basetype);
13076       if (!basetype
13077           || (TREE_CODE (basetype) != RECORD_TYPE
13078               && TREE_CODE (basetype) != TYPENAME_TYPE
13079               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
13080               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
13081         {
13082           error ("base type `%T' fails to be a struct or class type",
13083                     TREE_VALUE (binfo));
13084           continue;
13085         }
13086
13087       /* This code replaces similar code in layout_basetypes.
13088          We put the complete_type first for implicit `typename'.  */
13089       if (!COMPLETE_TYPE_P (basetype)
13090           && ! (current_template_parms && uses_template_parms (basetype)))
13091         {
13092           error ("base class `%T' has incomplete type", basetype);
13093           continue;
13094         }
13095       else
13096         {
13097           if (CLASSTYPE_MARKED (basetype))
13098             {
13099               if (basetype == ref)
13100                 error ("recursive type `%T' undefined", basetype);
13101               else
13102                 error ("duplicate base type `%T' invalid", basetype);
13103               continue;
13104             }
13105
13106           if (TYPE_FOR_JAVA (basetype)
13107               && (current_lang_depth () == 0))
13108             TYPE_FOR_JAVA (ref) = 1;
13109
13110           /* Note that the BINFO records which describe individual
13111              inheritances are *not* shared in the lattice!  They
13112              cannot be shared because a given baseclass may be
13113              inherited with different `accessibility' by different
13114              derived classes.  (Each BINFO record describing an
13115              individual inheritance contains flags which say what
13116              the `accessibility' of that particular inheritance is.)  */
13117
13118           base_binfo
13119             = make_binfo (size_zero_node, basetype,
13120                           CLASS_TYPE_P (basetype)
13121                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13122                           CLASS_TYPE_P (basetype)
13123                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13124
13125           TREE_VEC_ELT (binfos, i) = base_binfo;
13126           TREE_VIA_PUBLIC (base_binfo) = via_public;
13127           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13128           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13129           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13130
13131           /* We need to unshare the binfos now so that lookups during class
13132              definition work.  */
13133           unshare_base_binfos (base_binfo);
13134
13135           SET_CLASSTYPE_MARKED (basetype);
13136
13137           /* We are free to modify these bits because they are meaningless
13138              at top level, and BASETYPE is a top-level type.  */
13139           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13140             {
13141               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13142               /* Converting to a virtual base class requires looking
13143                  up the offset of the virtual base.  */
13144               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13145             }
13146
13147           if (CLASS_TYPE_P (basetype))
13148             {
13149               TYPE_HAS_NEW_OPERATOR (ref)
13150                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13151               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13152                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13153               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13154               /* If the base-class uses multiple inheritance, so do we.  */
13155               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13156                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13157               /* Likewise, if converting to a base of the base may require
13158                  code, then we may need to generate code to convert to a
13159                  base as well.  */
13160               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13161                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13162             }
13163
13164           i += 1;
13165         }
13166     }
13167   if (i)
13168     TREE_VEC_LENGTH (binfos) = i;
13169   else
13170     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13171
13172   if (i > 1)
13173     {
13174       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13175       /* If there is more than one non-empty they cannot be at the same
13176          address.  */
13177       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13178     }
13179
13180   /* Unmark all the types.  */
13181   while (--i >= 0)
13182     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13183   CLEAR_CLASSTYPE_MARKED (ref);
13184
13185   /* Now that we know all the base-classes, set up the list of virtual
13186      bases.  */
13187   get_vbase_types (ref);
13188 }
13189
13190 \f
13191 /* Begin compiling the definition of an enumeration type.
13192    NAME is its name (or null if anonymous).
13193    Returns the type object, as yet incomplete.
13194    Also records info about it so that build_enumerator
13195    may be used to declare the individual values as they are read.  */
13196
13197 tree
13198 start_enum (name)
13199      tree name;
13200 {
13201   register tree enumtype = NULL_TREE;
13202   struct binding_level *b = current_binding_level;
13203
13204   /* If this is the real definition for a previous forward reference,
13205      fill in the contents in the same object that used to be the
13206      forward reference.  */
13207
13208   if (name != NULL_TREE)
13209     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13210
13211   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13212     {
13213       error ("multiple definition of `%#T'", enumtype);
13214       cp_error_at ("previous definition here", enumtype);
13215       /* Clear out TYPE_VALUES, and start again.  */
13216       TYPE_VALUES (enumtype) = NULL_TREE;
13217     }
13218   else
13219     {
13220       enumtype = make_node (ENUMERAL_TYPE);
13221       pushtag (name, enumtype, 0);
13222     }
13223
13224   return enumtype;
13225 }
13226
13227 /* After processing and defining all the values of an enumeration type,
13228    install their decls in the enumeration type and finish it off.
13229    ENUMTYPE is the type object and VALUES a list of name-value pairs.  */
13230
13231 void
13232 finish_enum (enumtype)
13233      tree enumtype;
13234 {
13235   tree pair;
13236   tree minnode;
13237   tree maxnode;
13238   tree t;
13239   bool unsignedp;
13240   int lowprec;
13241   int highprec;
13242   int precision;
13243
13244   /* We built up the VALUES in reverse order.  */
13245   TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
13246
13247   /* [dcl.enum]
13248
13249      Following the closing brace of an enum-specifier, each
13250      enumerator has the type of its enumeration.  Prior to the
13251      closing brace, the type of each enumerator is the type of
13252      its initializing value.  */
13253   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13254     TREE_TYPE (TREE_VALUE (pair)) = enumtype;
13255
13256   /* For a enum defined in a template, all further processing is
13257      postponed until the template is instantiated.  */
13258   if (processing_template_decl)
13259     {
13260       tree scope = current_scope ();
13261       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13262         add_stmt (build_min (TAG_DEFN, enumtype));
13263
13264
13265       return;
13266     }
13267
13268   /* Figure out what the minimum and maximum values of the enumerators
13269      are.  */
13270   if (TYPE_VALUES (enumtype))
13271     {
13272       minnode = maxnode = NULL_TREE;
13273
13274       for (pair = TYPE_VALUES (enumtype);
13275            pair;
13276            pair = TREE_CHAIN (pair))
13277         {
13278           tree value;
13279
13280           value = DECL_INITIAL (TREE_VALUE (pair));
13281
13282           if (!minnode)
13283             minnode = maxnode = value;
13284           else if (tree_int_cst_lt (maxnode, value))
13285             maxnode = value;
13286           else if (tree_int_cst_lt (value, minnode))
13287             minnode = value;
13288         }
13289     }
13290   else
13291     minnode = maxnode = integer_zero_node;
13292
13293   /* Compute the number of bits require to represent all values of the
13294      enumeration.  We must do this before the type of MINNODE and
13295      MAXNODE are transformed, since min_precision relies on the
13296      TREE_TYPE of the value it is passed.  */
13297   unsignedp = tree_int_cst_sgn (minnode) >= 0;
13298   lowprec = min_precision (minnode, unsignedp);
13299   highprec = min_precision (maxnode, unsignedp);
13300   precision = MAX (lowprec, highprec);
13301
13302   /* Set the TREE_TYPE for the values as well.  That's so that when we
13303      call decl_constant_value we get an entity of the right type (but
13304      with the constant value).  In addition, transform the TYPE_VALUES
13305      list to contain the values, rather than the CONST_DECLs for them.  */
13306   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13307     {
13308       tree value = DECL_INITIAL (TREE_VALUE (pair));
13309
13310       TREE_TYPE (value) = enumtype;
13311       TREE_VALUE (pair) = value;
13312     }
13313
13314   /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13315   TYPE_SIZE (enumtype) = NULL_TREE;
13316   TYPE_PRECISION (enumtype) = precision;
13317   if (unsignedp)
13318     fixup_unsigned_type (enumtype);
13319   else
13320     fixup_signed_type (enumtype);
13321
13322   if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13323     /* Use the width of the narrowest normal C type which is wide
13324        enough.  */
13325     TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13326                                                 (precision, 1));
13327   else
13328     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13329
13330   TYPE_SIZE (enumtype) = NULL_TREE;
13331   layout_type (enumtype);
13332
13333   /* Fix up all variant types of this enum type.  */
13334   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13335     {
13336       TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13337       TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
13338       TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
13339       TYPE_SIZE (t) = TYPE_SIZE (enumtype);
13340       TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
13341       TYPE_MODE (t) = TYPE_MODE (enumtype);
13342       TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
13343       TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
13344       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
13345       TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype);
13346     }
13347
13348   /* Finish debugging output for this type.  */
13349   rest_of_type_compilation (enumtype, namespace_bindings_p ());
13350 }
13351
13352 /* Build and install a CONST_DECL for an enumeration constant of the
13353    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13354    Assignment of sequential values by default is handled here.  */
13355
13356 void
13357 build_enumerator (name, value, enumtype)
13358      tree name;
13359      tree value;
13360      tree enumtype;
13361 {
13362   tree decl;
13363   tree context;
13364   tree type;
13365   tree values;
13366
13367   /* Remove no-op casts from the value.  */
13368   if (value)
13369     STRIP_TYPE_NOPS (value);
13370
13371   if (! processing_template_decl)
13372     {
13373       /* Validate and default VALUE.  */
13374       if (value != NULL_TREE)
13375         {
13376           value = decl_constant_value (value);
13377
13378           if (TREE_CODE (value) == INTEGER_CST)
13379             {
13380               value = default_conversion (value);
13381               constant_expression_warning (value);
13382             }
13383           else
13384             {
13385               error ("enumerator value for `%D' not integer constant", name);
13386               value = NULL_TREE;
13387             }
13388         }
13389
13390       /* Default based on previous value.  */
13391       if (value == NULL_TREE && ! processing_template_decl)
13392         {
13393           tree prev_value;
13394
13395           if (TYPE_VALUES (enumtype))
13396             {
13397               /* The next value is the previous value ... */
13398               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13399               /* ... plus one.  */
13400               value = cp_build_binary_op (PLUS_EXPR,
13401                                           prev_value,
13402                                           integer_one_node);
13403
13404               if (tree_int_cst_lt (value, prev_value))
13405                 error ("overflow in enumeration values at `%D'", name);
13406             }
13407           else
13408             value = integer_zero_node;
13409         }
13410
13411       /* Remove no-op casts from the value.  */
13412       if (value)
13413         STRIP_TYPE_NOPS (value);
13414 #if 0
13415       /* To fix MAX_VAL enum consts. (bkoz)  */
13416       TREE_TYPE (value) = integer_type_node;
13417 #endif
13418     }
13419
13420   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13421      Even in other cases, we will later (in finish_enum) be setting
13422      the type of VALUE.  But, we don't need to make a copy if this
13423      VALUE is one of the enumeration constants for this same
13424      enumeration type.  */
13425   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13426     if (TREE_VALUE (values) == value)
13427       break;
13428   /* If we didn't break out of the loop, then we do need a copy.  */
13429   if (!values && value)
13430     value = copy_node (value);
13431
13432   /* C++ associates enums with global, function, or class declarations.  */
13433   context = current_scope ();
13434
13435   /* Build the actual enumeration constant.  Note that the enumeration
13436     constants have the type of their initializers until the
13437     enumeration is complete:
13438
13439       [ dcl.enum ]
13440
13441       Following the closing brace of an enum-specifier, each enumer-
13442       ator has the type of its enumeration.  Prior to the closing
13443       brace, the type of each enumerator is the type of its
13444       initializing value.
13445
13446     In finish_enum we will reset the type.  Of course, if we're
13447     processing a template, there may be no value.   */
13448   type = value ? TREE_TYPE (value) : NULL_TREE;
13449
13450   if (context && context == current_class_type)
13451     /* This enum declaration is local to the class.  We need the full
13452        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13453     decl = build_lang_decl (CONST_DECL, name, type);
13454   else
13455     /* It's a global enum, or it's local to a function.  (Note local to
13456       a function could mean local to a class method.  */
13457     decl = build_decl (CONST_DECL, name, type);
13458
13459   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13460   DECL_INITIAL (decl) = value;
13461   TREE_READONLY (decl) = 1;
13462
13463   if (context && context == current_class_type)
13464     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13465       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13466       things like `S::i' later.)  */
13467     finish_member_declaration (decl);
13468   else
13469     pushdecl (decl);
13470
13471   /* Add this enumeration constant to the list for this type.  */
13472   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13473 }
13474
13475 \f
13476 /* We're defining DECL.  Make sure that it's type is OK.  */
13477
13478 static void
13479 check_function_type (decl, current_function_parms)
13480      tree decl;
13481      tree current_function_parms;
13482 {
13483   tree fntype = TREE_TYPE (decl);
13484   tree return_type = complete_type (TREE_TYPE (fntype));
13485
13486   /* In a function definition, arg types must be complete.  */
13487   require_complete_types_for_parms (current_function_parms);
13488
13489   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13490     {
13491       error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13492
13493       /* Make it return void instead, but don't change the
13494          type of the DECL_RESULT, in case we have a named return value.  */
13495       if (TREE_CODE (fntype) == METHOD_TYPE)
13496         {
13497           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13498           TREE_TYPE (decl)
13499             = build_cplus_method_type (ctype,
13500                                        void_type_node,
13501                                        FUNCTION_ARG_CHAIN (decl));
13502         }
13503       else
13504         TREE_TYPE (decl)
13505           = build_function_type (void_type_node,
13506                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13507       TREE_TYPE (decl)
13508         = build_exception_variant (fntype,
13509                                    TYPE_RAISES_EXCEPTIONS (fntype));
13510     }
13511   else
13512     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13513 }
13514
13515 /* Create the FUNCTION_DECL for a function definition.
13516    DECLSPECS and DECLARATOR are the parts of the declaration;
13517    they describe the function's name and the type it returns,
13518    but twisted together in a fashion that parallels the syntax of C.
13519
13520    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13521    DECLARATOR is really the DECL for the function we are about to
13522    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13523    indicating that the function is an inline defined in-class.
13524
13525    This function creates a binding context for the function body
13526    as well as setting up the FUNCTION_DECL in current_function_decl.
13527
13528    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13529    (it defines a datum instead), we return 0, which tells
13530    yyparse to report a parse error.
13531
13532    For C++, we must first check whether that datum makes any sense.
13533    For example, "class A local_a(1,2);" means that variable local_a
13534    is an aggregate of type A, which should have a constructor
13535    applied to it with the argument list [1, 2].  */
13536
13537 int
13538 start_function (declspecs, declarator, attrs, flags)
13539      tree declspecs, declarator, attrs;
13540      int flags;
13541 {
13542   tree decl1;
13543   tree ctype = NULL_TREE;
13544   tree fntype;
13545   tree restype;
13546   extern int have_extern_spec;
13547   extern int used_extern_spec;
13548   int doing_friend = 0;
13549   struct binding_level *bl;
13550   tree current_function_parms;
13551
13552   /* Sanity check.  */
13553   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13554   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13555
13556   /* This should only be done once on the top most decl.  */
13557   if (have_extern_spec && !used_extern_spec)
13558     {
13559       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13560       used_extern_spec = 1;
13561     }
13562
13563   if (flags & SF_PRE_PARSED)
13564     {
13565       decl1 = declarator;
13566
13567       fntype = TREE_TYPE (decl1);
13568       if (TREE_CODE (fntype) == METHOD_TYPE)
13569         ctype = TYPE_METHOD_BASETYPE (fntype);
13570
13571       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13572          the (lexical) scope of the class in which it is defined.  */
13573       if (!ctype && DECL_FRIEND_P (decl1))
13574         {
13575           ctype = DECL_FRIEND_CONTEXT (decl1);
13576
13577           /* CTYPE could be null here if we're dealing with a template;
13578              for example, `inline friend float foo()' inside a template
13579              will have no CTYPE set.  */
13580           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13581             ctype = NULL_TREE;
13582           else
13583             doing_friend = 1;
13584         }
13585
13586       last_function_parms = DECL_ARGUMENTS (decl1);
13587     }
13588   else
13589     {
13590       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL);
13591       /* If the declarator is not suitable for a function definition,
13592          cause a syntax error.  */
13593       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
13594         return 0;
13595
13596       cplus_decl_attributes (&decl1, attrs, 0);
13597
13598       /* If #pragma weak was used, mark the decl weak now.  */
13599       if (current_binding_level == global_binding_level)
13600         maybe_apply_pragma_weak (decl1);
13601
13602       fntype = TREE_TYPE (decl1);
13603
13604       restype = TREE_TYPE (fntype);
13605       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13606         {
13607           error ("semicolon missing after declaration of `%#T'", restype);
13608           shadow_tag (build_tree_list (NULL_TREE, restype));
13609           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13610           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13611             fntype = build_function_type (integer_type_node,
13612                                           TYPE_ARG_TYPES (fntype));
13613           else
13614             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13615                                               integer_type_node,
13616                                               TYPE_ARG_TYPES (fntype));
13617           TREE_TYPE (decl1) = fntype;
13618         }
13619
13620       if (TREE_CODE (fntype) == METHOD_TYPE)
13621         ctype = TYPE_METHOD_BASETYPE (fntype);
13622       else if (DECL_MAIN_P (decl1))
13623         {
13624           /* If this doesn't return integer_type, complain.  */
13625           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13626             {
13627               if (pedantic || warn_return_type)
13628                 pedwarn ("return type for `main' changed to `int'");
13629               TREE_TYPE (decl1) = fntype = default_function_type;
13630             }
13631         }
13632     }
13633
13634   if (DECL_DECLARED_INLINE_P (decl1)
13635       && lookup_attribute ("noinline", attrs))
13636     warning_with_decl (decl1,
13637                        "inline function `%s' given attribute noinline");
13638
13639   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13640     /* This is a constructor, we must ensure that any default args
13641        introduced by this definition are propagated to the clones
13642        now. The clones are used directly in overload resolution.  */
13643     adjust_clone_args (decl1);
13644
13645   /* Sometimes we don't notice that a function is a static member, and
13646      build a METHOD_TYPE for it.  Fix that up now.  */
13647   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13648       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13649     {
13650       revert_static_member_fn (decl1);
13651       last_function_parms = TREE_CHAIN (last_function_parms);
13652       ctype = NULL_TREE;
13653     }
13654
13655   /* Warn if function was previously implicitly declared
13656      (but not if we warned then).  */
13657   if (! warn_implicit
13658       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13659     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13660
13661   /* Set up current_class_type, and enter the scope of the class, if
13662      appropriate.  */
13663   if (ctype)
13664     push_nested_class (ctype, 1);
13665   else if (DECL_STATIC_FUNCTION_P (decl1))
13666     push_nested_class (DECL_CONTEXT (decl1), 2);
13667
13668   /* Now that we have entered the scope of the class, we must restore
13669      the bindings for any template parameters surrounding DECL1, if it
13670      is an inline member template.  (Order is important; consider the
13671      case where a template parameter has the same name as a field of
13672      the class.)  It is not until after this point that
13673      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13674   if (flags & SF_INCLASS_INLINE)
13675     maybe_begin_member_template_processing (decl1);
13676
13677   /* Effective C++ rule 15.  */
13678   if (warn_ecpp
13679       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13680       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13681     warning ("`operator=' should return a reference to `*this'");
13682
13683   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13684      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13685   if (!DECL_INITIAL (decl1))
13686     DECL_INITIAL (decl1) = error_mark_node;
13687
13688   /* This function exists in static storage.
13689      (This does not mean `static' in the C sense!)  */
13690   TREE_STATIC (decl1) = 1;
13691
13692   /* We must call push_template_decl after current_class_type is set
13693      up.  (If we are processing inline definitions after exiting a
13694      class scope, current_class_type will be NULL_TREE until set above
13695      by push_nested_class.)  */
13696   if (processing_template_decl)
13697     decl1 = push_template_decl (decl1);
13698
13699   /* We are now in the scope of the function being defined.  */
13700   current_function_decl = decl1;
13701
13702   /* Save the parm names or decls from this function's declarator
13703      where store_parm_decls will find them.  */
13704   current_function_parms = last_function_parms;
13705
13706   /* Make sure the parameter and return types are reasonable.  When
13707      you declare a function, these types can be incomplete, but they
13708      must be complete when you define the function.  */
13709   if (! processing_template_decl)
13710     check_function_type (decl1, current_function_parms);
13711
13712   /* Build the return declaration for the function.  */
13713   restype = TREE_TYPE (fntype);
13714   /* Promote the value to int before returning it.  */
13715   if (c_promoting_integer_type_p (restype))
13716     restype = type_promotes_to (restype);
13717   if (DECL_RESULT (decl1) == NULL_TREE)
13718     {
13719       DECL_RESULT (decl1)
13720         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13721       c_apply_type_quals_to_decl (cp_type_quals (restype),
13722                                   DECL_RESULT (decl1));
13723     }
13724
13725   /* Initialize RTL machinery.  We cannot do this until
13726      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13727      even when processing a template; this is how we get
13728      CFUN set up, and our per-function variables initialized.
13729      FIXME factor out the non-RTL stuff.  */
13730   bl = current_binding_level;
13731   init_function_start (decl1, input_filename, lineno);
13732   current_binding_level = bl;
13733
13734   /* Even though we're inside a function body, we still don't want to
13735      call expand_expr to calculate the size of a variable-sized array.
13736      We haven't necessarily assigned RTL to all variables yet, so it's
13737      not safe to try to expand expressions involving them.  */
13738   immediate_size_expand = 0;
13739   cfun->x_dont_save_pending_sizes_p = 1;
13740
13741   /* Start the statement-tree, start the tree now.  */
13742   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13743
13744   /* Let the user know we're compiling this function.  */
13745   announce_function (decl1);
13746
13747   /* Record the decl so that the function name is defined.
13748      If we already have a decl for this name, and it is a FUNCTION_DECL,
13749      use the old decl.  */
13750   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13751     {
13752       /* A specialization is not used to guide overload resolution.  */
13753       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13754           && ! DECL_FUNCTION_MEMBER_P (decl1))
13755         decl1 = pushdecl (decl1);
13756       else
13757         {
13758           /* We need to set the DECL_CONTEXT. */
13759           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13760             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13761           /* And make sure we have enough default args.  */
13762           check_default_args (decl1);
13763         }
13764       fntype = TREE_TYPE (decl1);
13765     }
13766
13767   /* Reset these in case the call to pushdecl changed them.  */
13768   current_function_decl = decl1;
13769   cfun->decl = decl1;
13770
13771   /* If we are (erroneously) defining a function that we have already
13772      defined before, wipe out what we knew before.  */
13773   if (!DECL_PENDING_INLINE_P (decl1)
13774       && DECL_SAVED_FUNCTION_DATA (decl1))
13775     {
13776       free (DECL_SAVED_FUNCTION_DATA (decl1));
13777       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13778     }
13779
13780   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13781     {
13782       /* We know that this was set up by `grokclassfn'.  We do not
13783          wait until `store_parm_decls', since evil parse errors may
13784          never get us to that point.  Here we keep the consistency
13785          between `current_class_type' and `current_class_ptr'.  */
13786       tree t = DECL_ARGUMENTS (decl1);
13787
13788       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13789                           162);
13790       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13791                           19990811);
13792
13793       cp_function_chain->x_current_class_ref
13794         = build_indirect_ref (t, NULL);
13795       cp_function_chain->x_current_class_ptr = t;
13796
13797       /* Constructors and destructors need to know whether they're "in
13798          charge" of initializing virtual base classes.  */
13799       t = TREE_CHAIN (t);
13800       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13801         {
13802           current_in_charge_parm = t;
13803           t = TREE_CHAIN (t);
13804         }
13805       if (DECL_HAS_VTT_PARM_P (decl1))
13806         {
13807           if (DECL_NAME (t) != vtt_parm_identifier)
13808             abort ();
13809           current_vtt_parm = t;
13810         }
13811     }
13812
13813   if (DECL_INTERFACE_KNOWN (decl1))
13814     {
13815       tree ctx = decl_function_context (decl1);
13816
13817       if (DECL_NOT_REALLY_EXTERN (decl1))
13818         DECL_EXTERNAL (decl1) = 0;
13819
13820       if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
13821           && TREE_PUBLIC (ctx))
13822         /* This is a function in a local class in an extern inline
13823            function.  */
13824         comdat_linkage (decl1);
13825     }
13826   /* If this function belongs to an interface, it is public.
13827      If it belongs to someone else's interface, it is also external.
13828      This only affects inlines and template instantiations.  */
13829   else if (interface_unknown == 0
13830            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13831                || flag_alt_external_templates))
13832     {
13833       if (DECL_DECLARED_INLINE_P (decl1)
13834           || DECL_TEMPLATE_INSTANTIATION (decl1)
13835           || processing_template_decl)
13836         {
13837           DECL_EXTERNAL (decl1)
13838             = (interface_only
13839                || (DECL_DECLARED_INLINE_P (decl1)
13840                    && ! flag_implement_inlines
13841                    && !DECL_VINDEX (decl1)));
13842
13843           /* For WIN32 we also want to put these in linkonce sections.  */
13844           maybe_make_one_only (decl1);
13845         }
13846       else
13847         DECL_EXTERNAL (decl1) = 0;
13848       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13849       DECL_INTERFACE_KNOWN (decl1) = 1;
13850     }
13851   else if (interface_unknown && interface_only
13852            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13853                || flag_alt_external_templates))
13854     {
13855       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13856          interface, we will have interface_only set but not
13857          interface_known.  In that case, we don't want to use the normal
13858          heuristics because someone will supply a #pragma implementation
13859          elsewhere, and deducing it here would produce a conflict.  */
13860       comdat_linkage (decl1);
13861       DECL_EXTERNAL (decl1) = 0;
13862       DECL_INTERFACE_KNOWN (decl1) = 1;
13863       DECL_DEFER_OUTPUT (decl1) = 1;
13864     }
13865   else
13866     {
13867       /* This is a definition, not a reference.
13868          So clear DECL_EXTERNAL.  */
13869       DECL_EXTERNAL (decl1) = 0;
13870
13871       if ((DECL_DECLARED_INLINE_P (decl1)
13872            || DECL_TEMPLATE_INSTANTIATION (decl1))
13873           && ! DECL_INTERFACE_KNOWN (decl1)
13874           /* Don't try to defer nested functions for now.  */
13875           && ! decl_function_context (decl1))
13876         DECL_DEFER_OUTPUT (decl1) = 1;
13877       else
13878         DECL_INTERFACE_KNOWN (decl1) = 1;
13879     }
13880
13881   pushlevel (0);
13882   current_binding_level->parm_flag = 1;
13883
13884   ++function_depth;
13885
13886   if (DECL_DESTRUCTOR_P (decl1))
13887     {
13888       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13889       DECL_CONTEXT (dtor_label) = current_function_decl;
13890     }
13891
13892   start_fname_decls ();
13893
13894   store_parm_decls (current_function_parms);
13895
13896   return 1;
13897 }
13898 \f
13899 /* Store the parameter declarations into the current function declaration.
13900    This is called after parsing the parameter declarations, before
13901    digesting the body of the function.
13902
13903    Also install to binding contour return value identifier, if any.  */
13904
13905 static void
13906 store_parm_decls (current_function_parms)
13907      tree current_function_parms;
13908 {
13909   register tree fndecl = current_function_decl;
13910   register tree parm;
13911
13912   /* This is a chain of any other decls that came in among the parm
13913      declarations.  If a parm is declared with  enum {foo, bar} x;
13914      then CONST_DECLs for foo and bar are put here.  */
13915   tree nonparms = NULL_TREE;
13916
13917   if (current_function_parms)
13918     {
13919       /* This case is when the function was defined with an ANSI prototype.
13920          The parms already have decls, so we need not do anything here
13921          except record them as in effect
13922          and complain if any redundant old-style parm decls were written.  */
13923
13924       tree specparms = current_function_parms;
13925       tree next;
13926
13927       /* Must clear this because it might contain TYPE_DECLs declared
13928              at class level.  */
13929       storedecls (NULL_TREE);
13930
13931       /* If we're doing semantic analysis, then we'll call pushdecl
13932              for each of these.  We must do them in reverse order so that
13933              they end in the correct forward order.  */
13934       specparms = nreverse (specparms);
13935
13936       for (parm = specparms; parm; parm = next)
13937         {
13938           next = TREE_CHAIN (parm);
13939           if (TREE_CODE (parm) == PARM_DECL)
13940             {
13941               if (DECL_NAME (parm) == NULL_TREE
13942                   || TREE_CODE (parm) != VOID_TYPE)
13943                 pushdecl (parm);
13944               else
13945                 error ("parameter `%D' declared void", parm);
13946             }
13947           else
13948             {
13949               /* If we find an enum constant or a type tag,
13950                  put it aside for the moment.  */
13951               TREE_CHAIN (parm) = NULL_TREE;
13952               nonparms = chainon (nonparms, parm);
13953             }
13954         }
13955
13956       /* Get the decls in their original chain order and record in the
13957          function.  This is all and only the PARM_DECLs that were
13958          pushed into scope by the loop above.  */
13959       DECL_ARGUMENTS (fndecl) = getdecls ();
13960       storetags (gettags ());
13961     }
13962   else
13963     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13964
13965   /* Now store the final chain of decls for the arguments
13966      as the decl-chain of the current lexical scope.
13967      Put the enumerators in as well, at the front so that
13968      DECL_ARGUMENTS is not modified.  */
13969   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13970
13971   /* Do the starting of the exception specifications, if we have any.  */
13972   if (flag_exceptions && !processing_template_decl
13973       && flag_enforce_eh_specs
13974       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13975     current_eh_spec_block = begin_eh_spec_block ();
13976 }
13977
13978 \f
13979 /* We have finished doing semantic analysis on DECL, but have not yet
13980    generated RTL for its body.  Save away our current state, so that
13981    when we want to generate RTL later we know what to do.  */
13982
13983 static void
13984 save_function_data (decl)
13985      tree decl;
13986 {
13987   struct cp_language_function *f;
13988
13989   /* Save the language-specific per-function data so that we can
13990      get it back when we really expand this function.  */
13991   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13992                       19990908);
13993
13994   /* Make a copy.  */
13995   f = ((struct cp_language_function *)
13996        xmalloc (sizeof (struct cp_language_function)));
13997   memcpy (f, cp_function_chain, sizeof (struct cp_language_function));
13998   DECL_SAVED_FUNCTION_DATA (decl) = f;
13999
14000   /* Clear out the bits we don't need.  */
14001   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
14002   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
14003   f->x_named_label_uses = NULL;
14004   f->bindings = NULL;
14005   f->x_local_names = NULL;
14006
14007   /* When we get back here again, we will be expanding.  */
14008   f->x_expanding_p = 1;
14009
14010   /* If we've already decided that we cannot inline this function, we
14011      must remember that fact when we actually go to expand the
14012      function.  */
14013   if (current_function_cannot_inline)
14014     {
14015       f->cannot_inline = current_function_cannot_inline;
14016       DECL_INLINE (decl) = 0;
14017     }
14018 }
14019
14020 /* Add a note to mark the beginning of the main body of the constructor.
14021    This is used to set up the data structures for the cleanup regions for
14022    fully-constructed bases and members.  */
14023
14024 static void
14025 begin_constructor_body ()
14026 {
14027   tree ctor_stmt = build_stmt (CTOR_STMT);
14028   CTOR_BEGIN_P (ctor_stmt) = 1;
14029   add_stmt (ctor_stmt);
14030 }
14031
14032 /* Add a note to mark the end of the main body of the constructor.  This is
14033    used to end the cleanup regions for fully-constructed bases and
14034    members.  */
14035
14036 static void
14037 finish_constructor_body ()
14038 {
14039   /* Mark the end of the cleanups for a partially constructed object.
14040
14041      ??? These should really be handled automatically by closing the block,
14042      as with the destructor cleanups; the only difference is that these are
14043      only run if an exception is thrown.  */
14044   add_stmt (build_stmt (CTOR_STMT));
14045 }
14046
14047 /* Do all the processing for the beginning of a destructor; set up the
14048    vtable pointers and cleanups for bases and members.  */
14049
14050 static void
14051 begin_destructor_body ()
14052 {
14053   tree if_stmt;
14054   tree compound_stmt;
14055
14056   /* If the dtor is empty, and we know there is not any possible
14057      way we could use any vtable entries, before they are possibly
14058      set by a base class dtor, we don't have to setup the vtables,
14059      as we know that any base class dtor will set up any vtables
14060      it needs.  We avoid MI, because one base class dtor can do a
14061      virtual dispatch to an overridden function that would need to
14062      have a non-related vtable set up, we cannot avoid setting up
14063      vtables in that case.  We could change this to see if there
14064      is just one vtable.
14065
14066      ??? In the destructor for a class, the vtables are set
14067      appropriately for that class.  There will be no non-related
14068      vtables.  jason 2001-12-11.  */
14069   if_stmt = begin_if_stmt ();
14070
14071   /* If it is not safe to avoid setting up the vtables, then
14072      someone will change the condition to be boolean_true_node.
14073      (Actually, for now, we do not have code to set the condition
14074      appropriately, so we just assume that we always need to
14075      initialize the vtables.)  */
14076   finish_if_stmt_cond (boolean_true_node, if_stmt);
14077   current_vcalls_possible_p = &IF_COND (if_stmt);
14078
14079   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14080
14081   /* Make all virtual function table pointers in non-virtual base
14082      classes point to CURRENT_CLASS_TYPE's virtual function
14083      tables.  */
14084   initialize_vtbl_ptrs (current_class_ptr);
14085
14086   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14087   finish_then_clause (if_stmt);
14088   finish_if_stmt ();
14089 }
14090
14091 /* At the end of every destructor we generate code to delete the object if
14092    necessary.  Do that now.  */
14093
14094 static void
14095 finish_destructor_body ()
14096 {
14097   tree exprstmt;
14098
14099   /* And perform cleanups for our bases and members.  */
14100   perform_base_cleanups ();
14101
14102   /* In a virtual destructor, we must call delete.  */
14103   if (DECL_VIRTUAL_P (current_function_decl))
14104     {
14105       tree if_stmt;
14106       tree virtual_size = c_sizeof (current_class_type);
14107
14108       /* [class.dtor]
14109
14110       At the point of definition of a virtual destructor (including
14111       an implicit definition), non-placement operator delete shall
14112       be looked up in the scope of the destructor's class and if
14113       found shall be accessible and unambiguous.  */
14114       exprstmt = build_op_delete_call
14115         (DELETE_EXPR, current_class_ptr, virtual_size,
14116          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14117
14118       if_stmt = begin_if_stmt ();
14119       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14120                                   current_in_charge_parm,
14121                                   integer_one_node),
14122                            if_stmt);
14123       finish_expr_stmt (exprstmt);
14124       finish_then_clause (if_stmt);
14125       finish_if_stmt ();
14126     }
14127 }
14128
14129 /* Do the necessary processing for the beginning of a function body, which
14130    in this case includes member-initializers, but not the catch clauses of
14131    a function-try-block.  Currently, this means opening a binding level
14132    for the member-initializers (in a ctor) and member cleanups (in a dtor).
14133    In other functions, this isn't necessary, but it doesn't hurt.  */
14134
14135 tree
14136 begin_function_body ()
14137 {
14138   tree stmt;
14139
14140   if (processing_template_decl)
14141     /* Do nothing now.  */;
14142   else
14143     /* Always keep the BLOCK node associated with the outermost pair of
14144        curly braces of a function.  These are needed for correct
14145        operation of dwarfout.c.  */
14146     keep_next_level (1);
14147
14148   stmt = begin_compound_stmt (0);
14149   COMPOUND_STMT_BODY_BLOCK (stmt) = 1;
14150
14151   if (processing_template_decl)
14152     /* Do nothing now.  */;
14153   else if (DECL_CONSTRUCTOR_P (current_function_decl))
14154     begin_constructor_body ();
14155   else if (DECL_DESTRUCTOR_P (current_function_decl))
14156     begin_destructor_body ();
14157
14158   return stmt;
14159 }
14160
14161 /* Do the processing for the end of a function body.  Currently, this means
14162    closing out the cleanups for fully-constructed bases and members, and in
14163    the case of the destructor, deleting the object if desired.  Again, this
14164    is only meaningful for [cd]tors, since they are the only functions where
14165    there is a significant distinction between the main body and any
14166    function catch clauses.  Handling, say, main() return semantics here
14167    would be wrong, as flowing off the end of a function catch clause for
14168    main() would also need to return 0.  */
14169
14170 void
14171 finish_function_body (compstmt)
14172      tree compstmt;
14173 {
14174   if (processing_template_decl)
14175     /* Do nothing now.  */;
14176   else if (DECL_DESTRUCTOR_P (current_function_decl))
14177     /* Any return from a destructor will end up here.  Put it before the
14178        cleanups so that an explicit return doesn't duplicate them.  */
14179     add_stmt (build_stmt (LABEL_STMT, dtor_label));
14180
14181   /* Close the block; in a destructor, run the member cleanups.  */
14182   finish_compound_stmt (0, compstmt);
14183
14184   if (processing_template_decl)
14185     /* Do nothing now.  */;
14186   else if (DECL_CONSTRUCTOR_P (current_function_decl))
14187     finish_constructor_body ();
14188   else if (DECL_DESTRUCTOR_P (current_function_decl))
14189     finish_destructor_body ();
14190 }
14191
14192 /* Finish up a function declaration and compile that function
14193    all the way to assembler language output.  The free the storage
14194    for the function definition.
14195
14196    FLAGS is a bitwise or of the following values:
14197      2 - INCLASS_INLINE
14198        We just finished processing the body of an in-class inline
14199        function definition.  (This processing will have taken place
14200        after the class definition is complete.)  */
14201
14202 tree
14203 finish_function (flags)
14204      int flags;
14205 {
14206   register tree fndecl = current_function_decl;
14207   tree fntype, ctype = NULL_TREE;
14208   int inclass_inline = (flags & 2) != 0;
14209   int nested;
14210
14211   /* When we get some parse errors, we can end up without a
14212      current_function_decl, so cope.  */
14213   if (fndecl == NULL_TREE)
14214     return error_mark_node;
14215
14216   nested = function_depth > 1;
14217   fntype = TREE_TYPE (fndecl);
14218
14219   /*  TREE_READONLY (fndecl) = 1;
14220       This caused &foo to be of type ptr-to-const-function
14221       which then got a warning when stored in a ptr-to-function variable.  */
14222
14223   my_friendly_assert (building_stmt_tree (), 20000911);
14224
14225   finish_fname_decls ();
14226
14227   /* For a cloned function, we've already got all the code we need;
14228      there's no need to add any extra bits.  */
14229   if (!DECL_CLONED_FUNCTION_P (fndecl))
14230     {
14231       if (DECL_MAIN_P (current_function_decl))
14232         {
14233           /* Make it so that `main' always returns 0 by default.  */
14234 #ifdef VMS_TARGET
14235           finish_return_stmt (integer_one_node);
14236 #else
14237           finish_return_stmt (integer_zero_node);
14238 #endif
14239         }
14240
14241       /* Finish dealing with exception specifiers.  */
14242       if (flag_exceptions && !processing_template_decl
14243           && flag_enforce_eh_specs
14244           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14245         finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14246                               (TREE_TYPE (current_function_decl)),
14247                               current_eh_spec_block);
14248     }
14249
14250   /* If we're saving up tree structure, tie off the function now.  */
14251   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14252
14253   /* This must come after expand_function_end because cleanups might
14254      have declarations (from inline functions) that need to go into
14255      this function's blocks.  */
14256
14257   /* If the current binding level isn't the outermost binding level
14258      for this function, either there is a bug, or we have experienced
14259      syntax errors and the statement tree is malformed.  */
14260   if (current_binding_level->parm_flag != 1)
14261     {
14262       /* Make sure we have already experienced errors.  */
14263       if (errorcount == 0)
14264         abort ();
14265
14266       /* Throw away the broken statement tree and extra binding
14267          levels.  */
14268       DECL_SAVED_TREE (fndecl) = build_stmt (COMPOUND_STMT, NULL_TREE);
14269
14270       while (current_binding_level->parm_flag != 1)
14271         {
14272           if (current_binding_level->parm_flag == 2)
14273             pop_nested_class ();
14274           else
14275             poplevel (0, 0, 0);
14276         }
14277     }
14278   poplevel (1, 0, 1);
14279
14280   /* Set up the named return value optimization, if we can.  Here, we
14281      eliminate the copy from the nrv into the RESULT_DECL and any cleanup
14282      for the nrv.  genrtl_start_function and declare_return_variable
14283      handle making the nrv and RESULT_DECL share space.  */
14284   if (current_function_return_value)
14285     {
14286       tree r = current_function_return_value;
14287       /* This is only worth doing for fns that return in memory--and
14288          simpler, since we don't have to worry about promoted modes.  */
14289       if (r != error_mark_node
14290           && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl))))
14291         {
14292           DECL_ALIGN (r) = DECL_ALIGN (DECL_RESULT (fndecl));
14293           walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl),
14294                                         nullify_returns_r, r);
14295         }
14296       else
14297         /* Clear it so genrtl_start_function and declare_return_variable
14298            know we're not optimizing.  */
14299         current_function_return_value = NULL_TREE;
14300     }
14301
14302   /* Remember that we were in class scope.  */
14303   if (current_class_name)
14304     ctype = current_class_type;
14305
14306   /* Must mark the RESULT_DECL as being in this function.  */
14307   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14308
14309   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14310      to the FUNCTION_DECL node itself.  */
14311   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14312
14313   /* Save away current state, if appropriate.  */
14314   if (!processing_template_decl)
14315     save_function_data (fndecl);
14316
14317   /* If this function calls `setjmp' it cannot be inlined.  When
14318      `longjmp' is called it is not guaranteed to restore the value of
14319      local variables that have been modified since the call to
14320      `setjmp'.  So, if were to inline this function into some caller
14321      `c', then when we `longjmp', we might not restore all variables
14322      in `c'.  (It might seem, at first blush, that there's no way for
14323      this function to modify local variables in `c', but their
14324      addresses may have been stored somewhere accessible to this
14325      function.)  */
14326   if (!processing_template_decl && calls_setjmp_p (fndecl))
14327     DECL_UNINLINABLE (fndecl) = 1;
14328
14329   /* Complain if there's just no return statement.  */
14330   if (warn_return_type
14331       && !processing_template_decl
14332       && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
14333       && !current_function_returns_value && !current_function_returns_null
14334       /* Don't complain if we abort or throw.  */
14335       && !current_function_returns_abnormally
14336       && !DECL_NAME (DECL_RESULT (fndecl))
14337       /* Normally, with -Wreturn-type, flow will complain.  Unless we're an
14338          inline function, as we might never be compiled separately.  */
14339       && DECL_INLINE (fndecl))
14340     warning ("no return statement in function returning non-void");
14341
14342   /* Clear out memory we no longer need.  */
14343   free_after_parsing (cfun);
14344   /* Since we never call rest_of_compilation, we never clear
14345      CFUN.  Do so explicitly.  */
14346   free_after_compilation (cfun);
14347   cfun = NULL;
14348
14349   /* If this is a in-class inline definition, we may have to pop the
14350      bindings for the template parameters that we added in
14351      maybe_begin_member_template_processing when start_function was
14352      called.  */
14353   if (inclass_inline)
14354     maybe_end_member_template_processing ();
14355
14356   /* Leave the scope of the class.  */
14357   if (ctype)
14358     pop_nested_class ();
14359
14360   --function_depth;
14361
14362   /* Clean up.  */
14363   if (! nested)
14364     /* Let the error reporting routines know that we're outside a
14365        function.  For a nested function, this value is used in
14366        pop_cp_function_context and then reset via pop_function_context.  */
14367     current_function_decl = NULL_TREE;
14368
14369   return fndecl;
14370 }
14371 \f
14372 /* Create the FUNCTION_DECL for a function definition.
14373    DECLSPECS and DECLARATOR are the parts of the declaration;
14374    they describe the return type and the name of the function,
14375    but twisted together in a fashion that parallels the syntax of C.
14376
14377    This function creates a binding context for the function body
14378    as well as setting up the FUNCTION_DECL in current_function_decl.
14379
14380    Returns a FUNCTION_DECL on success.
14381
14382    If the DECLARATOR is not suitable for a function (it defines a datum
14383    instead), we return 0, which tells yyparse to report a parse error.
14384
14385    May return void_type_node indicating that this method is actually
14386    a friend.  See grokfield for more details.
14387
14388    Came here with a `.pushlevel' .
14389
14390    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14391    CHANGES TO CODE IN `grokfield'.  */
14392
14393 tree
14394 start_method (declspecs, declarator, attrlist)
14395      tree declarator, declspecs, attrlist;
14396 {
14397   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14398                                 &attrlist);
14399
14400   /* Something too ugly to handle.  */
14401   if (fndecl == NULL_TREE)
14402     return NULL_TREE;
14403
14404   if (attrlist)
14405     cplus_decl_attributes (&fndecl, attrlist, 0);
14406
14407   /* Pass friends other than inline friend functions back.  */
14408   if (fndecl == void_type_node)
14409     return fndecl;
14410
14411   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14412     /* Not a function, tell parser to report parse error.  */
14413     return NULL_TREE;
14414
14415   if (DECL_IN_AGGR_P (fndecl))
14416     {
14417       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14418         {
14419           if (DECL_CONTEXT (fndecl)
14420               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14421             error ("`%D' is already defined in class `%T'", fndecl,
14422                       DECL_CONTEXT (fndecl));
14423         }
14424       return void_type_node;
14425     }
14426
14427   check_template_shadow (fndecl);
14428
14429   DECL_DECLARED_INLINE_P (fndecl) = 1;
14430
14431   if (flag_default_inline)
14432     DECL_INLINE (fndecl) = 1;
14433
14434   /* We process method specializations in finish_struct_1.  */
14435   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14436     fndecl = push_template_decl (fndecl);
14437
14438   if (! DECL_FRIEND_P (fndecl))
14439     {
14440       if (TREE_CHAIN (fndecl))
14441         {
14442           fndecl = copy_node (fndecl);
14443           TREE_CHAIN (fndecl) = NULL_TREE;
14444         }
14445       grok_special_member_properties (fndecl);
14446     }
14447
14448   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14449
14450   /* Make a place for the parms */
14451   pushlevel (0);
14452   current_binding_level->parm_flag = 1;
14453
14454   DECL_IN_AGGR_P (fndecl) = 1;
14455   return fndecl;
14456 }
14457
14458 /* Go through the motions of finishing a function definition.
14459    We don't compile this method until after the whole class has
14460    been processed.
14461
14462    FINISH_METHOD must return something that looks as though it
14463    came from GROKFIELD (since we are defining a method, after all).
14464
14465    This is called after parsing the body of the function definition.
14466    STMTS is the chain of statements that makes up the function body.
14467
14468    DECL is the ..._DECL that `start_method' provided.  */
14469
14470 tree
14471 finish_method (decl)
14472      tree decl;
14473 {
14474   register tree fndecl = decl;
14475   tree old_initial;
14476
14477   register tree link;
14478
14479   if (decl == void_type_node)
14480     return decl;
14481
14482   old_initial = DECL_INITIAL (fndecl);
14483
14484   /* Undo the level for the parms (from start_method).
14485      This is like poplevel, but it causes nothing to be
14486      saved.  Saving information here confuses symbol-table
14487      output routines.  Besides, this information will
14488      be correctly output when this method is actually
14489      compiled.  */
14490
14491   /* Clear out the meanings of the local variables of this level;
14492      also record in each decl which block it belongs to.  */
14493
14494   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14495     {
14496       if (DECL_NAME (link) != NULL_TREE)
14497         pop_binding (DECL_NAME (link), link);
14498       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14499       DECL_CONTEXT (link) = NULL_TREE;
14500     }
14501
14502   poplevel (0, 0, 0);
14503
14504   DECL_INITIAL (fndecl) = old_initial;
14505
14506   /* We used to check if the context of FNDECL was different from
14507      current_class_type as another way to get inside here.  This didn't work
14508      for String.cc in libg++.  */
14509   if (DECL_FRIEND_P (fndecl))
14510     {
14511       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14512         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14513       decl = void_type_node;
14514     }
14515
14516   return decl;
14517 }
14518 \f
14519
14520 /* VAR is a VAR_DECL.  If its type is incomplete, remember VAR so that
14521    we can lay it out later, when and if its type becomes complete.  */
14522
14523 void
14524 maybe_register_incomplete_var (var)
14525      tree var;
14526 {
14527   my_friendly_assert (TREE_CODE (var) == VAR_DECL, 20020406);
14528
14529   /* Keep track of variables with incomplete types.  */
14530   if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
14531       && DECL_EXTERNAL (var))
14532     {
14533       tree inner_type = TREE_TYPE (var);
14534
14535       while (TREE_CODE (inner_type) == ARRAY_TYPE)
14536         inner_type = TREE_TYPE (inner_type);
14537       inner_type = TYPE_MAIN_VARIANT (inner_type);
14538
14539       if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
14540           /* RTTI TD entries are created while defining the type_info.  */
14541           || (TYPE_LANG_SPECIFIC (inner_type)
14542               && TYPE_BEING_DEFINED (inner_type)))
14543         incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
14544     }
14545 }
14546
14547 /* Called when a class type (given by TYPE) is defined.  If there are
14548    any existing VAR_DECLs whose type hsa been completed by this
14549    declaration, update them now.  */
14550
14551 void
14552 complete_vars (type)
14553      tree type;
14554 {
14555   tree *list = &incomplete_vars;
14556
14557   my_friendly_assert (CLASS_TYPE_P (type), 20020406);
14558   while (*list)
14559     {
14560       if (same_type_p (type, TREE_PURPOSE (*list)))
14561         {
14562           tree var = TREE_VALUE (*list);
14563           /* Complete the type of the variable.  The VAR_DECL itself
14564              will be laid out in expand_expr.  */
14565           complete_type (TREE_TYPE (var));
14566           /* Remove this entry from the list.  */
14567           *list = TREE_CHAIN (*list);
14568         }
14569       else
14570         list = &TREE_CHAIN (*list);
14571     }
14572 }
14573
14574 /* If DECL is of a type which needs a cleanup, build that cleanup
14575    here.  */
14576
14577 tree
14578 maybe_build_cleanup (decl)
14579      tree decl;
14580 {
14581   tree type = TREE_TYPE (decl);
14582
14583   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14584     {
14585       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14586       tree rval;
14587
14588       if (TREE_CODE (type) == ARRAY_TYPE)
14589         rval = decl;
14590       else
14591         {
14592           mark_addressable (decl);
14593           rval = build_unary_op (ADDR_EXPR, decl, 0);
14594         }
14595
14596       /* Optimize for space over speed here.  */
14597       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14598           || flag_expensive_optimizations)
14599         flags |= LOOKUP_NONVIRTUAL;
14600
14601       rval = build_delete (TREE_TYPE (rval), rval,
14602                            sfk_complete_destructor, flags, 0);
14603
14604       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14605           && ! TYPE_HAS_DESTRUCTOR (type))
14606         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14607                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14608
14609       return rval;
14610     }
14611   return NULL_TREE;
14612 }
14613 \f
14614 /* When a stmt has been parsed, this function is called.  */
14615
14616 void
14617 finish_stmt ()
14618 {
14619   /* Always assume this statement was not an expression statement.  If
14620      it actually was an expression statement, its our callers
14621      responsibility to fix this up.  */
14622   last_expr_type = NULL_TREE;
14623 }
14624
14625 /* DECL was originally constructed as a non-static member function,
14626    but turned out to be static.  Update it accordingly.  */
14627
14628 void
14629 revert_static_member_fn (decl)
14630      tree decl;
14631 {
14632   tree tmp;
14633   tree function = TREE_TYPE (decl);
14634   tree args = TYPE_ARG_TYPES (function);
14635
14636   if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
14637       != TYPE_UNQUALIFIED)
14638     error ("static member function `%#D' declared with type qualifiers",
14639               decl);
14640
14641   args = TREE_CHAIN (args);
14642   tmp = build_function_type (TREE_TYPE (function), args);
14643   tmp = build_qualified_type (tmp, cp_type_quals (function));
14644   tmp = build_exception_variant (tmp,
14645                                  TYPE_RAISES_EXCEPTIONS (function));
14646   TREE_TYPE (decl) = tmp;
14647   if (DECL_ARGUMENTS (decl))
14648     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14649   DECL_STATIC_FUNCTION_P (decl) = 1;
14650 }
14651
14652 /* Initialize the variables used during compilation of a C++
14653    function.  */
14654
14655 static void
14656 push_cp_function_context (f)
14657      struct function *f;
14658 {
14659   struct cp_language_function *p
14660     = ((struct cp_language_function *)
14661        xcalloc (1, sizeof (struct cp_language_function)));
14662   f->language = (struct language_function *) p;
14663
14664   /* It takes an explicit call to expand_body to generate RTL for a
14665      function.  */
14666   expanding_p = 0;
14667
14668   /* Whenever we start a new function, we destroy temporaries in the
14669      usual way.  */
14670   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14671 }
14672
14673 /* Free the language-specific parts of F, now that we've finished
14674    compiling the function.  */
14675
14676 static void
14677 pop_cp_function_context (f)
14678      struct function *f;
14679 {
14680   if (f->language)
14681     {
14682       struct cp_language_function *cp =
14683         (struct cp_language_function *) f->language;
14684       if (cp->x_local_names)
14685         VARRAY_FREE (cp->x_local_names);
14686       free (f->language);
14687     }
14688   f->language = 0;
14689 }
14690
14691 /* Mark P for GC.  */
14692
14693 static void
14694 mark_lang_function (p)
14695      struct cp_language_function *p;
14696 {
14697   if (!p)
14698     return;
14699
14700   mark_c_language_function (&p->base);
14701
14702   ggc_mark_tree (p->x_dtor_label);
14703   ggc_mark_tree (p->x_current_class_ptr);
14704   ggc_mark_tree (p->x_current_class_ref);
14705   ggc_mark_tree (p->x_eh_spec_block);
14706   ggc_mark_tree_varray (p->x_local_names);
14707
14708   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14709   mark_binding_level (&p->bindings);
14710   mark_pending_inlines (&p->unparsed_inlines);
14711 }
14712
14713 /* Mark the language-specific data in F for GC.  */
14714
14715 static void
14716 mark_cp_function_context (f)
14717      struct function *f;
14718 {
14719   mark_lang_function ((struct cp_language_function *) f->language);
14720 }
14721
14722 void
14723 lang_mark_tree (t)
14724      tree t;
14725 {
14726   enum tree_code code = TREE_CODE (t);
14727   if (code == IDENTIFIER_NODE)
14728     {
14729       struct lang_identifier *li = (struct lang_identifier *) t;
14730       struct lang_id2 *li2 = li->x;
14731       ggc_mark_tree (li->namespace_bindings);
14732       ggc_mark_tree (li->bindings);
14733       ggc_mark_tree (li->class_value);
14734       ggc_mark_tree (li->class_template_info);
14735
14736       if (li2)
14737         {
14738           ggc_mark_tree (li2->label_value);
14739           ggc_mark_tree (li2->implicit_decl);
14740           ggc_mark_tree (li2->error_locus);
14741         }
14742     }
14743   else if (code == CPLUS_BINDING)
14744     {
14745       if (BINDING_HAS_LEVEL_P (t))
14746         mark_binding_level (&BINDING_LEVEL (t));
14747       else
14748         ggc_mark_tree (BINDING_SCOPE (t));
14749       ggc_mark_tree (BINDING_VALUE (t));
14750     }
14751   else if (code == OVERLOAD)
14752     ggc_mark_tree (OVL_FUNCTION (t));
14753   else if (code == TEMPLATE_PARM_INDEX)
14754     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14755   else if (TREE_CODE_CLASS (code) == 'd')
14756     {
14757       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14758
14759       if (ld)
14760         {
14761           ggc_mark (ld);
14762           c_mark_lang_decl (&ld->decl_flags.base);
14763           if (!DECL_GLOBAL_CTOR_P (t)
14764               && !DECL_GLOBAL_DTOR_P (t)
14765               && !DECL_THUNK_P (t)
14766               && !DECL_DISCRIMINATOR_P (t))
14767             ggc_mark_tree (ld->decl_flags.u2.access);
14768           else if (DECL_THUNK_P (t))
14769             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14770           if (TREE_CODE (t) != NAMESPACE_DECL)
14771             ggc_mark_tree (ld->decl_flags.u.template_info);
14772           else
14773             mark_binding_level (&NAMESPACE_LEVEL (t));
14774           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14775             {
14776               ggc_mark_tree (ld->befriending_classes);
14777               ggc_mark_tree (ld->context);
14778               ggc_mark_tree (ld->cloned_function);
14779               if (TREE_CODE (t) == TYPE_DECL)
14780                 ggc_mark_tree (ld->u.sorted_fields);
14781               else if (TREE_CODE (t) == FUNCTION_DECL
14782                        && !DECL_PENDING_INLINE_P (t))
14783                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14784             }
14785         }
14786     }
14787   else if (TREE_CODE_CLASS (code) == 't')
14788     {
14789       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14790
14791       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14792                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14793         {
14794           ggc_mark (lt);
14795           ggc_mark_tree (lt->primary_base);
14796           ggc_mark_tree (lt->vfields);
14797           ggc_mark_tree (lt->vbases);
14798           ggc_mark_tree (lt->tags);
14799           ggc_mark_tree (lt->size);
14800           ggc_mark_tree (lt->pure_virtuals);
14801           ggc_mark_tree (lt->friend_classes);
14802           ggc_mark_tree (lt->rtti);
14803           ggc_mark_tree (lt->methods);
14804           ggc_mark_tree (lt->template_info);
14805           ggc_mark_tree (lt->befriending_classes);
14806         }
14807       else if (lt)
14808         /* In the case of pointer-to-member function types, the
14809            TYPE_LANG_SPECIFIC is really just a tree.  */
14810         ggc_mark_tree ((tree) lt);
14811     }
14812 }
14813
14814 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14815    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
14816
14817 tree
14818 identifier_global_value (t)
14819      tree t;
14820 {
14821   return IDENTIFIER_GLOBAL_VALUE (t);
14822 }
14823
14824 /* Build the void_list_node (void_type_node having been created).  */
14825 tree
14826 build_void_list_node ()
14827 {
14828   tree t = build_tree_list (NULL_TREE, void_type_node);
14829   TREE_PARMLIST (t) = 1;
14830   return t;
14831 }
14832
14833 static int
14834 cp_missing_noreturn_ok_p (decl)
14835      tree decl;
14836 {
14837   /* A missing noreturn is ok for the `main' function.  */
14838   return DECL_MAIN_P (decl);
14839 }