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  Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* Process declarations and symbol lookup for C front end.
  25    Also constructs types; the standard scalar types at initialization,
  26    and structure, union, array and enum types when they are declared.  */
  27
  28 /* ??? not all decl nodes are given the most useful possible
  29    line numbers.  For example, the CONST_DECLs for enum values.  */
  30
  31 #include "config.h"
  32 #include "system.h"
  33 #include "tree.h"
  34 #include "rtl.h"
  35 #include "expr.h"
  36 #include "flags.h"
  37 #include "cp-tree.h"
  38 #include "decl.h"
  39 #include "lex.h"
  40 #include "output.h"
  41 #include "except.h"
  42 #include "toplev.h"
  43 #include "../hash.h"
  44 #include "ggc.h"
  45 #include "tm_p.h"
  46 #include "target.h"
  47
  48 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  49
  50 #ifndef BOOL_TYPE_SIZE
  51 /* In the new ABI, `bool' has size and alignment `1', on all
  52    platforms.  */
  53 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  54 #endif
  55
  56 static tree grokparms                           PARAMS ((tree));
  57 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  58
  59 static void push_binding_level PARAMS ((struct binding_level *, int,
  60                                       int));
  61 static void pop_binding_level PARAMS ((void));
  62 static void suspend_binding_level PARAMS ((void));
  63 static void resume_binding_level PARAMS ((struct binding_level *));
  64 static struct binding_level *make_binding_level PARAMS ((void));
  65 static void declare_namespace_level PARAMS ((void));
  66 static int decl_jump_unsafe PARAMS ((tree));
  67 static void storedecls PARAMS ((tree));
  68 static void require_complete_types_for_parms PARAMS ((tree));
  69 static int ambi_op_p PARAMS ((enum tree_code));
  70 static int unary_op_p PARAMS ((enum tree_code));
  71 static tree store_bindings PARAMS ((tree, tree));
  72 static tree lookup_tag_reverse PARAMS ((tree, tree));
  73 static tree obscure_complex_init PARAMS ((tree, tree));
  74 static tree lookup_name_real PARAMS ((tree, int, int, int));
  75 static void push_local_name PARAMS ((tree));
  76 static void warn_extern_redeclared_static PARAMS ((tree, tree));
  77 static tree grok_reference_init PARAMS ((tree, tree, tree));
  78 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
  79                               enum overload_flags, tree,
  80                               tree, int, int, int, int, int, int, tree));
  81 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
  82 static tree lookup_tag PARAMS ((enum tree_code, tree,
  83                               struct binding_level *, int));
  84 static void set_identifier_type_value_with_scope
  85         PARAMS ((tree, tree, struct binding_level *));
  86 static void record_unknown_type PARAMS ((tree, const char *));
  87 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
  88 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
  89 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
  90                                   int));
  91 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
  92 static void check_for_uninitialized_const_var PARAMS ((tree));
  93 static unsigned long typename_hash PARAMS ((hash_table_key));
  94 static bool typename_compare PARAMS ((hash_table_key, hash_table_key));
  95 static void push_binding PARAMS ((tree, tree, struct binding_level*));
  96 static int add_binding PARAMS ((tree, tree));
  97 static void pop_binding PARAMS ((tree, tree));
  98 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
  99 static tree find_binding PARAMS ((tree, tree));
 100 static tree select_decl PARAMS ((tree, int));
 101 static int lookup_flags PARAMS ((int, int));
 102 static tree qualify_lookup PARAMS ((tree, int));
 103 static tree record_builtin_java_type PARAMS ((const char *, int));
 104 static const char *tag_name PARAMS ((enum tag_types code));
 105 static void find_class_binding_level PARAMS ((void));
 106 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 107 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 108 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 109 static int walk_globals_r PARAMS ((tree, void *));
 110 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 111 static tree make_label_decl PARAMS ((tree, int));
 112 static void use_label PARAMS ((tree));
 113 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 114                                            const char *, int));
 115 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 116 static void check_switch_goto PARAMS ((struct binding_level *));
 117 static void check_previous_gotos PARAMS ((tree));
 118 static void pop_label PARAMS ((tree, tree));
 119 static void pop_labels PARAMS ((tree));
 120 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 121 static void layout_var_decl PARAMS ((tree));
 122 static void maybe_commonize_var PARAMS ((tree));
 123 static tree check_initializer PARAMS ((tree, tree));
 124 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 125 static void push_cp_function_context PARAMS ((struct function *));
 126 static void pop_cp_function_context PARAMS ((struct function *));
 127 static void mark_binding_level PARAMS ((void *));
 128 static void mark_named_label_lists PARAMS ((void *, void *));
 129 static void mark_cp_function_context PARAMS ((struct function *));
 130 static void mark_saved_scope PARAMS ((void *));
 131 static void mark_lang_function PARAMS ((struct cp_language_function *));
 132 static void save_function_data PARAMS ((tree));
 133 static void check_function_type PARAMS ((tree, tree));
 134 static void destroy_local_var PARAMS ((tree));
 135 static void finish_constructor_body PARAMS ((void));
 136 static void finish_destructor_body PARAMS ((void));
 137 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 138 static tree get_atexit_node PARAMS ((void));
 139 static tree get_dso_handle_node PARAMS ((void));
 140 static tree start_cleanup_fn PARAMS ((void));
 141 static void end_cleanup_fn PARAMS ((void));
 142 static tree cp_make_fname_decl PARAMS ((tree, int));
 143 static void initialize_predefined_identifiers PARAMS ((void));
 144 static tree check_special_function_return_type
 145   PARAMS ((special_function_kind, tree, tree));
 146 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 147 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 148 static void store_parm_decls PARAMS ((tree));
 149 static int cp_missing_noreturn_ok_p PARAMS ((tree));
 150
 151 #if defined (DEBUG_CP_BINDING_LEVELS)
 152 static void indent PARAMS ((void));
 153 #endif
 154
 155 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 156 tree error_mark_list;
 157
 158 /* The following symbols are subsumed in the cp_global_trees array, and
 159    listed here individually for documentation purposes.
 160
 161    C++ extensions
 162         tree wchar_decl_node;
 163
 164         tree vtable_entry_type;
 165         tree delta_type_node;
 166 #if 0
 167    Old rtti stuff.
 168         tree __baselist_desc_type_node;
 169         tree __i_desc_type_node, __m_desc_type_node;
 170         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 171 #endif
 172         tree __t_desc_type_node;
 173 #if 0
 174         tree __tp_desc_type_node;
 175 #endif
 176         tree ti_desc_type_node;
 177         tree bltn_desc_type_node, ptr_desc_type_node;
 178         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 179         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 180         tree ptm_desc_type_node;
 181         tree base_desc_type_node;
 182 #if 0
 183    Not needed yet?  May be needed one day?
 184         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 185         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 186         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 187 #endif
 188
 189         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 190         tree unknown_type_node;
 191
 192    Array type `vtable_entry_type[]'
 193
 194         tree vtbl_type_node;
 195         tree vtbl_ptr_type_node;
 196
 197    Namespaces,
 198
 199         tree std_node;
 200         tree abi_node;
 201
 202    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 203    one that the user will declare, but sufficient to be called
 204    by routines that want to abort the program.
 205
 206         tree abort_fndecl;
 207
 208    The FUNCTION_DECL for the default `::operator delete'.
 209
 210         tree global_delete_fndecl;
 211
 212    Used by RTTI
 213         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 214         tree tinfo_var_id;
 215
 216 */
 217
 218 tree cp_global_trees[CPTI_MAX];
 219
 220 /* Indicates that there is a type value in some namespace, although
 221    that is not necessarily in scope at the moment.  */
 222
 223 static tree global_type_node;
 224
 225 /* If non-zero, this is the number of times we have entered the `std'
 226    namespace when we are treating that namespace as an alias for the
 227    global namespace.  */
 228 static int in_fake_std;
 229
 230 /* Expect only namespace names now. */
 231 static int only_namespace_names;
 232
 233 /* Used only for jumps to as-yet undefined labels, since jumps to
 234    defined labels can have their validity checked immediately.  */
 235
 236 struct named_label_use_list
 237 {
 238   struct binding_level *binding_level;
 239   tree names_in_scope;
 240   tree label_decl;
 241   const char *filename_o_goto;
 242   int lineno_o_goto;
 243   struct named_label_use_list *next;
 244 };
 245
 246 #define named_label_uses cp_function_chain->x_named_label_uses
 247
 248 #define local_names cp_function_chain->x_local_names
 249
 250 /* A list of objects which have constructors or destructors
 251    which reside in the global scope.  The decl is stored in
 252    the TREE_VALUE slot and the initializer is stored
 253    in the TREE_PURPOSE slot.  */
 254 tree static_aggregates;
 255
 256 /* -- end of C++ */
 257
 258 /* A node for the integer constants 2, and 3.  */
 259
 260 tree integer_two_node, integer_three_node;
 261
 262 /* Parsing a function declarator leaves here a chain of structure
 263    and enum types declared in the parmlist.  */
 264
 265 static tree last_function_parm_tags;
 266
 267 /* Similar, for last_function_parm_tags.  */
 268 tree last_function_parms;
 269 static tree current_function_parm_tags;
 270
 271 /* A list of all LABEL_DECLs in the function that have names.  Here so
 272    we can clear out their names' definitions at the end of the
 273    function, and so we can check the validity of jumps to these labels.  */
 274
 275 struct named_label_list
 276 {
 277   struct binding_level *binding_level;
 278   tree names_in_scope;
 279   tree old_value;
 280   tree label_decl;
 281   tree bad_decls;
 282   struct named_label_list *next;
 283   unsigned int in_try_scope : 1;
 284   unsigned int in_catch_scope : 1;
 285 };
 286
 287 #define named_labels cp_function_chain->x_named_labels
 288
 289 /* Nonzero means use the ISO C94 dialect of C.  */
 290
 291 int flag_isoc94;
 292
 293 /* Nonzero means use the ISO C99 dialect of C.  */
 294
 295 int flag_isoc99;
 296
 297 /* Nonzero means we are a hosted implementation for code shared with C.  */
 298
 299 int flag_hosted = 1;
 300
 301 /* Nonzero means add default format_arg attributes for functions not
 302    in ISO C.  */
 303
 304 int flag_noniso_default_format_attributes = 1;
 305
 306 /* Nonzero if we want to conserve space in the .o files.  We do this
 307    by putting uninitialized data and runtime initialized data into
 308    .common instead of .data at the expense of not flagging multiple
 309    definitions.  */
 310 extern int flag_conserve_space;
 311 \f
 312 /* C and C++ flags are in decl2.c.  */
 313
 314 /* Flag used when debugging spew.c */
 315
 316 extern int spew_debug;
 317
 318 /* A expression of value 0 with the same precision as a sizetype
 319    node, but signed.  */
 320 tree signed_size_zero_node;
 321
 322 /* The name of the anonymous namespace, throughout this translation
 323    unit.  */
 324 tree anonymous_namespace_name;
 325
 326 /* The number of function bodies which we are currently processing.
 327    (Zero if we are at namespace scope, one inside the body of a
 328    function, two inside the body of a function in a local class, etc.)  */
 329 int function_depth;
 330 \f
 331 /* For each binding contour we allocate a binding_level structure
 332    which records the names defined in that contour.
 333    Contours include:
 334     0) the global one
 335     1) one for each function definition,
 336        where internal declarations of the parameters appear.
 337     2) one for each compound statement,
 338        to record its declarations.
 339
 340    The current meaning of a name can be found by searching the levels
 341    from the current one out to the global one.
 342
 343    Off to the side, may be the class_binding_level.  This exists only
 344    to catch class-local declarations.  It is otherwise nonexistent.
 345
 346    Also there may be binding levels that catch cleanups that must be
 347    run when exceptions occur.  Thus, to see whether a name is bound in
 348    the current scope, it is not enough to look in the
 349    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 350    instead.  */
 351
 352 /* Note that the information in the `names' component of the global contour
 353    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 354
 355 struct binding_level
 356   {
 357     /* A chain of _DECL nodes for all variables, constants, functions,
 358        and typedef types.  These are in the reverse of the order
 359        supplied.  There may be OVERLOADs on this list, too, but they
 360        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 361     tree names;
 362
 363     /* A list of structure, union and enum definitions, for looking up
 364        tag names.
 365        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 366        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 367        or ENUMERAL_TYPE node.
 368
 369        C++: the TREE_VALUE nodes can be simple types for
 370        component_bindings.  */
 371     tree tags;
 372
 373     /* A list of USING_DECL nodes. */
 374     tree usings;
 375
 376     /* A list of used namespaces. PURPOSE is the namespace,
 377        VALUE the common ancestor with this binding_level's namespace. */
 378     tree using_directives;
 379
 380     /* If this binding level is the binding level for a class, then
 381        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 382        is the name of an entity bound in the class.  The TREE_TYPE is
 383        the DECL bound by this name in the class.  */
 384     tree class_shadowed;
 385
 386     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 387        is used for all binding levels. In addition the TREE_VALUE is the
 388        IDENTIFIER_TYPE_VALUE before we entered the class.  */
 389     tree type_shadowed;
 390
 391     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 392        label in this scope.  The TREE_PURPOSE is the previous value of
 393        the IDENTIFIER_LABEL VALUE.  */
 394     tree shadowed_labels;
 395
 396     /* For each level (except not the global one),
 397        a chain of BLOCK nodes for all the levels
 398        that were entered and exited one level down.  */
 399     tree blocks;
 400
 401     /* The _TYPE node for this level, if parm_flag == 2.  */
 402     tree this_class;
 403
 404     /* The binding level which this one is contained in (inherits from).  */
 405     struct binding_level *level_chain;
 406
 407     /* List of decls in `names' that have incomplete
 408        structure or union types.  */
 409     tree incomplete;
 410
 411     /* List of VAR_DECLS saved from a previous for statement.
 412        These would be dead in ISO-conforming code, but might
 413        be referenced in ARM-era code.  These are stored in a
 414        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 415     tree dead_vars_from_for;
 416
 417     /* 1 for the level that holds the parameters of a function.
 418        2 for the level that holds a class declaration.  */
 419     unsigned parm_flag : 2;
 420
 421     /* 1 means make a BLOCK for this level regardless of all else.
 422        2 for temporary binding contours created by the compiler.  */
 423     unsigned keep : 2;
 424
 425     /* Nonzero if this level "doesn't exist" for tags.  */
 426     unsigned tag_transparent : 1;
 427
 428     /* Nonzero if this level can safely have additional
 429        cleanup-needing variables added to it.  */
 430     unsigned more_cleanups_ok : 1;
 431     unsigned have_cleanups : 1;
 432
 433     /* Nonzero if this scope is for storing the decls for template
 434        parameters and generic decls; these decls will be discarded and
 435        replaced with a TEMPLATE_DECL.  */
 436     unsigned template_parms_p : 1;
 437
 438     /* Nonzero if this scope corresponds to the `<>' in a
 439        `template <>' clause.  Whenever this flag is set,
 440        TEMPLATE_PARMS_P will be set as well.  */
 441     unsigned template_spec_p : 1;
 442
 443     /* This is set for a namespace binding level.  */
 444     unsigned namespace_p : 1;
 445
 446     /* True if this level is that of a for-statement where we need to
 447        worry about ambiguous (ARM or ISO) scope rules.  */
 448     unsigned is_for_scope : 1;
 449
 450     /* True if this level corresponds to a TRY block.  Currently this
 451        information is only available while building the tree structure.  */
 452     unsigned is_try_scope : 1;
 453
 454     /* True if this level corresponds to a CATCH block.  Currently this
 455        information is only available while building the tree structure.  */
 456     unsigned is_catch_scope : 1;
 457
 458     /* Three bits left for this word.  */
 459
 460 #if defined(DEBUG_CP_BINDING_LEVELS)
 461     /* Binding depth at which this level began.  */
 462     unsigned binding_depth;
 463 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 464   };
 465
 466 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 467
 468 /* The binding level currently in effect.  */
 469
 470 #define current_binding_level                   \
 471   (cfun && cp_function_chain->bindings          \
 472    ? cp_function_chain->bindings                \
 473    : scope_chain->bindings)
 474
 475 /* The binding level of the current class, if any.  */
 476
 477 #define class_binding_level scope_chain->class_bindings
 478
 479 /* A chain of binding_level structures awaiting reuse.  */
 480
 481 static struct binding_level *free_binding_level;
 482
 483 /* The outermost binding level, for names of file scope.
 484    This is created when the compiler is started and exists
 485    through the entire run.  */
 486
 487 static struct binding_level *global_binding_level;
 488
 489 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 490
 491 static int keep_next_level_flag;
 492
 493 #if defined(DEBUG_CP_BINDING_LEVELS)
 494 static int binding_depth = 0;
 495 static int is_class_level = 0;
 496
 497 static void
 498 indent ()
 499 {
 500   register unsigned i;
 501
 502   for (i = 0; i < binding_depth*2; i++)
 503     putc (' ', stderr);
 504 }
 505 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 506
 507 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 508
 509 static void
 510 push_binding_level (newlevel, tag_transparent, keep)
 511      struct binding_level *newlevel;
 512      int tag_transparent, keep;
 513 {
 514   /* Add this level to the front of the chain (stack) of levels that
 515      are active.  */
 516   memset ((char*) newlevel, 0, sizeof (struct binding_level));
 517   newlevel->level_chain = current_binding_level;
 518   current_binding_level = newlevel;
 519   newlevel->tag_transparent = tag_transparent;
 520   newlevel->more_cleanups_ok = 1;
 521
 522   newlevel->keep = keep;
 523 #if defined(DEBUG_CP_BINDING_LEVELS)
 524   newlevel->binding_depth = binding_depth;
 525   indent ();
 526   fprintf (stderr, "push %s level 0x%08x line %d\n",
 527            (is_class_level) ? "class" : "block", newlevel, lineno);
 528   is_class_level = 0;
 529   binding_depth++;
 530 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 531 }
 532
 533 /* Find the innermost enclosing class scope, and reset
 534    CLASS_BINDING_LEVEL appropriately.  */
 535
 536 static void
 537 find_class_binding_level ()
 538 {
 539   struct binding_level *level = current_binding_level;
 540
 541   while (level && level->parm_flag != 2)
 542     level = level->level_chain;
 543   if (level && level->parm_flag == 2)
 544     class_binding_level = level;
 545   else
 546     class_binding_level = 0;
 547 }
 548
 549 static void
 550 pop_binding_level ()
 551 {
 552   if (global_binding_level)
 553     {
 554       /* Cannot pop a level, if there are none left to pop.  */
 555       if (current_binding_level == global_binding_level)
 556         my_friendly_abort (123);
 557     }
 558   /* Pop the current level, and free the structure for reuse.  */
 559 #if defined(DEBUG_CP_BINDING_LEVELS)
 560   binding_depth--;
 561   indent ();
 562   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 563           (is_class_level) ? "class" : "block",
 564           current_binding_level, lineno);
 565   if (is_class_level != (current_binding_level == class_binding_level))
 566     {
 567       indent ();
 568       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 569     }
 570   is_class_level = 0;
 571 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 572   {
 573     register struct binding_level *level = current_binding_level;
 574     current_binding_level = current_binding_level->level_chain;
 575     level->level_chain = free_binding_level;
 576 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 577     if (level->binding_depth != binding_depth)
 578       abort ();
 579 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 580     free_binding_level = level;
 581     find_class_binding_level ();
 582   }
 583 }
 584
 585 static void
 586 suspend_binding_level ()
 587 {
 588   if (class_binding_level)
 589     current_binding_level = class_binding_level;
 590
 591   if (global_binding_level)
 592     {
 593       /* Cannot suspend a level, if there are none left to suspend.  */
 594       if (current_binding_level == global_binding_level)
 595         my_friendly_abort (123);
 596     }
 597   /* Suspend the current level.  */
 598 #if defined(DEBUG_CP_BINDING_LEVELS)
 599   binding_depth--;
 600   indent ();
 601   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 602           (is_class_level) ? "class" : "block",
 603           current_binding_level, lineno);
 604   if (is_class_level != (current_binding_level == class_binding_level))
 605     {
 606       indent ();
 607       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 608     }
 609   is_class_level = 0;
 610 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 611   current_binding_level = current_binding_level->level_chain;
 612   find_class_binding_level ();
 613 }
 614
 615 static void
 616 resume_binding_level (b)
 617      struct binding_level *b;
 618 {
 619   /* Resuming binding levels is meant only for namespaces,
 620      and those cannot nest into classes. */
 621   my_friendly_assert(!class_binding_level, 386);
 622   /* Also, resuming a non-directly nested namespace is a no-no.  */
 623   my_friendly_assert(b->level_chain == current_binding_level, 386);
 624   current_binding_level = b;
 625 #if defined(DEBUG_CP_BINDING_LEVELS)
 626   b->binding_depth = binding_depth;
 627   indent ();
 628   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 629            (is_class_level) ? "class" : "block", b, lineno);
 630   is_class_level = 0;
 631   binding_depth++;
 632 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 633 }
 634 \f
 635 /* Create a new `struct binding_level'.  */
 636
 637 static
 638 struct binding_level *
 639 make_binding_level ()
 640 {
 641   /* NOSTRICT */
 642   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 643 }
 644
 645 /* Nonzero if we are currently in the global binding level.  */
 646
 647 int
 648 global_bindings_p ()
 649 {
 650   return current_binding_level == global_binding_level;
 651 }
 652
 653 /* Return the innermost binding level that is not for a class scope.  */
 654
 655 static struct binding_level *
 656 innermost_nonclass_level ()
 657 {
 658   struct binding_level *b;
 659
 660   b = current_binding_level;
 661   while (b->parm_flag == 2)
 662     b = b->level_chain;
 663
 664   return b;
 665 }
 666
 667 /* Nonzero if we are currently in a toplevel binding level.  This
 668    means either the global binding level or a namespace in a toplevel
 669    binding level.  Since there are no non-toplevel namespace levels,
 670    this really means any namespace or template parameter level.  We
 671    also include a class whose context is toplevel.  */
 672
 673 int
 674 toplevel_bindings_p ()
 675 {
 676   struct binding_level *b = innermost_nonclass_level ();
 677
 678   return b->namespace_p || b->template_parms_p;
 679 }
 680
 681 /* Nonzero if this is a namespace scope, or if we are defining a class
 682    which is itself at namespace scope, or whose enclosing class is
 683    such a class, etc.  */
 684
 685 int
 686 namespace_bindings_p ()
 687 {
 688   struct binding_level *b = innermost_nonclass_level ();
 689
 690   return b->namespace_p;
 691 }
 692
 693 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 694    unconditionally.  Otherwise, use the normal logic to decide whether
 695    or not to create a BLOCK.  */
 696
 697 void
 698 keep_next_level (keep)
 699      int keep;
 700 {
 701   keep_next_level_flag = keep;
 702 }
 703
 704 /* Nonzero if the current level needs to have a BLOCK made.  */
 705
 706 int
 707 kept_level_p ()
 708 {
 709   return (current_binding_level->blocks != NULL_TREE
 710           || current_binding_level->keep
 711           || current_binding_level->names != NULL_TREE
 712           || (current_binding_level->tags != NULL_TREE
 713               && !current_binding_level->tag_transparent));
 714 }
 715
 716 static void
 717 declare_namespace_level ()
 718 {
 719   current_binding_level->namespace_p = 1;
 720 }
 721
 722 /* Returns non-zero if this scope was created to store template
 723    parameters.  */
 724
 725 int
 726 template_parm_scope_p ()
 727 {
 728   return current_binding_level->template_parms_p;
 729 }
 730
 731 /* Returns the kind of template specialization we are currently
 732    processing, given that it's declaration contained N_CLASS_SCOPES
 733    explicit scope qualifications.  */
 734
 735 tmpl_spec_kind
 736 current_tmpl_spec_kind (n_class_scopes)
 737      int n_class_scopes;
 738 {
 739   int n_template_parm_scopes = 0;
 740   int seen_specialization_p = 0;
 741   int innermost_specialization_p = 0;
 742   struct binding_level *b;
 743
 744   /* Scan through the template parameter scopes.  */
 745   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 746     {
 747       /* If we see a specialization scope inside a parameter scope,
 748          then something is wrong.  That corresponds to a declaration
 749          like:
 750
 751             template <class T> template <> ...
 752
 753          which is always illegal since [temp.expl.spec] forbids the
 754          specialization of a class member template if the enclosing
 755          class templates are not explicitly specialized as well.  */
 756       if (b->template_spec_p)
 757         {
 758           if (n_template_parm_scopes == 0)
 759             innermost_specialization_p = 1;
 760           else
 761             seen_specialization_p = 1;
 762         }
 763       else if (seen_specialization_p == 1)
 764         return tsk_invalid_member_spec;
 765
 766       ++n_template_parm_scopes;
 767     }
 768
 769   /* Handle explicit instantiations.  */
 770   if (processing_explicit_instantiation)
 771     {
 772       if (n_template_parm_scopes != 0)
 773         /* We've seen a template parameter list during an explicit
 774            instantiation.  For example:
 775
 776              template <class T> template void f(int);
 777
 778            This is erroneous.  */
 779         return tsk_invalid_expl_inst;
 780       else
 781         return tsk_expl_inst;
 782     }
 783
 784   if (n_template_parm_scopes < n_class_scopes)
 785     /* We've not seen enough template headers to match all the
 786        specialized classes present.  For example:
 787
 788          template <class T> void R<T>::S<T>::f(int);
 789
 790        This is illegal; there needs to be one set of template
 791        parameters for each class.  */
 792     return tsk_insufficient_parms;
 793   else if (n_template_parm_scopes == n_class_scopes)
 794     /* We're processing a non-template declaration (even though it may
 795        be a member of a template class.)  For example:
 796
 797          template <class T> void S<T>::f(int);
 798
 799        The `class T' maches the `S<T>', leaving no template headers
 800        corresponding to the `f'.  */
 801     return tsk_none;
 802   else if (n_template_parm_scopes > n_class_scopes + 1)
 803     /* We've got too many template headers.  For example:
 804
 805          template <> template <class T> void f (T);
 806
 807        There need to be more enclosing classes.  */
 808     return tsk_excessive_parms;
 809   else
 810     /* This must be a template.  It's of the form:
 811
 812          template <class T> template <class U> void S<T>::f(U);
 813
 814        This is a specialization if the innermost level was a
 815        specialization; otherwise it's just a definition of the
 816        template.  */
 817     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 818 }
 819
 820 void
 821 set_class_shadows (shadows)
 822      tree shadows;
 823 {
 824   class_binding_level->class_shadowed = shadows;
 825 }
 826
 827 /* Enter a new binding level.
 828    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 829    not for that of tags.  */
 830
 831 void
 832 pushlevel (tag_transparent)
 833      int tag_transparent;
 834 {
 835   struct binding_level *newlevel;
 836
 837   if (cfun && !doing_semantic_analysis_p ())
 838     return;
 839
 840   /* Reuse or create a struct for this binding level.  */
 841 #if defined(DEBUG_CP_BINDING_LEVELS)
 842   if (0)
 843 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 844   if (free_binding_level)
 845 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 846     {
 847       newlevel = free_binding_level;
 848       free_binding_level = free_binding_level->level_chain;
 849     }
 850   else
 851     newlevel = make_binding_level ();
 852
 853   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 854   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 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       my_friendly_abort (20000309);
 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     /* We have two typedef-names, both naming the same type to have
1012        the same name.  This is OK because of:
1013
1014          [dcl.typedef]
1015
1016          In a given scope, a typedef specifier can be used to redefine
1017          the name of any type declared in that scope to refer to the
1018          type to which it already refers.  */
1019     ok = 0;
1020   /* There can be two block-scope declarations of the same variable,
1021      so long as they are `extern' declarations.  */
1022   else if (TREE_CODE (decl) == VAR_DECL
1023            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1024            && DECL_EXTERNAL (decl)
1025            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1026     {
1027       duplicate_decls (decl, BINDING_VALUE (binding));
1028       ok = 0;
1029     }
1030   else
1031     {
1032       cp_error ("declaration of `%#D'", decl);
1033       cp_error_at ("conflicts with previous declaration `%#D'",
1034                    BINDING_VALUE (binding));
1035       ok = 0;
1036     }
1037
1038   return ok;
1039 }
1040
1041 /* Add DECL to the list of things declared in B.  */
1042
1043 static void
1044 add_decl_to_level (decl, b)
1045      tree decl;
1046      struct binding_level *b;
1047 {
1048   /* We build up the list in reverse order, and reverse it later if
1049      necessary.  */
1050   TREE_CHAIN (decl) = b->names;
1051   b->names = decl;
1052 }
1053
1054 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1055    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1056    doesn't really belong to this binding level, that it got here
1057    through a using-declaration.  */
1058
1059 void
1060 push_local_binding (id, decl, flags)
1061      tree id;
1062      tree decl;
1063      int flags;
1064 {
1065   struct binding_level *b;
1066
1067   /* Skip over any local classes.  This makes sense if we call
1068      push_local_binding with a friend decl of a local class.  */
1069   b = current_binding_level;
1070   while (b->parm_flag == 2)
1071     b = b->level_chain;
1072
1073   if (lookup_name_current_level (id))
1074     {
1075       /* Supplement the existing binding.  */
1076       if (!add_binding (id, decl))
1077         /* It didn't work.  Something else must be bound at this
1078            level.  Do not add DECL to the list of things to pop
1079            later.  */
1080         return;
1081     }
1082   else
1083     /* Create a new binding.  */
1084     push_binding (id, decl, b);
1085
1086   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1087     /* We must put the OVERLOAD into a TREE_LIST since the
1088        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1089        decls that got here through a using-declaration.  */
1090     decl = build_tree_list (NULL_TREE, decl);
1091
1092   /* And put DECL on the list of things declared by the current
1093      binding level.  */
1094   add_decl_to_level (decl, b);
1095 }
1096
1097 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1098    binding was successful.  */
1099
1100 int
1101 push_class_binding (id, decl)
1102      tree id;
1103      tree decl;
1104 {
1105   int result = 1;
1106   tree binding = IDENTIFIER_BINDING (id);
1107   tree context;
1108
1109   /* Note that we declared this value so that we can issue an error if
1110      this an illegal redeclaration of a name already used for some
1111      other purpose.  */
1112   note_name_declared_in_class (id, decl);
1113
1114   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1115     /* Supplement the existing binding.  */
1116     result = add_binding (id, decl);
1117   else
1118     /* Create a new binding.  */
1119     push_binding (id, decl, class_binding_level);
1120
1121   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1122      class-level declaration.  Note that we do not use DECL here
1123      because of the possibility of the `struct stat' hack; if DECL is
1124      a class-name or enum-name we might prefer a field-name, or some
1125      such.  */
1126   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1127
1128   /* If this is a binding from a base class, mark it as such.  */
1129   binding = IDENTIFIER_BINDING (id);
1130   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1131     {
1132       /* Any implicit typename must be from a base-class.  The
1133          context for an implicit typename declaration is always
1134          the derived class in which the lookup was done, so the checks
1135          based on the context of DECL below will not trigger.  */
1136       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1137         INHERITED_VALUE_BINDING_P (binding) = 1;
1138       else
1139         {
1140           if (TREE_CODE (decl) == OVERLOAD)
1141             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1142           else
1143             {
1144               my_friendly_assert (DECL_P (decl), 0);
1145               context = context_for_name_lookup (decl);
1146             }
1147
1148           if (is_properly_derived_from (current_class_type, context))
1149             INHERITED_VALUE_BINDING_P (binding) = 1;
1150           else
1151             INHERITED_VALUE_BINDING_P (binding) = 0;
1152         }
1153     }
1154   else if (BINDING_VALUE (binding) == decl)
1155     /* We only encounter a TREE_LIST when push_class_decls detects an
1156        ambiguity.  Such an ambiguity can be overridden by a definition
1157        in this class.  */
1158     INHERITED_VALUE_BINDING_P (binding) = 1;
1159
1160   return result;
1161 }
1162
1163 /* Remove the binding for DECL which should be the innermost binding
1164    for ID.  */
1165
1166 static void
1167 pop_binding (id, decl)
1168      tree id;
1169      tree decl;
1170 {
1171   tree binding;
1172
1173   if (id == NULL_TREE)
1174     /* It's easiest to write the loops that call this function without
1175        checking whether or not the entities involved have names.  We
1176        get here for such an entity.  */
1177     return;
1178
1179   /* Get the innermost binding for ID.  */
1180   binding = IDENTIFIER_BINDING (id);
1181
1182   /* The name should be bound.  */
1183   my_friendly_assert (binding != NULL_TREE, 0);
1184
1185   /* The DECL will be either the ordinary binding or the type
1186      binding for this identifier.  Remove that binding.  */
1187   if (BINDING_VALUE (binding) == decl)
1188     BINDING_VALUE (binding) = NULL_TREE;
1189   else if (BINDING_TYPE (binding) == decl)
1190     BINDING_TYPE (binding) = NULL_TREE;
1191   else
1192     my_friendly_abort (0);
1193
1194   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1195     {
1196       /* We're completely done with the innermost binding for this
1197          identifier.  Unhook it from the list of bindings.  */
1198       IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1199
1200       /* Add it to the free list.  */
1201       TREE_CHAIN (binding) = free_bindings;
1202       free_bindings = binding;
1203
1204       /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
1205          it.  */
1206       BINDING_LEVEL (binding) = NULL;
1207     }
1208 }
1209
1210 /* When a label goes out of scope, check to see if that label was used
1211    in a valid manner, and issue any appropriate warnings or errors.  */
1212
1213 static void
1214 pop_label (label, old_value)
1215      tree label;
1216      tree old_value;
1217 {
1218   if (!processing_template_decl && doing_semantic_analysis_p ())
1219     {
1220       if (DECL_INITIAL (label) == NULL_TREE)
1221         {
1222           cp_error_at ("label `%D' used but not defined", label);
1223           /* Avoid crashing later.  */
1224           define_label (input_filename, 1, DECL_NAME (label));
1225         }
1226       else if (warn_unused_label && !TREE_USED (label))
1227         cp_warning_at ("label `%D' defined but not used", label);
1228     }
1229
1230   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1231 }
1232
1233 /* At the end of a function, all labels declared within the function
1234    go out of scope.  BLOCK is the top-level block for the
1235    function.  */
1236
1237 static void
1238 pop_labels (block)
1239      tree block;
1240 {
1241   struct named_label_list *link;
1242
1243   /* Clear out the definitions of all label names, since their scopes
1244      end here.  */
1245   for (link = named_labels; link; link = link->next)
1246     {
1247       pop_label (link->label_decl, link->old_value);
1248       /* Put the labels into the "variables" of the top-level block,
1249          so debugger can see them.  */
1250       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1251       BLOCK_VARS (block) = link->label_decl;
1252     }
1253
1254   named_labels = NULL;
1255 }
1256
1257 /* Exit a binding level.
1258    Pop the level off, and restore the state of the identifier-decl mappings
1259    that were in effect when this level was entered.
1260
1261    If KEEP == 1, this level had explicit declarations, so
1262    and create a "block" (a BLOCK node) for the level
1263    to record its declarations and subblocks for symbol table output.
1264
1265    If FUNCTIONBODY is nonzero, this level is the body of a function,
1266    so create a block as if KEEP were set and also clear out all
1267    label names.
1268
1269    If REVERSE is nonzero, reverse the order of decls before putting
1270    them into the BLOCK.  */
1271
1272 tree
1273 poplevel (keep, reverse, functionbody)
1274      int keep;
1275      int reverse;
1276      int functionbody;
1277 {
1278   register tree link;
1279   /* The chain of decls was accumulated in reverse order.
1280      Put it into forward order, just for cleanliness.  */
1281   tree decls;
1282   int tmp = functionbody;
1283   int real_functionbody;
1284   tree tags;
1285   tree subblocks;
1286   tree block = NULL_TREE;
1287   tree decl;
1288   int leaving_for_scope;
1289
1290   if (cfun && !doing_semantic_analysis_p ())
1291     return NULL_TREE;
1292
1293   my_friendly_assert (current_binding_level->parm_flag != 2,
1294                       19990916);
1295
1296   real_functionbody = (current_binding_level->keep == 2
1297                        ? ((functionbody = 0), tmp) : functionbody);
1298   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1299   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1300
1301   my_friendly_assert (!current_binding_level->class_shadowed,
1302                       19990414);
1303
1304   /* We used to use KEEP == 2 to indicate that the new block should go
1305      at the beginning of the list of blocks at this binding level,
1306      rather than the end.  This hack is no longer used.  */
1307   my_friendly_assert (keep == 0 || keep == 1, 0);
1308
1309   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1310                       (HOST_WIDE_INT) current_binding_level->level_chain,
1311                       current_binding_level->parm_flag,
1312                       current_binding_level->keep);
1313
1314   if (current_binding_level->keep == 1)
1315     keep = 1;
1316
1317   /* Any uses of undefined labels, and any defined labels, now operate
1318      under constraints of next binding contour.  */
1319   if (cfun && !functionbody)
1320     {
1321       struct binding_level *level_chain;
1322       level_chain = current_binding_level->level_chain;
1323       if (level_chain)
1324         {
1325           struct named_label_use_list *uses;
1326           struct named_label_list *labels;
1327           for (labels = named_labels; labels; labels = labels->next)
1328             if (labels->binding_level == current_binding_level)
1329               {
1330                 tree decl;
1331                 if (current_binding_level->is_try_scope)
1332                   labels->in_try_scope = 1;
1333                 if (current_binding_level->is_catch_scope)
1334                   labels->in_catch_scope = 1;
1335                 for (decl = labels->names_in_scope; decl;
1336                      decl = TREE_CHAIN (decl))
1337                   if (decl_jump_unsafe (decl))
1338                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1339                                                    labels->bad_decls);
1340                 labels->binding_level = level_chain;
1341                 labels->names_in_scope = level_chain->names;
1342               }
1343
1344           for (uses = named_label_uses; uses; uses = uses->next)
1345             if (uses->binding_level == current_binding_level)
1346               {
1347                 uses->binding_level = level_chain;
1348                 uses->names_in_scope = level_chain->names;
1349               }
1350         }
1351     }
1352
1353   /* Get the decls in the order they were written.
1354      Usually current_binding_level->names is in reverse order.
1355      But parameter decls were previously put in forward order.  */
1356
1357   if (reverse)
1358     current_binding_level->names
1359       = decls = nreverse (current_binding_level->names);
1360   else
1361     decls = current_binding_level->names;
1362
1363   /* Output any nested inline functions within this block
1364      if they weren't already output.  */
1365   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1366     if (TREE_CODE (decl) == FUNCTION_DECL
1367         && ! TREE_ASM_WRITTEN (decl)
1368         && DECL_INITIAL (decl) != NULL_TREE
1369         && TREE_ADDRESSABLE (decl)
1370         && decl_function_context (decl) == current_function_decl)
1371       {
1372         /* If this decl was copied from a file-scope decl
1373            on account of a block-scope extern decl,
1374            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1375         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1376           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1377         else
1378           {
1379             push_function_context ();
1380             output_inline_function (decl);
1381             pop_function_context ();
1382           }
1383       }
1384
1385   /* When not in function-at-a-time mode, expand_end_bindings will
1386      warn about unused variables.  But, in function-at-a-time mode
1387      expand_end_bindings is not passed the list of variables in the
1388      current scope, and therefore no warning is emitted.  So, we
1389      explicitly warn here.  */
1390   if (!processing_template_decl)
1391     warn_about_unused_variables (getdecls ());
1392
1393   /* If there were any declarations or structure tags in that level,
1394      or if this level is a function body,
1395      create a BLOCK to record them for the life of this function.  */
1396   block = NULL_TREE;
1397   if (keep == 1 || functionbody)
1398     block = make_node (BLOCK);
1399   if (block != NULL_TREE)
1400     {
1401       BLOCK_VARS (block) = decls;
1402       BLOCK_SUBBLOCKS (block) = subblocks;
1403     }
1404
1405   /* In each subblock, record that this is its superior.  */
1406   if (keep >= 0)
1407     for (link = subblocks; link; link = TREE_CHAIN (link))
1408       BLOCK_SUPERCONTEXT (link) = block;
1409
1410   /* We still support the old for-scope rules, whereby the variables
1411      in a for-init statement were in scope after the for-statement
1412      ended.  We only use the new rules in flag_new_for_scope is
1413      nonzero.  */
1414   leaving_for_scope
1415     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1416
1417   /* Remove declarations for all the DECLs in this level.  */
1418   for (link = decls; link; link = TREE_CHAIN (link))
1419     {
1420       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1421           && DECL_NAME (link))
1422         {
1423           tree outer_binding
1424             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1425           tree ns_binding;
1426
1427           if (!outer_binding)
1428             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1429           else
1430             ns_binding = NULL_TREE;
1431
1432           if (outer_binding
1433               && (BINDING_LEVEL (outer_binding)
1434                   == current_binding_level->level_chain))
1435             /* We have something like:
1436
1437                  int i;
1438                  for (int i; ;);
1439
1440                and we are leaving the `for' scope.  There's no reason to
1441                keep the binding of the inner `i' in this case.  */
1442             pop_binding (DECL_NAME (link), link);
1443           else if ((outer_binding
1444                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1445                         == TYPE_DECL))
1446                    || (ns_binding
1447                        && TREE_CODE (ns_binding) == TYPE_DECL))
1448             /* Here, we have something like:
1449
1450                  typedef int I;
1451
1452                  void f () {
1453                    for (int I; ;);
1454                  }
1455
1456                We must pop the for-scope binding so we know what's a
1457                type and what isn't.  */
1458             pop_binding (DECL_NAME (link), link);
1459           else
1460             {
1461               /* Mark this VAR_DECL as dead so that we can tell we left it
1462                  there only for backward compatibility.  */
1463               DECL_DEAD_FOR_LOCAL (link) = 1;
1464
1465               /* Keep track of what should of have happenned when we
1466                  popped the binding.  */
1467               if (outer_binding && BINDING_VALUE (outer_binding))
1468                 DECL_SHADOWED_FOR_VAR (link)
1469                   = BINDING_VALUE (outer_binding);
1470
1471               /* Add it to the list of dead variables in the next
1472                  outermost binding to that we can remove these when we
1473                  leave that binding.  */
1474               current_binding_level->level_chain->dead_vars_from_for
1475                 = tree_cons (NULL_TREE, link,
1476                              current_binding_level->level_chain->
1477                              dead_vars_from_for);
1478
1479               /* Although we don't pop the CPLUS_BINDING, we do clear
1480                  its BINDING_LEVEL since the level is going away now.  */
1481               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1482                 = 0;
1483             }
1484         }
1485       else
1486         {
1487           /* Remove the binding.  */
1488           decl = link;
1489           if (TREE_CODE (decl) == TREE_LIST)
1490             decl = TREE_VALUE (decl);
1491           if (DECL_P (decl))
1492             pop_binding (DECL_NAME (decl), decl);
1493           else if (TREE_CODE (decl) == OVERLOAD)
1494             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1495           else
1496             my_friendly_abort (0);
1497         }
1498     }
1499
1500   /* Remove declarations for any `for' variables from inner scopes
1501      that we kept around.  */
1502   for (link = current_binding_level->dead_vars_from_for;
1503        link; link = TREE_CHAIN (link))
1504     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1505
1506   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1507   for (link = current_binding_level->type_shadowed;
1508        link; link = TREE_CHAIN (link))
1509     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1510
1511   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1512   for (link = current_binding_level->shadowed_labels;
1513        link;
1514        link = TREE_CHAIN (link))
1515     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1516
1517   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1518      list if a `using' declaration put them there.  The debugging
1519      back-ends won't understand OVERLOAD, so we remove them here.
1520      Because the BLOCK_VARS are (temporarily) shared with
1521      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1522      popped all the bindings.  */
1523   if (block)
1524     {
1525       tree* d;
1526
1527       for (d = &BLOCK_VARS (block); *d; )
1528         {
1529           if (TREE_CODE (*d) == TREE_LIST)
1530             *d = TREE_CHAIN (*d);
1531           else
1532             d = &TREE_CHAIN (*d);
1533         }
1534     }
1535
1536   /* If the level being exited is the top level of a function,
1537      check over all the labels.  */
1538   if (functionbody)
1539     {
1540       /* Since this is the top level block of a function, the vars are
1541          the function's parameters.  Don't leave them in the BLOCK
1542          because they are found in the FUNCTION_DECL instead.  */
1543       BLOCK_VARS (block) = 0;
1544       pop_labels (block);
1545     }
1546
1547   tmp = current_binding_level->keep;
1548
1549   pop_binding_level ();
1550   if (functionbody)
1551     DECL_INITIAL (current_function_decl) = block;
1552   else if (block)
1553     current_binding_level->blocks
1554       = chainon (current_binding_level->blocks, block);
1555
1556   /* If we did not make a block for the level just exited,
1557      any blocks made for inner levels
1558      (since they cannot be recorded as subblocks in that level)
1559      must be carried forward so they will later become subblocks
1560      of something else.  */
1561   else if (subblocks)
1562     current_binding_level->blocks
1563       = chainon (current_binding_level->blocks, subblocks);
1564
1565   /* Each and every BLOCK node created here in `poplevel' is important
1566      (e.g. for proper debugging information) so if we created one
1567      earlier, mark it as "used".  */
1568   if (block)
1569     TREE_USED (block) = 1;
1570
1571   /* Take care of compiler's internal binding structures.  */
1572   if (tmp == 2)
1573     {
1574       tree scope_stmts;
1575
1576       scope_stmts
1577         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1578       if (block)
1579         {
1580           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1581           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1582         }
1583
1584       block = poplevel (keep, reverse, functionbody);
1585     }
1586
1587   return block;
1588 }
1589
1590 /* Delete the node BLOCK from the current binding level.
1591    This is used for the block inside a stmt expr ({...})
1592    so that the block can be reinserted where appropriate.  */
1593
1594 void
1595 delete_block (block)
1596      tree block;
1597 {
1598   tree t;
1599   if (current_binding_level->blocks == block)
1600     current_binding_level->blocks = TREE_CHAIN (block);
1601   for (t = current_binding_level->blocks; t;)
1602     {
1603       if (TREE_CHAIN (t) == block)
1604         TREE_CHAIN (t) = TREE_CHAIN (block);
1605       else
1606         t = TREE_CHAIN (t);
1607     }
1608   TREE_CHAIN (block) = NULL_TREE;
1609   /* Clear TREE_USED which is always set by poplevel.
1610      The flag is set again if insert_block is called.  */
1611   TREE_USED (block) = 0;
1612 }
1613
1614 /* Insert BLOCK at the end of the list of subblocks of the
1615    current binding level.  This is used when a BIND_EXPR is expanded,
1616    to handle the BLOCK node inside the BIND_EXPR.  */
1617
1618 void
1619 insert_block (block)
1620      tree block;
1621 {
1622   TREE_USED (block) = 1;
1623   current_binding_level->blocks
1624     = chainon (current_binding_level->blocks, block);
1625 }
1626
1627 /* Set the BLOCK node for the innermost scope
1628    (the one we are currently in).  */
1629
1630 void
1631 set_block (block)
1632     tree block ATTRIBUTE_UNUSED;
1633 {
1634   /* The RTL expansion machinery requires us to provide this callback,
1635      but it is not applicable in function-at-a-time mode.  */
1636   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1637 }
1638
1639 /* Do a pushlevel for class declarations.  */
1640
1641 void
1642 pushlevel_class ()
1643 {
1644   register struct binding_level *newlevel;
1645
1646   /* Reuse or create a struct for this binding level.  */
1647 #if defined(DEBUG_CP_BINDING_LEVELS)
1648   if (0)
1649 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1650   if (free_binding_level)
1651 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1652     {
1653       newlevel = free_binding_level;
1654       free_binding_level = free_binding_level->level_chain;
1655     }
1656   else
1657     newlevel = make_binding_level ();
1658
1659 #if defined(DEBUG_CP_BINDING_LEVELS)
1660   is_class_level = 1;
1661 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1662
1663   push_binding_level (newlevel, 0, 0);
1664
1665   class_binding_level = current_binding_level;
1666   class_binding_level->parm_flag = 2;
1667   class_binding_level->this_class = current_class_type;
1668 }
1669
1670 /* ...and a poplevel for class declarations.  */
1671
1672 void
1673 poplevel_class ()
1674 {
1675   register struct binding_level *level = class_binding_level;
1676   tree shadowed;
1677
1678   my_friendly_assert (level != 0, 354);
1679
1680   /* If we're leaving a toplevel class, don't bother to do the setting
1681      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1682      shouldn't even be used when current_class_type isn't set, and second,
1683      if we don't touch it here, we're able to use the cache effect if the
1684      next time we're entering a class scope, it is the same class.  */
1685   if (current_class_depth != 1)
1686     {
1687       struct binding_level* b;
1688
1689       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1690       for (shadowed = level->class_shadowed;
1691            shadowed;
1692            shadowed = TREE_CHAIN (shadowed))
1693         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1694
1695       /* Find the next enclosing class, and recreate
1696          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1697       b = level->level_chain;
1698       while (b && b->parm_flag != 2)
1699         b = b->level_chain;
1700
1701       if (b)
1702         for (shadowed = b->class_shadowed;
1703              shadowed;
1704              shadowed = TREE_CHAIN (shadowed))
1705           {
1706             tree t;
1707
1708             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1709             while (t && BINDING_LEVEL (t) != b)
1710               t = TREE_CHAIN (t);
1711
1712             if (t)
1713               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1714                 = BINDING_VALUE (t);
1715           }
1716     }
1717   else
1718     /* Remember to save what IDENTIFIER's were bound in this scope so we
1719        can recover from cache misses.  */
1720     {
1721       previous_class_type = current_class_type;
1722       previous_class_values = class_binding_level->class_shadowed;
1723     }
1724   for (shadowed = level->type_shadowed;
1725        shadowed;
1726        shadowed = TREE_CHAIN (shadowed))
1727     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1728
1729   /* Remove the bindings for all of the class-level declarations.  */
1730   for (shadowed = level->class_shadowed;
1731        shadowed;
1732        shadowed = TREE_CHAIN (shadowed))
1733     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1734
1735   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1736                       (HOST_WIDE_INT) class_binding_level->level_chain,
1737                       class_binding_level->parm_flag,
1738                       class_binding_level->keep);
1739
1740   /* Now, pop out of the binding level which we created up in the
1741      `pushlevel_class' routine.  */
1742 #if defined(DEBUG_CP_BINDING_LEVELS)
1743   is_class_level = 1;
1744 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1745
1746   pop_binding_level ();
1747 }
1748
1749 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1750    for any names in enclosing classes.  */
1751
1752 void
1753 clear_identifier_class_values ()
1754 {
1755   tree t;
1756
1757   if (!class_binding_level)
1758     return;
1759
1760   for (t = class_binding_level->class_shadowed;
1761        t;
1762        t = TREE_CHAIN (t))
1763     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1764 }
1765
1766 /* Returns non-zero if T is a virtual function table.  */
1767
1768 int
1769 vtable_decl_p (t, data)
1770      tree t;
1771      void *data ATTRIBUTE_UNUSED;
1772 {
1773   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1774 }
1775
1776 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1777    functions.  */
1778
1779 int
1780 vtype_decl_p (t, data)
1781      tree t;
1782      void *data ATTRIBUTE_UNUSED;
1783 {
1784   return (TREE_CODE (t) == TYPE_DECL
1785           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1786           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1787 }
1788
1789 /* Return the declarations that are members of the namespace NS.  */
1790
1791 tree
1792 cp_namespace_decls (ns)
1793      tree ns;
1794 {
1795   return NAMESPACE_LEVEL (ns)->names;
1796 }
1797
1798 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1799    itself, calling F for each.  The DATA is passed to F as well.  */
1800
1801 static int
1802 walk_namespaces_r (namespace, f, data)
1803      tree namespace;
1804      walk_namespaces_fn f;
1805      void *data;
1806 {
1807   tree current;
1808   int result = 0;
1809
1810   result |= (*f) (namespace, data);
1811
1812   for (current = cp_namespace_decls (namespace);
1813        current;
1814        current = TREE_CHAIN (current))
1815     {
1816       if (TREE_CODE (current) != NAMESPACE_DECL
1817           || DECL_NAMESPACE_ALIAS (current))
1818         continue;
1819       if (!DECL_LANG_SPECIFIC (current))
1820         {
1821           /* Hmm. std. */
1822           my_friendly_assert (current == fake_std_node, 393);
1823           continue;
1824         }
1825
1826       /* We found a namespace.  */
1827       result |= walk_namespaces_r (current, f, data);
1828     }
1829
1830   return result;
1831 }
1832
1833 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1834    F as well.  */
1835
1836 int
1837 walk_namespaces (f, data)
1838      walk_namespaces_fn f;
1839      void *data;
1840 {
1841   return walk_namespaces_r (global_namespace, f, data);
1842 }
1843
1844 struct walk_globals_data {
1845   walk_globals_pred p;
1846   walk_globals_fn f;
1847   void *data;
1848 };
1849
1850 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1851    for which P returns non-zero, call F with its address.  If any call
1852    to F returns a non-zero value, return a non-zero value.  */
1853
1854 static int
1855 walk_globals_r (namespace, data)
1856      tree namespace;
1857      void *data;
1858 {
1859   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1860   walk_globals_pred p = wgd->p;
1861   walk_globals_fn f = wgd->f;
1862   void *d = wgd->data;
1863   tree *t;
1864   int result = 0;
1865
1866   t = &NAMESPACE_LEVEL (namespace)->names;
1867
1868   while (*t)
1869     {
1870       tree glbl = *t;
1871
1872       if ((*p) (glbl, d))
1873         result |= (*f) (t, d);
1874
1875       /* If F changed *T, then *T still points at the next item to
1876          examine.  */
1877       if (*t == glbl)
1878         t = &TREE_CHAIN (*t);
1879     }
1880
1881   return result;
1882 }
1883
1884 /* Walk the global declarations.  Whenever one is found for which P
1885    returns non-zero, call F with its address.  If any call to F
1886    returns a non-zero value, return a non-zero value.  */
1887
1888 int
1889 walk_globals (p, f, data)
1890      walk_globals_pred p;
1891      walk_globals_fn f;
1892      void *data;
1893 {
1894   struct walk_globals_data wgd;
1895   wgd.p = p;
1896   wgd.f = f;
1897   wgd.data = data;
1898
1899   return walk_namespaces (walk_globals_r, &wgd);
1900 }
1901
1902 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1903    DATA is non-NULL, this is the last time we will call
1904    wrapup_global_declarations for this NAMESPACE.  */
1905
1906 int
1907 wrapup_globals_for_namespace (namespace, data)
1908      tree namespace;
1909      void *data;
1910 {
1911   tree globals = cp_namespace_decls (namespace);
1912   int len = list_length (globals);
1913   tree *vec = (tree *) alloca (sizeof (tree) * len);
1914   int i;
1915   int result;
1916   tree decl;
1917   int last_time = (data != 0);
1918
1919   if (last_time && namespace == global_namespace)
1920     /* Let compile_file handle the global namespace.  */
1921     return 0;
1922
1923   /* Process the decls in reverse order--earliest first.
1924      Put them into VEC from back to front, then take out from front.  */
1925   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1926     vec[len - i - 1] = decl;
1927
1928   if (last_time)
1929     {
1930       check_global_declarations (vec, len);
1931       return 0;
1932     }
1933
1934   /* Temporarily mark vtables as external.  That prevents
1935      wrapup_global_declarations from writing them out; we must process
1936      them ourselves in finish_vtable_vardecl.  */
1937   for (i = 0; i < len; ++i)
1938     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1939       {
1940         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1941         DECL_EXTERNAL (vec[i]) = 1;
1942       }
1943
1944   /* Write out any globals that need to be output.  */
1945   result = wrapup_global_declarations (vec, len);
1946
1947   /* Undo the hack to DECL_EXTERNAL above.  */
1948   for (i = 0; i < len; ++i)
1949     if (vtable_decl_p (vec[i], /*data=*/0)
1950         && DECL_NOT_REALLY_EXTERN (vec[i]))
1951       {
1952         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1953         DECL_EXTERNAL (vec[i]) = 0;
1954       }
1955
1956   return result;
1957 }
1958
1959 \f
1960 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1961
1962 static void
1963 mark_binding_level (arg)
1964      void *arg;
1965 {
1966   struct binding_level *lvl = *(struct binding_level **)arg;
1967
1968   for (; lvl; lvl = lvl->level_chain)
1969     {
1970       ggc_mark_tree (lvl->names);
1971       ggc_mark_tree (lvl->tags);
1972       ggc_mark_tree (lvl->usings);
1973       ggc_mark_tree (lvl->using_directives);
1974       ggc_mark_tree (lvl->class_shadowed);
1975       ggc_mark_tree (lvl->type_shadowed);
1976       ggc_mark_tree (lvl->shadowed_labels);
1977       ggc_mark_tree (lvl->blocks);
1978       ggc_mark_tree (lvl->this_class);
1979       ggc_mark_tree (lvl->incomplete);
1980       ggc_mark_tree (lvl->dead_vars_from_for);
1981     }
1982 }
1983
1984 static void
1985 mark_named_label_lists (labs, uses)
1986      void *labs;
1987      void *uses;
1988 {
1989   struct named_label_list *l = *(struct named_label_list **)labs;
1990   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
1991
1992   for (; l; l = l->next)
1993     {
1994       ggc_mark (l);
1995       mark_binding_level (l->binding_level);
1996       ggc_mark_tree (l->old_value);
1997       ggc_mark_tree (l->label_decl);
1998       ggc_mark_tree (l->bad_decls);
1999     }
2000
2001   for (; u; u = u->next)
2002     ggc_mark (u);
2003 }
2004 \f
2005 /* For debugging.  */
2006 static int no_print_functions = 0;
2007 static int no_print_builtins = 0;
2008
2009 void
2010 print_binding_level (lvl)
2011      struct binding_level *lvl;
2012 {
2013   tree t;
2014   int i = 0, len;
2015   fprintf (stderr, " blocks=");
2016   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2017   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2018            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2019   if (lvl->tag_transparent)
2020     fprintf (stderr, " tag-transparent");
2021   if (lvl->more_cleanups_ok)
2022     fprintf (stderr, " more-cleanups-ok");
2023   if (lvl->have_cleanups)
2024     fprintf (stderr, " have-cleanups");
2025   fprintf (stderr, "\n");
2026   if (lvl->names)
2027     {
2028       fprintf (stderr, " names:\t");
2029       /* We can probably fit 3 names to a line?  */
2030       for (t = lvl->names; t; t = TREE_CHAIN (t))
2031         {
2032           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2033             continue;
2034           if (no_print_builtins
2035               && (TREE_CODE (t) == TYPE_DECL)
2036               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2037             continue;
2038
2039           /* Function decls tend to have longer names.  */
2040           if (TREE_CODE (t) == FUNCTION_DECL)
2041             len = 3;
2042           else
2043             len = 2;
2044           i += len;
2045           if (i > 6)
2046             {
2047               fprintf (stderr, "\n\t");
2048               i = len;
2049             }
2050           print_node_brief (stderr, "", t, 0);
2051           if (t == error_mark_node)
2052             break;
2053         }
2054       if (i)
2055         fprintf (stderr, "\n");
2056     }
2057   if (lvl->tags)
2058     {
2059       fprintf (stderr, " tags:\t");
2060       i = 0;
2061       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2062         {
2063           if (TREE_PURPOSE (t) == NULL_TREE)
2064             len = 3;
2065           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2066             len = 2;
2067           else
2068             len = 4;
2069           i += len;
2070           if (i > 5)
2071             {
2072               fprintf (stderr, "\n\t");
2073               i = len;
2074             }
2075           if (TREE_PURPOSE (t) == NULL_TREE)
2076             {
2077               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2078               fprintf (stderr, ">");
2079             }
2080           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2081             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2082           else
2083             {
2084               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2085               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2086               fprintf (stderr, ">");
2087             }
2088         }
2089       if (i)
2090         fprintf (stderr, "\n");
2091     }
2092   if (lvl->class_shadowed)
2093     {
2094       fprintf (stderr, " class-shadowed:");
2095       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2096         {
2097           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2098         }
2099       fprintf (stderr, "\n");
2100     }
2101   if (lvl->type_shadowed)
2102     {
2103       fprintf (stderr, " type-shadowed:");
2104       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2105         {
2106           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2107         }
2108       fprintf (stderr, "\n");
2109     }
2110 }
2111
2112 void
2113 print_other_binding_stack (stack)
2114      struct binding_level *stack;
2115 {
2116   struct binding_level *level;
2117   for (level = stack; level != global_binding_level; level = level->level_chain)
2118     {
2119       fprintf (stderr, "binding level ");
2120       fprintf (stderr, HOST_PTR_PRINTF, level);
2121       fprintf (stderr, "\n");
2122       print_binding_level (level);
2123     }
2124 }
2125
2126 void
2127 print_binding_stack ()
2128 {
2129   struct binding_level *b;
2130   fprintf (stderr, "current_binding_level=");
2131   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2132   fprintf (stderr, "\nclass_binding_level=");
2133   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2134   fprintf (stderr, "\nglobal_binding_level=");
2135   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2136   fprintf (stderr, "\n");
2137   if (class_binding_level)
2138     {
2139       for (b = class_binding_level; b; b = b->level_chain)
2140         if (b == current_binding_level)
2141           break;
2142       if (b)
2143         b = class_binding_level;
2144       else
2145         b = current_binding_level;
2146     }
2147   else
2148     b = current_binding_level;
2149   print_other_binding_stack (b);
2150   fprintf (stderr, "global:\n");
2151   print_binding_level (global_binding_level);
2152 }
2153
2154 /* Namespace binding access routines: The namespace_bindings field of
2155    the identifier is polymorphic, with three possible values:
2156    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2157    indicating the BINDING_VALUE of global_namespace. */
2158
2159 /* Check whether the a binding for the name to scope is known.
2160    Assumes that the bindings of the name are already a list
2161    of bindings. Returns the binding found, or NULL_TREE. */
2162
2163 static tree
2164 find_binding (name, scope)
2165      tree name;
2166      tree scope;
2167 {
2168   tree iter, prev = NULL_TREE;
2169
2170   scope = ORIGINAL_NAMESPACE (scope);
2171
2172   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2173        iter = TREE_CHAIN (iter))
2174     {
2175       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2176       if (BINDING_SCOPE (iter) == scope)
2177         {
2178           /* Move binding found to the front of the list, so
2179              subsequent lookups will find it faster. */
2180           if (prev)
2181             {
2182               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2183               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2184               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2185             }
2186           return iter;
2187         }
2188       prev = iter;
2189     }
2190   return NULL_TREE;
2191 }
2192
2193 /* Always returns a binding for name in scope. If the
2194    namespace_bindings is not a list, convert it to one first.
2195    If no binding is found, make a new one. */
2196
2197 tree
2198 binding_for_name (name, scope)
2199      tree name;
2200      tree scope;
2201 {
2202   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2203   tree result;
2204
2205   scope = ORIGINAL_NAMESPACE (scope);
2206
2207   if (b && TREE_CODE (b) != CPLUS_BINDING)
2208     {
2209       /* Get rid of optimization for global scope. */
2210       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2211       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2212       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2213     }
2214   if (b && (result = find_binding (name, scope)))
2215     return result;
2216   /* Not found, make a new one. */
2217   result = make_node (CPLUS_BINDING);
2218   TREE_CHAIN (result) = b;
2219   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2220   BINDING_SCOPE (result) = scope;
2221   BINDING_TYPE (result) = NULL_TREE;
2222   BINDING_VALUE (result) = NULL_TREE;
2223   return result;
2224 }
2225
2226 /* Return the binding value for name in scope, considering that
2227    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2228
2229 tree
2230 namespace_binding (name, scope)
2231      tree name;
2232      tree scope;
2233 {
2234   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2235   if (b == NULL_TREE)
2236     return NULL_TREE;
2237   if (scope == NULL_TREE)
2238     scope = global_namespace;
2239   if (TREE_CODE (b) != CPLUS_BINDING)
2240     return (scope == global_namespace) ? b : NULL_TREE;
2241   name = find_binding (name,scope);
2242   if (name == NULL_TREE)
2243     return name;
2244   return BINDING_VALUE (name);
2245 }
2246
2247 /* Set the binding value for name in scope. If modifying the binding
2248    of global_namespace is attempted, try to optimize it. */
2249
2250 void
2251 set_namespace_binding (name, scope, val)
2252      tree name;
2253      tree scope;
2254      tree val;
2255 {
2256   tree b;
2257
2258   if (scope == NULL_TREE)
2259     scope = global_namespace;
2260
2261   if (scope == global_namespace)
2262     {
2263       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2264       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2265         {
2266           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2267           return;
2268         }
2269     }
2270   b = binding_for_name (name, scope);
2271   BINDING_VALUE (b) = val;
2272 }
2273
2274 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2275    select a name that is unique to this compilation unit.  */
2276
2277 void
2278 push_namespace (name)
2279      tree name;
2280 {
2281   tree d = NULL_TREE;
2282   int need_new = 1;
2283   int implicit_use = 0;
2284   int global = 0;
2285   if (!global_namespace)
2286     {
2287       /* This must be ::. */
2288       my_friendly_assert (name == get_identifier ("::"), 377);
2289       global = 1;
2290     }
2291   else if (!name)
2292     {
2293       /* The name of anonymous namespace is unique for the translation
2294          unit.  */
2295       if (!anonymous_namespace_name)
2296         anonymous_namespace_name = get_file_function_name ('N');
2297       name = anonymous_namespace_name;
2298       d = IDENTIFIER_NAMESPACE_VALUE (name);
2299       if (d)
2300         /* Reopening anonymous namespace.  */
2301         need_new = 0;
2302       implicit_use = 1;
2303     }
2304   else if (current_namespace == global_namespace
2305            && !flag_honor_std
2306            && name == std_identifier)
2307     {
2308       in_fake_std++;
2309       return;
2310     }
2311   else
2312     {
2313       /* Check whether this is an extended namespace definition. */
2314       d = IDENTIFIER_NAMESPACE_VALUE (name);
2315       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2316         {
2317           need_new = 0;
2318           if (DECL_NAMESPACE_ALIAS (d))
2319             {
2320               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2321                         d, DECL_NAMESPACE_ALIAS (d));
2322               d = DECL_NAMESPACE_ALIAS (d);
2323             }
2324         }
2325     }
2326
2327   if (need_new)
2328     {
2329       /* Make a new namespace, binding the name to it. */
2330       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2331       /* The global namespace is not pushed, and the global binding
2332          level is set elsewhere.  */
2333       if (!global)
2334         {
2335           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2336           d = pushdecl (d);
2337           pushlevel (0);
2338           declare_namespace_level ();
2339           NAMESPACE_LEVEL (d) = current_binding_level;
2340         }
2341     }
2342   else
2343     resume_binding_level (NAMESPACE_LEVEL (d));
2344
2345   if (implicit_use)
2346     do_using_directive (d);
2347   /* Enter the name space. */
2348   current_namespace = d;
2349 }
2350
2351 /* Pop from the scope of the current namespace.  */
2352
2353 void
2354 pop_namespace ()
2355 {
2356   if (current_namespace == global_namespace)
2357     {
2358       my_friendly_assert (in_fake_std > 0, 980421);
2359       in_fake_std--;
2360       return;
2361     }
2362   current_namespace = CP_DECL_CONTEXT (current_namespace);
2363   /* The binding level is not popped, as it might be re-opened later.  */
2364   suspend_binding_level ();
2365 }
2366
2367 /* Push into the scope of the namespace NS, even if it is deeply
2368    nested within another namespace.  */
2369
2370 void
2371 push_nested_namespace (ns)
2372      tree ns;
2373 {
2374   if (ns == global_namespace)
2375     push_to_top_level ();
2376   else
2377     {
2378       push_nested_namespace (CP_DECL_CONTEXT (ns));
2379       push_namespace (DECL_NAME (ns));
2380     }
2381 }
2382
2383 /* Pop back from the scope of the namespace NS, which was previously
2384    entered with push_nested_namespace.  */
2385
2386 void
2387 pop_nested_namespace (ns)
2388      tree ns;
2389 {
2390   while (ns != global_namespace)
2391     {
2392       pop_namespace ();
2393       ns = CP_DECL_CONTEXT (ns);
2394     }
2395
2396   pop_from_top_level ();
2397 }
2398
2399 \f
2400 /* Subroutines for reverting temporarily to top-level for instantiation
2401    of templates and such.  We actually need to clear out the class- and
2402    local-value slots of all identifiers, so that only the global values
2403    are at all visible.  Simply setting current_binding_level to the global
2404    scope isn't enough, because more binding levels may be pushed.  */
2405 struct saved_scope *scope_chain;
2406
2407 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2408
2409 static void
2410 mark_saved_scope (arg)
2411      void *arg;
2412 {
2413   struct saved_scope *t = *(struct saved_scope **)arg;
2414   while (t)
2415     {
2416       mark_binding_level (&t->class_bindings);
2417       ggc_mark_tree (t->old_bindings);
2418       ggc_mark_tree (t->old_namespace);
2419       ggc_mark_tree (t->decl_ns_list);
2420       ggc_mark_tree (t->class_name);
2421       ggc_mark_tree (t->class_type);
2422       ggc_mark_tree (t->access_specifier);
2423       ggc_mark_tree (t->function_decl);
2424       if (t->lang_base)
2425         ggc_mark_tree_varray (t->lang_base);
2426       ggc_mark_tree (t->lang_name);
2427       ggc_mark_tree (t->template_parms);
2428       ggc_mark_tree (t->x_previous_class_type);
2429       ggc_mark_tree (t->x_previous_class_values);
2430       ggc_mark_tree (t->x_saved_tree);
2431       ggc_mark_tree (t->incomplete);
2432       ggc_mark_tree (t->lookups);
2433
2434       mark_stmt_tree (&t->x_stmt_tree);
2435       mark_binding_level (&t->bindings);
2436       t = t->prev;
2437     }
2438 }
2439
2440 static tree
2441 store_bindings (names, old_bindings)
2442      tree names, old_bindings;
2443 {
2444   tree t;
2445   tree search_bindings = old_bindings;
2446
2447   for (t = names; t; t = TREE_CHAIN (t))
2448     {
2449       tree binding, t1, id;
2450
2451       if (TREE_CODE (t) == TREE_LIST)
2452         id = TREE_PURPOSE (t);
2453       else
2454         id = DECL_NAME (t);
2455
2456       if (!id
2457           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2458              we have no IDENTIFIER_BINDING if we have left the class
2459              scope, but cached the class-level declarations.  */
2460           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2461         continue;
2462
2463       for (t1 = search_bindings; t1; t1 = TREE_CHAIN (t1))
2464         if (TREE_VEC_ELT (t1, 0) == id)
2465           goto skip_it;
2466
2467       my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2468       binding = make_tree_vec (4);
2469       TREE_VEC_ELT (binding, 0) = id;
2470       TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2471       TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2472       TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2473       IDENTIFIER_BINDING (id) = NULL_TREE;
2474       IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2475       TREE_CHAIN (binding) = old_bindings;
2476       old_bindings = binding;
2477     skip_it:
2478       ;
2479     }
2480   return old_bindings;
2481 }
2482
2483 void
2484 maybe_push_to_top_level (pseudo)
2485      int pseudo;
2486 {
2487   struct saved_scope *s;
2488   struct binding_level *b;
2489   tree old_bindings;
2490   int need_pop;
2491
2492   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2493
2494   b = scope_chain ? current_binding_level : 0;
2495
2496   /* If we're in the middle of some function, save our state.  */
2497   if (cfun)
2498     {
2499       need_pop = 1;
2500       push_function_context_to (NULL_TREE);
2501     }
2502   else
2503     need_pop = 0;
2504
2505   old_bindings = NULL_TREE;
2506   if (scope_chain && previous_class_type)
2507     old_bindings = store_bindings (previous_class_values, old_bindings);
2508
2509   /* Have to include global_binding_level, because class-level decls
2510      aren't listed anywhere useful.  */
2511   for (; b; b = b->level_chain)
2512     {
2513       tree t;
2514
2515       /* Template IDs are inserted into the global level. If they were
2516          inserted into namespace level, finish_file wouldn't find them
2517          when doing pending instantiations. Therefore, don't stop at
2518          namespace level, but continue until :: .  */
2519       if (b == global_binding_level || (pseudo && b->template_parms_p))
2520         break;
2521
2522       old_bindings = store_bindings (b->names, old_bindings);
2523       /* We also need to check class_shadowed to save class-level type
2524          bindings, since pushclass doesn't fill in b->names.  */
2525       if (b->parm_flag == 2)
2526         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2527
2528       /* Unwind type-value slots back to top level.  */
2529       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2530         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2531     }
2532   s->prev = scope_chain;
2533   s->old_bindings = old_bindings;
2534   s->bindings = b;
2535   s->need_pop_function_context = need_pop;
2536   s->function_decl = current_function_decl;
2537
2538   scope_chain = s;
2539   current_function_decl = NULL_TREE;
2540   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2541   current_lang_name = lang_name_cplusplus;
2542   current_namespace = global_namespace;
2543 }
2544
2545 void
2546 push_to_top_level ()
2547 {
2548   maybe_push_to_top_level (0);
2549 }
2550
2551 void
2552 pop_from_top_level ()
2553 {
2554   struct saved_scope *s = scope_chain;
2555   tree t;
2556
2557   /* Clear out class-level bindings cache.  */
2558   if (previous_class_type)
2559     invalidate_class_lookup_cache ();
2560
2561   VARRAY_FREE (current_lang_base);
2562
2563   scope_chain = s->prev;
2564   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2565     {
2566       tree id = TREE_VEC_ELT (t, 0);
2567
2568       SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2569       IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2570       IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2571     }
2572
2573   /* If we were in the middle of compiling a function, restore our
2574      state.  */
2575   if (s->need_pop_function_context)
2576     pop_function_context_from (NULL_TREE);
2577   current_function_decl = s->function_decl;
2578
2579   free (s);
2580 }
2581 \f
2582 /* Push a definition of struct, union or enum tag "name".
2583    into binding_level "b".   "type" should be the type node,
2584    We assume that the tag "name" is not already defined.
2585
2586    Note that the definition may really be just a forward reference.
2587    In that case, the TYPE_SIZE will be a NULL_TREE.
2588
2589    C++ gratuitously puts all these tags in the name space.  */
2590
2591 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2592    record the shadowed value for this binding contour.  TYPE is
2593    the type that ID maps to.  */
2594
2595 static void
2596 set_identifier_type_value_with_scope (id, type, b)
2597      tree id;
2598      tree type;
2599      struct binding_level *b;
2600 {
2601   if (!b->namespace_p)
2602     {
2603       /* Shadow the marker, not the real thing, so that the marker
2604          gets restored later. */
2605       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2606       b->type_shadowed
2607         = tree_cons (id, old_type_value, b->type_shadowed);
2608     }
2609   else
2610     {
2611       tree binding = binding_for_name (id, current_namespace);
2612       BINDING_TYPE (binding) = type;
2613       /* Store marker instead of real type. */
2614       type = global_type_node;
2615     }
2616   SET_IDENTIFIER_TYPE_VALUE (id, type);
2617 }
2618
2619 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2620
2621 void
2622 set_identifier_type_value (id, type)
2623      tree id;
2624      tree type;
2625 {
2626   set_identifier_type_value_with_scope (id, type, current_binding_level);
2627 }
2628
2629 /* Return the type associated with id. */
2630
2631 tree
2632 identifier_type_value (id)
2633      tree id;
2634 {
2635   /* There is no type with that name, anywhere. */
2636   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2637     return NULL_TREE;
2638   /* This is not the type marker, but the real thing. */
2639   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2640     return REAL_IDENTIFIER_TYPE_VALUE (id);
2641   /* Have to search for it. It must be on the global level, now.
2642      Ask lookup_name not to return non-types. */
2643   id = lookup_name_real (id, 2, 1, 0);
2644   if (id)
2645     return TREE_TYPE (id);
2646   return NULL_TREE;
2647 }
2648
2649 /* Pop off extraneous binding levels left over due to syntax errors.
2650
2651    We don't pop past namespaces, as they might be valid.  */
2652
2653 void
2654 pop_everything ()
2655 {
2656 #ifdef DEBUG_CP_BINDING_LEVELS
2657   fprintf (stderr, "XXX entering pop_everything ()\n");
2658 #endif
2659   while (!toplevel_bindings_p ())
2660     {
2661       if (current_binding_level->parm_flag == 2)
2662         pop_nested_class ();
2663       else
2664         poplevel (0, 0, 0);
2665     }
2666 #ifdef DEBUG_CP_BINDING_LEVELS
2667   fprintf (stderr, "XXX leaving pop_everything ()\n");
2668 #endif
2669 }
2670
2671 /* The type TYPE is being declared.  If it is a class template, or a
2672    specialization of a class template, do any processing required and
2673    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2674    being declared a friend.  B is the binding level at which this TYPE
2675    should be bound.
2676
2677    Returns the TYPE_DECL for TYPE, which may have been altered by this
2678    processing.  */
2679
2680 static tree
2681 maybe_process_template_type_declaration (type, globalize, b)
2682      tree type;
2683      int globalize;
2684      struct binding_level* b;
2685 {
2686   tree decl = TYPE_NAME (type);
2687
2688   if (processing_template_parmlist)
2689     /* You can't declare a new template type in a template parameter
2690        list.  But, you can declare a non-template type:
2691
2692          template <class A*> struct S;
2693
2694        is a forward-declaration of `A'.  */
2695     ;
2696   else
2697     {
2698       maybe_check_template_type (type);
2699
2700       my_friendly_assert (IS_AGGR_TYPE (type)
2701                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2702
2703
2704       if (processing_template_decl)
2705         {
2706           /* This may change after the call to
2707              push_template_decl_real, but we want the original value.  */
2708           tree name = DECL_NAME (decl);
2709
2710           decl = push_template_decl_real (decl, globalize);
2711           /* If the current binding level is the binding level for the
2712              template parameters (see the comment in
2713              begin_template_parm_list) and the enclosing level is a class
2714              scope, and we're not looking at a friend, push the
2715              declaration of the member class into the class scope.  In the
2716              friend case, push_template_decl will already have put the
2717              friend into global scope, if appropriate.  */
2718           if (TREE_CODE (type) != ENUMERAL_TYPE
2719               && !globalize && b->template_parms_p
2720               && b->level_chain->parm_flag == 2)
2721             {
2722               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2723               /* Put this tag on the list of tags for the class, since
2724                  that won't happen below because B is not the class
2725                  binding level, but is instead the pseudo-global level.  */
2726               b->level_chain->tags =
2727                 tree_cons (name, type, b->level_chain->tags);
2728               if (!COMPLETE_TYPE_P (current_class_type))
2729                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2730             }
2731         }
2732     }
2733
2734   return decl;
2735 }
2736
2737 /* In C++, you don't have to write `struct S' to refer to `S'; you
2738    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2739    if the user had written `typedef struct S S'.  Create and return
2740    the TYPE_DECL for TYPE.  */
2741
2742 tree
2743 create_implicit_typedef (name, type)
2744      tree name;
2745      tree type;
2746 {
2747   tree decl;
2748
2749   decl = build_decl (TYPE_DECL, name, type);
2750   DECL_ARTIFICIAL (decl) = 1;
2751   /* There are other implicit type declarations, like the one *within*
2752      a class that allows you to write `S::S'.  We must distinguish
2753      amongst these.  */
2754   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2755   TYPE_NAME (type) = decl;
2756
2757   return decl;
2758 }
2759
2760 /* Remember a local name for name-mangling purposes.  */
2761
2762 static void
2763 push_local_name (decl)
2764      tree decl;
2765 {
2766   size_t i, nelts;
2767   tree t, name;
2768
2769   if (!local_names)
2770     VARRAY_TREE_INIT (local_names, 8, "local_names");
2771
2772   name = DECL_NAME (decl);
2773
2774   nelts = VARRAY_ACTIVE_SIZE (local_names);
2775   for (i = 0; i < nelts; i++)
2776     {
2777       t = VARRAY_TREE (local_names, i);
2778       if (DECL_NAME (t) == name)
2779         {
2780           if (!DECL_LANG_SPECIFIC (decl))
2781             retrofit_lang_decl (decl);
2782           if (DECL_LANG_SPECIFIC (t))
2783             DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
2784           else
2785             DECL_DISCRIMINATOR (decl) = 1;
2786
2787           VARRAY_TREE (local_names, i) = decl;
2788           return;
2789         }
2790     }
2791
2792   VARRAY_PUSH_TREE (local_names, decl);
2793 }
2794
2795 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2796    Normally put it into the inner-most non-tag-transparent scope,
2797    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2798    The latter is needed for implicit declarations.  */
2799
2800 void
2801 pushtag (name, type, globalize)
2802      tree name, type;
2803      int globalize;
2804 {
2805   register struct binding_level *b;
2806
2807   b = current_binding_level;
2808   while (b->tag_transparent
2809          || (b->parm_flag == 2
2810              && (globalize
2811                  /* We may be defining a new type in the initializer
2812                     of a static member variable. We allow this when
2813                     not pedantic, and it is particularly useful for
2814                     type punning via an anonymous union. */
2815                  || COMPLETE_TYPE_P (b->this_class))))
2816     b = b->level_chain;
2817
2818   b->tags = tree_cons (name, type, b->tags);
2819
2820   if (name)
2821     {
2822       /* Do C++ gratuitous typedefing.  */
2823       if (IDENTIFIER_TYPE_VALUE (name) != type)
2824         {
2825           register tree d = NULL_TREE;
2826           int in_class = 0;
2827           tree context = TYPE_CONTEXT (type);
2828
2829           if (! context)
2830             {
2831               tree cs = current_scope ();
2832
2833               if (! globalize)
2834                 context = cs;
2835               else if (cs != NULL_TREE && TYPE_P (cs))
2836                 /* When declaring a friend class of a local class, we want
2837                    to inject the newly named class into the scope
2838                    containing the local class, not the namespace scope.  */
2839                 context = decl_function_context (get_type_decl (cs));
2840             }
2841           if (!context)
2842             context = current_namespace;
2843
2844           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2845               || b->parm_flag == 2)
2846             in_class = 1;
2847
2848           if (current_lang_name == lang_name_java)
2849             TYPE_FOR_JAVA (type) = 1;
2850
2851           d = create_implicit_typedef (name, type);
2852           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2853           if (! in_class)
2854             set_identifier_type_value_with_scope (name, type, b);
2855
2856           d = maybe_process_template_type_declaration (type,
2857                                                        globalize, b);
2858
2859           if (b->parm_flag == 2)
2860             {
2861               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2862                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2863                    class.  But if it's a member template class, we
2864                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2865                    is done later.  */
2866                 finish_member_declaration (d);
2867               else
2868                 pushdecl_class_level (d);
2869             }
2870           else
2871             d = pushdecl_with_scope (d, b);
2872
2873           /* FIXME what if it gets a name from typedef?  */
2874           if (ANON_AGGRNAME_P (name))
2875             DECL_IGNORED_P (d) = 1;
2876
2877           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2878
2879           /* If this is a local class, keep track of it.  We need this
2880              information for name-mangling, and so that it is possible to find
2881              all function definitions in a translation unit in a convenient
2882              way.  (It's otherwise tricky to find a member function definition
2883              it's only pointed to from within a local class.)  */
2884           if (TYPE_CONTEXT (type)
2885               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2886               && !processing_template_decl)
2887             VARRAY_PUSH_TREE (local_classes, type);
2888         }
2889       if (b->parm_flag == 2)
2890         {
2891           if (!COMPLETE_TYPE_P (current_class_type))
2892             CLASSTYPE_TAGS (current_class_type) = b->tags;
2893         }
2894     }
2895
2896   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2897     /* Use the canonical TYPE_DECL for this node.  */
2898     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2899   else
2900     {
2901       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2902          will be the tagged type we just added to the current
2903          binding level.  This fake NULL-named TYPE_DECL node helps
2904          dwarfout.c to know when it needs to output a
2905          representation of a tagged type, and it also gives us a
2906          convenient place to record the "scope start" address for
2907          the tagged type.  */
2908
2909       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2910       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2911     }
2912 }
2913
2914 /* Counter used to create anonymous type names.  */
2915
2916 static int anon_cnt = 0;
2917
2918 /* Return an IDENTIFIER which can be used as a name for
2919    anonymous structs and unions.  */
2920
2921 tree
2922 make_anon_name ()
2923 {
2924   char buf[32];
2925
2926   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2927   return get_identifier (buf);
2928 }
2929
2930 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2931    This keeps dbxout from getting confused.  */
2932
2933 void
2934 clear_anon_tags ()
2935 {
2936   register struct binding_level *b;
2937   register tree tags;
2938   static int last_cnt = 0;
2939
2940   /* Fast out if no new anon names were declared.  */
2941   if (last_cnt == anon_cnt)
2942     return;
2943
2944   b = current_binding_level;
2945   while (b->tag_transparent)
2946     b = b->level_chain;
2947   tags = b->tags;
2948   while (tags)
2949     {
2950       /* A NULL purpose means we have already processed all tags
2951          from here to the end of the list.  */
2952       if (TREE_PURPOSE (tags) == NULL_TREE)
2953         break;
2954       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2955         TREE_PURPOSE (tags) = NULL_TREE;
2956       tags = TREE_CHAIN (tags);
2957     }
2958   last_cnt = anon_cnt;
2959 }
2960 \f
2961 /* Subroutine of duplicate_decls: return truthvalue of whether
2962    or not types of these decls match.
2963
2964    For C++, we must compare the parameter list so that `int' can match
2965    `int&' in a parameter position, but `int&' is not confused with
2966    `const int&'.  */
2967
2968 int
2969 decls_match (newdecl, olddecl)
2970      tree newdecl, olddecl;
2971 {
2972   int types_match;
2973
2974   if (newdecl == olddecl)
2975     return 1;
2976
2977   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2978     /* If the two DECLs are not even the same kind of thing, we're not
2979        interested in their types.  */
2980     return 0;
2981
2982   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2983     {
2984       tree f1 = TREE_TYPE (newdecl);
2985       tree f2 = TREE_TYPE (olddecl);
2986       tree p1 = TYPE_ARG_TYPES (f1);
2987       tree p2 = TYPE_ARG_TYPES (f2);
2988
2989       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2990           && ! (DECL_EXTERN_C_P (newdecl)
2991                 && DECL_EXTERN_C_P (olddecl)))
2992         return 0;
2993
2994       if (TREE_CODE (f1) != TREE_CODE (f2))
2995         return 0;
2996
2997       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2998         {
2999           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
3000               && (DECL_BUILT_IN (olddecl)
3001 #ifndef NO_IMPLICIT_EXTERN_C
3002                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
3003                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
3004 #endif
3005               ))
3006             {
3007               types_match = self_promoting_args_p (p1);
3008               if (p1 == void_list_node)
3009                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3010             }
3011 #ifndef NO_IMPLICIT_EXTERN_C
3012           else if (p1 == NULL_TREE
3013                    && (DECL_EXTERN_C_P (olddecl)
3014                        && DECL_IN_SYSTEM_HEADER (olddecl)
3015                        && !DECL_CLASS_SCOPE_P (olddecl))
3016                    && (DECL_EXTERN_C_P (newdecl)
3017                        && DECL_IN_SYSTEM_HEADER (newdecl)
3018                        && !DECL_CLASS_SCOPE_P (newdecl)))
3019             {
3020               types_match = self_promoting_args_p (p2);
3021               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3022             }
3023 #endif
3024           else
3025             types_match = compparms (p1, p2);
3026         }
3027       else
3028         types_match = 0;
3029     }
3030   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3031     {
3032       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3033                                 DECL_TEMPLATE_PARMS (olddecl)))
3034         return 0;
3035
3036       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
3037           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
3038         return 0;
3039
3040       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3041         types_match = 1;
3042       else
3043         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3044                                    DECL_TEMPLATE_RESULT (newdecl));
3045     }
3046   else
3047     {
3048       if (TREE_TYPE (newdecl) == error_mark_node)
3049         types_match = TREE_TYPE (olddecl) == error_mark_node;
3050       else if (TREE_TYPE (olddecl) == NULL_TREE)
3051         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3052       else if (TREE_TYPE (newdecl) == NULL_TREE)
3053         types_match = 0;
3054       else
3055         types_match = comptypes (TREE_TYPE (newdecl),
3056                                  TREE_TYPE (olddecl),
3057                                  COMPARE_REDECLARATION);
3058     }
3059
3060   return types_match;
3061 }
3062
3063 /* If NEWDECL is `static' and an `extern' was seen previously,
3064    warn about it.  OLDDECL is the previous declaration.
3065
3066    Note that this does not apply to the C++ case of declaring
3067    a variable `extern const' and then later `const'.
3068
3069    Don't complain about built-in functions, since they are beyond
3070    the user's control.  */
3071
3072 static void
3073 warn_extern_redeclared_static (newdecl, olddecl)
3074      tree newdecl, olddecl;
3075 {
3076   static const char *explicit_extern_static_warning
3077     = "`%D' was declared `extern' and later `static'";
3078   static const char *implicit_extern_static_warning
3079     = "`%D' was declared implicitly `extern' and later `static'";
3080
3081   tree name;
3082
3083   if (TREE_CODE (newdecl) == TYPE_DECL
3084       || TREE_CODE (newdecl) == TEMPLATE_DECL
3085       || TREE_CODE (newdecl) == CONST_DECL)
3086     return;
3087
3088   /* Don't get confused by static member functions; that's a different
3089      use of `static'.  */
3090   if (TREE_CODE (newdecl) == FUNCTION_DECL
3091       && DECL_STATIC_FUNCTION_P (newdecl))
3092     return;
3093
3094   /* If the old declaration was `static', or the new one isn't, then
3095      then everything is OK.  */
3096   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3097     return;
3098
3099   /* It's OK to declare a builtin function as `static'.  */
3100   if (TREE_CODE (olddecl) == FUNCTION_DECL
3101       && DECL_ARTIFICIAL (olddecl))
3102     return;
3103
3104   name = DECL_ASSEMBLER_NAME (newdecl);
3105   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3106               ? implicit_extern_static_warning
3107               : explicit_extern_static_warning, newdecl);
3108   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3109 }
3110
3111 /* Handle when a new declaration NEWDECL has the same name as an old
3112    one OLDDECL in the same binding contour.  Prints an error message
3113    if appropriate.
3114
3115    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3116    Otherwise, return 0.  */
3117
3118 int
3119 duplicate_decls (newdecl, olddecl)
3120      tree newdecl, olddecl;
3121 {
3122   unsigned olddecl_uid = DECL_UID (olddecl);
3123   int olddecl_friend = 0, types_match = 0;
3124   int new_defines_function = 0;
3125
3126   if (newdecl == olddecl)
3127     return 1;
3128
3129   types_match = decls_match (newdecl, olddecl);
3130
3131   /* If either the type of the new decl or the type of the old decl is an
3132      error_mark_node, then that implies that we have already issued an
3133      error (earlier) for some bogus type specification, and in that case,
3134      it is rather pointless to harass the user with yet more error message
3135      about the same declaration, so just pretend the types match here.  */
3136   if (TREE_TYPE (newdecl) == error_mark_node
3137       || TREE_TYPE (olddecl) == error_mark_node)
3138     types_match = 1;
3139
3140   /* Check for redeclaration and other discrepancies. */
3141   if (TREE_CODE (olddecl) == FUNCTION_DECL
3142       && DECL_ARTIFICIAL (olddecl))
3143     {
3144       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3145         {
3146           /* If you declare a built-in or predefined function name as static,
3147              the old definition is overridden, but optionally warn this was a
3148              bad choice of name.  */
3149           if (! TREE_PUBLIC (newdecl))
3150             {
3151               if (warn_shadow)
3152                 cp_warning ("shadowing %s function `%#D'",
3153                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3154                             olddecl);
3155               /* Discard the old built-in function.  */
3156               return 0;
3157             }
3158           /* If the built-in is not ansi, then programs can override
3159              it even globally without an error.  */
3160           else if (! DECL_BUILT_IN (olddecl))
3161             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3162                         olddecl, newdecl);
3163           else
3164             {
3165               cp_error ("declaration of `%#D'", newdecl);
3166               cp_error ("conflicts with built-in declaration `%#D'",
3167                         olddecl);
3168             }
3169           return 0;
3170         }
3171       else if (!types_match)
3172         {
3173           if ((DECL_EXTERN_C_P (newdecl)
3174                && DECL_EXTERN_C_P (olddecl))
3175               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3176                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3177             {
3178               /* A near match; override the builtin.  */
3179
3180               if (TREE_PUBLIC (newdecl))
3181                 {
3182                   cp_warning ("new declaration `%#D'", newdecl);
3183                   cp_warning ("ambiguates built-in declaration `%#D'",
3184                               olddecl);
3185                 }
3186               else if (warn_shadow)
3187                 cp_warning ("shadowing %s function `%#D'",
3188                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3189                             olddecl);
3190             }
3191           else
3192             /* Discard the old built-in function.  */
3193             return 0;
3194         }
3195
3196       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3197         {
3198           /* If a builtin function is redeclared as `static', merge
3199              the declarations, but make the original one static.  */
3200           DECL_THIS_STATIC (olddecl) = 1;
3201           TREE_PUBLIC (olddecl) = 0;
3202
3203           /* Make the old declaration consistent with the new one so
3204              that all remnants of the builtin-ness of this function
3205              will be banished.  */
3206           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3207           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3208           COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3209           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3210                                        newdecl);
3211         }
3212     }
3213   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3214     {
3215       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3216            && TREE_CODE (newdecl) != TYPE_DECL
3217            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3218                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3219           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3220               && TREE_CODE (olddecl) != TYPE_DECL
3221               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3222                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3223                         == TYPE_DECL))))
3224         {
3225           /* We do nothing special here, because C++ does such nasty
3226              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3227              get shadowed, and know that if we need to find a TYPE_DECL
3228              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3229              slot of the identifier.  */
3230           return 0;
3231         }
3232
3233       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3234            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3235           || (TREE_CODE (olddecl) == FUNCTION_DECL
3236               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3237         return 0;
3238
3239       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3240       if (TREE_CODE (olddecl) == TREE_LIST)
3241         olddecl = TREE_VALUE (olddecl);
3242       cp_error_at ("previous declaration of `%#D'", olddecl);
3243
3244       /* New decl is completely inconsistent with the old one =>
3245          tell caller to replace the old one.  */
3246
3247       return 0;
3248     }
3249   else if (!types_match)
3250     {
3251       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3252         /* These are certainly not duplicate declarations; they're
3253            from different scopes.  */
3254         return 0;
3255
3256       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3257         {
3258           /* The name of a class template may not be declared to refer to
3259              any other template, class, function, object, namespace, value,
3260              or type in the same scope.  */
3261           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3262               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3263             {
3264               cp_error ("declaration of template `%#D'", newdecl);
3265               cp_error_at ("conflicts with previous declaration `%#D'",
3266                            olddecl);
3267             }
3268           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3269                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3270                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3271                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3272                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3273                                            DECL_TEMPLATE_PARMS (olddecl)))
3274             {
3275               cp_error ("new declaration `%#D'", newdecl);
3276               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3277             }
3278           return 0;
3279         }
3280       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3281         {
3282           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3283             {
3284               cp_error ("declaration of C function `%#D' conflicts with",
3285                         newdecl);
3286               cp_error_at ("previous declaration `%#D' here", olddecl);
3287             }
3288           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3289                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3290             {
3291               cp_error ("new declaration `%#D'", newdecl);
3292               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3293             }
3294           else
3295             return 0;
3296         }
3297
3298       /* Already complained about this, so don't do so again.  */
3299       else if (current_class_type == NULL_TREE
3300           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3301         {
3302           cp_error ("conflicting types for `%#D'", newdecl);
3303           cp_error_at ("previous declaration as `%#D'", olddecl);
3304         }
3305     }
3306   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3307             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3308                  && (!DECL_TEMPLATE_INFO (newdecl)
3309                      || (DECL_TI_TEMPLATE (newdecl)
3310                          != DECL_TI_TEMPLATE (olddecl))))
3311                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3312                     && (!DECL_TEMPLATE_INFO (olddecl)
3313                         || (DECL_TI_TEMPLATE (olddecl)
3314                             != DECL_TI_TEMPLATE (newdecl))))))
3315     /* It's OK to have a template specialization and a non-template
3316        with the same type, or to have specializations of two
3317        different templates with the same type.  Note that if one is a
3318        specialization, and the other is an instantiation of the same
3319        template, that we do not exit at this point.  That situation
3320        can occur if we instantiate a template class, and then
3321        specialize one of its methods.  This situation is legal, but
3322        the declarations must be merged in the usual way.  */
3323     return 0;
3324   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3325            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3326                 && !DECL_USE_TEMPLATE (newdecl))
3327                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3328                    && !DECL_USE_TEMPLATE (olddecl))))
3329     /* One of the declarations is a template instantiation, and the
3330        other is not a template at all.  That's OK.  */
3331     return 0;
3332   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3333            && DECL_NAMESPACE_ALIAS (newdecl)
3334            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3335     /* Redeclaration of namespace alias, ignore it. */
3336     return 1;
3337   else
3338     {
3339       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3340       if (errmsg)
3341         {
3342           cp_error (errmsg, newdecl);
3343           if (DECL_NAME (olddecl) != NULL_TREE)
3344             cp_error_at ((DECL_INITIAL (olddecl)
3345                           && namespace_bindings_p ())
3346                          ? "`%#D' previously defined here"
3347                          : "`%#D' previously declared here", olddecl);
3348         }
3349       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3350                && DECL_INITIAL (olddecl) != NULL_TREE
3351                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3352                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3353         {
3354           /* Prototype decl follows defn w/o prototype.  */
3355           cp_warning_at ("prototype for `%#D'", newdecl);
3356           cp_warning_at ("follows non-prototype definition here", olddecl);
3357         }
3358       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3359                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3360         {
3361           /* extern "C" int foo ();
3362              int foo () { bar (); }
3363              is OK.  */
3364           if (current_lang_depth () == 0)
3365             SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3366           else
3367             {
3368               cp_error_at ("previous declaration of `%#D' with %L linkage",
3369                            olddecl, DECL_LANGUAGE (olddecl));
3370               cp_error ("conflicts with new declaration with %L linkage",
3371                         DECL_LANGUAGE (newdecl));
3372             }
3373         }
3374
3375       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3376         ;
3377       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3378         {
3379           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3380           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3381           int i = 1;
3382
3383           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3384             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3385
3386           for (; t1 && t1 != void_list_node;
3387                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3388             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3389               {
3390                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3391                                            TREE_PURPOSE (t2)))
3392                   {
3393                     if (pedantic)
3394                       {
3395                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3396                                     i, newdecl);
3397                         cp_pedwarn_at ("after previous specification in `%#D'",
3398                                        olddecl);
3399                       }
3400                   }
3401                 else
3402                   {
3403                     cp_error ("default argument given for parameter %d of `%#D'",
3404                               i, newdecl);
3405                     cp_error_at ("after previous specification in `%#D'",
3406                                  olddecl);
3407                   }
3408               }
3409
3410           if (DECL_DECLARED_INLINE_P (newdecl)
3411               && ! DECL_DECLARED_INLINE_P (olddecl)
3412               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3413             {
3414               cp_warning ("`%#D' was used before it was declared inline",
3415                           newdecl);
3416               cp_warning_at ("previous non-inline declaration here",
3417                              olddecl);
3418             }
3419         }
3420     }
3421
3422   /* If new decl is `static' and an `extern' was seen previously,
3423      warn about it.  */
3424   warn_extern_redeclared_static (newdecl, olddecl);
3425
3426   /* We have committed to returning 1 at this point.  */
3427   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3428     {
3429       /* Now that functions must hold information normally held
3430          by field decls, there is extra work to do so that
3431          declaration information does not get destroyed during
3432          definition.  */
3433       if (DECL_VINDEX (olddecl))
3434         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3435       if (DECL_VIRTUAL_CONTEXT (olddecl))
3436         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3437       if (DECL_CONTEXT (olddecl))
3438         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3439       if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3440         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3441       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3442       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3443       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3444       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3445       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3446       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3447       if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
3448         SET_OVERLOADED_OPERATOR_CODE
3449           (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
3450       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3451
3452       /* Optionally warn about more than one declaration for the same
3453          name, but don't warn about a function declaration followed by a
3454          definition.  */
3455       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3456           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3457           /* Don't warn about extern decl followed by definition. */
3458           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3459           /* Don't warn about friends, let add_friend take care of it. */
3460           && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
3461         {
3462           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3463           cp_warning_at ("previous declaration of `%D'", olddecl);
3464         }
3465     }
3466
3467   /* Deal with C++: must preserve virtual function table size.  */
3468   if (TREE_CODE (olddecl) == TYPE_DECL)
3469     {
3470       register tree newtype = TREE_TYPE (newdecl);
3471       register tree oldtype = TREE_TYPE (olddecl);
3472
3473       if (newtype != error_mark_node && oldtype != error_mark_node
3474           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3475         {
3476           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3477           CLASSTYPE_FRIEND_CLASSES (newtype)
3478             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3479         }
3480
3481       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3482     }
3483
3484   /* Copy all the DECL_... slots specified in the new decl
3485      except for any that we copy here from the old type.  */
3486   DECL_MACHINE_ATTRIBUTES (newdecl)
3487     = (*targetm.merge_decl_attributes) (olddecl, newdecl);
3488
3489   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3490     {
3491       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3492       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3493         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3494                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3495
3496       /* If the new declaration is a definition, update the file and
3497          line information on the declaration.  */
3498       if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
3499           && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
3500         {
3501           DECL_SOURCE_LINE (olddecl)
3502             = DECL_SOURCE_LINE (DECL_TEMPLATE_RESULT (olddecl))
3503             = DECL_SOURCE_LINE (newdecl);
3504           DECL_SOURCE_FILE (olddecl)
3505             = DECL_SOURCE_FILE (DECL_TEMPLATE_RESULT (olddecl))
3506             = DECL_SOURCE_FILE (newdecl);
3507         }
3508
3509       return 1;
3510     }
3511
3512   if (types_match)
3513     {
3514       /* Automatically handles default parameters.  */
3515       tree oldtype = TREE_TYPE (olddecl);
3516       tree newtype;
3517
3518       /* Merge the data types specified in the two decls.  */
3519       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3520
3521       /* If common_type produces a non-typedef type, just use the old type.  */
3522       if (TREE_CODE (newdecl) == TYPE_DECL
3523           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3524         newtype = oldtype;
3525
3526       if (TREE_CODE (newdecl) == VAR_DECL)
3527         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3528       /* Do this after calling `common_type' so that default
3529          parameters don't confuse us.  */
3530       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3531           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3532               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3533         {
3534           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3535                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3536           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3537                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3538
3539           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3540               && DECL_SOURCE_LINE (olddecl) != 0
3541               && flag_exceptions
3542               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3543                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3544             {
3545               cp_error ("declaration of `%F' throws different exceptions",
3546                         newdecl);
3547               cp_error_at ("than previous declaration `%F'", olddecl);
3548             }
3549         }
3550       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3551
3552       /* Lay the type out, unless already done.  */
3553       if (! same_type_p (newtype, oldtype)
3554           && TREE_TYPE (newdecl) != error_mark_node
3555           && !(processing_template_decl && uses_template_parms (newdecl)))
3556         layout_type (TREE_TYPE (newdecl));
3557
3558       if ((TREE_CODE (newdecl) == VAR_DECL
3559            || TREE_CODE (newdecl) == PARM_DECL
3560            || TREE_CODE (newdecl) == RESULT_DECL
3561            || TREE_CODE (newdecl) == FIELD_DECL
3562            || TREE_CODE (newdecl) == TYPE_DECL)
3563           && !(processing_template_decl && uses_template_parms (newdecl)))
3564         layout_decl (newdecl, 0);
3565
3566       /* Merge the type qualifiers.  */
3567       if (TREE_READONLY (newdecl))
3568         TREE_READONLY (olddecl) = 1;
3569       if (TREE_THIS_VOLATILE (newdecl))
3570         TREE_THIS_VOLATILE (olddecl) = 1;
3571
3572       /* Merge the initialization information.  */
3573       if (DECL_INITIAL (newdecl) == NULL_TREE
3574           && DECL_INITIAL (olddecl) != NULL_TREE)
3575         {
3576           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3577           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3578           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3579           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3580               && DECL_LANG_SPECIFIC (newdecl)
3581               && DECL_LANG_SPECIFIC (olddecl))
3582             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3583         }
3584
3585       /* Merge the section attribute.
3586          We want to issue an error if the sections conflict but that must be
3587          done later in decl_attributes since we are called before attributes
3588          are assigned.  */
3589       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3590         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3591
3592       /* Keep the old rtl since we can safely use it.  */
3593       COPY_DECL_RTL (olddecl, newdecl);
3594
3595       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3596         {
3597           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3598             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3599           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3600             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3601           DECL_NO_LIMIT_STACK (newdecl)
3602             |= DECL_NO_LIMIT_STACK (olddecl);
3603         }
3604     }
3605   /* If cannot merge, then use the new type and qualifiers,
3606      and don't preserve the old rtl.  */
3607   else
3608     {
3609       /* Clean out any memory we had of the old declaration.  */
3610       tree oldstatic = value_member (olddecl, static_aggregates);
3611       if (oldstatic)
3612         TREE_VALUE (oldstatic) = error_mark_node;
3613
3614       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3615       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3616       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3617       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3618     }
3619
3620   /* Merge the storage class information.  */
3621   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3622   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3623   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3624   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3625   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3626   if (! DECL_EXTERNAL (olddecl))
3627     DECL_EXTERNAL (newdecl) = 0;
3628
3629   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3630     {
3631       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3632       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3633       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3634       DECL_TEMPLATE_INSTANTIATED (newdecl)
3635         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3636       /* Don't really know how much of the language-specific
3637          values we should copy from old to new.  */
3638       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3639       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3640       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3641       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3642       DECL_INITIALIZED_IN_CLASS_P (newdecl)
3643         |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
3644       olddecl_friend = DECL_FRIEND_P (olddecl);
3645
3646       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3647       if (TREE_CODE (newdecl) == FUNCTION_DECL
3648           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3649         DECL_BEFRIENDING_CLASSES (newdecl)
3650           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3651                      DECL_BEFRIENDING_CLASSES (olddecl));
3652     }
3653
3654   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3655     {
3656       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3657           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3658         {
3659           /* If newdecl is not a specialization, then it is not a
3660              template-related function at all.  And that means that we
3661              shoud have exited above, returning 0.  */
3662           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3663                               0);
3664
3665           if (TREE_USED (olddecl))
3666             /* From [temp.expl.spec]:
3667
3668                If a template, a member template or the member of a class
3669                template is explicitly specialized then that
3670                specialization shall be declared before the first use of
3671                that specialization that would cause an implicit
3672                instantiation to take place, in every translation unit in
3673                which such a use occurs.  */
3674             cp_error ("explicit specialization of %D after first use",
3675                       olddecl);
3676
3677           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3678         }
3679       DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
3680
3681       /* If either decl says `inline', this fn is inline, unless its
3682          definition was passed already.  */
3683       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3684         DECL_INLINE (olddecl) = 1;
3685       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3686
3687       /* Preserve abstractness on cloned [cd]tors.  */
3688       DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
3689
3690       if (! types_match)
3691         {
3692           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3693           COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
3694           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3695         }
3696       if (! types_match || new_defines_function)
3697         {
3698           /* These need to be copied so that the names are available.
3699              Note that if the types do match, we'll preserve inline
3700              info and other bits, but if not, we won't.  */
3701           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3702           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3703         }
3704       if (new_defines_function)
3705         /* If defining a function declared with other language
3706            linkage, use the previously declared language linkage.  */
3707         SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3708       else if (types_match)
3709         {
3710           /* If redeclaring a builtin function, and not a definition,
3711              it stays built in.  */
3712           if (DECL_BUILT_IN (olddecl))
3713             {
3714               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3715               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3716               /* If we're keeping the built-in definition, keep the rtl,
3717                  regardless of declaration matches.  */
3718               SET_DECL_RTL (newdecl, DECL_RTL (olddecl));
3719             }
3720           else
3721             DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
3722
3723           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3724           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3725             /* Previously saved insns go together with
3726                the function's previous definition.  */
3727             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3728           /* Don't clear out the arguments if we're redefining a function.  */
3729           if (DECL_ARGUMENTS (olddecl))
3730             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3731         }
3732     }
3733   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3734     NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3735
3736   /* Now preserve various other info from the definition.  */
3737   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3738   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3739   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3740   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3741
3742   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3743     {
3744       int function_size;
3745
3746       function_size = sizeof (struct tree_decl);
3747
3748       memcpy ((char *) olddecl + sizeof (struct tree_common),
3749               (char *) newdecl + sizeof (struct tree_common),
3750               function_size - sizeof (struct tree_common));
3751
3752       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3753         {
3754           /* If newdecl is a template instantiation, it is possible that
3755              the following sequence of events has occurred:
3756
3757              o A friend function was declared in a class template.  The
3758              class template was instantiated.
3759
3760              o The instantiation of the friend declaration was
3761              recorded on the instantiation list, and is newdecl.
3762
3763              o Later, however, instantiate_class_template called pushdecl
3764              on the newdecl to perform name injection.  But, pushdecl in
3765              turn called duplicate_decls when it discovered that another
3766              declaration of a global function with the same name already
3767              existed.
3768
3769              o Here, in duplicate_decls, we decided to clobber newdecl.
3770
3771              If we're going to do that, we'd better make sure that
3772              olddecl, and not newdecl, is on the list of
3773              instantiations so that if we try to do the instantiation
3774              again we won't get the clobbered declaration.  */
3775
3776           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3777           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3778
3779           for (; decls; decls = TREE_CHAIN (decls))
3780             if (TREE_VALUE (decls) == newdecl)
3781               TREE_VALUE (decls) = olddecl;
3782         }
3783     }
3784   else
3785     {
3786       memcpy ((char *) olddecl + sizeof (struct tree_common),
3787               (char *) newdecl + sizeof (struct tree_common),
3788               sizeof (struct tree_decl) - sizeof (struct tree_common)
3789               + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3790     }
3791
3792   DECL_UID (olddecl) = olddecl_uid;
3793   if (olddecl_friend)
3794     DECL_FRIEND_P (olddecl) = 1;
3795
3796   /* NEWDECL contains the merged attribute lists.
3797      Update OLDDECL to be the same.  */
3798   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3799
3800   return 1;
3801 }
3802
3803 /* Record a decl-node X as belonging to the current lexical scope.
3804    Check for errors (such as an incompatible declaration for the same
3805    name already seen in the same scope).
3806
3807    Returns either X or an old decl for the same name.
3808    If an old decl is returned, it may have been smashed
3809    to agree with what X says.  */
3810
3811 tree
3812 pushdecl (x)
3813      tree x;
3814 {
3815   register tree t;
3816   register tree name;
3817   int need_new_binding;
3818
3819   /* We shouldn't be calling pushdecl when we're generating RTL for a
3820      function that we already did semantic analysis on previously.  */
3821   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3822                       19990913);
3823
3824   need_new_binding = 1;
3825
3826   if (DECL_TEMPLATE_PARM_P (x))
3827     /* Template parameters have no context; they are not X::T even
3828        when declared within a class or namespace.  */
3829     ;
3830   else
3831     {
3832       if (current_function_decl && x != current_function_decl
3833           /* A local declaration for a function doesn't constitute
3834              nesting.  */
3835           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3836           /* A local declaration for an `extern' variable is in the
3837              scope of the current namespace, not the current
3838              function.  */
3839           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3840           && !DECL_CONTEXT (x))
3841         DECL_CONTEXT (x) = current_function_decl;
3842
3843       /* If this is the declaration for a namespace-scope function,
3844          but the declaration itself is in a local scope, mark the
3845          declaration.  */
3846       if (TREE_CODE (x) == FUNCTION_DECL
3847           && DECL_NAMESPACE_SCOPE_P (x)
3848           && current_function_decl
3849           && x != current_function_decl)
3850         DECL_LOCAL_FUNCTION_P (x) = 1;
3851     }
3852
3853   name = DECL_NAME (x);
3854   if (name)
3855     {
3856       int different_binding_level = 0;
3857
3858       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3859         name = TREE_OPERAND (name, 0);
3860
3861       /* In case this decl was explicitly namespace-qualified, look it
3862          up in its namespace context.  */
3863       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3864           && namespace_bindings_p ())
3865         t = namespace_binding (name, DECL_CONTEXT (x));
3866       else
3867         t = lookup_name_current_level (name);
3868
3869       /* [basic.link] If there is a visible declaration of an entity
3870          with linkage having the same name and type, ignoring entities
3871          declared outside the innermost enclosing namespace scope, the
3872          block scope declaration declares that same entity and
3873          receives the linkage of the previous declaration.  */
3874       if (! t && current_function_decl && x != current_function_decl
3875           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3876           && DECL_EXTERNAL (x))
3877         {
3878           /* Look in block scope.  */
3879           t = IDENTIFIER_VALUE (name);
3880           /* Or in the innermost namespace.  */
3881           if (! t)
3882             t = namespace_binding (name, DECL_CONTEXT (x));
3883           /* Does it have linkage?  Note that if this isn't a DECL, it's an
3884              OVERLOAD, which is OK.  */
3885           if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3886             t = NULL_TREE;
3887           if (t)
3888             different_binding_level = 1;
3889         }
3890
3891       /* If we are declaring a function, and the result of name-lookup
3892          was an OVERLOAD, look for an overloaded instance that is
3893          actually the same as the function we are declaring.  (If
3894          there is one, we have to merge our declaration with the
3895          previous declaration.)  */
3896       if (t && TREE_CODE (t) == OVERLOAD)
3897         {
3898           tree match;
3899
3900           if (TREE_CODE (x) == FUNCTION_DECL)
3901             for (match = t; match; match = OVL_NEXT (match))
3902               {
3903                 if (decls_match (OVL_CURRENT (match), x))
3904                   break;
3905               }
3906           else
3907             /* Just choose one.  */
3908             match = t;
3909
3910           if (match)
3911             t = OVL_CURRENT (match);
3912           else
3913             t = NULL_TREE;
3914         }
3915
3916       if (t == error_mark_node)
3917         {
3918           /* error_mark_node is 0 for a while during initialization!  */
3919           t = NULL_TREE;
3920           cp_error_at ("`%#D' used prior to declaration", x);
3921         }
3922       else if (t != NULL_TREE)
3923         {
3924           if (different_binding_level)
3925             {
3926               if (decls_match (x, t))
3927                 /* The standard only says that the local extern
3928                    inherits linkage from the previous decl; in
3929                    particular, default args are not shared.  It would
3930                    be nice to propagate inlining info, though.  FIXME.  */
3931                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3932             }
3933           else if (TREE_CODE (t) == PARM_DECL)
3934             {
3935               if (DECL_CONTEXT (t) == NULL_TREE)
3936                 /* This is probaby caused by too many errors, but calling
3937                    abort will say that if errors have occurred.  */
3938                 abort ();
3939
3940               /* Check for duplicate params.  */
3941               if (duplicate_decls (x, t))
3942                 return t;
3943             }
3944           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3945                     || DECL_FUNCTION_TEMPLATE_P (x))
3946                    && is_overloaded_fn (t))
3947             /* Don't do anything just yet. */;
3948           else if (t == wchar_decl_node)
3949             {
3950               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3951                 cp_pedwarn ("redeclaration of `wchar_t' as `%T'",
3952                             TREE_TYPE (x));
3953
3954               /* Throw away the redeclaration.  */
3955               return t;
3956             }
3957           else if (TREE_CODE (t) != TREE_CODE (x))
3958             {
3959               if (duplicate_decls (x, t))
3960                 return t;
3961             }
3962           else if (duplicate_decls (x, t))
3963             {
3964               if (TREE_CODE (t) == TYPE_DECL)
3965                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3966               else if (TREE_CODE (t) == FUNCTION_DECL)
3967                 check_default_args (t);
3968
3969               return t;
3970             }
3971           else if (DECL_MAIN_P (x))
3972             {
3973               /* A redeclaration of main, but not a duplicate of the
3974                  previous one.
3975
3976                  [basic.start.main]
3977
3978                  This function shall not be overloaded.  */
3979               cp_error_at ("invalid redeclaration of `%D'", t);
3980               cp_error ("as `%D'", x);
3981               /* We don't try to push this declaration since that
3982                  causes a crash.  */
3983               return x;
3984             }
3985         }
3986
3987       check_template_shadow (x);
3988
3989       /* If this is a function conjured up by the backend, massage it
3990          so it looks friendly.  */
3991       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3992         {
3993           retrofit_lang_decl (x);
3994           SET_DECL_LANGUAGE (x, lang_c);
3995         }
3996
3997       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3998         {
3999           t = push_overloaded_decl (x, PUSH_LOCAL);
4000           if (t != x)
4001             return t;
4002           if (!namespace_bindings_p ())
4003             /* We do not need to create a binding for this name;
4004                push_overloaded_decl will have already done so if
4005                necessary.  */
4006             need_new_binding = 0;
4007         }
4008       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
4009         {
4010           t = push_overloaded_decl (x, PUSH_GLOBAL);
4011           if (t == x)
4012             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
4013           return t;
4014         }
4015
4016       /* If declaring a type as a typedef, copy the type (unless we're
4017          at line 0), and install this TYPE_DECL as the new type's typedef
4018          name.  See the extensive comment in ../c-decl.c (pushdecl). */
4019       if (TREE_CODE (x) == TYPE_DECL)
4020         {
4021           tree type = TREE_TYPE (x);
4022           if (DECL_SOURCE_LINE (x) == 0)
4023             {
4024               if (TYPE_NAME (type) == 0)
4025                 TYPE_NAME (type) = x;
4026             }
4027           else if (type != error_mark_node && TYPE_NAME (type) != x
4028                    /* We don't want to copy the type when all we're
4029                       doing is making a TYPE_DECL for the purposes of
4030                       inlining.  */
4031                    && (!TYPE_NAME (type)
4032                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
4033             {
4034               DECL_ORIGINAL_TYPE (x) = type;
4035               type = build_type_copy (type);
4036               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4037               TYPE_NAME (type) = x;
4038               TREE_TYPE (x) = type;
4039             }
4040
4041           if (type != error_mark_node
4042               && TYPE_NAME (type)
4043               && TYPE_IDENTIFIER (type))
4044             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4045                                                   current_binding_level);
4046
4047         }
4048
4049       /* Multiple external decls of the same identifier ought to match.
4050
4051          We get warnings about inline functions where they are defined.
4052          We get warnings about other functions from push_overloaded_decl.
4053
4054          Avoid duplicate warnings where they are used.  */
4055       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4056         {
4057           tree decl;
4058
4059           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4060           if (decl && TREE_CODE (decl) == OVERLOAD)
4061             decl = OVL_FUNCTION (decl);
4062
4063           if (decl && decl != error_mark_node
4064               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4065               /* If different sort of thing, we already gave an error.  */
4066               && TREE_CODE (decl) == TREE_CODE (x)
4067               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4068             {
4069               cp_pedwarn ("type mismatch with previous external decl", x);
4070               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4071             }
4072         }
4073
4074       /* This name is new in its binding level.
4075          Install the new declaration and return it.  */
4076       if (namespace_bindings_p ())
4077         {
4078           /* Install a global value.  */
4079
4080           /* If the first global decl has external linkage,
4081              warn if we later see static one.  */
4082           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4083             TREE_PUBLIC (name) = 1;
4084
4085           /* Bind the name for the entity.  */
4086           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4087                 && t != NULL_TREE)
4088               && (TREE_CODE (x) == TYPE_DECL
4089                   || TREE_CODE (x) == VAR_DECL
4090                   || TREE_CODE (x) == NAMESPACE_DECL
4091                   || TREE_CODE (x) == CONST_DECL
4092                   || TREE_CODE (x) == TEMPLATE_DECL))
4093             SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
4094
4095           /* Don't forget if the function was used via an implicit decl.  */
4096           if (IDENTIFIER_IMPLICIT_DECL (name)
4097               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4098             TREE_USED (x) = 1;
4099
4100           /* Don't forget if its address was taken in that way.  */
4101           if (IDENTIFIER_IMPLICIT_DECL (name)
4102               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4103             TREE_ADDRESSABLE (x) = 1;
4104
4105           /* Warn about mismatches against previous implicit decl.  */
4106           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4107               /* If this real decl matches the implicit, don't complain.  */
4108               && ! (TREE_CODE (x) == FUNCTION_DECL
4109                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4110             cp_warning
4111               ("`%D' was previously implicitly declared to return `int'", x);
4112
4113           /* If new decl is `static' and an `extern' was seen previously,
4114              warn about it.  */
4115           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4116             warn_extern_redeclared_static (x, t);
4117         }
4118       else
4119         {
4120           /* Here to install a non-global value.  */
4121           tree oldlocal = IDENTIFIER_VALUE (name);
4122           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4123
4124           if (need_new_binding)
4125             {
4126               push_local_binding (name, x, 0);
4127               /* Because push_local_binding will hook X on to the
4128                  current_binding_level's name list, we don't want to
4129                  do that again below.  */
4130               need_new_binding = 0;
4131             }
4132
4133           /* If this is a TYPE_DECL, push it into the type value slot.  */
4134           if (TREE_CODE (x) == TYPE_DECL)
4135             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4136                                                   current_binding_level);
4137
4138           /* Clear out any TYPE_DECL shadowed by a namespace so that
4139              we won't think this is a type.  The C struct hack doesn't
4140              go through namespaces.  */
4141           if (TREE_CODE (x) == NAMESPACE_DECL)
4142             set_identifier_type_value_with_scope (name, NULL_TREE,
4143                                                   current_binding_level);
4144
4145           if (oldlocal)
4146             {
4147               tree d = oldlocal;
4148
4149               while (oldlocal
4150                      && TREE_CODE (oldlocal) == VAR_DECL
4151                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4152                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4153
4154               if (oldlocal == NULL_TREE)
4155                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4156             }
4157
4158           /* If this is an extern function declaration, see if we
4159              have a global definition or declaration for the function.  */
4160           if (oldlocal == NULL_TREE
4161               && DECL_EXTERNAL (x)
4162               && oldglobal != NULL_TREE
4163               && TREE_CODE (x) == FUNCTION_DECL
4164               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4165             {
4166               /* We have one.  Their types must agree.  */
4167               if (decls_match (x, oldglobal))
4168                 /* OK */;
4169               else
4170                 {
4171                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4172                   cp_warning_at ("global declaration `%#D'", oldglobal);
4173                 }
4174             }
4175           /* If we have a local external declaration,
4176              and no file-scope declaration has yet been seen,
4177              then if we later have a file-scope decl it must not be static.  */
4178           if (oldlocal == NULL_TREE
4179               && oldglobal == NULL_TREE
4180               && DECL_EXTERNAL (x)
4181               && TREE_PUBLIC (x))
4182             TREE_PUBLIC (name) = 1;
4183
4184           /* Warn if shadowing an argument at the top level of the body.  */
4185           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4186               /* Inline decls shadow nothing.  */
4187               && !DECL_FROM_INLINE (x)
4188               && TREE_CODE (oldlocal) == PARM_DECL
4189               /* Don't complain if it's from an enclosing function.  */
4190               && DECL_CONTEXT (oldlocal) == current_function_decl
4191               && TREE_CODE (x) != PARM_DECL)
4192             {
4193               /* Go to where the parms should be and see if we
4194                  find them there.  */
4195               struct binding_level *b = current_binding_level->level_chain;
4196
4197               if (cleanup_label)
4198                 b = b->level_chain;
4199
4200               /* ARM $8.3 */
4201               if (b->parm_flag == 1)
4202                 cp_error ("declaration of `%#D' shadows a parameter", name);
4203             }
4204
4205           /* Maybe warn if shadowing something else.  */
4206           if (warn_shadow && !DECL_EXTERNAL (x)
4207               /* Inline decls shadow nothing.  */
4208               && !DECL_FROM_INLINE (x)
4209               /* No shadow warnings for internally generated vars.  */
4210               && ! DECL_ARTIFICIAL (x)
4211               /* No shadow warnings for vars made for inlining.  */
4212               && ! DECL_FROM_INLINE (x))
4213             {
4214               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4215                 warning ("declaration of `%s' shadows a parameter",
4216                         IDENTIFIER_POINTER (name));
4217               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4218                        && current_class_ptr
4219                        && !TREE_STATIC (name))
4220                 warning ("declaration of `%s' shadows a member of `this'",
4221                         IDENTIFIER_POINTER (name));
4222               else if (oldlocal != NULL_TREE)
4223                 warning ("declaration of `%s' shadows previous local",
4224                         IDENTIFIER_POINTER (name));
4225               else if (oldglobal != NULL_TREE)
4226                 /* XXX shadow warnings in outer-more namespaces */
4227                 warning ("declaration of `%s' shadows global declaration",
4228                         IDENTIFIER_POINTER (name));
4229             }
4230         }
4231
4232       if (TREE_CODE (x) == FUNCTION_DECL)
4233         check_default_args (x);
4234
4235       /* Keep count of variables in this level with incomplete type.  */
4236       if (TREE_CODE (x) == VAR_DECL
4237           && TREE_TYPE (x) != error_mark_node
4238           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4239                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4240               /* RTTI TD entries are created while defining the type_info.  */
4241               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4242                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4243         {
4244           if (namespace_bindings_p ())
4245             namespace_scope_incomplete
4246               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4247           else
4248             current_binding_level->incomplete
4249               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4250         }
4251     }
4252
4253   if (need_new_binding)
4254     add_decl_to_level (x,
4255                        DECL_NAMESPACE_SCOPE_P (x)
4256                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4257                        : current_binding_level);
4258
4259   return x;
4260 }
4261
4262 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4263    caller to set DECL_CONTEXT properly.  */
4264
4265 static tree
4266 pushdecl_with_scope (x, level)
4267      tree x;
4268      struct binding_level *level;
4269 {
4270   register struct binding_level *b;
4271   tree function_decl = current_function_decl;
4272
4273   current_function_decl = NULL_TREE;
4274   if (level->parm_flag == 2)
4275     {
4276       b = class_binding_level;
4277       class_binding_level = level;
4278       pushdecl_class_level (x);
4279       class_binding_level = b;
4280     }
4281   else
4282     {
4283       b = current_binding_level;
4284       current_binding_level = level;
4285       x = pushdecl (x);
4286       current_binding_level = b;
4287     }
4288   current_function_decl = function_decl;
4289   return x;
4290 }
4291
4292 /* Like pushdecl, only it places X in the current namespace,
4293    if appropriate.  */
4294
4295 tree
4296 pushdecl_namespace_level (x)
4297      tree x;
4298 {
4299   register struct binding_level *b = current_binding_level;
4300   register tree t;
4301
4302   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4303
4304   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4305      what we want.  */
4306   if (TREE_CODE (x) == TYPE_DECL)
4307     {
4308       tree name = DECL_NAME (x);
4309       tree newval;
4310       tree *ptr = (tree *)0;
4311       for (; b != global_binding_level; b = b->level_chain)
4312         {
4313           tree shadowed = b->type_shadowed;
4314           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4315             if (TREE_PURPOSE (shadowed) == name)
4316               {
4317                 ptr = &TREE_VALUE (shadowed);
4318                 /* Can't break out of the loop here because sometimes
4319                    a binding level will have duplicate bindings for
4320                    PT names.  It's gross, but I haven't time to fix it.  */
4321               }
4322         }
4323       newval = TREE_TYPE (x);
4324       if (ptr == (tree *)0)
4325         {
4326           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4327              up here if this is changed to an assertion.  --KR  */
4328           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4329         }
4330       else
4331         {
4332           *ptr = newval;
4333         }
4334     }
4335   return t;
4336 }
4337
4338 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4339    if appropriate.  */
4340
4341 tree
4342 pushdecl_top_level (x)
4343      tree x;
4344 {
4345   push_to_top_level ();
4346   x = pushdecl_namespace_level (x);
4347   pop_from_top_level ();
4348   return x;
4349 }
4350
4351 /* Make the declaration of X appear in CLASS scope.  */
4352
4353 void
4354 pushdecl_class_level (x)
4355      tree x;
4356 {
4357   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4358      scope looks for the pre-mangled name.  */
4359   register tree name;
4360
4361   if (TREE_CODE (x) == OVERLOAD)
4362     x = OVL_CURRENT (x);
4363   name = DECL_NAME (x);
4364
4365   if (name)
4366     {
4367       push_class_level_binding (name, x);
4368       if (TREE_CODE (x) == TYPE_DECL)
4369         set_identifier_type_value (name, TREE_TYPE (x));
4370     }
4371   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4372     {
4373       tree f;
4374
4375       for (f = TYPE_FIELDS (TREE_TYPE (x));
4376            f;
4377            f = TREE_CHAIN (f))
4378         pushdecl_class_level (f);
4379     }
4380 }
4381
4382 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4383    DECL, or a modified version thereof.  */
4384
4385 tree
4386 maybe_push_decl (decl)
4387      tree decl;
4388 {
4389   tree type = TREE_TYPE (decl);
4390
4391   /* Add this decl to the current binding level, but not if it comes
4392      from another scope, e.g. a static member variable.  TEM may equal
4393      DECL or it may be a previous decl of the same name.  */
4394   if (decl == error_mark_node
4395       || (TREE_CODE (decl) != PARM_DECL
4396           && DECL_CONTEXT (decl) != NULL_TREE
4397           /* Definitions of namespace members outside their namespace are
4398              possible. */
4399           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4400       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4401       || TREE_CODE (type) == UNKNOWN_TYPE
4402       /* The declaration of a template specialization does not affect
4403          the functions available for overload resolution, so we do not
4404          call pushdecl.  */
4405       || (TREE_CODE (decl) == FUNCTION_DECL
4406           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4407     return decl;
4408   else
4409     return pushdecl (decl);
4410 }
4411
4412 /* Make the declaration(s) of X appear in CLASS scope
4413    under the name NAME.  */
4414
4415 void
4416 push_class_level_binding (name, x)
4417      tree name;
4418      tree x;
4419 {
4420   tree binding;
4421   /* The class_binding_level will be NULL if x is a template
4422      parameter name in a member template.  */
4423   if (!class_binding_level)
4424     return;
4425
4426   /* Make sure that this new member does not have the same name
4427      as a template parameter.  */
4428   if (TYPE_BEING_DEFINED (current_class_type))
4429     check_template_shadow (x);
4430
4431   /* If this declaration shadows a declaration from an enclosing
4432      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4433      we leave this class.  Record the shadowed declaration here.  */
4434   binding = IDENTIFIER_BINDING (name);
4435   if (binding
4436       && ((TREE_CODE (x) == OVERLOAD
4437            && BINDING_VALUE (binding)
4438            && is_overloaded_fn (BINDING_VALUE (binding)))
4439           || INHERITED_VALUE_BINDING_P (binding)))
4440     {
4441       tree shadow;
4442       tree old_decl;
4443
4444       /* If the old binding was from a base class, and was for a tag
4445          name, slide it over to make room for the new binding.  The
4446          old binding is still visible if explicitly qualified with a
4447          class-key.  */
4448       if (INHERITED_VALUE_BINDING_P (binding)
4449           && BINDING_VALUE (binding)
4450           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4451           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4452           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4453         {
4454           old_decl = BINDING_TYPE (binding);
4455           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4456           BINDING_VALUE (binding) = NULL_TREE;
4457           INHERITED_VALUE_BINDING_P (binding) = 0;
4458         }
4459       else
4460         old_decl = BINDING_VALUE (binding);
4461
4462       /* Find the previous binding of name on the class-shadowed
4463          list, and update it.  */
4464       for (shadow = class_binding_level->class_shadowed;
4465            shadow;
4466            shadow = TREE_CHAIN (shadow))
4467         if (TREE_PURPOSE (shadow) == name
4468             && TREE_TYPE (shadow) == old_decl)
4469           {
4470             BINDING_VALUE (binding) = x;
4471             INHERITED_VALUE_BINDING_P (binding) = 0;
4472             TREE_TYPE (shadow) = x;
4473             IDENTIFIER_CLASS_VALUE (name) = x;
4474             return;
4475           }
4476     }
4477
4478   /* If we didn't replace an existing binding, put the binding on the
4479      stack of bindings for the identifier, and update the shadowed list.  */
4480   if (push_class_binding (name, x))
4481     {
4482       class_binding_level->class_shadowed
4483         = tree_cons (name, NULL,
4484                      class_binding_level->class_shadowed);
4485       /* Record the value we are binding NAME to so that we can know
4486          what to pop later.  */
4487       TREE_TYPE (class_binding_level->class_shadowed) = x;
4488     }
4489 }
4490
4491 /* Insert another USING_DECL into the current binding level, returning
4492    this declaration. If this is a redeclaration, do nothing, and
4493    return NULL_TREE if this not in namespace scope (in namespace
4494    scope, a using decl might extend any previous bindings).  */
4495
4496 tree
4497 push_using_decl (scope, name)
4498      tree scope;
4499      tree name;
4500 {
4501   tree decl;
4502
4503   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4504   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4505   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4506     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4507       break;
4508   if (decl)
4509     return namespace_bindings_p () ? decl : NULL_TREE;
4510   decl = build_lang_decl (USING_DECL, name, void_type_node);
4511   DECL_INITIAL (decl) = scope;
4512   TREE_CHAIN (decl) = current_binding_level->usings;
4513   current_binding_level->usings = decl;
4514   return decl;
4515 }
4516
4517 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4518    changed (i.e. there was already a directive), or the fresh
4519    TREE_LIST otherwise.  */
4520
4521 tree
4522 push_using_directive (used)
4523      tree used;
4524 {
4525   tree ud = current_binding_level->using_directives;
4526   tree iter, ancestor;
4527
4528   /* Check if we already have this. */
4529   if (purpose_member (used, ud) != NULL_TREE)
4530     return NULL_TREE;
4531
4532   /* Recursively add all namespaces used. */
4533   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4534     push_using_directive (TREE_PURPOSE (iter));
4535
4536   ancestor = namespace_ancestor (current_decl_namespace (), used);
4537   ud = current_binding_level->using_directives;
4538   ud = tree_cons (used, ancestor, ud);
4539   current_binding_level->using_directives = ud;
4540   return ud;
4541 }
4542
4543 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4544    other definitions already in place.  We get around this by making
4545    the value of the identifier point to a list of all the things that
4546    want to be referenced by that name.  It is then up to the users of
4547    that name to decide what to do with that list.
4548
4549    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4550    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4551
4552    FLAGS is a bitwise-or of the following values:
4553      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4554                  namespace scope.
4555      PUSH_USING: DECL is being pushed as the result of a using
4556                  declaration.
4557
4558    The value returned may be a previous declaration if we guessed wrong
4559    about what language DECL should belong to (C or C++).  Otherwise,
4560    it's always DECL (and never something that's not a _DECL).  */
4561
4562 tree
4563 push_overloaded_decl (decl, flags)
4564      tree decl;
4565      int flags;
4566 {
4567   tree name = DECL_NAME (decl);
4568   tree old;
4569   tree new_binding;
4570   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4571
4572   if (doing_global)
4573     old = namespace_binding (name, DECL_CONTEXT (decl));
4574   else
4575     old = lookup_name_current_level (name);
4576
4577   if (old)
4578     {
4579       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4580         {
4581           tree t = TREE_TYPE (old);
4582           if (IS_AGGR_TYPE (t) && warn_shadow
4583               && (! DECL_IN_SYSTEM_HEADER (decl)
4584                   || ! DECL_IN_SYSTEM_HEADER (old)))
4585             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4586           old = NULL_TREE;
4587         }
4588       else if (is_overloaded_fn (old))
4589         {
4590           tree tmp;
4591
4592           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4593             {
4594               tree fn = OVL_CURRENT (tmp);
4595
4596               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4597                   && !(flags & PUSH_USING)
4598                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4599                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4600                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4601                           decl, fn);
4602
4603               if (duplicate_decls (decl, fn))
4604                 return fn;
4605             }
4606         }
4607       else if (old == error_mark_node)
4608         /* Ignore the undefined symbol marker.  */
4609         old = NULL_TREE;
4610       else
4611         {
4612           cp_error_at ("previous non-function declaration `%#D'", old);
4613           cp_error ("conflicts with function declaration `%#D'", decl);
4614           return decl;
4615         }
4616     }
4617
4618   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4619     {
4620       if (old && TREE_CODE (old) != OVERLOAD)
4621         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4622       else
4623         new_binding = ovl_cons (decl, old);
4624       if (flags & PUSH_USING)
4625         OVL_USED (new_binding) = 1;
4626     }
4627   else
4628     /* NAME is not ambiguous.  */
4629     new_binding = decl;
4630
4631   if (doing_global)
4632     set_namespace_binding (name, current_namespace, new_binding);
4633   else
4634     {
4635       /* We only create an OVERLOAD if there was a previous binding at
4636          this level, or if decl is a template. In the former case, we
4637          need to remove the old binding and replace it with the new
4638          binding.  We must also run through the NAMES on the binding
4639          level where the name was bound to update the chain.  */
4640
4641       if (TREE_CODE (new_binding) == OVERLOAD && old)
4642         {
4643           tree *d;
4644
4645           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4646                *d;
4647                d = &TREE_CHAIN (*d))
4648             if (*d == old
4649                 || (TREE_CODE (*d) == TREE_LIST
4650                     && TREE_VALUE (*d) == old))
4651               {
4652                 if (TREE_CODE (*d) == TREE_LIST)
4653                   /* Just replace the old binding with the new.  */
4654                   TREE_VALUE (*d) = new_binding;
4655                 else
4656                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4657                   *d = tree_cons (NULL_TREE, new_binding,
4658                                   TREE_CHAIN (*d));
4659
4660                 /* And update the CPLUS_BINDING node.  */
4661                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4662                   = new_binding;
4663                 return decl;
4664               }
4665
4666           /* We should always find a previous binding in this case.  */
4667           my_friendly_abort (0);
4668         }
4669
4670       /* Install the new binding.  */
4671       push_local_binding (name, new_binding, flags);
4672     }
4673
4674   return decl;
4675 }
4676 \f
4677 /* Generate an implicit declaration for identifier FUNCTIONID
4678    as a function of type int ().  Print a warning if appropriate.  */
4679
4680 tree
4681 implicitly_declare (functionid)
4682      tree functionid;
4683 {
4684   register tree decl;
4685
4686   /* We used to reuse an old implicit decl here,
4687      but this loses with inline functions because it can clobber
4688      the saved decl chains.  */
4689   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4690
4691   DECL_EXTERNAL (decl) = 1;
4692   TREE_PUBLIC (decl) = 1;
4693
4694   /* ISO standard says implicit declarations are in the innermost block.
4695      So we record the decl in the standard fashion.  */
4696   pushdecl (decl);
4697   rest_of_decl_compilation (decl, NULL, 0, 0);
4698
4699   if (warn_implicit
4700       /* Only one warning per identifier.  */
4701       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4702     {
4703       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4704     }
4705
4706   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4707
4708   return decl;
4709 }
4710
4711 /* Return zero if the declaration NEWDECL is valid
4712    when the declaration OLDDECL (assumed to be for the same name)
4713    has already been seen.
4714    Otherwise return an error message format string with a %s
4715    where the identifier should go.  */
4716
4717 static const char *
4718 redeclaration_error_message (newdecl, olddecl)
4719      tree newdecl, olddecl;
4720 {
4721   if (TREE_CODE (newdecl) == TYPE_DECL)
4722     {
4723       /* Because C++ can put things into name space for free,
4724          constructs like "typedef struct foo { ... } foo"
4725          would look like an erroneous redeclaration.  */
4726       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4727         return 0;
4728       else
4729         return "redefinition of `%#D'";
4730     }
4731   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4732     {
4733       /* If this is a pure function, its olddecl will actually be
4734          the original initialization to `0' (which we force to call
4735          abort()).  Don't complain about redefinition in this case.  */
4736       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4737         return 0;
4738
4739       /* If both functions come from different namespaces, this is not
4740          a redeclaration - this is a conflict with a used function. */
4741       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4742           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4743         return "`%D' conflicts with used function";
4744
4745       /* We'll complain about linkage mismatches in
4746          warn_extern_redeclared_static.  */
4747
4748       /* Defining the same name twice is no good.  */
4749       if (DECL_INITIAL (olddecl) != NULL_TREE
4750           && DECL_INITIAL (newdecl) != NULL_TREE)
4751         {
4752           if (DECL_NAME (olddecl) == NULL_TREE)
4753             return "`%#D' not declared in class";
4754           else
4755             return "redefinition of `%#D'";
4756         }
4757       return 0;
4758     }
4759   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4760     {
4761       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4762            && (DECL_TEMPLATE_RESULT (newdecl)
4763                != DECL_TEMPLATE_RESULT (olddecl))
4764            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4765            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4766           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4767               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4768               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4769         return "redefinition of `%#D'";
4770       return 0;
4771     }
4772   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4773     {
4774       /* Objects declared at top level:  */
4775       /* If at least one is a reference, it's ok.  */
4776       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4777         return 0;
4778       /* Reject two definitions.  */
4779       return "redefinition of `%#D'";
4780     }
4781   else
4782     {
4783       /* Objects declared with block scope:  */
4784       /* Reject two definitions, and reject a definition
4785          together with an external reference.  */
4786       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4787         return "redeclaration of `%#D'";
4788       return 0;
4789     }
4790 }
4791 \f
4792 /* Create a new label, named ID.  */
4793
4794 static tree
4795 make_label_decl (id, local_p)
4796      tree id;
4797      int local_p;
4798 {
4799   tree decl;
4800
4801   decl = build_decl (LABEL_DECL, id, void_type_node);
4802   if (expanding_p)
4803     /* Make sure every label has an rtx.  */
4804     label_rtx (decl);
4805
4806   DECL_CONTEXT (decl) = current_function_decl;
4807   DECL_MODE (decl) = VOIDmode;
4808   C_DECLARED_LABEL_FLAG (decl) = local_p;
4809
4810   /* Say where one reference is to the label, for the sake of the
4811      error if it is not defined.  */
4812   DECL_SOURCE_LINE (decl) = lineno;
4813   DECL_SOURCE_FILE (decl) = input_filename;
4814
4815   /* Record the fact that this identifier is bound to this label.  */
4816   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4817
4818   return decl;
4819 }
4820
4821 /* Record this label on the list of used labels so that we can check
4822    at the end of the function to see whether or not the label was
4823    actually defined, and so we can check when the label is defined whether
4824    this use is valid.  */
4825
4826 static void
4827 use_label (decl)
4828      tree decl;
4829 {
4830   if (named_label_uses == NULL
4831       || named_label_uses->names_in_scope != current_binding_level->names
4832       || named_label_uses->label_decl != decl)
4833     {
4834       struct named_label_use_list *new_ent;
4835       new_ent = ((struct named_label_use_list *)
4836                  ggc_alloc (sizeof (struct named_label_use_list)));
4837       new_ent->label_decl = decl;
4838       new_ent->names_in_scope = current_binding_level->names;
4839       new_ent->binding_level = current_binding_level;
4840       new_ent->lineno_o_goto = lineno;
4841       new_ent->filename_o_goto = input_filename;
4842       new_ent->next = named_label_uses;
4843       named_label_uses = new_ent;
4844     }
4845 }
4846
4847 /* Look for a label named ID in the current function.  If one cannot
4848    be found, create one.  (We keep track of used, but undefined,
4849    labels, and complain about them at the end of a function.)  */
4850
4851 tree
4852 lookup_label (id)
4853      tree id;
4854 {
4855   tree decl;
4856   struct named_label_list *ent;
4857
4858   /* You can't use labels at global scope.  */
4859   if (current_function_decl == NULL_TREE)
4860     {
4861       error ("label `%s' referenced outside of any function",
4862              IDENTIFIER_POINTER (id));
4863       return NULL_TREE;
4864     }
4865
4866   /* See if we've already got this label.  */
4867   decl = IDENTIFIER_LABEL_VALUE (id);
4868   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4869     return decl;
4870
4871   /* Record this label on the list of labels used in this function.
4872      We do this before calling make_label_decl so that we get the
4873      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4874   ent = ((struct named_label_list *)
4875          ggc_alloc_cleared (sizeof (struct named_label_list)));
4876   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4877   ent->next = named_labels;
4878   named_labels = ent;
4879
4880   /* We need a new label.  */
4881   decl = make_label_decl (id, /*local_p=*/0);
4882
4883   /* Now fill in the information we didn't have before.  */
4884   ent->label_decl = decl;
4885
4886   return decl;
4887 }
4888
4889 /* Declare a local label named ID.  */
4890
4891 tree
4892 declare_local_label (id)
4893      tree id;
4894 {
4895   tree decl;
4896
4897   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4898      this scope we can restore the old value of
4899      IDENTIFIER_TYPE_VALUE.  */
4900   current_binding_level->shadowed_labels
4901     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4902                  current_binding_level->shadowed_labels);
4903   /* Look for the label.  */
4904   decl = make_label_decl (id, /*local_p=*/1);
4905   /* Now fill in the information we didn't have before.  */
4906   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4907
4908   return decl;
4909 }
4910
4911 /* Returns nonzero if it is ill-formed to jump past the declaration of
4912    DECL.  Returns 2 if it's also a real problem.  */
4913
4914 static int
4915 decl_jump_unsafe (decl)
4916      tree decl;
4917 {
4918   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4919     return 0;
4920
4921   if (DECL_INITIAL (decl) == NULL_TREE
4922       && pod_type_p (TREE_TYPE (decl)))
4923     return 0;
4924
4925   /* This is really only important if we're crossing an initialization.
4926      The POD stuff is just pedantry; why should it matter if the class
4927      contains a field of pointer to member type?  */
4928   if (DECL_INITIAL (decl)
4929       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4930     return 2;
4931   return 1;
4932 }
4933
4934 /* Check that a single previously seen jump to a newly defined label
4935    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4936    the jump context; NAMES are the names in scope in LEVEL at the jump
4937    context; FILE and LINE are the source position of the jump or 0.  */
4938
4939 static void
4940 check_previous_goto_1 (decl, level, names, file, line)
4941      tree decl;
4942      struct binding_level *level;
4943      tree names;
4944      const char *file;
4945      int line;
4946 {
4947   int identified = 0;
4948   int saw_eh = 0;
4949   struct binding_level *b = current_binding_level;
4950   for (; b; b = b->level_chain)
4951     {
4952       tree new_decls = b->names;
4953       tree old_decls = (b == level ? names : NULL_TREE);
4954       for (; new_decls != old_decls;
4955            new_decls = TREE_CHAIN (new_decls))
4956         {
4957           int problem = decl_jump_unsafe (new_decls);
4958           if (! problem)
4959             continue;
4960
4961           if (! identified)
4962             {
4963               if (decl)
4964                 cp_pedwarn ("jump to label `%D'", decl);
4965               else
4966                 pedwarn ("jump to case label");
4967
4968               if (file)
4969                 pedwarn_with_file_and_line (file, line, "  from here");
4970               identified = 1;
4971             }
4972
4973           if (problem > 1)
4974             cp_error_at ("  crosses initialization of `%#D'",
4975                          new_decls);
4976           else
4977             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4978                            new_decls);
4979         }
4980
4981       if (b == level)
4982         break;
4983       if ((b->is_try_scope || b->is_catch_scope) && ! saw_eh)
4984         {
4985           if (! identified)
4986             {
4987               if (decl)
4988                 cp_pedwarn ("jump to label `%D'", decl);
4989               else
4990                 pedwarn ("jump to case label");
4991
4992               if (file)
4993                 pedwarn_with_file_and_line (file, line, "  from here");
4994               identified = 1;
4995             }
4996           if (b->is_try_scope)
4997             error ("  enters try block");
4998           else
4999             error ("  enters catch block");
5000           saw_eh = 1;
5001         }
5002     }
5003 }
5004
5005 static void
5006 check_previous_goto (use)
5007      struct named_label_use_list *use;
5008 {
5009   check_previous_goto_1 (use->label_decl, use->binding_level,
5010                          use->names_in_scope, use->filename_o_goto,
5011                          use->lineno_o_goto);
5012 }
5013
5014 static void
5015 check_switch_goto (level)
5016      struct binding_level *level;
5017 {
5018   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
5019 }
5020
5021 /* Check that any previously seen jumps to a newly defined label DECL
5022    are OK.  Called by define_label.  */
5023
5024 static void
5025 check_previous_gotos (decl)
5026      tree decl;
5027 {
5028   struct named_label_use_list **usep;
5029
5030   if (! TREE_USED (decl))
5031     return;
5032
5033   for (usep = &named_label_uses; *usep; )
5034     {
5035       struct named_label_use_list *use = *usep;
5036       if (use->label_decl == decl)
5037         {
5038           check_previous_goto (use);
5039           *usep = use->next;
5040         }
5041       else
5042         usep = &(use->next);
5043     }
5044 }
5045
5046 /* Check that a new jump to a label DECL is OK.  Called by
5047    finish_goto_stmt.  */
5048
5049 void
5050 check_goto (decl)
5051      tree decl;
5052 {
5053   int identified = 0;
5054   tree bad;
5055   struct named_label_list *lab;
5056
5057   /* We can't know where a computed goto is jumping.  So we assume
5058      that it's OK.  */
5059   if (! DECL_P (decl))
5060     return;
5061
5062   /* If the label hasn't been defined yet, defer checking.  */
5063   if (! DECL_INITIAL (decl))
5064     {
5065       use_label (decl);
5066       return;
5067     }
5068
5069   for (lab = named_labels; lab; lab = lab->next)
5070     if (decl == lab->label_decl)
5071       break;
5072
5073   /* If the label is not on named_labels it's a gcc local label, so
5074      it must be in an outer scope, so jumping to it is always OK.  */
5075   if (lab == 0)
5076     return;
5077
5078   if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
5079       && !identified)
5080     {
5081       cp_pedwarn_at ("jump to label `%D'", decl);
5082       pedwarn ("  from here");
5083       identified = 1;
5084     }
5085
5086   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5087     {
5088       tree b = TREE_VALUE (bad);
5089       int u = decl_jump_unsafe (b);
5090
5091       if (u > 1 && DECL_ARTIFICIAL (b))
5092         /* Can't skip init of __exception_info.  */
5093         cp_error_at ("  enters catch block", b);
5094       else if (u > 1)
5095         cp_error_at ("  skips initialization of `%#D'", b);
5096       else
5097         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5098     }
5099
5100   if (lab->in_try_scope)
5101     error ("  enters try block");
5102   else if (lab->in_catch_scope)
5103     error ("  enters catch block");
5104 }
5105
5106 /* Define a label, specifying the location in the source file.
5107    Return the LABEL_DECL node for the label, if the definition is valid.
5108    Otherwise return 0.  */
5109
5110 tree
5111 define_label (filename, line, name)
5112      const char *filename;
5113      int line;
5114      tree name;
5115 {
5116   tree decl = lookup_label (name);
5117   struct named_label_list *ent;
5118   register struct binding_level *p;
5119
5120   for (ent = named_labels; ent; ent = ent->next)
5121     if (ent->label_decl == decl)
5122       break;
5123
5124   /* After labels, make any new cleanups in the function go into their
5125      own new (temporary) binding contour.  */
5126   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5127     p->more_cleanups_ok = 0;
5128
5129   if (name == get_identifier ("wchar_t"))
5130     cp_pedwarn ("label named wchar_t");
5131
5132   if (DECL_INITIAL (decl) != NULL_TREE)
5133     {
5134       cp_error ("duplicate label `%D'", decl);
5135       return 0;
5136     }
5137   else
5138     {
5139       /* Mark label as having been defined.  */
5140       DECL_INITIAL (decl) = error_mark_node;
5141       /* Say where in the source.  */
5142       DECL_SOURCE_FILE (decl) = filename;
5143       DECL_SOURCE_LINE (decl) = line;
5144       if (ent)
5145         {
5146           ent->names_in_scope = current_binding_level->names;
5147           ent->binding_level = current_binding_level;
5148         }
5149       check_previous_gotos (decl);
5150       return decl;
5151     }
5152 }
5153
5154 struct cp_switch
5155 {
5156   struct binding_level *level;
5157   struct cp_switch *next;
5158   /* The SWITCH_STMT being built.  */
5159   tree switch_stmt;
5160   /* A splay-tree mapping the low element of a case range to the high
5161      element, or NULL_TREE if there is no high element.  Used to
5162      determine whether or not a new case label duplicates an old case
5163      label.  We need a tree, rather than simply a hash table, because
5164      of the GNU case range extension.  */
5165   splay_tree cases;
5166 };
5167
5168 /* A stack of the currently active switch statements.  The innermost
5169    switch statement is on the top of the stack.  There is no need to
5170    mark the stack for garbage collection because it is only active
5171    during the processing of the body of a function, and we never
5172    collect at that point.  */
5173
5174 static struct cp_switch *switch_stack;
5175
5176 /* Called right after a switch-statement condition is parsed.
5177    SWITCH_STMT is the switch statement being parsed.  */
5178
5179 void
5180 push_switch (switch_stmt)
5181      tree switch_stmt;
5182 {
5183   struct cp_switch *p
5184     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5185   p->level = current_binding_level;
5186   p->next = switch_stack;
5187   p->switch_stmt = switch_stmt;
5188   p->cases = splay_tree_new (case_compare, NULL, NULL);
5189   switch_stack = p;
5190 }
5191
5192 void
5193 pop_switch ()
5194 {
5195   struct cp_switch *cs;
5196
5197   cs = switch_stack;
5198   splay_tree_delete (cs->cases);
5199   switch_stack = switch_stack->next;
5200   free (cs);
5201 }
5202
5203 /* Note that we've seen a definition of a case label, and complain if this
5204    is a bad place for one.  */
5205
5206 tree
5207 finish_case_label (low_value, high_value)
5208      tree low_value;
5209      tree high_value;
5210 {
5211   tree cond, r;
5212   register struct binding_level *p;
5213
5214   if (! switch_stack)
5215     {
5216       if (high_value)
5217         error ("case label not within a switch statement");
5218       else if (low_value)
5219         cp_error ("case label `%E' not within a switch statement",
5220                   low_value);
5221       else
5222         error ("`default' label not within a switch statement");
5223       return NULL_TREE;
5224     }
5225
5226   if (processing_template_decl)
5227     {
5228       tree label;
5229
5230       /* For templates, just add the case label; we'll do semantic
5231          analysis at instantiation-time.  */
5232       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5233       return add_stmt (build_case_label (low_value, high_value, label));
5234     }
5235
5236   /* Find the condition on which this switch statement depends.  */
5237   cond = SWITCH_COND (switch_stack->switch_stmt);
5238   if (cond && TREE_CODE (cond) == TREE_LIST)
5239     cond = TREE_VALUE (cond);
5240
5241   r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5242   if (r == error_mark_node)
5243     r = NULL_TREE;
5244
5245   check_switch_goto (switch_stack->level);
5246
5247   /* After labels, make any new cleanups in the function go into their
5248      own new (temporary) binding contour.  */
5249   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5250     p->more_cleanups_ok = 0;
5251
5252   return r;
5253 }
5254 \f
5255 /* Return the list of declarations of the current level.
5256    Note that this list is in reverse order unless/until
5257    you nreverse it; and when you do nreverse it, you must
5258    store the result back using `storedecls' or you will lose.  */
5259
5260 tree
5261 getdecls ()
5262 {
5263   return current_binding_level->names;
5264 }
5265
5266 /* Return the list of type-tags (for structs, etc) of the current level.  */
5267
5268 tree
5269 gettags ()
5270 {
5271   return current_binding_level->tags;
5272 }
5273
5274 /* Store the list of declarations of the current level.
5275    This is done for the parameter declarations of a function being defined,
5276    after they are modified in the light of any missing parameters.  */
5277
5278 static void
5279 storedecls (decls)
5280      tree decls;
5281 {
5282   current_binding_level->names = decls;
5283 }
5284
5285 /* Similarly, store the list of tags of the current level.  */
5286
5287 void
5288 storetags (tags)
5289      tree tags;
5290 {
5291   current_binding_level->tags = tags;
5292 }
5293 \f
5294 /* Given NAME, an IDENTIFIER_NODE,
5295    return the structure (or union or enum) definition for that name.
5296    Searches binding levels from BINDING_LEVEL up to the global level.
5297    If THISLEVEL_ONLY is nonzero, searches only the specified context
5298    (but skips any tag-transparent contexts to find one that is
5299    meaningful for tags).
5300    FORM says which kind of type the caller wants;
5301    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5302    If the wrong kind of type is found, and it's not a template, an error is
5303    reported.  */
5304
5305 static tree
5306 lookup_tag (form, name, binding_level, thislevel_only)
5307      enum tree_code form;
5308      tree name;
5309      struct binding_level *binding_level;
5310      int thislevel_only;
5311 {
5312   register struct binding_level *level;
5313   /* Non-zero if, we should look past a template parameter level, even
5314      if THISLEVEL_ONLY.  */
5315   int allow_template_parms_p = 1;
5316
5317   for (level = binding_level; level; level = level->level_chain)
5318     {
5319       register tree tail;
5320       if (ANON_AGGRNAME_P (name))
5321         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5322           {
5323             /* There's no need for error checking here, because
5324                anon names are unique throughout the compilation.  */
5325             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5326               return TREE_VALUE (tail);
5327           }
5328       else if (level->namespace_p)
5329         /* Do namespace lookup. */
5330         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5331           {
5332             tree old = binding_for_name (name, tail);
5333
5334             /* If we just skipped past a template parameter level,
5335                even though THISLEVEL_ONLY, and we find a template
5336                class declaration, then we use the _TYPE node for the
5337                template.  See the example below.  */
5338             if (thislevel_only && !allow_template_parms_p
5339                 && old && BINDING_VALUE (old)
5340                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5341               old = TREE_TYPE (BINDING_VALUE (old));
5342             else
5343               old = BINDING_TYPE (old);
5344
5345             /* If it has an original type, it is a typedef, and we
5346                should not return it.  */
5347             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5348               old = NULL_TREE;
5349             if (old && TREE_CODE (old) != form
5350                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5351               {
5352                 cp_error ("`%#D' redeclared as %C", old, form);
5353                 return NULL_TREE;
5354               }
5355             if (old)
5356               return old;
5357             if (thislevel_only || tail == global_namespace)
5358               return NULL_TREE;
5359           }
5360       else
5361         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5362           {
5363             if (TREE_PURPOSE (tail) == name)
5364               {
5365                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5366                 /* Should tighten this up; it'll probably permit
5367                    UNION_TYPE and a struct template, for example.  */
5368                 if (code != form
5369                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5370                   {
5371                     /* Definition isn't the kind we were looking for.  */
5372                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5373                               form);
5374                     return NULL_TREE;
5375                   }
5376                 return TREE_VALUE (tail);
5377               }
5378           }
5379       if (thislevel_only && ! level->tag_transparent)
5380         {
5381           if (level->template_parms_p && allow_template_parms_p)
5382             {
5383               /* We must deal with cases like this:
5384
5385                    template <class T> struct S;
5386                    template <class T> struct S {};
5387
5388                  When looking up `S', for the second declaration, we
5389                  would like to find the first declaration.  But, we
5390                  are in the pseudo-global level created for the
5391                  template parameters, rather than the (surrounding)
5392                  namespace level.  Thus, we keep going one more level,
5393                  even though THISLEVEL_ONLY is non-zero.  */
5394               allow_template_parms_p = 0;
5395               continue;
5396             }
5397           else
5398             return NULL_TREE;
5399         }
5400     }
5401   return NULL_TREE;
5402 }
5403
5404 #if 0
5405 void
5406 set_current_level_tags_transparency (tags_transparent)
5407      int tags_transparent;
5408 {
5409   current_binding_level->tag_transparent = tags_transparent;
5410 }
5411 #endif
5412
5413 /* Given a type, find the tag that was defined for it and return the tag name.
5414    Otherwise return 0.  However, the value can never be 0
5415    in the cases in which this is used.
5416
5417    C++: If NAME is non-zero, this is the new name to install.  This is
5418    done when replacing anonymous tags with real tag names.  */
5419
5420 static tree
5421 lookup_tag_reverse (type, name)
5422      tree type;
5423      tree name;
5424 {
5425   register struct binding_level *level;
5426
5427   for (level = current_binding_level; level; level = level->level_chain)
5428     {
5429       register tree tail;
5430       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5431         {
5432           if (TREE_VALUE (tail) == type)
5433             {
5434               if (name)
5435                 TREE_PURPOSE (tail) = name;
5436               return TREE_PURPOSE (tail);
5437             }
5438         }
5439     }
5440   return NULL_TREE;
5441 }
5442 \f
5443 /* Look up NAME in the NAMESPACE.  */
5444
5445 tree
5446 lookup_namespace_name (namespace, name)
5447      tree namespace, name;
5448 {
5449   tree val;
5450   tree template_id = NULL_TREE;
5451
5452   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5453
5454   if (TREE_CODE (name) == NAMESPACE_DECL)
5455     /* This happens for A::B<int> when B is a namespace. */
5456     return name;
5457   else if (TREE_CODE (name) == TEMPLATE_DECL)
5458     {
5459       /* This happens for A::B where B is a template, and there are no
5460          template arguments.  */
5461       cp_error ("invalid use of `%D'", name);
5462       return error_mark_node;
5463     }
5464
5465   namespace = ORIGINAL_NAMESPACE (namespace);
5466
5467   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5468     {
5469       template_id = name;
5470       name = TREE_OPERAND (name, 0);
5471       if (TREE_CODE (name) == OVERLOAD)
5472         name = DECL_NAME (OVL_CURRENT (name));
5473       else if (DECL_P (name))
5474         name = DECL_NAME (name);
5475     }
5476
5477   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5478
5479   val = make_node (CPLUS_BINDING);
5480   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5481     return error_mark_node;
5482
5483   if (BINDING_VALUE (val))
5484     {
5485       val = BINDING_VALUE (val);
5486
5487       if (template_id)
5488         {
5489           if (DECL_CLASS_TEMPLATE_P (val))
5490             val = lookup_template_class (val,
5491                                          TREE_OPERAND (template_id, 1),
5492                                          /*in_decl=*/NULL_TREE,
5493                                          /*context=*/NULL_TREE,
5494                                          /*entering_scope=*/0,
5495                                          /*complain=*/1);
5496           else if (DECL_FUNCTION_TEMPLATE_P (val)
5497                    || TREE_CODE (val) == OVERLOAD)
5498             val = lookup_template_function (val,
5499                                             TREE_OPERAND (template_id, 1));
5500           else
5501             {
5502               cp_error ("`%D::%D' is not a template",
5503                         namespace, name);
5504               return error_mark_node;
5505             }
5506         }
5507
5508       /* If we have a single function from a using decl, pull it out.  */
5509       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5510         val = OVL_FUNCTION (val);
5511       return val;
5512     }
5513
5514   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5515   return error_mark_node;
5516 }
5517
5518 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5519
5520 static unsigned long
5521 typename_hash (k)
5522      hash_table_key k;
5523 {
5524   unsigned long hash;
5525   tree t;
5526
5527   t = (tree) k;
5528   hash = (((unsigned long) TYPE_CONTEXT (t))
5529           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5530
5531   return hash;
5532 }
5533
5534 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5535
5536 static bool
5537 typename_compare (k1, k2)
5538      hash_table_key k1;
5539      hash_table_key k2;
5540 {
5541   tree t1;
5542   tree t2;
5543   tree d1;
5544   tree d2;
5545
5546   t1 = (tree) k1;
5547   t2 = (tree) k2;
5548   d1 = TYPE_NAME (t1);
5549   d2 = TYPE_NAME (t2);
5550
5551   return (DECL_NAME (d1) == DECL_NAME (d2)
5552           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5553           && ((TREE_TYPE (t1) != NULL_TREE)
5554               == (TREE_TYPE (t2) != NULL_TREE))
5555           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5556           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5557 }
5558
5559 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5560    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5561    is non-NULL, this type is being created by the implicit typename
5562    extension, and BASE_TYPE is a type named `t' in some base class of
5563    `T' which depends on template parameters.
5564
5565    Returns the new TYPENAME_TYPE.  */
5566
5567 tree
5568 build_typename_type (context, name, fullname, base_type)
5569      tree context;
5570      tree name;
5571      tree fullname;
5572      tree base_type;
5573 {
5574   tree t;
5575   tree d;
5576   struct hash_entry *e;
5577
5578   static struct hash_table ht;
5579
5580   if (!ht.table)
5581     {
5582       static struct hash_table *h = &ht;
5583
5584       hash_table_init (&ht, &hash_newfunc, &typename_hash, &typename_compare);
5585       ggc_add_tree_hash_table_root (&h, 1);
5586     }
5587
5588   /* Build the TYPENAME_TYPE.  */
5589   t = make_aggr_type (TYPENAME_TYPE);
5590   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5591   TYPENAME_TYPE_FULLNAME (t) = fullname;
5592   TREE_TYPE (t) = base_type;
5593
5594   /* Build the corresponding TYPE_DECL.  */
5595   d = build_decl (TYPE_DECL, name, t);
5596   TYPE_NAME (TREE_TYPE (d)) = d;
5597   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5598   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5599   DECL_ARTIFICIAL (d) = 1;
5600
5601   /* See if we already have this type.  */
5602   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5603   if (e)
5604     t = (tree) e->key;
5605   else
5606     /* Insert the type into the table.  */
5607     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5608
5609   return t;
5610 }
5611
5612 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5613    unless an error occurs, in which case error_mark_node is returned.
5614    If COMPLAIN zero, don't complain about any errors that occur.  */
5615
5616 tree
5617 make_typename_type (context, name, complain)
5618      tree context, name;
5619      int complain;
5620 {
5621   tree fullname;
5622
5623   if (TYPE_P (name))
5624     {
5625       if (!(TYPE_LANG_SPECIFIC (name)
5626             && (CLASSTYPE_IS_TEMPLATE (name)
5627                 || CLASSTYPE_USE_TEMPLATE (name))))
5628         name = TYPE_IDENTIFIER (name);
5629       else
5630         /* Create a TEMPLATE_ID_EXPR for the type.  */
5631         name = build_nt (TEMPLATE_ID_EXPR,
5632                          CLASSTYPE_TI_TEMPLATE (name),
5633                          CLASSTYPE_TI_ARGS (name));
5634     }
5635   else if (TREE_CODE (name) == TYPE_DECL)
5636     name = DECL_NAME (name);
5637
5638   fullname = name;
5639
5640   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5641     {
5642       name = TREE_OPERAND (name, 0);
5643       if (TREE_CODE (name) == TEMPLATE_DECL)
5644         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5645     }
5646   if (TREE_CODE (name) != IDENTIFIER_NODE)
5647     my_friendly_abort (2000);
5648
5649   if (TREE_CODE (context) == NAMESPACE_DECL)
5650     {
5651       /* We can get here from typename_sub0 in the explicit_template_type
5652          expansion.  Just fail.  */
5653       if (complain)
5654         cp_error ("no class template named `%#T' in `%#T'",
5655                   name, context);
5656       return error_mark_node;
5657     }
5658
5659   if (! uses_template_parms (context)
5660       || currently_open_class (context))
5661     {
5662       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5663         {
5664           tree tmpl = NULL_TREE;
5665           if (IS_AGGR_TYPE (context))
5666             tmpl = lookup_field (context, name, 0, 0);
5667           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5668             {
5669               if (complain)
5670                 cp_error ("no class template named `%#T' in `%#T'",
5671                           name, context);
5672               return error_mark_node;
5673             }
5674
5675           return lookup_template_class (tmpl,
5676                                         TREE_OPERAND (fullname, 1),
5677                                         NULL_TREE, context,
5678                                         /*entering_scope=*/0,
5679                                         /*complain=*/1);
5680         }
5681       else
5682         {
5683           tree t;
5684
5685           if (!IS_AGGR_TYPE (context))
5686             {
5687               if (complain)
5688                 cp_error ("no type named `%#T' in `%#T'", name, context);
5689               return error_mark_node;
5690             }
5691
5692           t = lookup_field (context, name, 0, 1);
5693           if (t)
5694             return TREE_TYPE (t);
5695         }
5696     }
5697
5698   /* If the CONTEXT is not a template type, then either the field is
5699      there now or its never going to be.  */
5700   if (!uses_template_parms (context))
5701     {
5702       if (complain)
5703         cp_error ("no type named `%#T' in `%#T'", name, context);
5704       return error_mark_node;
5705     }
5706
5707
5708   return build_typename_type (context, name, fullname,  NULL_TREE);
5709 }
5710
5711 /* Select the right _DECL from multiple choices. */
5712
5713 static tree
5714 select_decl (binding, flags)
5715      tree binding;
5716      int flags;
5717 {
5718   tree val;
5719   val = BINDING_VALUE (binding);
5720
5721   /* When we implicitly declare some builtin entity, we mark it
5722      DECL_ANTICIPATED, so that we know to ignore it until it is
5723      really declared.  */
5724   if (val && DECL_P (val)
5725       && DECL_LANG_SPECIFIC (val)
5726       && DECL_ANTICIPATED (val))
5727     return NULL_TREE;
5728
5729   if (LOOKUP_NAMESPACES_ONLY (flags))
5730     {
5731       /* We are not interested in types. */
5732       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5733         return val;
5734       return NULL_TREE;
5735     }
5736
5737   /* If we could have a type and
5738      we have nothing or we need a type and have none.  */
5739   if (BINDING_TYPE (binding)
5740       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5741                    && TREE_CODE (val) != TYPE_DECL)))
5742     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5743   /* Don't return non-types if we really prefer types. */
5744   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5745            && (TREE_CODE (val) != TEMPLATE_DECL
5746                || !DECL_CLASS_TEMPLATE_P (val)))
5747     val = NULL_TREE;
5748
5749   return val;
5750 }
5751
5752 /* Unscoped lookup of a global: iterate over current namespaces,
5753    considering using-directives.  If SPACESP is non-NULL, store a list
5754    of the namespaces we've considered in it.  */
5755
5756 tree
5757 unqualified_namespace_lookup (name, flags, spacesp)
5758      tree name;
5759      int flags;
5760      tree *spacesp;
5761 {
5762   tree b = make_node (CPLUS_BINDING);
5763   tree initial = current_decl_namespace ();
5764   tree scope = initial;
5765   tree siter;
5766   struct binding_level *level;
5767   tree val = NULL_TREE;
5768
5769   if (spacesp)
5770     *spacesp = NULL_TREE;
5771
5772   for (; !val; scope = CP_DECL_CONTEXT (scope))
5773     {
5774       if (spacesp)
5775         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5776       val = binding_for_name (name, scope);
5777
5778       /* Initialize binding for this context. */
5779       BINDING_VALUE (b) = BINDING_VALUE (val);
5780       BINDING_TYPE (b) = BINDING_TYPE (val);
5781
5782       /* Add all _DECLs seen through local using-directives. */
5783       for (level = current_binding_level;
5784            !level->namespace_p;
5785            level = level->level_chain)
5786         if (!lookup_using_namespace (name, b, level->using_directives,
5787                                      scope, flags, spacesp))
5788           /* Give up because of error. */
5789           return error_mark_node;
5790
5791       /* Add all _DECLs seen through global using-directives. */
5792       /* XXX local and global using lists should work equally. */
5793       siter = initial;
5794       while (1)
5795         {
5796           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5797                                        scope, flags, spacesp))
5798             /* Give up because of error. */
5799             return error_mark_node;
5800           if (siter == scope) break;
5801           siter = CP_DECL_CONTEXT (siter);
5802         }
5803
5804       val = select_decl (b, flags);
5805       if (scope == global_namespace)
5806         break;
5807     }
5808   return val;
5809 }
5810
5811 /* Combine prefer_type and namespaces_only into flags.  */
5812
5813 static int
5814 lookup_flags (prefer_type, namespaces_only)
5815   int prefer_type, namespaces_only;
5816 {
5817   if (namespaces_only)
5818     return LOOKUP_PREFER_NAMESPACES;
5819   if (prefer_type > 1)
5820     return LOOKUP_PREFER_TYPES;
5821   if (prefer_type > 0)
5822     return LOOKUP_PREFER_BOTH;
5823   return 0;
5824 }
5825
5826 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5827    ignore it or not.  Subroutine of lookup_name_real.  */
5828
5829 static tree
5830 qualify_lookup (val, flags)
5831      tree val;
5832      int flags;
5833 {
5834   if (val == NULL_TREE)
5835     return val;
5836   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5837     return val;
5838   if ((flags & LOOKUP_PREFER_TYPES)
5839       && (TREE_CODE (val) == TYPE_DECL
5840           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5841               && DECL_CLASS_TEMPLATE_P (val))))
5842     return val;
5843   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5844     return NULL_TREE;
5845   return val;
5846 }
5847
5848 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5849    that.  */
5850
5851 static void
5852 warn_about_implicit_typename_lookup (typename, binding)
5853      tree typename;
5854      tree binding;
5855 {
5856   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5857   tree name = DECL_NAME (typename);
5858
5859   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5860          && CLASSTYPE_TEMPLATE_INFO (subtype)
5861          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5862       && ! (TREE_CODE (binding) == TYPE_DECL
5863             && same_type_p (TREE_TYPE (binding), subtype)))
5864     {
5865       cp_warning ("lookup of `%D' finds `%#D'",
5866                   name, binding);
5867       cp_warning ("  instead of `%D' from dependent base class",
5868                   typename);
5869       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5870                   constructor_name (current_class_type), name);
5871     }
5872 }
5873
5874 /* Look up NAME in the current binding level and its superiors in the
5875    namespace of variables, functions and typedefs.  Return a ..._DECL
5876    node of some kind representing its definition if there is only one
5877    such declaration, or return a TREE_LIST with all the overloaded
5878    definitions if there are many, or return 0 if it is undefined.
5879
5880    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5881    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5882    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5883    Otherwise we prefer non-TYPE_DECLs.
5884
5885    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5886    using IDENTIFIER_CLASS_VALUE.  */
5887
5888 static tree
5889 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5890      tree name;
5891      int prefer_type, nonclass, namespaces_only;
5892 {
5893   tree t;
5894   tree val = NULL_TREE;
5895   int yylex = 0;
5896   tree from_obj = NULL_TREE;
5897   int flags;
5898   int val_is_implicit_typename = 0;
5899
5900   /* Hack: copy flag set by parser, if set. */
5901   if (only_namespace_names)
5902     namespaces_only = 1;
5903
5904   if (prefer_type == -2)
5905     {
5906       extern int looking_for_typename;
5907       tree type = NULL_TREE;
5908
5909       yylex = 1;
5910       prefer_type = looking_for_typename;
5911
5912       flags = lookup_flags (prefer_type, namespaces_only);
5913       /* If the next thing is '<', class templates are types. */
5914       if (looking_for_template)
5915         flags |= LOOKUP_TEMPLATES_EXPECTED;
5916
5917       /* std:: becomes :: for now.  */
5918       if (got_scope && got_scope == fake_std_node)
5919         got_scope = void_type_node;
5920
5921       if (got_scope)
5922         type = got_scope;
5923       else if (got_object != error_mark_node)
5924         type = got_object;
5925
5926       if (type)
5927         {
5928           if (type == error_mark_node)
5929             return error_mark_node;
5930           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5931             type = TREE_TYPE (type);
5932
5933           if (TYPE_P (type))
5934             type = complete_type (type);
5935
5936           if (TREE_CODE (type) == VOID_TYPE)
5937             type = global_namespace;
5938           if (TREE_CODE (type) == NAMESPACE_DECL)
5939             {
5940               val = make_node (CPLUS_BINDING);
5941               flags |= LOOKUP_COMPLAIN;
5942               if (!qualified_lookup_using_namespace (name, type, val, flags))
5943                 return NULL_TREE;
5944               val = select_decl (val, flags);
5945             }
5946           else if (! IS_AGGR_TYPE (type)
5947                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5948                    || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
5949                    || TREE_CODE (type) == TYPENAME_TYPE)
5950             /* Someone else will give an error about this if needed.  */
5951             val = NULL_TREE;
5952           else if (type == current_class_type)
5953             val = IDENTIFIER_CLASS_VALUE (name);
5954           else
5955             {
5956               val = lookup_member (type, name, 0, prefer_type);
5957               type_access_control (type, val);
5958
5959               /* Restore the containing TYPENAME_TYPE if we looked
5960                  through it before.  */
5961               if (got_scope && got_scope != type
5962                   && val && TREE_CODE (val) == TYPE_DECL
5963                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
5964                 TYPE_CONTEXT (TREE_TYPE (val)) = got_scope;
5965             }
5966         }
5967       else
5968         val = NULL_TREE;
5969
5970       if (got_scope)
5971         goto done;
5972       else if (got_object && val)
5973         {
5974           from_obj = val;
5975           val = NULL_TREE;
5976         }
5977     }
5978   else
5979     {
5980       flags = lookup_flags (prefer_type, namespaces_only);
5981       /* If we're not parsing, we need to complain. */
5982       flags |= LOOKUP_COMPLAIN;
5983     }
5984
5985   /* First, look in non-namespace scopes.  */
5986
5987   if (current_class_type == NULL_TREE)
5988     nonclass = 1;
5989
5990   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5991     {
5992       tree binding;
5993
5994       if (!LOCAL_BINDING_P (t) && nonclass)
5995         /* We're not looking for class-scoped bindings, so keep going.  */
5996         continue;
5997
5998       /* If this is the kind of thing we're looking for, we're done.  */
5999       if (qualify_lookup (BINDING_VALUE (t), flags))
6000         binding = BINDING_VALUE (t);
6001       else if ((flags & LOOKUP_PREFER_TYPES)
6002                && qualify_lookup (BINDING_TYPE (t), flags))
6003         binding = BINDING_TYPE (t);
6004       else
6005         binding = NULL_TREE;
6006
6007       /* Handle access control on types from enclosing or base classes.  */
6008       if (binding && ! yylex
6009           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
6010         type_access_control (BINDING_LEVEL (t)->this_class, binding);
6011
6012       if (binding
6013           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
6014         {
6015           if (val_is_implicit_typename && !yylex)
6016             warn_about_implicit_typename_lookup (val, binding);
6017           val = binding;
6018           val_is_implicit_typename
6019             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
6020           if (!val_is_implicit_typename)
6021             break;
6022         }
6023     }
6024
6025   /* Now lookup in namespace scopes.  */
6026   if (!val || val_is_implicit_typename)
6027     {
6028       t = unqualified_namespace_lookup (name, flags, 0);
6029       if (t)
6030         {
6031           if (val_is_implicit_typename && !yylex)
6032             warn_about_implicit_typename_lookup (val, t);
6033           val = t;
6034         }
6035     }
6036
6037  done:
6038   if (val)
6039     {
6040       /* This should only warn about types used in qualified-ids.  */
6041       if (from_obj && from_obj != val)
6042         {
6043           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
6044               && TREE_CODE (val) == TYPE_DECL
6045               && ! same_type_p (TREE_TYPE (from_obj), TREE_TYPE (val)))
6046             cp_pedwarn ("\
6047 lookup of `%D' in the scope of `%#T' (`%#D') \
6048 does not match lookup in the current scope (`%#D')",
6049                         name, got_object, from_obj, val);
6050
6051           /* We don't change val to from_obj if got_object depends on
6052              template parms because that breaks implicit typename for
6053              destructor calls.  */
6054           if (! uses_template_parms (got_object))
6055             val = from_obj;
6056         }
6057
6058       /* If we have a single function from a using decl, pull it out.  */
6059       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6060         val = OVL_FUNCTION (val);
6061     }
6062   else if (from_obj)
6063     val = from_obj;
6064
6065   return val;
6066 }
6067
6068 tree
6069 lookup_name_nonclass (name)
6070      tree name;
6071 {
6072   return lookup_name_real (name, 0, 1, 0);
6073 }
6074
6075 tree
6076 lookup_function_nonclass (name, args)
6077      tree name;
6078      tree args;
6079 {
6080   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6081 }
6082
6083 tree
6084 lookup_name_namespace_only (name)
6085      tree name;
6086 {
6087   /* type-or-namespace, nonclass, namespace_only */
6088   return lookup_name_real (name, 1, 1, 1);
6089 }
6090
6091 tree
6092 lookup_name (name, prefer_type)
6093      tree name;
6094      int prefer_type;
6095 {
6096   return lookup_name_real (name, prefer_type, 0, 0);
6097 }
6098
6099 /* Similar to `lookup_name' but look only in the innermost non-class
6100    binding level.  */
6101
6102 tree
6103 lookup_name_current_level (name)
6104      tree name;
6105 {
6106   struct binding_level *b;
6107   tree t = NULL_TREE;
6108
6109   b = current_binding_level;
6110   while (b->parm_flag == 2)
6111     b = b->level_chain;
6112
6113   if (b->namespace_p)
6114     {
6115       t = IDENTIFIER_NAMESPACE_VALUE (name);
6116
6117       /* extern "C" function() */
6118       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6119         t = TREE_VALUE (t);
6120     }
6121   else if (IDENTIFIER_BINDING (name)
6122            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6123     {
6124       while (1)
6125         {
6126           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6127             return IDENTIFIER_VALUE (name);
6128
6129           if (b->keep == 2)
6130             b = b->level_chain;
6131           else
6132             break;
6133         }
6134     }
6135
6136   return t;
6137 }
6138
6139 /* Like lookup_name_current_level, but for types.  */
6140
6141 tree
6142 lookup_type_current_level (name)
6143      tree name;
6144 {
6145   register tree t = NULL_TREE;
6146
6147   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6148
6149   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6150       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6151     {
6152       struct binding_level *b = current_binding_level;
6153       while (1)
6154         {
6155           if (purpose_member (name, b->type_shadowed))
6156             return REAL_IDENTIFIER_TYPE_VALUE (name);
6157           if (b->keep == 2)
6158             b = b->level_chain;
6159           else
6160             break;
6161         }
6162     }
6163
6164   return t;
6165 }
6166
6167 void
6168 begin_only_namespace_names ()
6169 {
6170   only_namespace_names = 1;
6171 }
6172
6173 void
6174 end_only_namespace_names ()
6175 {
6176   only_namespace_names = 0;
6177 }
6178 \f
6179 /* Push the declarations of builtin types into the namespace.
6180    RID_INDEX is the index of the builtin type
6181    in the array RID_POINTERS.  NAME is the name used when looking
6182    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6183
6184 void
6185 record_builtin_type (rid_index, name, type)
6186      enum rid rid_index;
6187      const char *name;
6188      tree type;
6189 {
6190   tree rname = NULL_TREE, tname = NULL_TREE;
6191   tree tdecl = NULL_TREE;
6192
6193   if ((int) rid_index < (int) RID_MAX)
6194     rname = ridpointers[(int) rid_index];
6195   if (name)
6196     tname = get_identifier (name);
6197
6198   TYPE_BUILT_IN (type) = 1;
6199
6200   if (tname)
6201     {
6202       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6203       set_identifier_type_value (tname, NULL_TREE);
6204       if ((int) rid_index < (int) RID_MAX)
6205         /* Built-in types live in the global namespace. */
6206         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6207     }
6208   if (rname != NULL_TREE)
6209     {
6210       if (tname != NULL_TREE)
6211         {
6212           set_identifier_type_value (rname, NULL_TREE);
6213           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6214         }
6215       else
6216         {
6217           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6218           set_identifier_type_value (rname, NULL_TREE);
6219         }
6220     }
6221 }
6222
6223 /* Record one of the standard Java types.
6224  * Declare it as having the given NAME.
6225  * If SIZE > 0, it is the size of one of the integral types;
6226  * otherwise it is the negative of the size of one of the other types.  */
6227
6228 static tree
6229 record_builtin_java_type (name, size)
6230      const char *name;
6231      int size;
6232 {
6233   tree type, decl;
6234   if (size > 0)
6235     type = make_signed_type (size);
6236   else if (size > -32)
6237     { /* "__java_char" or ""__java_boolean". */
6238       type = make_unsigned_type (-size);
6239       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6240     }
6241   else
6242     { /* "__java_float" or ""__java_double". */
6243       type = make_node (REAL_TYPE);
6244       TYPE_PRECISION (type) = - size;
6245       layout_type (type);
6246     }
6247   record_builtin_type (RID_MAX, name, type);
6248   decl = TYPE_NAME (type);
6249
6250   /* Suppress generate debug symbol entries for these types,
6251      since for normal C++ they are just clutter.
6252      However, push_lang_context undoes this if extern "Java" is seen. */
6253   DECL_IGNORED_P (decl) = 1;
6254
6255   TYPE_FOR_JAVA (type) = 1;
6256   return type;
6257 }
6258
6259 /* Push a type into the namespace so that the back-ends ignore it. */
6260
6261 static void
6262 record_unknown_type (type, name)
6263      tree type;
6264      const char *name;
6265 {
6266   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6267   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6268   DECL_IGNORED_P (decl) = 1;
6269   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6270   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6271   TYPE_ALIGN (type) = 1;
6272   TYPE_USER_ALIGN (type) = 0;
6273   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6274 }
6275
6276 /* An string for which we should create an IDENTIFIER_NODE at
6277    startup.  */
6278
6279 typedef struct predefined_identifier
6280 {
6281   /* The name of the identifier.  */
6282   const char *name;
6283   /* The place where the IDENTIFIER_NODE should be stored.  */
6284   tree *node;
6285   /* Non-zero if this is the name of a constructor or destructor.  */
6286   int ctor_or_dtor_p;
6287 } predefined_identifier;
6288
6289 /* Create all the predefined identifiers.  */
6290
6291 static void
6292 initialize_predefined_identifiers ()
6293 {
6294   struct predefined_identifier *pid;
6295
6296   /* A table of identifiers to create at startup.  */
6297   static predefined_identifier predefined_identifiers[] = {
6298     { "C++", &lang_name_cplusplus, 0 },
6299     { "C", &lang_name_c, 0 },
6300     { "Java", &lang_name_java, 0 },
6301     { CTOR_NAME, &ctor_identifier, 1 },
6302     { "__base_ctor", &base_ctor_identifier, 1 },
6303     { "__comp_ctor", &complete_ctor_identifier, 1 },
6304     { DTOR_NAME, &dtor_identifier, 1 },
6305     { "__comp_dtor", &complete_dtor_identifier, 1 },
6306     { "__base_dtor", &base_dtor_identifier, 1 },
6307     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6308     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6309     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6310     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6311     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6312     { "nelts", &nelts_identifier, 0 },
6313     { THIS_NAME, &this_identifier, 0 },
6314     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6315     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6316     { "_vptr", &vptr_identifier, 0 },
6317     { "__vtt_parm", &vtt_parm_identifier, 0 },
6318     { "std", &std_identifier, 0 },
6319     { NULL, NULL, 0 }
6320   };
6321
6322   for (pid = predefined_identifiers; pid->name; ++pid)
6323     {
6324       *pid->node = get_identifier (pid->name);
6325       if (pid->ctor_or_dtor_p)
6326         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6327     }
6328 }
6329
6330 /* Create the predefined scalar types of C,
6331    and some nodes representing standard constants (0, 1, (void *)0).
6332    Initialize the global binding level.
6333    Make definitions for built-in primitive functions.  */
6334
6335 void
6336 init_decl_processing ()
6337 {
6338   tree fields[20];
6339   tree void_ftype;
6340   tree void_ftype_ptr;
6341
6342   /* Check to see that the user did not specify an invalid combination
6343      of command-line options.  */
6344   if (!flag_vtable_thunks)
6345     error ("the ABI requires vtable thunks");
6346
6347   /* Create all the identifiers we need.  */
6348   initialize_predefined_identifiers ();
6349
6350   /* Fill in back-end hooks.  */
6351   init_lang_status = &push_cp_function_context;
6352   free_lang_status = &pop_cp_function_context;
6353   mark_lang_status = &mark_cp_function_context;
6354   lang_safe_from_p = &c_safe_from_p;
6355   lang_dump_tree = &cp_dump_tree;
6356   lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
6357
6358   cp_parse_init ();
6359   init_decl2 ();
6360   init_pt ();
6361
6362   /* Create the global variables.  */
6363   push_to_top_level ();
6364
6365   /* Enter the global namespace. */
6366   my_friendly_assert (global_namespace == NULL_TREE, 375);
6367   push_namespace (get_identifier ("::"));
6368   global_namespace = current_namespace;
6369   current_lang_name = NULL_TREE;
6370
6371   /* Adjust various flags based on command-line settings.  */
6372   if (! flag_permissive && ! pedantic)
6373     flag_pedantic_errors = 1;
6374   if (!flag_no_inline)
6375     {
6376       flag_inline_trees = 1;
6377       flag_no_inline = 1;
6378     }
6379   if (flag_inline_functions)
6380     {
6381       flag_inline_trees = 2;
6382       flag_inline_functions = 0;
6383     }
6384
6385   /* In C++, we never create builtin functions whose name does not
6386      begin with `__'.  Users should be using headers to get prototypes
6387      in C++.  It would be nice if we could warn when `-fbuiltin' is
6388      used explicitly, but we do not have that information.  */
6389   flag_no_builtin = 1;
6390
6391   /* Initially, C.  */
6392   current_lang_name = lang_name_c;
6393
6394   current_function_decl = NULL_TREE;
6395   current_binding_level = NULL_BINDING_LEVEL;
6396   free_binding_level = NULL_BINDING_LEVEL;
6397
6398   build_common_tree_nodes (flag_signed_char);
6399
6400   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6401   TREE_TYPE (error_mark_list) = error_mark_node;
6402
6403   /* Make the binding_level structure for global names.  */
6404   pushlevel (0);
6405   global_binding_level = current_binding_level;
6406   /* The global level is the namespace level of ::.  */
6407   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6408   declare_namespace_level ();
6409
6410   /* Create the `std' namespace.  */
6411   if (flag_honor_std)
6412     {
6413       push_namespace (std_identifier);
6414       std_node = current_namespace;
6415       pop_namespace ();
6416       fake_std_node = error_mark_node;
6417     }
6418   else
6419     {
6420       fake_std_node = build_decl (NAMESPACE_DECL,
6421                                   std_identifier,
6422                                   void_type_node);
6423       pushdecl (fake_std_node);
6424     }
6425
6426   c_common_nodes_and_builtins ();
6427
6428   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6429   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6430   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6431   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6432   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6433   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6434   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6435   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6436
6437   integer_two_node = build_int_2 (2, 0);
6438   TREE_TYPE (integer_two_node) = integer_type_node;
6439   integer_three_node = build_int_2 (3, 0);
6440   TREE_TYPE (integer_three_node) = integer_type_node;
6441
6442   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6443   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6444   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6445   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6446   TYPE_PRECISION (boolean_type_node) = 1;
6447   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6448   boolean_false_node = build_int_2 (0, 0);
6449   TREE_TYPE (boolean_false_node) = boolean_type_node;
6450   boolean_true_node = build_int_2 (1, 0);
6451   TREE_TYPE (boolean_true_node) = boolean_type_node;
6452
6453   signed_size_zero_node = build_int_2 (0, 0);
6454   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6455
6456   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6457
6458 #if 0
6459   record_builtin_type (RID_MAX, NULL, string_type_node);
6460 #endif
6461
6462   delta_type_node = ptrdiff_type_node;
6463   vtable_index_type = ptrdiff_type_node;
6464
6465   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6466   lang_type_promotes_to = convert_type_from_ellipsis;
6467
6468   void_ftype = build_function_type (void_type_node, void_list_node);
6469   void_ftype_ptr = build_function_type (void_type_node,
6470                                         tree_cons (NULL_TREE,
6471                                                    ptr_type_node,
6472                                                    void_list_node));
6473   void_ftype_ptr
6474     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6475
6476   /* C++ extensions */
6477
6478   unknown_type_node = make_node (UNKNOWN_TYPE);
6479   record_unknown_type (unknown_type_node, "unknown type");
6480
6481   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6482   TREE_TYPE (unknown_type_node) = unknown_type_node;
6483
6484   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6485
6486   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6487      result.  */
6488   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6489   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6490
6491   if (flag_vtable_thunks)
6492     {
6493       /* Make sure we get a unique function type, so we can give
6494          its pointer type a name.  (This wins for gdb.) */
6495       tree vfunc_type = make_node (FUNCTION_TYPE);
6496       TREE_TYPE (vfunc_type) = integer_type_node;
6497       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6498       layout_type (vfunc_type);
6499
6500       vtable_entry_type = build_pointer_type (vfunc_type);
6501     }
6502   else
6503     {
6504       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6505       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6506                               delta_type_node);
6507       fields[1] = build_decl (FIELD_DECL, index_identifier,
6508                               delta_type_node);
6509       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6510                               ptr_type_node);
6511       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6512                            double_type_node);
6513
6514       /* Make this part of an invisible union.  */
6515       fields[3] = copy_node (fields[2]);
6516       TREE_TYPE (fields[3]) = delta_type_node;
6517       DECL_NAME (fields[3]) = delta2_identifier;
6518       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6519       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6520       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6521       TREE_UNSIGNED (fields[3]) = 0;
6522       TREE_CHAIN (fields[2]) = fields[3];
6523       vtable_entry_type = build_qualified_type (vtable_entry_type,
6524                                                 TYPE_QUAL_CONST);
6525     }
6526   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6527
6528   vtbl_type_node
6529     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6530   layout_type (vtbl_type_node);
6531   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6532   record_builtin_type (RID_MAX, NULL, vtbl_type_node);
6533   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6534   layout_type (vtbl_ptr_type_node);
6535   record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
6536
6537   push_namespace (get_identifier ("__cxxabiv1"));
6538   abi_node = current_namespace;
6539   pop_namespace ();
6540
6541   global_type_node = make_node (LANG_TYPE);
6542   record_unknown_type (global_type_node, "global type");
6543
6544   /* Now, C++.  */
6545   current_lang_name = lang_name_cplusplus;
6546
6547   {
6548     tree bad_alloc_type_node, newtype, deltype;
6549     tree ptr_ftype_sizetype;
6550
6551     if (flag_honor_std)
6552       push_namespace (std_identifier);
6553     bad_alloc_type_node = xref_tag
6554       (class_type_node, get_identifier ("bad_alloc"), 1);
6555     if (flag_honor_std)
6556       pop_namespace ();
6557     ptr_ftype_sizetype
6558       = build_function_type (ptr_type_node,
6559                              tree_cons (NULL_TREE,
6560                                         c_size_type_node,
6561                                         void_list_node));
6562     newtype = build_exception_variant
6563       (ptr_ftype_sizetype, add_exception_specifier
6564        (NULL_TREE, bad_alloc_type_node, -1));
6565     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6566     push_cp_library_fn (NEW_EXPR, newtype);
6567     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6568     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6569     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6570   }
6571
6572   abort_fndecl
6573     = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
6574
6575   /* Perform other language dependent initializations.  */
6576   init_class_processing ();
6577   init_init_processing ();
6578   init_search_processing ();
6579   init_rtti_processing ();
6580
6581   if (flag_exceptions)
6582     init_exception_processing ();
6583
6584   if (! supports_one_only ())
6585     flag_weak = 0;
6586
6587   make_fname_decl = cp_make_fname_decl;
6588   start_fname_decls ();
6589
6590   /* Prepare to check format strings against argument lists.  */
6591   init_function_format_info ();
6592
6593   /* Show we use EH for cleanups.  */
6594   using_eh_for_cleanups ();
6595
6596   valid_lang_attribute = cp_valid_lang_attribute;
6597
6598   /* Maintain consistency.  Perhaps we should just complain if they
6599      say -fwritable-strings?  */
6600   if (flag_writable_strings)
6601     flag_const_strings = 0;
6602
6603   /* Add GC roots for all of our global variables.  */
6604   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6605   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6606   ggc_add_tree_root (&integer_three_node, 1);
6607   ggc_add_tree_root (&integer_two_node, 1);
6608   ggc_add_tree_root (&signed_size_zero_node, 1);
6609   ggc_add_tree_root (&size_one_node, 1);
6610   ggc_add_tree_root (&size_zero_node, 1);
6611   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6612                 mark_binding_level);
6613   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6614   ggc_add_tree_root (&static_ctors, 1);
6615   ggc_add_tree_root (&static_dtors, 1);
6616   ggc_add_tree_root (&lastiddecl, 1);
6617
6618   ggc_add_tree_root (&last_function_parm_tags, 1);
6619   ggc_add_tree_root (&current_function_parm_tags, 1);
6620   ggc_add_tree_root (&last_function_parms, 1);
6621   ggc_add_tree_root (&error_mark_list, 1);
6622
6623   ggc_add_tree_root (&global_namespace, 1);
6624   ggc_add_tree_root (&global_type_node, 1);
6625   ggc_add_tree_root (&anonymous_namespace_name, 1);
6626
6627   ggc_add_tree_root (&got_object, 1);
6628   ggc_add_tree_root (&got_scope, 1);
6629
6630   ggc_add_tree_root (&current_lang_name, 1);
6631   ggc_add_tree_root (&static_aggregates, 1);
6632   ggc_add_tree_root (&free_bindings, 1);
6633 }
6634
6635 /* Generate an initializer for a function naming variable from
6636    NAME. NAME may be NULL, in which case we generate a special
6637    ERROR_MARK node which should be replaced later. */
6638
6639 tree
6640 cp_fname_init (name)
6641      const char *name;
6642 {
6643   tree domain = NULL_TREE;
6644   tree type;
6645   tree init = NULL_TREE;
6646   size_t length = 0;
6647
6648   if (name)
6649     {
6650       length = strlen (name);
6651       domain = build_index_type (size_int (length));
6652       init = build_string (length + 1, name);
6653     }
6654
6655   type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
6656   type = build_cplus_array_type (type, domain);
6657
6658   if (init)
6659     TREE_TYPE (init) = type;
6660   else
6661     /* We don't know the value until instantiation time. Make
6662        something which will be digested now, but replaced later. */
6663     init = build (ERROR_MARK, type);
6664
6665   return init;
6666 }
6667
6668 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6669    decl, NAME is the initialization string and TYPE_DEP indicates whether
6670    NAME depended on the type of the function. We make use of that to detect
6671    __PRETTY_FUNCTION__ inside a template fn. This is being done
6672    lazily at the point of first use, so we musn't push the decl now.  */
6673
6674 static tree
6675 cp_make_fname_decl (id, type_dep)
6676      tree id;
6677      int type_dep;
6678 {
6679   const char *name = (type_dep && processing_template_decl
6680                       ? NULL : fname_as_string (type_dep));
6681   tree init = cp_fname_init (name);
6682   tree decl = build_decl (VAR_DECL, id, TREE_TYPE (init));
6683
6684   /* As we don't push the decl here, we must set the context. */
6685   DECL_CONTEXT (decl) = current_function_decl;
6686   DECL_PRETTY_FUNCTION_P (decl) = type_dep;
6687
6688   TREE_STATIC (decl) = 1;
6689   TREE_READONLY (decl) = 1;
6690   DECL_ARTIFICIAL (decl) = 1;
6691   DECL_INITIAL (decl) = init;
6692
6693   TREE_USED (decl) = 1;
6694
6695   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6696
6697   return decl;
6698 }
6699
6700 /* Entry point for the benefit of c_common_nodes_and_builtins.
6701
6702    Make a definition for a builtin function named NAME and whose data type
6703    is TYPE.  TYPE should be a function type with argument types.
6704
6705    CLASS and CODE tell later passes how to compile calls to this function.
6706    See tree.h for possible values.
6707
6708    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6709    the name to be called if we can't opencode the function.  */
6710
6711 tree
6712 builtin_function (name, type, code, class, libname)
6713      const char *name;
6714      tree type;
6715      int code;
6716      enum built_in_class class;
6717      const char *libname;
6718 {
6719   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6720   DECL_BUILT_IN_CLASS (decl) = class;
6721   DECL_FUNCTION_CODE (decl) = code;
6722
6723   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6724
6725   /* All builtins that don't begin with an `_' should go in the `std'
6726      namespace.  */
6727   if (flag_honor_std && name[0] != '_')
6728     {
6729       push_namespace (std_identifier);
6730       DECL_CONTEXT (decl) = std_node;
6731     }
6732   pushdecl (decl);
6733   if (flag_honor_std && name[0] != '_')
6734     pop_namespace ();
6735
6736   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6737      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6738      function in the namespace.  */
6739   if (libname)
6740     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
6741   make_decl_rtl (decl, NULL);
6742
6743   /* Warn if a function in the namespace for users
6744      is used without an occasion to consider it declared.  */
6745   if (name[0] != '_' || name[1] != '_')
6746     DECL_ANTICIPATED (decl) = 1;
6747
6748   return decl;
6749 }
6750
6751 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6752    function.  Not called directly.  */
6753
6754 static tree
6755 build_library_fn_1 (name, operator_code, type)
6756      tree name;
6757      enum tree_code operator_code;
6758      tree type;
6759 {
6760   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6761   DECL_EXTERNAL (fn) = 1;
6762   TREE_PUBLIC (fn) = 1;
6763   DECL_ARTIFICIAL (fn) = 1;
6764   TREE_NOTHROW (fn) = 1;
6765   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6766   SET_DECL_LANGUAGE (fn, lang_c);
6767   return fn;
6768 }
6769
6770 /* Returns the _DECL for a library function with C linkage.
6771    We assume that such functions never throw; if this is incorrect,
6772    callers should unset TREE_NOTHROW.  */
6773
6774 tree
6775 build_library_fn (name, type)
6776      tree name;
6777      tree type;
6778 {
6779   return build_library_fn_1 (name, ERROR_MARK, type);
6780 }
6781
6782 /* Returns the _DECL for a library function with C++ linkage.  */
6783
6784 static tree
6785 build_cp_library_fn (name, operator_code, type)
6786      tree name;
6787      enum tree_code operator_code;
6788      tree type;
6789 {
6790   tree fn = build_library_fn_1 (name, operator_code, type);
6791   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6792   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6793   SET_DECL_LANGUAGE (fn, lang_cplusplus);
6794   set_mangled_name_for_decl (fn);
6795   return fn;
6796 }
6797
6798 /* Like build_library_fn, but takes a C string instead of an
6799    IDENTIFIER_NODE.  */
6800
6801 tree
6802 build_library_fn_ptr (name, type)
6803      const char *name;
6804      tree type;
6805 {
6806   return build_library_fn (get_identifier (name), type);
6807 }
6808
6809 /* Like build_cp_library_fn, but takes a C string instead of an
6810    IDENTIFIER_NODE.  */
6811
6812 tree
6813 build_cp_library_fn_ptr (name, type)
6814      const char *name;
6815      tree type;
6816 {
6817   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6818 }
6819
6820 /* Like build_library_fn, but also pushes the function so that we will
6821    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6822
6823 tree
6824 push_library_fn (name, type)
6825      tree name, type;
6826 {
6827   tree fn = build_library_fn (name, type);
6828   pushdecl_top_level (fn);
6829   return fn;
6830 }
6831
6832 /* Like build_cp_library_fn, but also pushes the function so that it
6833    will be found by normal lookup.  */
6834
6835 static tree
6836 push_cp_library_fn (operator_code, type)
6837      enum tree_code operator_code;
6838      tree type;
6839 {
6840   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6841                                  operator_code,
6842                                  type);
6843   pushdecl (fn);
6844   return fn;
6845 }
6846
6847 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6848    a FUNCTION_TYPE.  */
6849
6850 tree
6851 push_void_library_fn (name, parmtypes)
6852      tree name, parmtypes;
6853 {
6854   tree type = build_function_type (void_type_node, parmtypes);
6855   return push_library_fn (name, type);
6856 }
6857
6858 /* Like push_library_fn, but also note that this function throws
6859    and does not return.  Used for __throw_foo and the like.  */
6860
6861 tree
6862 push_throw_library_fn (name, type)
6863      tree name, type;
6864 {
6865   tree fn = push_library_fn (name, type);
6866   TREE_THIS_VOLATILE (fn) = 1;
6867   TREE_NOTHROW (fn) = 0;
6868   return fn;
6869 }
6870 \f
6871 /* When we call finish_struct for an anonymous union, we create
6872    default copy constructors and such.  But, an anonymous union
6873    shouldn't have such things; this function undoes the damage to the
6874    anonymous union type T.
6875
6876    (The reason that we create the synthesized methods is that we don't
6877    distinguish `union { int i; }' from `typedef union { int i; } U'.
6878    The first is an anonymous union; the second is just an ordinary
6879    union type.)  */
6880
6881 void
6882 fixup_anonymous_aggr (t)
6883      tree t;
6884 {
6885   tree *q;
6886
6887   /* Wipe out memory of synthesized methods */
6888   TYPE_HAS_CONSTRUCTOR (t) = 0;
6889   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6890   TYPE_HAS_INIT_REF (t) = 0;
6891   TYPE_HAS_CONST_INIT_REF (t) = 0;
6892   TYPE_HAS_ASSIGN_REF (t) = 0;
6893   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6894
6895   /* Splice the implicitly generated functions out of the TYPE_METHODS
6896      list.  */
6897   q = &TYPE_METHODS (t);
6898   while (*q)
6899     {
6900       if (DECL_ARTIFICIAL (*q))
6901         *q = TREE_CHAIN (*q);
6902       else
6903         q = &TREE_CHAIN (*q);
6904     }
6905
6906   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6907   if (TYPE_METHODS (t))
6908     cp_error_at ("an anonymous union cannot have function members", t);
6909
6910   /* Anonymous aggregates cannot have fields with ctors, dtors or complex
6911      assignment operators (because they cannot have these methods themselves).
6912      For anonymous unions this is already checked because they are not allowed
6913      in any union, otherwise we have to check it.  */
6914   if (TREE_CODE (t) != UNION_TYPE)
6915     {
6916       tree field, type;
6917
6918       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
6919         if (TREE_CODE (field) == FIELD_DECL)
6920           {
6921             type = TREE_TYPE (field);
6922             if (CLASS_TYPE_P (type))
6923               {
6924                 if (TYPE_NEEDS_CONSTRUCTING (type))
6925                   cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
6926                                field);
6927                 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6928                   cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
6929                                field);
6930                 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
6931                   cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
6932                                field);
6933               }
6934           }
6935     }
6936 }
6937
6938 /* Make sure that a declaration with no declarator is well-formed, i.e.
6939    just defines a tagged type or anonymous union.
6940
6941    Returns the type defined, if any.  */
6942
6943 tree
6944 check_tag_decl (declspecs)
6945      tree declspecs;
6946 {
6947   int found_type = 0;
6948   int saw_friend = 0;
6949   int saw_typedef = 0;
6950   tree ob_modifier = NULL_TREE;
6951   register tree link;
6952   register tree t = NULL_TREE;
6953
6954   for (link = declspecs; link; link = TREE_CHAIN (link))
6955     {
6956       register tree value = TREE_VALUE (link);
6957
6958       if (TYPE_P (value)
6959           || TREE_CODE (value) == TYPE_DECL
6960           || (TREE_CODE (value) == IDENTIFIER_NODE
6961               && IDENTIFIER_GLOBAL_VALUE (value)
6962               && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value)) == TYPE_DECL))
6963         {
6964           ++found_type;
6965
6966           if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
6967             {
6968               if (! in_system_header)
6969                 cp_pedwarn ("redeclaration of C++ built-in type `%T'", value);
6970               return NULL_TREE;
6971             }
6972
6973           if (TYPE_P (value)
6974               && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
6975                   || TREE_CODE (value) == ENUMERAL_TYPE))
6976             {
6977               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6978               t = value;
6979             }
6980         }
6981       else if (value == ridpointers[(int) RID_TYPEDEF])
6982         saw_typedef = 1;
6983       else if (value == ridpointers[(int) RID_FRIEND])
6984         {
6985           if (current_class_type == NULL_TREE
6986               || current_scope () != current_class_type)
6987             ob_modifier = value;
6988           else
6989             saw_friend = 1;
6990         }
6991       else if (value == ridpointers[(int) RID_STATIC]
6992                || value == ridpointers[(int) RID_EXTERN]
6993                || value == ridpointers[(int) RID_AUTO]
6994                || value == ridpointers[(int) RID_REGISTER]
6995                || value == ridpointers[(int) RID_INLINE]
6996                || value == ridpointers[(int) RID_VIRTUAL]
6997                || value == ridpointers[(int) RID_CONST]
6998                || value == ridpointers[(int) RID_VOLATILE]
6999                || value == ridpointers[(int) RID_EXPLICIT])
7000         ob_modifier = value;
7001     }
7002
7003   if (found_type > 1)
7004     error ("multiple types in one declaration");
7005
7006   if (t == NULL_TREE && ! saw_friend)
7007     pedwarn ("declaration does not declare anything");
7008
7009   /* Check for an anonymous union.  */
7010   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7011            && TYPE_ANONYMOUS_P (t))
7012     {
7013       /* 7/3 In a simple-declaration, the optional init-declarator-list
7014          can be omitted only when declaring a class (clause 9) or
7015          enumeration (7.2), that is, when the decl-specifier-seq contains
7016          either a class-specifier, an elaborated-type-specifier with
7017          a class-key (9.1), or an enum-specifier.  In these cases and
7018          whenever a class-specifier or enum-specifier is present in the
7019          decl-specifier-seq, the identifiers in these specifiers are among
7020          the names being declared by the declaration (as class-name,
7021          enum-names, or enumerators, depending on the syntax).  In such
7022          cases, and except for the declaration of an unnamed bit-field (9.6),
7023          the decl-specifier-seq shall introduce one or more names into the
7024          program, or shall redeclare a name introduced by a previous
7025          declaration.  [Example:
7026              enum { };            // ill-formed
7027              typedef class { };   // ill-formed
7028          --end example]  */
7029       if (saw_typedef)
7030         {
7031           error ("Missing type-name in typedef-declaration.");
7032           return NULL_TREE;
7033         }
7034       /* Anonymous unions are objects, so they can have specifiers.  */;
7035       SET_ANON_AGGR_TYPE_P (t);
7036
7037       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7038         pedwarn ("ISO C++ prohibits anonymous structs");
7039     }
7040
7041   else if (ob_modifier)
7042     {
7043       if (ob_modifier == ridpointers[(int) RID_INLINE]
7044           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7045         cp_error ("`%D' can only be specified for functions", ob_modifier);
7046       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7047         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7048       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7049         cp_error ("`%D' can only be specified for constructors",
7050                   ob_modifier);
7051       else
7052         cp_error ("`%D' can only be specified for objects and functions",
7053                   ob_modifier);
7054     }
7055
7056   return t;
7057 }
7058
7059 /* Called when a declaration is seen that contains no names to declare.
7060    If its type is a reference to a structure, union or enum inherited
7061    from a containing scope, shadow that tag name for the current scope
7062    with a forward reference.
7063    If its type defines a new named structure or union
7064    or defines an enum, it is valid but we need not do anything here.
7065    Otherwise, it is an error.
7066
7067    C++: may have to grok the declspecs to learn about static,
7068    complain for anonymous unions.  */
7069
7070 void
7071 shadow_tag (declspecs)
7072      tree declspecs;
7073 {
7074   tree t = check_tag_decl (declspecs);
7075
7076   if (t)
7077     maybe_process_partial_specialization (t);
7078
7079   /* This is where the variables in an anonymous union are
7080      declared.  An anonymous union declaration looks like:
7081      union { ... } ;
7082      because there is no declarator after the union, the parser
7083      sends that declaration here.  */
7084   if (t && ANON_AGGR_TYPE_P (t))
7085     {
7086       fixup_anonymous_aggr (t);
7087
7088       if (TYPE_FIELDS (t))
7089         {
7090           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7091                                       NULL_TREE);
7092           finish_anon_union (decl);
7093         }
7094     }
7095 }
7096 \f
7097 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7098
7099 tree
7100 groktypename (typename)
7101      tree typename;
7102 {
7103   if (TREE_CODE (typename) != TREE_LIST)
7104     return typename;
7105   return grokdeclarator (TREE_VALUE (typename),
7106                          TREE_PURPOSE (typename),
7107                          TYPENAME, 0, NULL_TREE);
7108 }
7109
7110 /* Decode a declarator in an ordinary declaration or data definition.
7111    This is called as soon as the type information and variable name
7112    have been parsed, before parsing the initializer if any.
7113    Here we create the ..._DECL node, fill in its type,
7114    and put it on the list of decls for the current context.
7115    The ..._DECL node is returned as the value.
7116
7117    Exception: for arrays where the length is not specified,
7118    the type is left null, to be filled in by `cp_finish_decl'.
7119
7120    Function definitions do not come here; they go to start_function
7121    instead.  However, external and forward declarations of functions
7122    do go through here.  Structure field declarations are done by
7123    grokfield and not through here.  */
7124
7125 tree
7126 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7127      tree declarator, declspecs;
7128      int initialized;
7129      tree attributes, prefix_attributes;
7130 {
7131   register tree decl;
7132   register tree type, tem;
7133   tree context;
7134   extern int have_extern_spec;
7135   extern int used_extern_spec;
7136   tree attrlist;
7137
7138 #if 0
7139   /* See code below that used this.  */
7140   int init_written = initialized;
7141 #endif
7142
7143   /* This should only be done once on the top most decl.  */
7144   if (have_extern_spec && !used_extern_spec)
7145     {
7146       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7147                              declspecs);
7148       used_extern_spec = 1;
7149     }
7150
7151   if (attributes || prefix_attributes)
7152     attrlist = build_tree_list (attributes, prefix_attributes);
7153   else
7154     attrlist = NULL_TREE;
7155
7156   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7157                          attrlist);
7158
7159   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7160     return NULL_TREE;
7161
7162   type = TREE_TYPE (decl);
7163
7164   if (type == error_mark_node)
7165     return NULL_TREE;
7166
7167   context = DECL_CONTEXT (decl);
7168
7169   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7170       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7171     {
7172       /* When parsing the initializer, lookup should use the object's
7173          namespace. */
7174       push_decl_namespace (context);
7175     }
7176
7177   /* We are only interested in class contexts, later. */
7178   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7179     context = NULL_TREE;
7180
7181   if (initialized)
7182     /* Is it valid for this decl to have an initializer at all?
7183        If not, set INITIALIZED to zero, which will indirectly
7184        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7185     switch (TREE_CODE (decl))
7186       {
7187       case TYPE_DECL:
7188         /* typedef foo = bar  means give foo the same type as bar.
7189            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7190            Any other case of an initialization in a TYPE_DECL is an error.  */
7191         if (pedantic || list_length (declspecs) > 1)
7192           {
7193             cp_error ("typedef `%D' is initialized", decl);
7194             initialized = 0;
7195           }
7196         break;
7197
7198       case FUNCTION_DECL:
7199         cp_error ("function `%#D' is initialized like a variable", decl);
7200         initialized = 0;
7201         break;
7202
7203       default:
7204         break;
7205       }
7206
7207   if (initialized)
7208     {
7209       if (! toplevel_bindings_p ()
7210           && DECL_EXTERNAL (decl))
7211         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7212                     decl);
7213       DECL_EXTERNAL (decl) = 0;
7214       if (toplevel_bindings_p ())
7215         TREE_STATIC (decl) = 1;
7216
7217       /* Tell `pushdecl' this is an initialized decl
7218          even though we don't yet have the initializer expression.
7219          Also tell `cp_finish_decl' it may store the real initializer.  */
7220       DECL_INITIAL (decl) = error_mark_node;
7221     }
7222
7223 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7224   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7225 #endif
7226
7227   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7228   cplus_decl_attributes (decl, attributes, prefix_attributes);
7229
7230   if (context && COMPLETE_TYPE_P (complete_type (context)))
7231     {
7232       push_nested_class (context, 2);
7233
7234       if (TREE_CODE (decl) == VAR_DECL)
7235         {
7236           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7237           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7238             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7239           else
7240             {
7241               if (DECL_CONTEXT (field) != context)
7242                 {
7243                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7244                               DECL_CONTEXT (field), DECL_NAME (decl),
7245                               context, DECL_NAME (decl));
7246                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7247                 }
7248               /* Static data member are tricky; an in-class initialization
7249                  still doesn't provide a definition, so the in-class
7250                  declaration will have DECL_EXTERNAL set, but will have an
7251                  initialization.  Thus, duplicate_decls won't warn
7252                  about this situation, and so we check here.  */
7253               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7254                 cp_error ("duplicate initialization of %D", decl);
7255               if (duplicate_decls (decl, field))
7256                 decl = field;
7257             }
7258         }
7259       else
7260         {
7261           tree field = check_classfn (context, decl);
7262           if (field && duplicate_decls (decl, field))
7263             decl = field;
7264         }
7265
7266       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7267       DECL_IN_AGGR_P (decl) = 0;
7268       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7269           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7270         {
7271           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7272           /* [temp.expl.spec] An explicit specialization of a static data
7273              member of a template is a definition if the declaration
7274              includes an initializer; otherwise, it is a declaration.
7275
7276              We check for processing_specialization so this only applies
7277              to the new specialization syntax.  */
7278           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7279             DECL_EXTERNAL (decl) = 1;
7280         }
7281
7282       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7283         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7284                     decl);
7285     }
7286
7287   /* Enter this declaration into the symbol table.  */
7288   tem = maybe_push_decl (decl);
7289
7290   if (processing_template_decl)
7291     tem = push_template_decl (tem);
7292
7293 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7294   /* Tell the back-end to use or not use .common as appropriate.  If we say
7295      -fconserve-space, we want this to save .data space, at the expense of
7296      wrong semantics.  If we say -fno-conserve-space, we want this to
7297      produce errors about redefs; to do this we force variables into the
7298      data segment.  */
7299   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7300 #endif
7301
7302   if (! processing_template_decl)
7303     start_decl_1 (tem);
7304
7305   return tem;
7306 }
7307
7308 void
7309 start_decl_1 (decl)
7310      tree decl;
7311 {
7312   tree type = TREE_TYPE (decl);
7313   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7314
7315   if (type == error_mark_node)
7316     return;
7317
7318   maybe_push_cleanup_level (type);
7319
7320   if (initialized)
7321     /* Is it valid for this decl to have an initializer at all?
7322        If not, set INITIALIZED to zero, which will indirectly
7323        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7324     {
7325       /* Don't allow initializations for incomplete types except for
7326          arrays which might be completed by the initialization.  */
7327       if (COMPLETE_TYPE_P (complete_type (type)))
7328         ;                       /* A complete type is ok.  */
7329       else if (TREE_CODE (type) != ARRAY_TYPE)
7330         {
7331           cp_error ("variable `%#D' has initializer but incomplete type",
7332                     decl);
7333           initialized = 0;
7334           type = TREE_TYPE (decl) = error_mark_node;
7335         }
7336       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7337         {
7338           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7339             cp_error ("elements of array `%#D' have incomplete type", decl);
7340           /* else we already gave an error in start_decl.  */
7341           initialized = 0;
7342         }
7343     }
7344
7345   if (!initialized
7346       && TREE_CODE (decl) != TYPE_DECL
7347       && TREE_CODE (decl) != TEMPLATE_DECL
7348       && type != error_mark_node
7349       && IS_AGGR_TYPE (type)
7350       && ! DECL_EXTERNAL (decl))
7351     {
7352       if ((! processing_template_decl || ! uses_template_parms (type))
7353           && !COMPLETE_TYPE_P (complete_type (type)))
7354         {
7355           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7356                  decl);
7357           /* Change the type so that assemble_variable will give
7358              DECL an rtl we can live with: (mem (const_int 0)).  */
7359           type = TREE_TYPE (decl) = error_mark_node;
7360         }
7361       else
7362         {
7363           /* If any base type in the hierarchy of TYPE needs a constructor,
7364              then we set initialized to 1.  This way any nodes which are
7365              created for the purposes of initializing this aggregate
7366              will live as long as it does.  This is necessary for global
7367              aggregates which do not have their initializers processed until
7368              the end of the file.  */
7369           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7370         }
7371     }
7372
7373   if (! initialized)
7374     DECL_INITIAL (decl) = NULL_TREE;
7375 }
7376
7377 /* Handle initialization of references.
7378    These three arguments are from `cp_finish_decl', and have the
7379    same meaning here that they do there.
7380
7381    Quotes on semantics can be found in ARM 8.4.3.  */
7382
7383 static tree
7384 grok_reference_init (decl, type, init)
7385      tree decl, type, init;
7386 {
7387   tree tmp;
7388
7389   if (init == NULL_TREE)
7390     {
7391       if ((DECL_LANG_SPECIFIC (decl) == 0
7392            || DECL_IN_AGGR_P (decl) == 0)
7393           && ! DECL_THIS_EXTERN (decl))
7394         cp_error ("`%D' declared as reference but not initialized", decl);
7395       return NULL_TREE;
7396     }
7397
7398   if (init == error_mark_node)
7399     return NULL_TREE;
7400
7401   if (TREE_CODE (init) == CONSTRUCTOR)
7402     {
7403       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7404       return NULL_TREE;
7405     }
7406
7407   if (TREE_CODE (init) == TREE_LIST)
7408     init = build_compound_expr (init);
7409
7410   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7411     init = convert_from_reference (init);
7412
7413   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7414       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7415     {
7416       /* Note: default conversion is only called in very special cases.  */
7417       init = default_conversion (init);
7418     }
7419
7420   /* Convert INIT to the reference type TYPE.  This may involve the
7421      creation of a temporary, whose lifetime must be the same as that
7422      of the reference.  If so, a DECL_STMT for the temporary will be
7423      added just after the DECL_STMT for DECL.  That's why we don't set
7424      DECL_INITIAL for local references (instead assigning to them
7425      explicitly); we need to allow the temporary to be initialized
7426      first.  */
7427   tmp = convert_to_reference
7428     (type, init, CONV_IMPLICIT,
7429      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7430      decl);
7431
7432   if (tmp == error_mark_node)
7433     return NULL_TREE;
7434   else if (tmp == NULL_TREE)
7435     {
7436       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7437       return NULL_TREE;
7438     }
7439
7440   if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
7441     return tmp;
7442
7443   if (building_stmt_tree ())
7444     {
7445       /* Initialize the declaration.  */
7446       tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7447       finish_expr_stmt (tmp);
7448     }
7449   else
7450     DECL_INITIAL (decl) = tmp;
7451
7452   return NULL_TREE;
7453 }
7454
7455 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7456    mucking with forces it does not comprehend (i.e. initialization with a
7457    constructor).  If we are at global scope and won't go into COMMON, fill
7458    it in with a dummy CONSTRUCTOR to force the variable into .data;
7459    otherwise we can use error_mark_node.  */
7460
7461 static tree
7462 obscure_complex_init (decl, init)
7463      tree decl, init;
7464 {
7465   if (! flag_no_inline && TREE_STATIC (decl))
7466     {
7467       if (extract_init (decl, init))
7468         return NULL_TREE;
7469     }
7470
7471 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7472   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7473     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7474                                  NULL_TREE);
7475   else
7476 #endif
7477     DECL_INITIAL (decl) = error_mark_node;
7478
7479   return init;
7480 }
7481
7482 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7483    array until we finish parsing the initializer.  If that's the
7484    situation we're in, update DECL accordingly.  */
7485
7486 static void
7487 maybe_deduce_size_from_array_init (decl, init)
7488      tree decl;
7489      tree init;
7490 {
7491   tree type = TREE_TYPE (decl);
7492
7493   if (TREE_CODE (type) == ARRAY_TYPE
7494       && TYPE_DOMAIN (type) == NULL_TREE
7495       && TREE_CODE (decl) != TYPE_DECL)
7496     {
7497       /* do_default is really a C-ism to deal with tentative definitions.
7498          But let's leave it here to ease the eventual merge.  */
7499       int do_default = !DECL_EXTERNAL (decl);
7500       tree initializer = init ? init : DECL_INITIAL (decl);
7501       int failure = complete_array_type (type, initializer, do_default);
7502
7503       if (failure == 1)
7504         cp_error ("initializer fails to determine size of `%D'", decl);
7505
7506       if (failure == 2)
7507         {
7508           if (do_default)
7509             cp_error ("array size missing in `%D'", decl);
7510           /* If a `static' var's size isn't known, make it extern as
7511              well as static, so it does not get allocated.  If it's not
7512              `static', then don't mark it extern; finish_incomplete_decl
7513              will give it a default size and it will get allocated.  */
7514           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7515             DECL_EXTERNAL (decl) = 1;
7516         }
7517
7518       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7519           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7520                               integer_zero_node))
7521         cp_error ("zero-size array `%D'", decl);
7522
7523       layout_decl (decl, 0);
7524     }
7525 }
7526
7527 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7528    any appropriate error messages regarding the layout.  */
7529
7530 static void
7531 layout_var_decl (decl)
7532      tree decl;
7533 {
7534   tree type = TREE_TYPE (decl);
7535 #if 0
7536   tree ttype = target_type (type);
7537 #endif
7538
7539   /* If we haven't already layed out this declaration, do so now.
7540      Note that we must not call complete type for an external object
7541      because it's type might involve templates that we are not
7542      supposed to isntantiate yet.  (And it's perfectly legal to say
7543      `extern X x' for some incomplete type `X'.)  */
7544   if (!DECL_EXTERNAL (decl))
7545     complete_type (type);
7546   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7547     layout_decl (decl, 0);
7548
7549   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7550     {
7551       /* An automatic variable with an incomplete type: that is an error.
7552          Don't talk about array types here, since we took care of that
7553          message in grokdeclarator.  */
7554       cp_error ("storage size of `%D' isn't known", decl);
7555       TREE_TYPE (decl) = error_mark_node;
7556     }
7557 #if 0
7558   /* Keep this code around in case we later want to control debug info
7559      based on whether a type is "used".  (jason 1999-11-11) */
7560
7561   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7562     /* Let debugger know it should output info for this type.  */
7563     note_debug_info_needed (ttype);
7564
7565   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7566     note_debug_info_needed (DECL_CONTEXT (decl));
7567 #endif
7568
7569   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7570       && DECL_SIZE (decl) != NULL_TREE
7571       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7572     {
7573       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7574         constant_expression_warning (DECL_SIZE (decl));
7575       else
7576         cp_error ("storage size of `%D' isn't constant", decl);
7577     }
7578
7579   if (TREE_STATIC (decl)
7580       && !DECL_ARTIFICIAL (decl)
7581       && current_function_decl
7582       && DECL_CONTEXT (decl) == current_function_decl)
7583     push_local_name (decl);
7584 }
7585
7586 /* If a local static variable is declared in an inline function, or if
7587    we have a weak definition, we must endeavor to create only one
7588    instance of the variable at link-time.  */
7589
7590 static void
7591 maybe_commonize_var (decl)
7592      tree decl;
7593 {
7594   /* Static data in a function with comdat linkage also has comdat
7595      linkage.  */
7596   if (TREE_STATIC (decl)
7597       /* Don't mess with __FUNCTION__.  */
7598       && ! DECL_ARTIFICIAL (decl)
7599       && current_function_decl
7600       && DECL_CONTEXT (decl) == current_function_decl
7601       && (DECL_DECLARED_INLINE_P (current_function_decl)
7602           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7603       && TREE_PUBLIC (current_function_decl))
7604     {
7605       /* If flag_weak, we don't need to mess with this, as we can just
7606          make the function weak, and let it refer to its unique local
7607          copy.  This works because we don't allow the function to be
7608          inlined.  */
7609       if (! flag_weak)
7610         {
7611           if (DECL_INTERFACE_KNOWN (current_function_decl))
7612             {
7613               TREE_PUBLIC (decl) = 1;
7614               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7615             }
7616           else if (DECL_INITIAL (decl) == NULL_TREE
7617                    || DECL_INITIAL (decl) == error_mark_node)
7618             {
7619               TREE_PUBLIC (decl) = 1;
7620               DECL_COMMON (decl) = 1;
7621             }
7622           /* else we lose. We can only do this if we can use common,
7623              which we can't if it has been initialized.  */
7624
7625           if (!TREE_PUBLIC (decl))
7626             {
7627               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7628               cp_warning_at ("  you can work around this by removing the initializer", decl);
7629             }
7630         }
7631       else
7632         comdat_linkage (decl);
7633     }
7634   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7635     /* Set it up again; we might have set DECL_INITIAL since the last
7636        time.  */
7637     comdat_linkage (decl);
7638 }
7639
7640 /* Issue an error message if DECL is an uninitialized const variable.  */
7641
7642 static void
7643 check_for_uninitialized_const_var (decl)
7644      tree decl;
7645 {
7646   tree type = TREE_TYPE (decl);
7647
7648   /* ``Unless explicitly declared extern, a const object does not have
7649      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7650      7.1.6 */
7651   if (TREE_CODE (decl) == VAR_DECL
7652       && TREE_CODE (type) != REFERENCE_TYPE
7653       && CP_TYPE_CONST_P (type)
7654       && !TYPE_NEEDS_CONSTRUCTING (type)
7655       && !DECL_INITIAL (decl))
7656     cp_error ("uninitialized const `%D'", decl);
7657 }
7658
7659 /* Verify INIT (the initializer for DECL), and record the
7660    initialization in DECL_INITIAL, if appropriate.  Returns a new
7661    value for INIT.  */
7662
7663 static tree
7664 check_initializer (decl, init)
7665      tree decl;
7666      tree init;
7667 {
7668   tree type;
7669
7670   if (TREE_CODE (decl) == FIELD_DECL)
7671     return init;
7672
7673   type = TREE_TYPE (decl);
7674
7675   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7676   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7677     init = NULL_TREE;
7678
7679   /* Check the initializer.  */
7680   if (init)
7681     {
7682       /* Things that are going to be initialized need to have complete
7683          type.  */
7684       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7685
7686       if (type == error_mark_node)
7687         /* We will have already complained.  */
7688         init = NULL_TREE;
7689       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7690         {
7691           cp_error ("variable-sized object `%D' may not be initialized", decl);
7692           init = NULL_TREE;
7693         }
7694       else if (TREE_CODE (type) == ARRAY_TYPE
7695                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7696         {
7697           cp_error ("elements of array `%#D' have incomplete type", decl);
7698           init = NULL_TREE;
7699         }
7700       else if (!COMPLETE_TYPE_P (type))
7701         {
7702           cp_error ("`%D' has incomplete type", decl);
7703           TREE_TYPE (decl) = error_mark_node;
7704           init = NULL_TREE;
7705         }
7706     }
7707
7708   if (TREE_CODE (decl) == CONST_DECL)
7709     {
7710       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7711
7712       DECL_INITIAL (decl) = init;
7713
7714       my_friendly_assert (init != NULL_TREE, 149);
7715       init = NULL_TREE;
7716     }
7717   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7718     {
7719       init = grok_reference_init (decl, type, init);
7720       if (init)
7721         init = obscure_complex_init (decl, init);
7722     }
7723   else if (init)
7724     {
7725       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7726         {
7727           if (TREE_CODE (type) == ARRAY_TYPE)
7728             init = digest_init (type, init, (tree *) 0);
7729           else if (TREE_CODE (init) == CONSTRUCTOR
7730                    && TREE_HAS_CONSTRUCTOR (init))
7731             {
7732               if (TYPE_NON_AGGREGATE_CLASS (type))
7733                 {
7734                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7735                             decl);
7736                   init = error_mark_node;
7737                 }
7738               else
7739                 goto dont_use_constructor;
7740             }
7741         }
7742       else
7743         {
7744         dont_use_constructor:
7745           if (TREE_CODE (init) != TREE_VEC)
7746             init = store_init_value (decl, init);
7747         }
7748
7749       if (init)
7750         /* We must hide the initializer so that expand_decl
7751            won't try to do something it does not understand.  */
7752         init = obscure_complex_init (decl, init);
7753     }
7754   else if (DECL_EXTERNAL (decl))
7755     ;
7756   else if (TYPE_P (type)
7757            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7758     {
7759       tree core_type = strip_array_types (type);
7760
7761       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7762         {
7763           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7764             cp_error ("structure `%D' with uninitialized const members", decl);
7765           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7766             cp_error ("structure `%D' with uninitialized reference members",
7767                       decl);
7768         }
7769
7770       check_for_uninitialized_const_var (decl);
7771
7772       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7773         init = obscure_complex_init (decl, NULL_TREE);
7774
7775     }
7776   else
7777     check_for_uninitialized_const_var (decl);
7778
7779   return init;
7780 }
7781
7782 /* If DECL is not a local variable, give it RTL.  */
7783
7784 static void
7785 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7786      tree decl;
7787      tree init;
7788      const char *asmspec;
7789 {
7790   int toplev = toplevel_bindings_p ();
7791   int defer_p;
7792
7793   /* Handle non-variables up front.  */
7794   if (TREE_CODE (decl) != VAR_DECL)
7795     {
7796       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7797       return;
7798     }
7799
7800   /* If we see a class member here, it should be a static data
7801      member.  */
7802   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7803     {
7804       my_friendly_assert (TREE_STATIC (decl), 19990828);
7805       /* An in-class declaration of a static data member should be
7806          external; it is only a declaration, and not a definition.  */
7807       if (init == NULL_TREE)
7808         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7809     }
7810
7811   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7812   if (asmspec)
7813     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
7814
7815   /* We don't create any RTL for local variables.  */
7816   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7817     return;
7818
7819   /* We defer emission of local statics until the corresponding
7820      DECL_STMT is expanded.  */
7821   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7822
7823   /* We try to defer namespace-scope static constants so that they are
7824      not emitted into the object file unncessarily.  */
7825   if (!DECL_VIRTUAL_P (decl)
7826       && TREE_READONLY (decl)
7827       && DECL_INITIAL (decl) != NULL_TREE
7828       && DECL_INITIAL (decl) != error_mark_node
7829       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7830       && toplev
7831       && !TREE_PUBLIC (decl))
7832     {
7833       /* Fool with the linkage according to #pragma interface.  */
7834       if (!interface_unknown)
7835         {
7836           TREE_PUBLIC (decl) = 1;
7837           DECL_EXTERNAL (decl) = interface_only;
7838         }
7839
7840       defer_p = 1;
7841     }
7842
7843   /* If we're deferring the variable, we only need to make RTL if
7844      there's an ASMSPEC.  Otherwise, we'll lazily create it later when
7845      we need it.  (There's no way to lazily create RTL for things that
7846      have assembly specs because the information about the specifier
7847      isn't stored in the tree, yet)  */
7848   if (defer_p && asmspec)
7849     make_decl_rtl (decl, asmspec);
7850   /* If we're not deferring, go ahead and assemble the variable.  */
7851   else if (!defer_p)
7852     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7853 }
7854
7855 /* The old ARM scoping rules injected variables declared in the
7856    initialization statement of a for-statement into the surrounding
7857    scope.  We support this usage, in order to be backward-compatible.
7858    DECL is a just-declared VAR_DECL; if necessary inject its
7859    declaration into the surrounding scope.  */
7860
7861 void
7862 maybe_inject_for_scope_var (decl)
7863      tree decl;
7864 {
7865   if (!DECL_NAME (decl))
7866     return;
7867
7868   if (current_binding_level->is_for_scope)
7869     {
7870       struct binding_level *outer
7871         = current_binding_level->level_chain;
7872
7873       /* Check to see if the same name is already bound at the outer
7874          level, either because it was directly declared, or because a
7875          dead for-decl got preserved.  In either case, the code would
7876          not have been valid under the ARM scope rules, so clear
7877          is_for_scope for the current_binding_level.
7878
7879          Otherwise, we need to preserve the temp slot for decl to last
7880          into the outer binding level.  */
7881
7882       tree outer_binding
7883         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7884
7885       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7886           && (TREE_CODE (BINDING_VALUE (outer_binding))
7887               == VAR_DECL)
7888           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7889         {
7890           BINDING_VALUE (outer_binding)
7891             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7892           current_binding_level->is_for_scope = 0;
7893         }
7894       else if (DECL_IN_MEMORY_P (decl))
7895         preserve_temp_slots (DECL_RTL (decl));
7896     }
7897 }
7898
7899 /* Generate code to initialize DECL (a local variable).  */
7900
7901 void
7902 initialize_local_var (decl, init, flags)
7903      tree decl;
7904      tree init;
7905      int flags;
7906 {
7907   tree type = TREE_TYPE (decl);
7908
7909   /* If the type is bogus, don't bother initializing the variable.  */
7910   if (type == error_mark_node)
7911     return;
7912
7913   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7914     {
7915       /* If we used it already as memory, it must stay in memory.  */
7916       DECL_INITIAL (decl) = NULL_TREE;
7917       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7918     }
7919
7920   /* Local statics are handled differently from ordinary automatic
7921      variables.  */
7922   if (TREE_STATIC (decl))
7923     {
7924       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7925           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7926         expand_static_init (decl, init);
7927       return;
7928     }
7929
7930   if (DECL_SIZE (decl) && type != error_mark_node)
7931     {
7932       int already_used;
7933
7934       /* Compute and store the initial value.  */
7935       already_used = TREE_USED (decl) || TREE_USED (type);
7936
7937       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7938         {
7939           int saved_stmts_are_full_exprs_p;
7940
7941           my_friendly_assert (building_stmt_tree (), 20000906);
7942           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7943           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
7944           finish_expr_stmt (build_aggr_init (decl, init, flags));
7945           current_stmt_tree ()->stmts_are_full_exprs_p =
7946             saved_stmts_are_full_exprs_p;
7947         }
7948
7949       /* Set this to 0 so we can tell whether an aggregate which was
7950          initialized was ever used.  Don't do this if it has a
7951          destructor, so we don't complain about the 'resource
7952          allocation is initialization' idiom.  Now set
7953          attribute((unused)) on types so decls of that type will be
7954          marked used. (see TREE_USED, above.)  */
7955       if (TYPE_NEEDS_CONSTRUCTING (type)
7956           && ! already_used
7957           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7958           && DECL_NAME (decl))
7959         TREE_USED (decl) = 0;
7960       else if (already_used)
7961         TREE_USED (decl) = 1;
7962     }
7963 }
7964
7965 /* Generate code to destroy DECL (a local variable).  */
7966
7967 static void
7968 destroy_local_var (decl)
7969      tree decl;
7970 {
7971   tree type = TREE_TYPE (decl);
7972   tree cleanup;
7973
7974   /* Only variables get cleaned up.  */
7975   if (TREE_CODE (decl) != VAR_DECL)
7976     return;
7977
7978   /* And only things with destructors need cleaning up.  */
7979   if (type == error_mark_node
7980       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7981     return;
7982
7983   if (TREE_CODE (decl) == VAR_DECL &&
7984       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7985     /* We don't clean up things that aren't defined in this
7986        translation unit, or that need a static cleanup.  The latter
7987        are handled by finish_file.  */
7988     return;
7989
7990   /* Compute the cleanup.  */
7991   cleanup = maybe_build_cleanup (decl);
7992
7993   /* Record the cleanup required for this declaration.  */
7994   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7995       && cleanup)
7996     finish_decl_cleanup (decl, cleanup);
7997 }
7998
7999 /* Finish processing of a declaration;
8000    install its line number and initial value.
8001    If the length of an array type is not known before,
8002    it must be determined now, from the initial value, or it is an error.
8003
8004    INIT holds the value of an initializer that should be allowed to escape
8005    the normal rules.
8006
8007    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8008    if the (init) syntax was used.  */
8009
8010 void
8011 cp_finish_decl (decl, init, asmspec_tree, flags)
8012      tree decl, init;
8013      tree asmspec_tree;
8014      int flags;
8015 {
8016   register tree type;
8017   tree ttype = NULL_TREE;
8018   const char *asmspec = NULL;
8019   int was_readonly = 0;
8020
8021   if (! decl)
8022     {
8023       if (init)
8024         error ("assignment (not initialization) in declaration");
8025       return;
8026     }
8027
8028   /* If a name was specified, get the string.  */
8029   if (asmspec_tree)
8030       asmspec = TREE_STRING_POINTER (asmspec_tree);
8031
8032   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8033     {
8034       cp_error ("cannot initialize `%D' to namespace `%D'",
8035                 decl, init);
8036       init = NULL_TREE;
8037     }
8038
8039   if (current_class_type
8040       && CP_DECL_CONTEXT (decl) == current_class_type
8041       && TYPE_BEING_DEFINED (current_class_type)
8042       && (DECL_INITIAL (decl) || init))
8043     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
8044
8045   if (TREE_CODE (decl) == VAR_DECL
8046       && DECL_CONTEXT (decl)
8047       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8048       && DECL_CONTEXT (decl) != current_namespace
8049       && init)
8050     {
8051       /* Leave the namespace of the object. */
8052       pop_decl_namespace ();
8053     }
8054
8055   type = TREE_TYPE (decl);
8056
8057   if (type == error_mark_node)
8058     return;
8059
8060   /* Add this declaration to the statement-tree.  */
8061   if (building_stmt_tree ()
8062       && at_function_scope_p ()
8063       && TREE_CODE (decl) != RESULT_DECL)
8064     add_decl_stmt (decl);
8065
8066   if (TYPE_HAS_MUTABLE_P (type))
8067     TREE_READONLY (decl) = 0;
8068
8069   if (processing_template_decl)
8070     {
8071       if (init && DECL_INITIAL (decl))
8072         DECL_INITIAL (decl) = init;
8073       goto finish_end0;
8074     }
8075
8076   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8077   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8078
8079   /* Take care of TYPE_DECLs up front.  */
8080   if (TREE_CODE (decl) == TYPE_DECL)
8081     {
8082       if (init && DECL_INITIAL (decl))
8083         {
8084           /* typedef foo = bar; store the type of bar as the type of foo.  */
8085           TREE_TYPE (decl) = type = TREE_TYPE (init);
8086           DECL_INITIAL (decl) = init = NULL_TREE;
8087         }
8088       if (type != error_mark_node
8089           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8090         {
8091           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8092             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8093           set_identifier_type_value (DECL_NAME (decl), type);
8094           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8095         }
8096       GNU_xref_decl (current_function_decl, decl);
8097
8098       /* If we have installed this as the canonical typedef for this
8099          type, and that type has not been defined yet, delay emitting
8100          the debug information for it, as we will emit it later.  */
8101       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8102           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8103         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8104
8105       rest_of_decl_compilation (decl, NULL,
8106                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8107       goto finish_end;
8108     }
8109
8110   if (TREE_CODE (decl) != FUNCTION_DECL)
8111     ttype = target_type (type);
8112
8113   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8114       && TYPE_NEEDS_CONSTRUCTING (type))
8115     {
8116       /* Currently, GNU C++ puts constants in text space, making them
8117          impossible to initialize.  In the future, one would hope for
8118          an operating system which understood the difference between
8119          initialization and the running of a program.  */
8120       was_readonly = 1;
8121       TREE_READONLY (decl) = 0;
8122     }
8123
8124   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8125     {
8126       /* This must override the asm specifier which was placed by
8127          grokclassfn.  Lay this out fresh.  */
8128       SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
8129       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8130       make_decl_rtl (decl, asmspec);
8131     }
8132
8133   /* Deduce size of array from initialization, if not already known.  */
8134   maybe_deduce_size_from_array_init (decl, init);
8135   init = check_initializer (decl, init);
8136
8137   GNU_xref_decl (current_function_decl, decl);
8138
8139   if (TREE_CODE (decl) == VAR_DECL)
8140     layout_var_decl (decl);
8141
8142   /* Output the assembler code and/or RTL code for variables and functions,
8143      unless the type is an undefined structure or union.
8144      If not, it will get done when the type is completed.  */
8145   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8146       || TREE_CODE (decl) == RESULT_DECL)
8147     {
8148       if (TREE_CODE (decl) == VAR_DECL)
8149         maybe_commonize_var (decl);
8150
8151       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8152
8153       if (TREE_CODE (type) == FUNCTION_TYPE
8154           || TREE_CODE (type) == METHOD_TYPE)
8155         abstract_virtuals_error (decl,
8156                                  strip_array_types (TREE_TYPE (type)));
8157       else
8158         abstract_virtuals_error (decl, strip_array_types (type));
8159
8160       if (TREE_CODE (decl) == FUNCTION_DECL)
8161         ;
8162       else if (DECL_EXTERNAL (decl)
8163                && ! (DECL_LANG_SPECIFIC (decl)
8164                      && DECL_NOT_REALLY_EXTERN (decl)))
8165         {
8166           if (init)
8167             DECL_INITIAL (decl) = init;
8168         }
8169       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8170         {
8171           /* This is a local declaration.  */
8172           if (doing_semantic_analysis_p ())
8173             maybe_inject_for_scope_var (decl);
8174           /* Initialize the local variable.  But, if we're building a
8175              statement-tree, we'll do the initialization when we
8176              expand the tree.  */
8177           if (processing_template_decl)
8178             {
8179               if (init || DECL_INITIAL (decl) == error_mark_node)
8180                 DECL_INITIAL (decl) = init;
8181             }
8182           else
8183             {
8184               /* If we're not building RTL, then we need to do so
8185                  now.  */
8186               my_friendly_assert (building_stmt_tree (), 20000906);
8187               /* Initialize the variable.  */
8188               initialize_local_var (decl, init, flags);
8189               /* Clean up the variable.  */
8190               destroy_local_var (decl);
8191             }
8192         }
8193       else if (TREE_STATIC (decl) && type != error_mark_node)
8194         {
8195           /* Cleanups for static variables are handled by `finish_file'.  */
8196           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8197               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8198             expand_static_init (decl, init);
8199         }
8200     finish_end0:
8201
8202       /* Undo call to `pushclass' that was done in `start_decl'
8203          due to initialization of qualified member variable.
8204          I.e., Foo::x = 10;  */
8205       {
8206         tree context = CP_DECL_CONTEXT (decl);
8207         if (context
8208             && TYPE_P (context)
8209             && (TREE_CODE (decl) == VAR_DECL
8210                 /* We also have a pushclass done that we need to undo here
8211                    if we're at top level and declare a method.  */
8212                 || TREE_CODE (decl) == FUNCTION_DECL)
8213             /* If size hasn't been set, we're still defining it,
8214                and therefore inside the class body; don't pop
8215                the binding level..  */
8216             && COMPLETE_TYPE_P (context)
8217             && context == current_class_type)
8218           pop_nested_class ();
8219       }
8220     }
8221
8222  finish_end:
8223
8224   if (was_readonly)
8225     TREE_READONLY (decl) = 1;
8226 }
8227
8228 /* This is here for a midend callback from c-common.c */
8229
8230 void
8231 finish_decl (decl, init, asmspec_tree)
8232      tree decl, init;
8233      tree asmspec_tree;
8234 {
8235   cp_finish_decl (decl, init, asmspec_tree, 0);
8236 }
8237
8238 /* Returns a declaration for a VAR_DECL as if:
8239
8240      extern "C" TYPE NAME;
8241
8242    had been seen.  Used to create compiler-generated global
8243    variables.  */
8244
8245 tree
8246 declare_global_var (name, type)
8247      tree name;
8248      tree type;
8249 {
8250   tree decl;
8251
8252   push_to_top_level ();
8253   decl = build_decl (VAR_DECL, name, type);
8254   TREE_PUBLIC (decl) = 1;
8255   DECL_EXTERNAL (decl) = 1;
8256   DECL_ARTIFICIAL (decl) = 1;
8257   pushdecl (decl);
8258   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8259   pop_from_top_level ();
8260
8261   return decl;
8262 }
8263
8264 /* Returns a pointer to the `atexit' function.  Note that if
8265    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8266    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8267
8268 static tree
8269 get_atexit_node ()
8270 {
8271   tree atexit_fndecl;
8272   tree arg_types;
8273   tree fn_type;
8274   tree fn_ptr_type;
8275   const char *name;
8276
8277   if (atexit_node)
8278     return atexit_node;
8279
8280   if (flag_use_cxa_atexit)
8281     {
8282       /* The declaration for `__cxa_atexit' is:
8283
8284            int __cxa_atexit (void (*)(void *), void *, void *)
8285
8286          We build up the argument types and then then function type
8287          itself.  */
8288
8289       /* First, build the pointer-to-function type for the first
8290          argument.  */
8291       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8292       fn_type = build_function_type (void_type_node, arg_types);
8293       fn_ptr_type = build_pointer_type (fn_type);
8294       /* Then, build the rest of the argument types.  */
8295       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8296       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8297       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8298       /* And the final __cxa_atexit type.  */
8299       fn_type = build_function_type (integer_type_node, arg_types);
8300       fn_ptr_type = build_pointer_type (fn_type);
8301       name = "__cxa_atexit";
8302     }
8303   else
8304     {
8305       /* The declaration for `atexit' is:
8306
8307            int atexit (void (*)());
8308
8309          We build up the argument types and then then function type
8310          itself.  */
8311       fn_type = build_function_type (void_type_node, void_list_node);
8312       fn_ptr_type = build_pointer_type (fn_type);
8313       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8314       /* Build the final atexit type.  */
8315       fn_type = build_function_type (integer_type_node, arg_types);
8316       name = "atexit";
8317     }
8318
8319   /* Now, build the function declaration.  */
8320   push_lang_context (lang_name_c);
8321   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8322   mark_used (atexit_fndecl);
8323   pop_lang_context ();
8324   atexit_node = default_conversion (atexit_fndecl);
8325
8326   return atexit_node;
8327 }
8328
8329 /* Returns the __dso_handle VAR_DECL.  */
8330
8331 static tree
8332 get_dso_handle_node ()
8333 {
8334   if (dso_handle_node)
8335     return dso_handle_node;
8336
8337   /* Declare the variable.  */
8338   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8339                                         ptr_type_node);
8340
8341   return dso_handle_node;
8342 }
8343
8344 /* Begin a new function with internal linkage whose job will be simply
8345    to destroy some particular variable.  */
8346
8347 static tree
8348 start_cleanup_fn ()
8349 {
8350   static int counter = 0;
8351   int old_interface_unknown = interface_unknown;
8352   char name[32];
8353   tree parmtypes;
8354   tree fntype;
8355   tree fndecl;
8356
8357   push_to_top_level ();
8358
8359   /* No need to mangle this.  */
8360   push_lang_context (lang_name_c);
8361
8362   interface_unknown = 1;
8363
8364   /* Build the parameter-types.  */
8365   parmtypes = void_list_node;
8366   /* Functions passed to __cxa_atexit take an additional parameter.
8367      We'll just ignore it.  After we implement the new calling
8368      convention for destructors, we can eliminate the use of
8369      additional cleanup functions entirely in the -fnew-abi case.  */
8370   if (flag_use_cxa_atexit)
8371     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8372   /* Build the function type itself.  */
8373   fntype = build_function_type (void_type_node, parmtypes);
8374   /* Build the name of the function.  */
8375   sprintf (name, "__tcf_%d", counter++);
8376   /* Build the function declaration.  */
8377   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8378   /* It's a function with internal linkage, generated by the
8379      compiler.  */
8380   TREE_PUBLIC (fndecl) = 0;
8381   DECL_ARTIFICIAL (fndecl) = 1;
8382   /* Make the function `inline' so that it is only emitted if it is
8383      actually needed.  It is unlikely that it will be inlined, since
8384      it is only called via a function pointer, but we avoid unncessary
8385      emissions this way.  */
8386   DECL_INLINE (fndecl) = 1;
8387   /* Build the parameter.  */
8388   if (flag_use_cxa_atexit)
8389     {
8390       tree parmdecl;
8391
8392       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8393       DECL_CONTEXT (parmdecl) = fndecl;
8394       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8395       TREE_USED (parmdecl) = 1;
8396       DECL_ARGUMENTS (fndecl) = parmdecl;
8397     }
8398
8399   pushdecl (fndecl);
8400   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8401   do_pushlevel ();
8402
8403   interface_unknown = old_interface_unknown;
8404
8405   pop_lang_context ();
8406
8407   return current_function_decl;
8408 }
8409
8410 /* Finish the cleanup function begun by start_cleanup_fn.  */
8411
8412 static void
8413 end_cleanup_fn ()
8414 {
8415   do_poplevel ();
8416
8417   expand_body (finish_function (0));
8418
8419   pop_from_top_level ();
8420 }
8421
8422 /* Generate code to handle the destruction of DECL, an object with
8423    static storage duration.  */
8424
8425 void
8426 register_dtor_fn (decl)
8427      tree decl;
8428 {
8429   tree cleanup;
8430   tree compound_stmt;
8431   tree args;
8432   tree fcall;
8433
8434   int saved_flag_access_control;
8435
8436   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8437     return;
8438
8439   /* Call build_cleanup before we enter the anonymous function so that
8440      any access checks will be done relative to the current scope,
8441      rather than the scope of the anonymous function.  */
8442   build_cleanup (decl);
8443
8444   /* Now start the function.  */
8445   cleanup = start_cleanup_fn ();
8446
8447   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8448      to the original function, rather than the anonymous one.  That
8449      will make the back-end think that nested functions are in use,
8450      which causes confusion.  */
8451   saved_flag_access_control = flag_access_control;
8452   flag_access_control = 0;
8453   fcall = build_cleanup (decl);
8454   flag_access_control = saved_flag_access_control;
8455
8456   /* Create the body of the anonymous function.  */
8457   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8458   finish_expr_stmt (fcall);
8459   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8460   end_cleanup_fn ();
8461
8462   /* Call atexit with the cleanup function.  */
8463   mark_addressable (cleanup);
8464   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8465   if (flag_use_cxa_atexit)
8466     {
8467       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8468       args = tree_cons (NULL_TREE, null_pointer_node, args);
8469       args = tree_cons (NULL_TREE, cleanup, args);
8470     }
8471   else
8472     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8473   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8474 }
8475
8476 void
8477 expand_static_init (decl, init)
8478      tree decl;
8479      tree init;
8480 {
8481   tree oldstatic = value_member (decl, static_aggregates);
8482
8483   if (oldstatic)
8484     {
8485       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8486         cp_error ("multiple initializations given for `%D'", decl);
8487     }
8488   else if (! toplevel_bindings_p ())
8489     {
8490       /* Emit code to perform this initialization but once.  */
8491       tree if_stmt;
8492       tree then_clause;
8493       tree assignment;
8494       tree guard;
8495       tree guard_init;
8496
8497       /* Emit code to perform this initialization but once.  This code
8498          looks like:
8499
8500            static int guard = 0;
8501            if (!guard) {
8502              // Do initialization.
8503              guard = 1;
8504              // Register variable for destruction at end of program.
8505            }
8506
8507          Note that the `temp' variable is only set to 1 *after* the
8508          initialization is complete.  This ensures that an exception,
8509          thrown during the construction, will cause the variable to
8510          reinitialized when we pass through this code again, as per:
8511
8512            [stmt.dcl]
8513
8514            If the initialization exits by throwing an exception, the
8515            initialization is not complete, so it will be tried again
8516            the next time control enters the declaration.
8517
8518          In theory, this process should be thread-safe, too; multiple
8519          threads should not be able to initialize the variable more
8520          than once.  We don't yet attempt to ensure thread-safety.  */
8521
8522       /* Create the guard variable.  */
8523       guard = get_guard (decl);
8524
8525       /* Begin the conditional initialization.  */
8526       if_stmt = begin_if_stmt ();
8527       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8528       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8529
8530       /* Do the initialization itself.  */
8531       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8532           || (init && TREE_CODE (init) == TREE_LIST))
8533         assignment = build_aggr_init (decl, init, 0);
8534       else if (init)
8535         /* The initialization we're doing here is just a bitwise
8536            copy.  */
8537         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8538       else
8539         assignment = NULL_TREE;
8540
8541       /* Once the assignment is complete, set TEMP to 1.  Since the
8542          construction of the static object is complete at this point,
8543          we want to make sure TEMP is set to 1 even if a temporary
8544          constructed during the initialization throws an exception
8545          when it is destroyed.  So, we combine the initialization and
8546          the assignment to TEMP into a single expression, ensuring
8547          that when we call finish_expr_stmt the cleanups will not be
8548          run until after TEMP is set to 1.  */
8549       guard_init = set_guard (guard);
8550       if (assignment)
8551         {
8552           assignment = tree_cons (NULL_TREE, assignment,
8553                                   build_tree_list (NULL_TREE,
8554                                                    guard_init));
8555           assignment = build_compound_expr (assignment);
8556         }
8557       else
8558         assignment = guard_init;
8559       finish_expr_stmt (assignment);
8560
8561       /* Use atexit to register a function for destroying this static
8562          variable.  */
8563       register_dtor_fn (decl);
8564
8565       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8566       finish_then_clause (if_stmt);
8567       finish_if_stmt ();
8568     }
8569   else
8570     static_aggregates = tree_cons (init, decl, static_aggregates);
8571 }
8572
8573 /* Finish the declaration of a catch-parameter.  */
8574
8575 tree
8576 start_handler_parms (declspecs, declarator)
8577      tree declspecs;
8578      tree declarator;
8579 {
8580   tree decl;
8581   if (declspecs)
8582     {
8583       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8584                              1, NULL_TREE);
8585       if (decl == NULL_TREE)
8586         error ("invalid catch parameter");
8587     }
8588   else
8589     decl = NULL_TREE;
8590
8591   return decl;
8592 }
8593
8594 \f
8595 /* Make TYPE a complete type based on INITIAL_VALUE.
8596    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8597    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8598
8599 int
8600 complete_array_type (type, initial_value, do_default)
8601      tree type, initial_value;
8602      int do_default;
8603 {
8604   register tree maxindex = NULL_TREE;
8605   int value = 0;
8606
8607   if (initial_value)
8608     {
8609       /* An array of character type can be initialized from a
8610          brace-enclosed string constant.  */
8611       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8612           && TREE_CODE (initial_value) == CONSTRUCTOR
8613           && CONSTRUCTOR_ELTS (initial_value)
8614           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8615               == STRING_CST)
8616           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8617         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8618
8619       /* Note MAXINDEX is really the maximum index, one less than the
8620          size.  */
8621       if (TREE_CODE (initial_value) == STRING_CST)
8622         {
8623           int eltsize
8624             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8625           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8626                                    / eltsize) - 1, 0);
8627         }
8628       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8629         {
8630           tree elts = CONSTRUCTOR_ELTS (initial_value);
8631
8632           maxindex = ssize_int (-1);
8633           for (; elts; elts = TREE_CHAIN (elts))
8634             {
8635               if (TREE_PURPOSE (elts))
8636                 maxindex = TREE_PURPOSE (elts);
8637               else
8638                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8639             }
8640           maxindex = copy_node (maxindex);
8641         }
8642       else
8643         {
8644           /* Make an error message unless that happened already.  */
8645           if (initial_value != error_mark_node)
8646             value = 1;
8647           else
8648             initial_value = NULL_TREE;
8649
8650           /* Prevent further error messages.  */
8651           maxindex = build_int_2 (0, 0);
8652         }
8653     }
8654
8655   if (!maxindex)
8656     {
8657       if (do_default)
8658         maxindex = build_int_2 (0, 0);
8659       value = 2;
8660     }
8661
8662   if (maxindex)
8663     {
8664       tree itype;
8665       tree domain;
8666
8667       domain = build_index_type (maxindex);
8668       TYPE_DOMAIN (type) = domain;
8669
8670       if (! TREE_TYPE (maxindex))
8671         TREE_TYPE (maxindex) = domain;
8672       if (initial_value)
8673         itype = TREE_TYPE (initial_value);
8674       else
8675         itype = NULL;
8676       if (itype && !TYPE_DOMAIN (itype))
8677         TYPE_DOMAIN (itype) = domain;
8678       /* The type of the main variant should never be used for arrays
8679          of different sizes.  It should only ever be completed with the
8680          size of the array.  */
8681       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8682         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8683     }
8684
8685   /* Lay out the type now that we can get the real answer.  */
8686
8687   layout_type (type);
8688
8689   return value;
8690 }
8691 \f
8692 /* Return zero if something is declared to be a member of type
8693    CTYPE when in the context of CUR_TYPE.  STRING is the error
8694    message to print in that case.  Otherwise, quietly return 1.  */
8695
8696 static int
8697 member_function_or_else (ctype, cur_type, flags)
8698      tree ctype, cur_type;
8699      enum overload_flags flags;
8700 {
8701   if (ctype && ctype != cur_type)
8702     {
8703       if (flags == DTOR_FLAG)
8704         cp_error ("destructor for alien class `%T' cannot be a member",
8705                   ctype);
8706       else
8707         cp_error ("constructor for alien class `%T' cannot be a member",
8708                   ctype);
8709       return 0;
8710     }
8711   return 1;
8712 }
8713 \f
8714 /* Subroutine of `grokdeclarator'.  */
8715
8716 /* Generate errors possibly applicable for a given set of specifiers.
8717    This is for ARM $7.1.2.  */
8718
8719 static void
8720 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8721      tree object;
8722      const char *type;
8723      int virtualp, quals, friendp, raises, inlinep;
8724 {
8725   if (virtualp)
8726     cp_error ("`%D' declared as a `virtual' %s", object, type);
8727   if (inlinep)
8728     cp_error ("`%D' declared as an `inline' %s", object, type);
8729   if (quals)
8730     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8731               object, type);
8732   if (friendp)
8733     cp_error_at ("`%D' declared as a friend", object);
8734   if (raises && !TYPE_PTRFN_P (TREE_TYPE (object))
8735       && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))
8736     cp_error_at ("`%D' declared with an exception specification", object);
8737 }
8738
8739 /* CTYPE is class type, or null if non-class.
8740    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8741    or METHOD_TYPE.
8742    DECLARATOR is the function's name.
8743    VIRTUALP is truthvalue of whether the function is virtual or not.
8744    FLAGS are to be passed through to `grokclassfn'.
8745    QUALS are qualifiers indicating whether the function is `const'
8746    or `volatile'.
8747    RAISES is a list of exceptions that this function can raise.
8748    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8749    not look, and -1 if we should not call `grokclassfn' at all.
8750
8751    Returns `NULL_TREE' if something goes wrong, after issuing
8752    applicable error messages.  */
8753
8754 static tree
8755 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8756             raises, check, friendp, publicp, inlinep, funcdef_flag,
8757             template_count, in_namespace)
8758      tree ctype, type;
8759      tree declarator;
8760      tree orig_declarator;
8761      int virtualp;
8762      enum overload_flags flags;
8763      tree quals, raises;
8764      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8765      tree in_namespace;
8766 {
8767   tree decl;
8768   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8769   int has_default_arg = 0;
8770   tree t;
8771
8772   if (raises)
8773     {
8774       type = build_exception_variant (type, raises);
8775     }
8776
8777   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8778   /* Propagate volatile out from type to decl. */
8779   if (TYPE_VOLATILE (type))
8780     TREE_THIS_VOLATILE (decl) = 1;
8781
8782   /* If this decl has namespace scope, set that up.  */
8783   if (in_namespace)
8784     set_decl_namespace (decl, in_namespace, friendp);
8785   else if (!ctype)
8786     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8787
8788   /* `main' and builtins have implicit 'C' linkage.  */
8789   if ((MAIN_NAME_P (declarator)
8790        || (IDENTIFIER_LENGTH (declarator) > 10
8791            && IDENTIFIER_POINTER (declarator)[0] == '_'
8792            && IDENTIFIER_POINTER (declarator)[1] == '_'
8793            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8794       && current_lang_name == lang_name_cplusplus
8795       && ctype == NULL_TREE
8796       /* NULL_TREE means global namespace.  */
8797       && DECL_CONTEXT (decl) == NULL_TREE)
8798     SET_DECL_LANGUAGE (decl, lang_c);
8799
8800   /* Should probably propagate const out from type to decl I bet (mrs).  */
8801   if (staticp)
8802     {
8803       DECL_STATIC_FUNCTION_P (decl) = 1;
8804       DECL_CONTEXT (decl) = ctype;
8805     }
8806
8807   if (ctype)
8808     DECL_CONTEXT (decl) = ctype;
8809
8810   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8811     {
8812       if (processing_template_decl)
8813         error ("cannot declare `::main' to be a template");
8814       if (inlinep)
8815         error ("cannot declare `::main' to be inline");
8816       if (!publicp)
8817         error ("cannot declare `::main' to be static");
8818       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8819                         integer_type_node))
8820         error ("`main' must return `int'");
8821       inlinep = 0;
8822       publicp = 1;
8823     }
8824
8825   /* Members of anonymous types and local classes have no linkage; make
8826      them internal.  */
8827   /* FIXME what if it gets a name from typedef?  */
8828   if (ctype && (TYPE_ANONYMOUS_P (ctype)
8829                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8830     publicp = 0;
8831
8832   if (publicp)
8833     {
8834       /* [basic.link]: A name with no linkage (notably, the name of a class
8835          or enumeration declared in a local scope) shall not be used to
8836          declare an entity with linkage.
8837
8838          Only check this for public decls for now.  */
8839       t = no_linkage_check (TREE_TYPE (decl));
8840       if (t)
8841         {
8842           if (TYPE_ANONYMOUS_P (t))
8843             {
8844               if (DECL_EXTERN_C_P (decl))
8845                 /* Allow this; it's pretty common in C.  */;
8846               else
8847                 {
8848                   cp_pedwarn ("non-local function `%#D' uses anonymous type",
8849                               decl);
8850                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
8851                     cp_pedwarn_at ("\
8852 `%#D' does not refer to the unqualified type, so it is not used for linkage",
8853                                 TYPE_NAME (t));
8854                 }
8855             }
8856           else
8857             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8858                         decl, t);
8859         }
8860     }
8861
8862   TREE_PUBLIC (decl) = publicp;
8863   if (! publicp)
8864     {
8865       DECL_INTERFACE_KNOWN (decl) = 1;
8866       DECL_NOT_REALLY_EXTERN (decl) = 1;
8867     }
8868
8869   /* If the declaration was declared inline, mark it as such.  */
8870   if (inlinep)
8871     DECL_DECLARED_INLINE_P (decl) = 1;
8872   /* We inline functions that are explicitly declared inline, or, when
8873      the user explicitly asks us to, all functions.  */
8874   if (DECL_DECLARED_INLINE_P (decl) || flag_inline_trees == 2)
8875     DECL_INLINE (decl) = 1;
8876
8877   DECL_EXTERNAL (decl) = 1;
8878   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8879     {
8880       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8881                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8882       quals = NULL_TREE;
8883     }
8884
8885   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8886     grok_op_properties (decl, virtualp, check < 0);
8887
8888   if (ctype && decl_function_context (decl))
8889     DECL_NO_STATIC_CHAIN (decl) = 1;
8890
8891   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8892     if (TREE_PURPOSE (t)
8893         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8894       {
8895         has_default_arg = 1;
8896         break;
8897       }
8898
8899   if (friendp
8900       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8901     {
8902       if (funcdef_flag)
8903         cp_error
8904           ("defining explicit specialization `%D' in friend declaration",
8905            orig_declarator);
8906       else
8907         {
8908           tree fns = TREE_OPERAND (orig_declarator, 0);
8909           tree args = TREE_OPERAND (orig_declarator, 1);
8910
8911           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8912             {
8913               /* Something like `template <class T> friend void f<T>()'.  */
8914               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8915                         orig_declarator);
8916               return NULL_TREE;
8917             }
8918
8919
8920           /* A friend declaration of the form friend void f<>().  Record
8921              the information in the TEMPLATE_ID_EXPR.  */
8922           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8923
8924           if (TREE_CODE (fns) == COMPONENT_REF)
8925             {
8926               /* Due to bison parser ickiness, we will have already looked
8927                  up an operator_name or PFUNCNAME within the current class
8928                  (see template_id in parse.y). If the current class contains
8929                  such a name, we'll get a COMPONENT_REF here. Undo that. */
8930
8931               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
8932                                   == current_class_type, 20001120);
8933               fns = TREE_OPERAND (fns, 1);
8934             }
8935           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
8936                               || TREE_CODE (fns) == LOOKUP_EXPR
8937                               || TREE_CODE (fns) == OVERLOAD, 20001120);
8938           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
8939
8940           if (has_default_arg)
8941             {
8942               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8943                         decl);
8944               return NULL_TREE;
8945             }
8946
8947           if (inlinep)
8948             {
8949               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8950                         decl);
8951               return NULL_TREE;
8952             }
8953         }
8954     }
8955
8956   if (has_default_arg)
8957     add_defarg_fn (decl);
8958
8959   if (funcdef_flag)
8960     /* Make the init_value nonzero so pushdecl knows this is not
8961        tentative.  error_mark_node is replaced later with the BLOCK.  */
8962     DECL_INITIAL (decl) = error_mark_node;
8963
8964   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8965     TREE_NOTHROW (decl) = 1;
8966
8967   /* Caller will do the rest of this.  */
8968   if (check < 0)
8969     return decl;
8970
8971   if (flags == NO_SPECIAL && ctype && constructor_name (ctype) == declarator)
8972     DECL_CONSTRUCTOR_P (decl) = 1;
8973
8974   /* Function gets the ugly name, field gets the nice one.  This call
8975      may change the type of the function (because of default
8976      parameters)!  */
8977   if (ctype != NULL_TREE)
8978     grokclassfn (ctype, decl, flags, quals);
8979
8980   decl = check_explicit_specialization (orig_declarator, decl,
8981                                         template_count,
8982                                         2 * (funcdef_flag != 0) +
8983                                         4 * (friendp != 0));
8984   if (decl == error_mark_node)
8985     return NULL_TREE;
8986
8987   if (ctype != NULL_TREE
8988       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8989       && check)
8990     {
8991       tree old_decl;
8992
8993       old_decl = check_classfn (ctype, decl);
8994
8995       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
8996         /* Because grokfndecl is always supposed to return a
8997            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8998            here.  We depend on our callers to figure out that its
8999            really a template that's being returned.  */
9000         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9001
9002       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9003           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9004         {
9005           /* Remove the `this' parm added by grokclassfn.
9006              XXX Isn't this done in start_function, too?  */
9007           revert_static_member_fn (decl);
9008           last_function_parms = TREE_CHAIN (last_function_parms);
9009         }
9010       if (old_decl && DECL_ARTIFICIAL (old_decl))
9011         cp_error ("definition of implicitly-declared `%D'", old_decl);
9012
9013       if (old_decl)
9014         {
9015           /* Since we've smashed OLD_DECL to its
9016              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9017           if (TREE_CODE (decl) == TEMPLATE_DECL)
9018             decl = DECL_TEMPLATE_RESULT (decl);
9019
9020           /* Attempt to merge the declarations.  This can fail, in
9021              the case of some illegal specialization declarations.  */
9022           if (!duplicate_decls (decl, old_decl))
9023             cp_error ("no `%#D' member function declared in class `%T'",
9024                       decl, ctype);
9025           return old_decl;
9026         }
9027     }
9028
9029   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9030     return NULL_TREE;
9031
9032   if (ctype == NULL_TREE || check)
9033     return decl;
9034
9035   if (virtualp)
9036     DECL_VIRTUAL_P (decl) = 1;
9037
9038   return decl;
9039 }
9040
9041 static tree
9042 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9043      tree type;
9044      tree declarator;
9045      RID_BIT_TYPE *specbits_in;
9046      int initialized;
9047      int constp;
9048      tree in_namespace;
9049 {
9050   tree decl;
9051   RID_BIT_TYPE specbits;
9052
9053   specbits = *specbits_in;
9054
9055   if (TREE_CODE (type) == OFFSET_TYPE)
9056     {
9057       /* If you declare a static member so that it
9058          can be initialized, the code will reach here.  */
9059       tree basetype = TYPE_OFFSET_BASETYPE (type);
9060       type = TREE_TYPE (type);
9061       decl = build_lang_decl (VAR_DECL, declarator, type);
9062       DECL_CONTEXT (decl) = basetype;
9063     }
9064   else
9065     {
9066       tree context;
9067
9068       if (in_namespace)
9069         context = in_namespace;
9070       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9071         context = current_namespace;
9072       else
9073         context = NULL_TREE;
9074
9075       /* For namespace-scope variables, declared in a template, we
9076          need the full lang_decl.  The same is true for
9077          namespace-scope variables that do not have C++ language
9078          linkage.  */
9079       if (context
9080           && (processing_template_decl
9081               || current_lang_name != lang_name_cplusplus))
9082         decl = build_lang_decl (VAR_DECL, declarator, type);
9083       else
9084         decl = build_decl (VAR_DECL, declarator, type);
9085
9086       if (context)
9087         set_decl_namespace (decl, context, 0);
9088
9089       context = DECL_CONTEXT (decl);
9090       if (declarator && context && current_lang_name != lang_name_c)
9091         /* We can't mangle lazily here because we don't have any
9092            way to recover whether or not a variable was `extern
9093            "C"' later.  */
9094         mangle_decl (decl);
9095     }
9096
9097   if (in_namespace)
9098     set_decl_namespace (decl, in_namespace, 0);
9099
9100   if (RIDBIT_SETP (RID_EXTERN, specbits))
9101     {
9102       DECL_THIS_EXTERN (decl) = 1;
9103       DECL_EXTERNAL (decl) = !initialized;
9104     }
9105
9106   /* In class context, static means one per class,
9107      public access, and static storage.  */
9108   if (DECL_CLASS_SCOPE_P (decl))
9109     {
9110       TREE_PUBLIC (decl) = 1;
9111       TREE_STATIC (decl) = 1;
9112       DECL_EXTERNAL (decl) = 0;
9113     }
9114   /* At top level, either `static' or no s.c. makes a definition
9115      (perhaps tentative), and absence of `static' makes it public.  */
9116   else if (toplevel_bindings_p ())
9117     {
9118       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9119                             && (DECL_THIS_EXTERN (decl) || ! constp));
9120       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9121     }
9122   /* Not at top level, only `static' makes a static definition.  */
9123   else
9124     {
9125       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9126       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9127     }
9128
9129   if (TREE_PUBLIC (decl))
9130     {
9131       /* [basic.link]: A name with no linkage (notably, the name of a class
9132          or enumeration declared in a local scope) shall not be used to
9133          declare an entity with linkage.
9134
9135          Only check this for public decls for now.  */
9136       tree t = no_linkage_check (TREE_TYPE (decl));
9137       if (t)
9138         {
9139           if (TYPE_ANONYMOUS_P (t))
9140             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9141           else
9142             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9143                         decl, t);
9144         }
9145     }
9146
9147   return decl;
9148 }
9149
9150 /* Create and return a canonical pointer to member function type, for
9151    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9152
9153 tree
9154 build_ptrmemfunc_type (type)
9155      tree type;
9156 {
9157   tree fields[4];
9158   tree t;
9159   tree unqualified_variant = NULL_TREE;
9160
9161   if (type == error_mark_node)
9162     return type;
9163
9164   /* If a canonical type already exists for this type, use it.  We use
9165      this method instead of type_hash_canon, because it only does a
9166      simple equality check on the list of field members.  */
9167
9168   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9169     return t;
9170
9171   /* Make sure that we always have the unqualified pointer-to-member
9172      type first.  */
9173   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9174     unqualified_variant
9175       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9176
9177   t = make_aggr_type (RECORD_TYPE);
9178   /* Let the front-end know this is a pointer to member function...  */
9179   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9180   /* ... and not really an aggregate.  */
9181   SET_IS_AGGR_TYPE (t, 0);
9182
9183   fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9184   fields[1] = build_decl (FIELD_DECL, delta_identifier,
9185                           delta_type_node);
9186   finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9187
9188   /* Zap out the name so that the back-end will give us the debugging
9189      information for this anonymous RECORD_TYPE.  */
9190   TYPE_NAME (t) = NULL_TREE;
9191
9192   /* If this is not the unqualified form of this pointer-to-member
9193      type, set the TYPE_MAIN_VARIANT for this type to be the
9194      unqualified type.  Since they are actually RECORD_TYPEs that are
9195      not variants of each other, we must do this manually.  */
9196   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9197     {
9198       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9199       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9200       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9201       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9202     }
9203
9204   /* Cache this pointer-to-member type so that we can find it again
9205      later.  */
9206   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9207
9208   /* Seems to be wanted.  */
9209   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9210
9211   return t;
9212 }
9213
9214 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9215    Check to see that the definition is valid.  Issue appropriate error
9216    messages.  Return 1 if the definition is particularly bad, or 0
9217    otherwise.  */
9218
9219 int
9220 check_static_variable_definition (decl, type)
9221      tree decl;
9222      tree type;
9223 {
9224   /* Motion 10 at San Diego: If a static const integral data member is
9225      initialized with an integral constant expression, the initializer
9226      may appear either in the declaration (within the class), or in
9227      the definition, but not both.  If it appears in the class, the
9228      member is a member constant.  The file-scope definition is always
9229      required.  */
9230   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9231     {
9232       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9233                 type);
9234       /* If we just return the declaration, crashes will sometimes
9235          occur.  We therefore return void_type_node, as if this was a
9236          friend declaration, to cause callers to completely ignore
9237          this declaration.  */
9238       return 1;
9239     }
9240   else if (!CP_TYPE_CONST_P (type))
9241     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9242               decl);
9243   else if (pedantic && !INTEGRAL_TYPE_P (type))
9244     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9245
9246   return 0;
9247 }
9248
9249 /* Given the SIZE (i.e., number of elements) in an array, compute an
9250    appropriate index type for the array.  If non-NULL, NAME is the
9251    name of the thing being declared.  */
9252
9253 tree
9254 compute_array_index_type (name, size)
9255      tree name;
9256      tree size;
9257 {
9258   tree itype;
9259
9260   /* If this involves a template parameter, it will be a constant at
9261      instantiation time, but we don't know what the value is yet.
9262      Even if no template parameters are involved, we may an expression
9263      that is not a constant; we don't even simplify `1 + 2' when
9264      processing a template.  */
9265   if (processing_template_decl)
9266     {
9267       /* Resolve a qualified reference to an enumerator or static
9268          const data member of ours.  */
9269       if (TREE_CODE (size) == SCOPE_REF
9270           && TREE_OPERAND (size, 0) == current_class_type)
9271         {
9272           tree t = lookup_field (current_class_type,
9273                                  TREE_OPERAND (size, 1), 0, 0);
9274           if (t)
9275             size = t;
9276         }
9277
9278       return build_index_type (build_min (MINUS_EXPR, sizetype,
9279                                           size, integer_one_node));
9280     }
9281
9282   /* The size might be the result of a cast. */
9283   STRIP_TYPE_NOPS (size);
9284
9285   /* It might be a const variable or enumeration constant.  */
9286   size = decl_constant_value (size);
9287
9288   /* The array bound must be an integer type.  */
9289   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9290       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9291       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9292     {
9293       if (name)
9294         cp_error ("size of array `%D' has non-integer type", name);
9295       else
9296         cp_error ("size of array has non-integer type");
9297       size = integer_one_node;
9298     }
9299
9300   /* Normally, the array-bound will be a constant.  */
9301   if (TREE_CODE (size) == INTEGER_CST)
9302     {
9303       /* Check to see if the array bound overflowed.  Make that an
9304          error, no matter how generous we're being.  */
9305       int old_flag_pedantic_errors = flag_pedantic_errors;
9306       int old_pedantic = pedantic;
9307       pedantic = flag_pedantic_errors = 1;
9308       constant_expression_warning (size);
9309       pedantic = old_pedantic;
9310       flag_pedantic_errors = old_flag_pedantic_errors;
9311
9312       /* An array must have a positive number of elements.  */
9313       if (INT_CST_LT (size, integer_zero_node))
9314         {
9315           if (name)
9316             cp_error ("size of array `%D' is negative", name);
9317           else
9318             cp_error ("size of array is negative");
9319           size = integer_one_node;
9320         }
9321       /* Except that an extension we allow zero-sized arrays.  We
9322          always allow them in system headers because glibc uses
9323          them.  */
9324       else if (integer_zerop (size) && pedantic && !in_system_header)
9325         {
9326           if (name)
9327             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9328           else
9329             cp_pedwarn ("ISO C++ forbids zero-size array");
9330         }
9331     }
9332   else if (TREE_CONSTANT (size))
9333     {
9334       /* `(int) &fn' is not a valid array bound.  */
9335       if (name)
9336         cp_error ("size of array `%D' is not an integral constant-expression",
9337                   name);
9338       else
9339         cp_error ("size of array is not an integral constant-expression");
9340     }
9341
9342   /* Compute the index of the largest element in the array.  It is
9343      one less than the number of elements in the array.  */
9344   itype
9345     = fold (cp_build_binary_op (MINUS_EXPR,
9346                                 cp_convert (ssizetype, size),
9347                                 cp_convert (ssizetype,
9348                                             integer_one_node)));
9349
9350   /* Check for variable-sized arrays.  We allow such things as an
9351      extension, even though they are not allowed in ANSI/ISO C++.  */
9352   if (!TREE_CONSTANT (itype))
9353     {
9354       if (pedantic)
9355         {
9356           if (name)
9357             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9358                         name);
9359           else
9360             cp_pedwarn ("ISO C++ forbids variable-size array");
9361         }
9362
9363       /* Create a variable-sized array index type.  */
9364       itype = variable_size (itype);
9365     }
9366   /* Make sure that there was no overflow when creating to a signed
9367      index type.  (For example, on a 32-bit machine, an array with
9368      size 2^32 - 1 is too big.)  */
9369   else if (TREE_OVERFLOW (itype))
9370     {
9371       error ("overflow in array dimension");
9372       TREE_OVERFLOW (itype) = 0;
9373     }
9374
9375   /* Create and return the appropriate index type.  */
9376   return build_index_type (itype);
9377 }
9378
9379 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9380    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9381    with this type.  */
9382
9383 static tree
9384 create_array_type_for_decl (name, type, size)
9385      tree name;
9386      tree type;
9387      tree size;
9388 {
9389   tree itype = NULL_TREE;
9390   const char* error_msg;
9391
9392   /* If things have already gone awry, bail now.  */
9393   if (type == error_mark_node || size == error_mark_node)
9394     return error_mark_node;
9395
9396   /* Assume that everything will go OK.  */
9397   error_msg = NULL;
9398
9399   /* There are some types which cannot be array elements.  */
9400   switch (TREE_CODE (type))
9401     {
9402     case VOID_TYPE:
9403       error_msg = "array of void";
9404       break;
9405
9406     case FUNCTION_TYPE:
9407       error_msg = "array of functions";
9408       break;
9409
9410     case REFERENCE_TYPE:
9411       error_msg = "array of references";
9412       break;
9413
9414     case OFFSET_TYPE:
9415       error_msg = "array of data members";
9416       break;
9417
9418     case METHOD_TYPE:
9419       error_msg = "array of function members";
9420       break;
9421
9422     default:
9423       break;
9424     }
9425
9426   /* If something went wrong, issue an error-message and return.  */
9427   if (error_msg)
9428     {
9429       if (name)
9430         cp_error ("declaration of `%D' as %s", name, error_msg);
9431       else
9432         cp_error ("creating %s", error_msg);
9433
9434       return error_mark_node;
9435     }
9436
9437   /* [dcl.array]
9438
9439      The constant expressions that specify the bounds of the arrays
9440      can be omitted only for the first member of the sequence.  */
9441   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9442     {
9443       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9444                 name);
9445
9446       return error_mark_node;
9447     }
9448
9449   /* Figure out the index type for the array.  */
9450   if (size)
9451     itype = compute_array_index_type (name, size);
9452
9453   return build_cplus_array_type (type, itype);
9454 }
9455
9456 /* Check that it's OK to declare a function with the indicated TYPE.
9457    SFK indicates the kind of special function (if any) that this
9458    function is.  OPTYPE is the type given in a conversion operator
9459    declaration.  Returns the actual return type of the function; that
9460    may be different than TYPE if an error occurs, or for certain
9461    special functions.  */
9462
9463 static tree
9464 check_special_function_return_type (sfk, type, optype)
9465      special_function_kind sfk;
9466      tree type;
9467      tree optype;
9468 {
9469   switch (sfk)
9470     {
9471     case sfk_constructor:
9472       if (type)
9473         cp_error ("return type specification for constructor invalid");
9474
9475       /* In the new ABI constructors do not return a value.  */
9476       type = void_type_node;
9477       break;
9478
9479     case sfk_destructor:
9480       if (type)
9481         cp_error ("return type specification for destructor invalid");
9482       type = void_type_node;
9483       break;
9484
9485     case sfk_conversion:
9486       if (type && !same_type_p (type, optype))
9487         cp_error ("operator `%T' declared to return `%T'", optype, type);
9488       else if (type)
9489         cp_pedwarn ("return type specified for `operator %T'",  optype);
9490       type = optype;
9491       break;
9492
9493     default:
9494       my_friendly_abort (20000408);
9495       break;
9496     }
9497
9498   return type;
9499 }
9500
9501 /* Given declspecs and a declarator,
9502    determine the name and type of the object declared
9503    and construct a ..._DECL node for it.
9504    (In one case we can return a ..._TYPE node instead.
9505     For invalid input we sometimes return 0.)
9506
9507    DECLSPECS is a chain of tree_list nodes whose value fields
9508     are the storage classes and type specifiers.
9509
9510    DECL_CONTEXT says which syntactic context this declaration is in:
9511      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9512      FUNCDEF for a function definition.  Like NORMAL but a few different
9513       error messages in each case.  Return value may be zero meaning
9514       this definition is too screwy to try to parse.
9515      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9516       handle member functions (which have FIELD context).
9517       Return value may be zero meaning this definition is too screwy to
9518       try to parse.
9519      PARM for a parameter declaration (either within a function prototype
9520       or before a function body).  Make a PARM_DECL, or return void_type_node.
9521      CATCHPARM for a parameter declaration before a catch clause.
9522      TYPENAME if for a typename (in a cast or sizeof).
9523       Don't make a DECL node; just return the ..._TYPE node.
9524      FIELD for a struct or union field; make a FIELD_DECL.
9525      BITFIELD for a field with specified width.
9526    INITIALIZED is 1 if the decl has an initializer.
9527
9528    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9529    normal attributes in TREE_PURPOSE, or NULL_TREE.
9530
9531    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9532    It may also be so in the PARM case, for a prototype where the
9533    argument type is specified but not the name.
9534
9535    This function is where the complicated C meanings of `static'
9536    and `extern' are interpreted.
9537
9538    For C++, if there is any monkey business to do, the function which
9539    calls this one must do it, i.e., prepending instance variables,
9540    renaming overloaded function names, etc.
9541
9542    Note that for this C++, it is an error to define a method within a class
9543    which does not belong to that class.
9544
9545    Except in the case where SCOPE_REFs are implicitly known (such as
9546    methods within a class being redundantly qualified),
9547    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9548    (class_name::decl_name).  The caller must also deal with this.
9549
9550    If a constructor or destructor is seen, and the context is FIELD,
9551    then the type gains the attribute TREE_HAS_x.  If such a declaration
9552    is erroneous, NULL_TREE is returned.
9553
9554    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9555    function, these are the qualifiers to give to the `this' pointer. We
9556    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9557
9558    May return void_type_node if the declarator turned out to be a friend.
9559    See grokfield for details.  */
9560
9561 tree
9562 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9563      tree declspecs;
9564      tree declarator;
9565      enum decl_context decl_context;
9566      int initialized;
9567      tree attrlist;
9568 {
9569   RID_BIT_TYPE specbits;
9570   int nclasses = 0;
9571   tree spec;
9572   tree type = NULL_TREE;
9573   int longlong = 0;
9574   int constp;
9575   int restrictp;
9576   int volatilep;
9577   int type_quals;
9578   int virtualp, explicitp, friendp, inlinep, staticp;
9579   int explicit_int = 0;
9580   int explicit_char = 0;
9581   int defaulted_int = 0;
9582   tree typedef_decl = NULL_TREE;
9583   const char *name;
9584   tree typedef_type = NULL_TREE;
9585   int funcdef_flag = 0;
9586   enum tree_code innermost_code = ERROR_MARK;
9587   int bitfield = 0;
9588 #if 0
9589   /* See the code below that used this.  */
9590   tree decl_machine_attr = NULL_TREE;
9591 #endif
9592   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9593      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9594   tree init = NULL_TREE;
9595
9596   /* Keep track of what sort of function is being processed
9597      so that we can warn about default return values, or explicit
9598      return values which do not match prescribed defaults.  */
9599   special_function_kind sfk = sfk_none;
9600
9601   tree dname = NULL_TREE;
9602   tree ctype = current_class_type;
9603   tree ctor_return_type = NULL_TREE;
9604   enum overload_flags flags = NO_SPECIAL;
9605   tree quals = NULL_TREE;
9606   tree raises = NULL_TREE;
9607   int template_count = 0;
9608   tree in_namespace = NULL_TREE;
9609   tree inner_attrs;
9610   int ignore_attrs;
9611
9612   RIDBIT_RESET_ALL (specbits);
9613   if (decl_context == FUNCDEF)
9614     funcdef_flag = 1, decl_context = NORMAL;
9615   else if (decl_context == MEMFUNCDEF)
9616     funcdef_flag = -1, decl_context = FIELD;
9617   else if (decl_context == BITFIELD)
9618     bitfield = 1, decl_context = FIELD;
9619
9620   /* Look inside a declarator for the name being declared
9621      and get it as a string, for an error message.  */
9622   {
9623     tree *next = &declarator;
9624     register tree decl;
9625     name = NULL;
9626
9627     while (next && *next)
9628       {
9629         decl = *next;
9630         switch (TREE_CODE (decl))
9631           {
9632           case TREE_LIST:
9633             /* For attributes.  */
9634             next = &TREE_VALUE (decl);
9635             break;
9636
9637           case COND_EXPR:
9638             ctype = NULL_TREE;
9639             next = &TREE_OPERAND (decl, 0);
9640             break;
9641
9642           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9643             {
9644               tree name = TREE_OPERAND (decl, 0);
9645               tree rename = NULL_TREE;
9646
9647               my_friendly_assert (flags == NO_SPECIAL, 152);
9648               flags = DTOR_FLAG;
9649               sfk = sfk_destructor;
9650               if (TREE_CODE (name) == TYPE_DECL)
9651                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9652               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9653               if (ctype == NULL_TREE)
9654                 {
9655                   if (current_class_type == NULL_TREE)
9656                     {
9657                       error ("destructors must be member functions");
9658                       flags = NO_SPECIAL;
9659                     }
9660                   else
9661                     {
9662                       tree t = constructor_name (current_class_name);
9663                       if (t != name)
9664                         rename = t;
9665                     }
9666                 }
9667               else
9668                 {
9669                   tree t = constructor_name (ctype);
9670                   if (t != name)
9671                     rename = t;
9672                 }
9673
9674               if (rename)
9675                 {
9676                   cp_error ("destructor `%T' must match class name `%T'",
9677                             name, rename);
9678                   TREE_OPERAND (decl, 0) = rename;
9679                 }
9680               next = &name;
9681             }
9682             break;
9683
9684           case ADDR_EXPR:       /* C++ reference declaration */
9685             /* Fall through. */
9686           case ARRAY_REF:
9687           case INDIRECT_REF:
9688             ctype = NULL_TREE;
9689             innermost_code = TREE_CODE (decl);
9690             next = &TREE_OPERAND (decl, 0);
9691             break;
9692
9693           case CALL_EXPR:
9694             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9695               {
9696                 /* This is actually a variable declaration using
9697                    constructor syntax.  We need to call start_decl and
9698                    cp_finish_decl so we can get the variable
9699                    initialized...  */
9700
9701                 tree attributes, prefix_attributes;
9702
9703                 *next = TREE_OPERAND (decl, 0);
9704                 init = CALL_DECLARATOR_PARMS (decl);
9705
9706                 if (attrlist)
9707                   {
9708                     attributes = TREE_PURPOSE (attrlist);
9709                     prefix_attributes = TREE_VALUE (attrlist);
9710                   }
9711                 else
9712                   {
9713                     attributes = NULL_TREE;
9714                     prefix_attributes = NULL_TREE;
9715                   }
9716
9717                 decl = start_decl (declarator, declspecs, 1,
9718                                    attributes, prefix_attributes);
9719                 decl_type_access_control (decl);
9720                 if (decl)
9721                   {
9722                     /* Look for __unused__ attribute */
9723                     if (TREE_USED (TREE_TYPE (decl)))
9724                       TREE_USED (decl) = 1;
9725                     finish_decl (decl, init, NULL_TREE);
9726                   }
9727                 else
9728                   cp_error ("invalid declarator");
9729                 return 0;
9730               }
9731             innermost_code = TREE_CODE (decl);
9732             if (decl_context == FIELD && ctype == NULL_TREE)
9733               ctype = current_class_type;
9734             if (ctype
9735                 && TREE_OPERAND (decl, 0)
9736                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9737                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9738                          == constructor_name_full (ctype))
9739                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9740                             == constructor_name (ctype)))))
9741               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9742             next = &TREE_OPERAND (decl, 0);
9743             decl = *next;
9744             if (ctype != NULL_TREE
9745                 && decl != NULL_TREE && flags != DTOR_FLAG
9746                 && decl == constructor_name (ctype))
9747               {
9748                 sfk = sfk_constructor;
9749                 ctor_return_type = ctype;
9750               }
9751             ctype = NULL_TREE;
9752             break;
9753
9754           case TEMPLATE_ID_EXPR:
9755               {
9756                 tree fns = TREE_OPERAND (decl, 0);
9757
9758                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9759                   fns = TREE_OPERAND (fns, 0);
9760
9761                 dname = fns;
9762                 if (TREE_CODE (dname) == COMPONENT_REF)
9763                   dname = TREE_OPERAND (dname, 1);
9764                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9765                   {
9766                     my_friendly_assert (is_overloaded_fn (dname),
9767                                         19990331);
9768                     dname = DECL_NAME (get_first_fn (dname));
9769                   }
9770               }
9771           /* Fall through. */
9772
9773           case IDENTIFIER_NODE:
9774             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9775               dname = decl;
9776
9777             next = 0;
9778
9779             if (C_IS_RESERVED_WORD (dname))
9780               {
9781                 cp_error ("declarator-id missing; using reserved word `%D'",
9782                           dname);
9783                 name = IDENTIFIER_POINTER (dname);
9784               }
9785             else if (!IDENTIFIER_TYPENAME_P (dname))
9786               name = IDENTIFIER_POINTER (dname);
9787             else
9788               {
9789                 my_friendly_assert (flags == NO_SPECIAL, 154);
9790                 flags = TYPENAME_FLAG;
9791                 ctor_return_type = TREE_TYPE (dname);
9792                 sfk = sfk_conversion;
9793                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9794                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9795                         == TYPE_DECL))
9796                   name = IDENTIFIER_POINTER (dname);
9797                 else
9798                   name = "<invalid operator>";
9799               }
9800             break;
9801
9802             /* C++ extension */
9803           case SCOPE_REF:
9804             {
9805               /* Perform error checking, and decide on a ctype.  */
9806               tree cname = TREE_OPERAND (decl, 0);
9807               if (cname == NULL_TREE)
9808                 ctype = NULL_TREE;
9809               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9810                 {
9811                   ctype = NULL_TREE;
9812                   in_namespace = TREE_OPERAND (decl, 0);
9813                   TREE_OPERAND (decl, 0) = NULL_TREE;
9814                 }
9815               else if (! is_aggr_type (cname, 1))
9816                 TREE_OPERAND (decl, 0) = NULL_TREE;
9817               /* Must test TREE_OPERAND (decl, 1), in case user gives
9818                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9819               else if (TREE_OPERAND (decl, 1)
9820                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9821                 ctype = cname;
9822               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9823                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9824                 {
9825                   cp_error ("`%T::%D' is not a valid declarator", cname,
9826                             TREE_OPERAND (decl, 1));
9827                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9828                             cname, TREE_OPERAND (decl, 1));
9829                   return void_type_node;
9830                 }
9831               else if (ctype == NULL_TREE)
9832                 ctype = cname;
9833               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9834                 TREE_OPERAND (decl, 0) = ctype;
9835               else
9836                 {
9837                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9838                     {
9839                       cp_error ("type `%T' is not derived from type `%T'",
9840                                 cname, ctype);
9841                       TREE_OPERAND (decl, 0) = NULL_TREE;
9842                     }
9843                   else
9844                     ctype = cname;
9845                 }
9846
9847               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9848                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9849                        == constructor_name_full (ctype))
9850                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9851                           == constructor_name (ctype))))
9852                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9853               next = &TREE_OPERAND (decl, 1);
9854               decl = *next;
9855               if (ctype)
9856                 {
9857                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9858                       && constructor_name (ctype) == decl)
9859                     {
9860                       sfk = sfk_constructor;
9861                       ctor_return_type = ctype;
9862                     }
9863                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9864                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9865                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9866                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9867                     {
9868                       sfk = sfk_destructor;
9869                       ctor_return_type = ctype;
9870                       flags = DTOR_FLAG;
9871                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9872                       next = &TREE_OPERAND (decl, 0);
9873                     }
9874                 }
9875             }
9876             break;
9877
9878           case ERROR_MARK:
9879             next = 0;
9880             break;
9881
9882           case TYPE_DECL:
9883             /* Parse error puts this typespec where
9884                a declarator should go.  */
9885             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9886             if (TREE_TYPE (decl) == current_class_type)
9887               cp_error ("  perhaps you want `%T' for a constructor",
9888                         current_class_name);
9889             dname = DECL_NAME (decl);
9890             name = IDENTIFIER_POINTER (dname);
9891
9892             /* Avoid giving two errors for this.  */
9893             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9894
9895             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9896             *next = dname;
9897             next = 0;
9898             break;
9899
9900           default:
9901             cp_compiler_error ("`%D' as declarator", decl);
9902             return 0; /* We used to do a 155 abort here.  */
9903           }
9904       }
9905   }
9906
9907   /* A function definition's declarator must have the form of
9908      a function declarator.  */
9909
9910   if (funcdef_flag && innermost_code != CALL_EXPR)
9911     return 0;
9912
9913   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9914       && innermost_code != CALL_EXPR
9915       && ! (ctype && declspecs == NULL_TREE))
9916     {
9917       cp_error ("declaration of `%D' as non-function", dname);
9918       return void_type_node;
9919     }
9920
9921   /* Anything declared one level down from the top level
9922      must be one of the parameters of a function
9923      (because the body is at least two levels down).  */
9924
9925   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9926      by not allowing C++ class definitions to specify their parameters
9927      with xdecls (must be spec.d in the parmlist).
9928
9929      Since we now wait to push a class scope until we are sure that
9930      we are in a legitimate method context, we must set oldcname
9931      explicitly (since current_class_name is not yet alive).
9932
9933      We also want to avoid calling this a PARM if it is in a namespace.  */
9934
9935   if (decl_context == NORMAL && !toplevel_bindings_p ())
9936     {
9937       struct binding_level *b = current_binding_level;
9938       current_binding_level = b->level_chain;
9939       if (current_binding_level != 0 && toplevel_bindings_p ())
9940         decl_context = PARM;
9941       current_binding_level = b;
9942     }
9943
9944   if (name == NULL)
9945     name = decl_context == PARM ? "parameter" : "type name";
9946
9947   /* Look through the decl specs and record which ones appear.
9948      Some typespecs are defined as built-in typenames.
9949      Others, the ones that are modifiers of other types,
9950      are represented by bits in SPECBITS: set the bits for
9951      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9952
9953      If there is a typedef name or a type, store the type in TYPE.
9954      This includes builtin typedefs such as `int'.
9955
9956      Set EXPLICIT_INT if the type is `int' or `char' and did not
9957      come from a user typedef.
9958
9959      Set LONGLONG if `long' is mentioned twice.
9960
9961      For C++, constructors and destructors have their own fast treatment.  */
9962
9963   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9964     {
9965       register int i;
9966       register tree id;
9967
9968       /* Certain parse errors slip through.  For example,
9969          `int class;' is not caught by the parser. Try
9970          weakly to recover here.  */
9971       if (TREE_CODE (spec) != TREE_LIST)
9972         return 0;
9973
9974       id = TREE_VALUE (spec);
9975
9976       if (TREE_CODE (id) == IDENTIFIER_NODE)
9977         {
9978           if (id == ridpointers[(int) RID_INT]
9979               || id == ridpointers[(int) RID_CHAR]
9980               || id == ridpointers[(int) RID_BOOL]
9981               || id == ridpointers[(int) RID_WCHAR])
9982             {
9983               if (type)
9984                 {
9985                   if (id == ridpointers[(int) RID_BOOL])
9986                     error ("`bool' is now a keyword");
9987                   else
9988                     cp_error ("extraneous `%T' ignored", id);
9989                 }
9990               else
9991                 {
9992                   if (id == ridpointers[(int) RID_INT])
9993                     explicit_int = 1;
9994                   else if (id == ridpointers[(int) RID_CHAR])
9995                     explicit_char = 1;
9996                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9997                 }
9998               goto found;
9999             }
10000           /* C++ aggregate types.  */
10001           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10002             {
10003               if (type)
10004                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10005               else
10006                 type = IDENTIFIER_TYPE_VALUE (id);
10007               goto found;
10008             }
10009
10010           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10011             {
10012               if (ridpointers[i] == id)
10013                 {
10014                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10015                     {
10016                       if (pedantic && ! in_system_header && warn_long_long)
10017                         pedwarn ("ISO C++ does not support `long long'");
10018                       if (longlong)
10019                         error ("`long long long' is too long for GCC");
10020                       else
10021                         longlong = 1;
10022                     }
10023                   else if (RIDBIT_SETP (i, specbits))
10024                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10025                   RIDBIT_SET (i, specbits);
10026                   goto found;
10027                 }
10028             }
10029         }
10030       /* C++ aggregate types.  */
10031       else if (TREE_CODE (id) == TYPE_DECL)
10032         {
10033           if (type)
10034             cp_error ("multiple declarations `%T' and `%T'", type,
10035                       TREE_TYPE (id));
10036           else
10037             {
10038               type = TREE_TYPE (id);
10039               TREE_VALUE (spec) = type;
10040             }
10041           goto found;
10042         }
10043       if (type)
10044         error ("two or more data types in declaration of `%s'", name);
10045       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10046         {
10047           register tree t = lookup_name (id, 1);
10048           if (!t || TREE_CODE (t) != TYPE_DECL)
10049             error ("`%s' fails to be a typedef or built in type",
10050                    IDENTIFIER_POINTER (id));
10051           else
10052             {
10053               type = TREE_TYPE (t);
10054 #if 0
10055               /* See the code below that used this.  */
10056               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10057 #endif
10058               typedef_decl = t;
10059             }
10060         }
10061       else if (id != error_mark_node)
10062         /* Can't change CLASS nodes into RECORD nodes here!  */
10063         type = id;
10064
10065     found: ;
10066     }
10067
10068   typedef_type = type;
10069
10070   /* No type at all: default to `int', and set DEFAULTED_INT
10071      because it was not a user-defined typedef.  */
10072
10073   if (type == NULL_TREE
10074       && (RIDBIT_SETP (RID_SIGNED, specbits)
10075           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10076           || RIDBIT_SETP (RID_LONG, specbits)
10077           || RIDBIT_SETP (RID_SHORT, specbits)))
10078     {
10079       /* These imply 'int'.  */
10080       type = integer_type_node;
10081       defaulted_int = 1;
10082     }
10083
10084   if (sfk != sfk_none)
10085     type = check_special_function_return_type (sfk, type,
10086                                                ctor_return_type);
10087   else if (type == NULL_TREE)
10088     {
10089       int is_main;
10090
10091       explicit_int = -1;
10092
10093       /* We handle `main' specially here, because 'main () { }' is so
10094          common.  With no options, it is allowed.  With -Wreturn-type,
10095          it is a warning.  It is only an error with -pedantic-errors.  */
10096       is_main = (funcdef_flag
10097                  && MAIN_NAME_P (dname)
10098                  && ctype == NULL_TREE
10099                  && in_namespace == NULL_TREE
10100                  && current_namespace == global_namespace);
10101
10102       if (in_system_header || flag_ms_extensions)
10103         /* Allow it, sigh.  */;
10104       else if (pedantic || ! is_main)
10105         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10106                     name);
10107       else if (warn_return_type)
10108         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10109                     name);
10110
10111       type = integer_type_node;
10112     }
10113
10114   ctype = NULL_TREE;
10115
10116   /* Now process the modifiers that were specified
10117      and check for invalid combinations.  */
10118
10119   /* Long double is a special combination.  */
10120
10121   if (RIDBIT_SETP (RID_LONG, specbits)
10122       && TYPE_MAIN_VARIANT (type) == double_type_node)
10123     {
10124       RIDBIT_RESET (RID_LONG, specbits);
10125       type = build_qualified_type (long_double_type_node,
10126                                    CP_TYPE_QUALS (type));
10127     }
10128
10129   /* Check all other uses of type modifiers.  */
10130
10131   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10132       || RIDBIT_SETP (RID_SIGNED, specbits)
10133       || RIDBIT_SETP (RID_LONG, specbits)
10134       || RIDBIT_SETP (RID_SHORT, specbits))
10135     {
10136       int ok = 0;
10137
10138       if (TREE_CODE (type) == REAL_TYPE)
10139         error ("short, signed or unsigned invalid for `%s'", name);
10140       else if (TREE_CODE (type) != INTEGER_TYPE)
10141         error ("long, short, signed or unsigned invalid for `%s'", name);
10142       else if (RIDBIT_SETP (RID_LONG, specbits)
10143                && RIDBIT_SETP (RID_SHORT, specbits))
10144         error ("long and short specified together for `%s'", name);
10145       else if ((RIDBIT_SETP (RID_LONG, specbits)
10146                 || RIDBIT_SETP (RID_SHORT, specbits))
10147                && explicit_char)
10148         error ("long or short specified with char for `%s'", name);
10149       else if ((RIDBIT_SETP (RID_LONG, specbits)
10150                 || RIDBIT_SETP (RID_SHORT, specbits))
10151                && TREE_CODE (type) == REAL_TYPE)
10152         error ("long or short specified with floating type for `%s'", name);
10153       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10154                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10155         error ("signed and unsigned given together for `%s'", name);
10156       else
10157         {
10158           ok = 1;
10159           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10160             {
10161               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10162                        name);
10163               if (flag_pedantic_errors)
10164                 ok = 0;
10165             }
10166         }
10167
10168       /* Discard the type modifiers if they are invalid.  */
10169       if (! ok)
10170         {
10171           RIDBIT_RESET (RID_UNSIGNED, specbits);
10172           RIDBIT_RESET (RID_SIGNED, specbits);
10173           RIDBIT_RESET (RID_LONG, specbits);
10174           RIDBIT_RESET (RID_SHORT, specbits);
10175           longlong = 0;
10176         }
10177     }
10178
10179   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10180       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10181     {
10182       error ("complex invalid for `%s'", name);
10183       RIDBIT_RESET (RID_COMPLEX, specbits);
10184     }
10185
10186   /* Decide whether an integer type is signed or not.
10187      Optionally treat bitfields as signed by default.  */
10188   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10189       /* [class.bit]
10190
10191          It is implementation-defined whether a plain (neither
10192          explicitly signed or unsigned) char, short, int, or long
10193          bit-field is signed or unsigned.
10194
10195          Naturally, we extend this to long long as well.  Note that
10196          this does not include wchar_t.  */
10197       || (bitfield && !flag_signed_bitfields
10198           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10199           /* A typedef for plain `int' without `signed' can be
10200              controlled just like plain `int', but a typedef for
10201              `signed int' cannot be so controlled.  */
10202           && !(typedef_decl
10203                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10204           && (TREE_CODE (type) == INTEGER_TYPE
10205               || TREE_CODE (type) == CHAR_TYPE)
10206           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10207     {
10208       if (longlong)
10209         type = long_long_unsigned_type_node;
10210       else if (RIDBIT_SETP (RID_LONG, specbits))
10211         type = long_unsigned_type_node;
10212       else if (RIDBIT_SETP (RID_SHORT, specbits))
10213         type = short_unsigned_type_node;
10214       else if (type == char_type_node)
10215         type = unsigned_char_type_node;
10216       else if (typedef_decl)
10217         type = unsigned_type (type);
10218       else
10219         type = unsigned_type_node;
10220     }
10221   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10222            && type == char_type_node)
10223     type = signed_char_type_node;
10224   else if (longlong)
10225     type = long_long_integer_type_node;
10226   else if (RIDBIT_SETP (RID_LONG, specbits))
10227     type = long_integer_type_node;
10228   else if (RIDBIT_SETP (RID_SHORT, specbits))
10229     type = short_integer_type_node;
10230
10231   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10232     {
10233       /* If we just have "complex", it is equivalent to
10234          "complex double", but if any modifiers at all are specified it is
10235          the complex form of TYPE.  E.g, "complex short" is
10236          "complex short int".  */
10237
10238       if (defaulted_int && ! longlong
10239           && ! (RIDBIT_SETP (RID_LONG, specbits)
10240                 || RIDBIT_SETP (RID_SHORT, specbits)
10241                 || RIDBIT_SETP (RID_SIGNED, specbits)
10242                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10243         type = complex_double_type_node;
10244       else if (type == integer_type_node)
10245         type = complex_integer_type_node;
10246       else if (type == float_type_node)
10247         type = complex_float_type_node;
10248       else if (type == double_type_node)
10249         type = complex_double_type_node;
10250       else if (type == long_double_type_node)
10251         type = complex_long_double_type_node;
10252       else
10253         type = build_complex_type (type);
10254     }
10255
10256   if (sfk == sfk_conversion
10257       && (RIDBIT_SETP (RID_CONST, specbits)
10258           || RIDBIT_SETP (RID_VOLATILE, specbits)
10259           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10260     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10261               ctor_return_type);
10262
10263   /* Set CONSTP if this declaration is `const', whether by
10264      explicit specification or via a typedef.
10265      Likewise for VOLATILEP.  */
10266
10267   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10268   restrictp =
10269     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10270   volatilep =
10271     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10272   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10273                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10274                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10275   type = cp_build_qualified_type (type, type_quals);
10276   staticp = 0;
10277   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10278   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10279   RIDBIT_RESET (RID_VIRTUAL, specbits);
10280   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10281   RIDBIT_RESET (RID_EXPLICIT, specbits);
10282
10283   if (RIDBIT_SETP (RID_STATIC, specbits))
10284     staticp = 1 + (decl_context == FIELD);
10285
10286   if (virtualp && staticp == 2)
10287     {
10288       cp_error ("member `%D' cannot be declared both virtual and static",
10289                 dname);
10290       staticp = 0;
10291     }
10292   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10293   RIDBIT_RESET (RID_FRIEND, specbits);
10294
10295   /* Warn if two storage classes are given. Default to `auto'.  */
10296
10297   if (RIDBIT_ANY_SET (specbits))
10298     {
10299       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10300       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10301       if (decl_context == PARM && nclasses > 0)
10302         error ("storage class specifiers invalid in parameter declarations");
10303       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10304         {
10305           if (decl_context == PARM)
10306             error ("typedef declaration invalid in parameter declaration");
10307           nclasses++;
10308         }
10309       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10310       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10311     }
10312
10313   /* Give error if `virtual' is used outside of class declaration.  */
10314   if (virtualp
10315       && (current_class_name == NULL_TREE || decl_context != FIELD))
10316     {
10317       error ("virtual outside class declaration");
10318       virtualp = 0;
10319     }
10320
10321   /* Static anonymous unions are dealt with here.  */
10322   if (staticp && decl_context == TYPENAME
10323       && TREE_CODE (declspecs) == TREE_LIST
10324       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10325     decl_context = FIELD;
10326
10327   /* Warn about storage classes that are invalid for certain
10328      kinds of declarations (parameters, typenames, etc.).  */
10329
10330   if (nclasses > 1)
10331     error ("multiple storage classes in declaration of `%s'", name);
10332   else if (decl_context != NORMAL && nclasses > 0)
10333     {
10334       if ((decl_context == PARM || decl_context == CATCHPARM)
10335           && (RIDBIT_SETP (RID_REGISTER, specbits)
10336               || RIDBIT_SETP (RID_AUTO, specbits)))
10337         ;
10338       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10339         ;
10340       else if (decl_context == FIELD
10341                /* C++ allows static class elements  */
10342                && RIDBIT_SETP (RID_STATIC, specbits))
10343         /* C++ also allows inlines and signed and unsigned elements,
10344            but in those cases we don't come in here.  */
10345         ;
10346       else
10347         {
10348           if (decl_context == FIELD)
10349             {
10350               tree tmp = NULL_TREE;
10351               register int op = 0;
10352
10353               if (declarator)
10354                 {
10355                   /* Avoid trying to get an operand off an identifier node.  */
10356                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10357                     tmp = declarator;
10358                   else
10359                     tmp = TREE_OPERAND (declarator, 0);
10360                   op = IDENTIFIER_OPNAME_P (tmp);
10361                   if (IDENTIFIER_TYPENAME_P (tmp))
10362                     {
10363                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10364                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10365                               == TYPE_DECL))
10366                         name = IDENTIFIER_POINTER (tmp);
10367                       else
10368                         name = "<invalid operator>";
10369                     }
10370                 }
10371               error ("storage class specified for %s `%s'",
10372                      op ? "member operator" : "field",
10373                      name);
10374             }
10375           else
10376             {
10377               if (decl_context == PARM || decl_context == CATCHPARM)
10378                 error ("storage class specified for parameter `%s'", name);
10379               else
10380                 error ("storage class specified for typename");
10381             }
10382           RIDBIT_RESET (RID_REGISTER, specbits);
10383           RIDBIT_RESET (RID_AUTO, specbits);
10384           RIDBIT_RESET (RID_EXTERN, specbits);
10385         }
10386     }
10387   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10388     {
10389       if (toplevel_bindings_p ())
10390         {
10391           /* It's common practice (and completely valid) to have a const
10392              be initialized and declared extern.  */
10393           if (!(type_quals & TYPE_QUAL_CONST))
10394             warning ("`%s' initialized and declared `extern'", name);
10395         }
10396       else
10397         error ("`%s' has both `extern' and initializer", name);
10398     }
10399   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10400            && ! toplevel_bindings_p ())
10401     error ("nested function `%s' declared `extern'", name);
10402   else if (toplevel_bindings_p ())
10403     {
10404       if (RIDBIT_SETP (RID_AUTO, specbits))
10405         error ("top-level declaration of `%s' specifies `auto'", name);
10406     }
10407
10408   if (nclasses > 0 && friendp)
10409     error ("storage class specifiers invalid in friend function declarations");
10410
10411   /* Now figure out the structure of the declarator proper.
10412      Descend through it, creating more complex types, until we reach
10413      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10414
10415   inner_attrs = NULL_TREE;
10416   ignore_attrs = 0;
10417
10418   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10419          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10420     {
10421       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10422          an INDIRECT_REF (for *...),
10423          a CALL_EXPR (for ...(...)),
10424          an identifier (for the name being declared)
10425          or a null pointer (for the place in an absolute declarator
10426          where the name was omitted).
10427          For the last two cases, we have just exited the loop.
10428
10429          For C++ it could also be
10430          a SCOPE_REF (for class :: ...).  In this case, we have converted
10431          sensible names to types, and those are the values we use to
10432          qualify the member name.
10433          an ADDR_EXPR (for &...),
10434          a BIT_NOT_EXPR (for destructors)
10435
10436          At this point, TYPE is the type of elements of an array,
10437          or for a function to return, or for a pointer to point to.
10438          After this sequence of ifs, TYPE is the type of the
10439          array or function or pointer, and DECLARATOR has had its
10440          outermost layer removed.  */
10441
10442       if (type == error_mark_node)
10443         {
10444           if (TREE_CODE (declarator) == SCOPE_REF)
10445             declarator = TREE_OPERAND (declarator, 1);
10446           else
10447             declarator = TREE_OPERAND (declarator, 0);
10448           continue;
10449         }
10450       if (quals != NULL_TREE
10451           && (declarator == NULL_TREE
10452               || TREE_CODE (declarator) != SCOPE_REF))
10453         {
10454           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10455             ctype = TYPE_METHOD_BASETYPE (type);
10456           if (ctype != NULL_TREE)
10457             {
10458               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10459               grok_method_quals (ctype, dummy, quals);
10460               type = TREE_TYPE (dummy);
10461               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10462               quals = NULL_TREE;
10463             }
10464         }
10465
10466       /* See the comment for the TREE_LIST case, below.  */
10467       if (ignore_attrs)
10468         ignore_attrs = 0;
10469       else if (inner_attrs)
10470         {
10471           decl_attributes (type, inner_attrs, NULL_TREE);
10472           inner_attrs = NULL_TREE;
10473         }
10474
10475       switch (TREE_CODE (declarator))
10476         {
10477         case TREE_LIST:
10478           {
10479             /* We encode a declarator with embedded attributes using
10480                a TREE_LIST.  The attributes apply to the declarator
10481                directly inside them, so we have to skip an iteration
10482                before applying them to the type.  If the declarator just
10483                inside is the declarator-id, we apply the attrs to the
10484                decl itself.  */
10485             inner_attrs = TREE_PURPOSE (declarator);
10486             ignore_attrs = 1;
10487             declarator = TREE_VALUE (declarator);
10488           }
10489           break;
10490
10491         case ARRAY_REF:
10492           {
10493             register tree size;
10494
10495             size = TREE_OPERAND (declarator, 1);
10496
10497             /* VC++ spells a zero-sized array with [].  */
10498             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10499                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10500               size = integer_zero_node;
10501
10502             declarator = TREE_OPERAND (declarator, 0);
10503
10504             type = create_array_type_for_decl (dname, type, size);
10505
10506             /* VLAs never work as fields. */
10507             if (decl_context == FIELD && !processing_template_decl
10508                 && TREE_CODE (type) == ARRAY_TYPE
10509                 && TYPE_DOMAIN (type) != NULL_TREE
10510                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10511               {
10512                 cp_error ("size of member `%D' is not constant", dname);
10513                 /* Proceed with arbitrary constant size, so that offset
10514                    computations don't get confused. */
10515                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10516                                                    integer_one_node);
10517               }
10518
10519             ctype = NULL_TREE;
10520           }
10521           break;
10522
10523         case CALL_EXPR:
10524           {
10525             tree arg_types;
10526             int funcdecl_p;
10527             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10528             tree inner_decl = TREE_OPERAND (declarator, 0);
10529
10530             /* Declaring a function type.
10531                Make sure we have a valid type for the function to return.  */
10532
10533             /* We now know that the TYPE_QUALS don't apply to the
10534                decl, but to its return type.  */
10535             type_quals = TYPE_UNQUALIFIED;
10536
10537             /* Warn about some types functions can't return.  */
10538
10539             if (TREE_CODE (type) == FUNCTION_TYPE)
10540               {
10541                 error ("`%s' declared as function returning a function", name);
10542                 type = integer_type_node;
10543               }
10544             if (TREE_CODE (type) == ARRAY_TYPE)
10545               {
10546                 error ("`%s' declared as function returning an array", name);
10547                 type = integer_type_node;
10548               }
10549
10550             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10551               inner_decl = TREE_OPERAND (inner_decl, 1);
10552
10553             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10554               inner_decl = dname;
10555
10556             /* Pick up type qualifiers which should be applied to `this'.  */
10557             quals = CALL_DECLARATOR_QUALS (declarator);
10558
10559             /* Pick up the exception specifications.  */
10560             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10561
10562             /* Say it's a definition only for the CALL_EXPR
10563                closest to the identifier.  */
10564             funcdecl_p
10565               = inner_decl
10566               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10567                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10568                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10569
10570             if (ctype == NULL_TREE
10571                 && decl_context == FIELD
10572                 && funcdecl_p
10573                 && (friendp == 0 || dname == current_class_name))
10574               ctype = current_class_type;
10575
10576             if (ctype && sfk == sfk_conversion)
10577               TYPE_HAS_CONVERSION (ctype) = 1;
10578             if (ctype && constructor_name (ctype) == dname)
10579               {
10580                 /* We are within a class's scope. If our declarator name
10581                    is the same as the class name, and we are defining
10582                    a function, then it is a constructor/destructor, and
10583                    therefore returns a void type.  */
10584
10585                 if (flags == DTOR_FLAG)
10586                   {
10587                     /* ISO C++ 12.4/2.  A destructor may not be
10588                        declared const or volatile.  A destructor may
10589                        not be static.  */
10590                     if (staticp == 2)
10591                       error ("destructor cannot be static member function");
10592                     if (quals)
10593                       {
10594                         cp_error ("destructors may not be `%s'",
10595                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10596                         quals = NULL_TREE;
10597                       }
10598                     if (decl_context == FIELD)
10599                       {
10600                         if (! member_function_or_else (ctype,
10601                                                        current_class_type,
10602                                                        flags))
10603                           return void_type_node;
10604                       }
10605                   }
10606                 else            /* It's a constructor.  */
10607                   {
10608                     if (explicitp == 1)
10609                       explicitp = 2;
10610                     /* ISO C++ 12.1.  A constructor may not be
10611                        declared const or volatile.  A constructor may
10612                        not be virtual.  A constructor may not be
10613                        static.  */
10614                     if (staticp == 2)
10615                       error ("constructor cannot be static member function");
10616                     if (virtualp)
10617                       {
10618                         pedwarn ("constructors cannot be declared virtual");
10619                         virtualp = 0;
10620                       }
10621                     if (quals)
10622                       {
10623                         cp_error ("constructors may not be `%s'",
10624                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10625                         quals = NULL_TREE;
10626                       }
10627                     {
10628                       RID_BIT_TYPE tmp_bits;
10629                       memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
10630                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10631                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10632                       if (RIDBIT_ANY_SET (tmp_bits))
10633                         error ("return value type specifier for constructor ignored");
10634                     }
10635                     if (decl_context == FIELD)
10636                       {
10637                         if (! member_function_or_else (ctype,
10638                                                        current_class_type,
10639                                                        flags))
10640                           return void_type_node;
10641                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10642                         if (sfk != sfk_constructor)
10643                           return NULL_TREE;
10644                       }
10645                   }
10646                 if (decl_context == FIELD)
10647                   staticp = 0;
10648               }
10649             else if (friendp)
10650               {
10651                 if (initialized)
10652                   error ("can't initialize friend function `%s'", name);
10653                 if (virtualp)
10654                   {
10655                     /* Cannot be both friend and virtual.  */
10656                     error ("virtual functions cannot be friends");
10657                     RIDBIT_RESET (RID_FRIEND, specbits);
10658                     friendp = 0;
10659                   }
10660                 if (decl_context == NORMAL)
10661                   error ("friend declaration not in class definition");
10662                 if (current_function_decl && funcdef_flag)
10663                   cp_error ("can't define friend function `%s' in a local class definition",
10664                             name);
10665               }
10666
10667             /* Construct the function type and go to the next
10668                inner layer of declarator.  */
10669
10670             declarator = TREE_OPERAND (declarator, 0);
10671
10672             /* FIXME: This is where default args should be fully
10673                processed.  */
10674
10675             arg_types = grokparms (inner_parms);
10676
10677             if (declarator && flags == DTOR_FLAG)
10678               {
10679                 /* A destructor declared in the body of a class will
10680                    be represented as a BIT_NOT_EXPR.  But, we just
10681                    want the underlying IDENTIFIER.  */
10682                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10683                   declarator = TREE_OPERAND (declarator, 0);
10684
10685                 if (arg_types != void_list_node)
10686                   {
10687                     cp_error ("destructors may not have parameters");
10688                     arg_types = void_list_node;
10689                     last_function_parms = NULL_TREE;
10690                   }
10691               }
10692
10693             /* ANSI says that `const int foo ();'
10694                does not make the function foo const.  */
10695             type = build_function_type (type, arg_types);
10696
10697             {
10698               tree t;
10699               for (t = arg_types; t; t = TREE_CHAIN (t))
10700                 if (TREE_PURPOSE (t)
10701                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10702                   {
10703                     add_defarg_fn (type);
10704                     break;
10705                   }
10706             }
10707           }
10708           break;
10709
10710         case ADDR_EXPR:
10711         case INDIRECT_REF:
10712           /* Filter out pointers-to-references and references-to-references.
10713              We can get these if a TYPE_DECL is used.  */
10714
10715           if (TREE_CODE (type) == REFERENCE_TYPE)
10716             {
10717               error ("cannot declare %s to references",
10718                      TREE_CODE (declarator) == ADDR_EXPR
10719                      ? "references" : "pointers");
10720               declarator = TREE_OPERAND (declarator, 0);
10721               continue;
10722             }
10723
10724           if (TREE_CODE (type) == OFFSET_TYPE
10725               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10726                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10727             {
10728               cp_error ("cannot declare pointer to `%#T' member",
10729                         TREE_TYPE (type));
10730               type = TREE_TYPE (type);
10731             }
10732
10733           /* Merge any constancy or volatility into the target type
10734              for the pointer.  */
10735
10736           /* We now know that the TYPE_QUALS don't apply to the decl,
10737              but to the target of the pointer.  */
10738           type_quals = TYPE_UNQUALIFIED;
10739
10740           if (TREE_CODE (declarator) == ADDR_EXPR)
10741             {
10742               if (TREE_CODE (type) == VOID_TYPE)
10743                 error ("invalid type: `void &'");
10744               else
10745                 type = build_reference_type (type);
10746             }
10747           else if (TREE_CODE (type) == METHOD_TYPE)
10748             type = build_ptrmemfunc_type (build_pointer_type (type));
10749           else
10750             type = build_pointer_type (type);
10751
10752           /* Process a list of type modifier keywords (such as
10753              const or volatile) that were given inside the `*' or `&'.  */
10754
10755           if (TREE_TYPE (declarator))
10756             {
10757               register tree typemodlist;
10758               int erred = 0;
10759
10760               constp = 0;
10761               volatilep = 0;
10762               restrictp = 0;
10763               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10764                    typemodlist = TREE_CHAIN (typemodlist))
10765                 {
10766                   tree qualifier = TREE_VALUE (typemodlist);
10767
10768                   if (qualifier == ridpointers[(int) RID_CONST])
10769                     constp++;
10770                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10771                     volatilep++;
10772                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10773                     restrictp++;
10774                   else if (!erred)
10775                     {
10776                       erred = 1;
10777                       error ("invalid type modifier within pointer declarator");
10778                     }
10779                 }
10780               if (constp > 1)
10781                 pedwarn ("duplicate `const'");
10782               if (volatilep > 1)
10783                 pedwarn ("duplicate `volatile'");
10784               if (restrictp > 1)
10785                 pedwarn ("duplicate `restrict'");
10786
10787               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10788                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10789                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10790               if (TREE_CODE (declarator) == ADDR_EXPR
10791                   && (constp || volatilep))
10792                 {
10793                   if (constp)
10794                     pedwarn ("discarding `const' applied to a reference");
10795                   if (volatilep)
10796                     pedwarn ("discarding `volatile' applied to a reference");
10797                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10798                 }
10799               type = cp_build_qualified_type (type, type_quals);
10800             }
10801           declarator = TREE_OPERAND (declarator, 0);
10802           ctype = NULL_TREE;
10803           break;
10804
10805         case SCOPE_REF:
10806           {
10807             /* We have converted type names to NULL_TREE if the
10808                name was bogus, or to a _TYPE node, if not.
10809
10810                The variable CTYPE holds the type we will ultimately
10811                resolve to.  The code here just needs to build
10812                up appropriate member types.  */
10813             tree sname = TREE_OPERAND (declarator, 1);
10814             tree t;
10815
10816             /* Destructors can have their visibilities changed as well.  */
10817             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10818               sname = TREE_OPERAND (sname, 0);
10819
10820             if (TREE_COMPLEXITY (declarator) == 0)
10821               /* This needs to be here, in case we are called
10822                  multiple times.  */ ;
10823             else if (TREE_COMPLEXITY (declarator) == -1)
10824               /* Namespace member. */
10825               pop_decl_namespace ();
10826             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10827               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10828             else if (! IS_AGGR_TYPE_CODE
10829                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10830               ;
10831             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10832               {
10833                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10834                    that refer to ctype.  They couldn't be resolved earlier
10835                    because we hadn't pushed into the class yet.
10836                    Example: resolve 'B<T>::type' in
10837                    'B<typename B<T>::type> B<T>::f () { }'.  */
10838                 if (current_template_parms
10839                     && uses_template_parms (type)
10840                     && uses_template_parms (current_class_type))
10841                   {
10842                     tree args = current_template_args ();
10843                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10844                   }
10845
10846                 /* This pop_nested_class corresponds to the
10847                    push_nested_class used to push into class scope for
10848                    parsing the argument list of a function decl, in
10849                    qualified_id.  */
10850                 pop_nested_class ();
10851                 TREE_COMPLEXITY (declarator) = current_class_depth;
10852               }
10853             else
10854               my_friendly_abort (16);
10855
10856             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10857               {
10858                 /* We had a reference to a global decl, or
10859                    perhaps we were given a non-aggregate typedef,
10860                    in which case we cleared this out, and should just
10861                    keep going as though it wasn't there.  */
10862                 declarator = sname;
10863                 continue;
10864               }
10865             ctype = TREE_OPERAND (declarator, 0);
10866
10867             t = ctype;
10868             while (t != NULL_TREE && CLASS_TYPE_P (t))
10869               {
10870                 /* You're supposed to have one `template <...>'
10871                    for every template class, but you don't need one
10872                    for a full specialization.  For example:
10873
10874                      template <class T> struct S{};
10875                      template <> struct S<int> { void f(); };
10876                      void S<int>::f () {}
10877
10878                    is correct; there shouldn't be a `template <>' for
10879                    the definition of `S<int>::f'.  */
10880                 if (CLASSTYPE_TEMPLATE_INFO (t)
10881                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10882                         || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
10883                     && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
10884                   template_count += 1;
10885
10886                 t = TYPE_MAIN_DECL (t);
10887                 t = DECL_CONTEXT (t);
10888               }
10889
10890             if (sname == NULL_TREE)
10891               goto done_scoping;
10892
10893             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10894               {
10895                 /* This is the `standard' use of the scoping operator:
10896                    basetype :: member .  */
10897
10898                 if (ctype == current_class_type)
10899                   {
10900                     /* class A {
10901                          void A::f ();
10902                        };
10903
10904                        Is this ill-formed?  */
10905
10906                     if (pedantic)
10907                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10908                                   ctype, name);
10909                   }
10910                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10911                   {
10912                     if (current_class_type == NULL_TREE || friendp)
10913                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10914                                                       TYPE_ARG_TYPES (type));
10915                     else
10916                       {
10917                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10918                                   ctype, name, current_class_type);
10919                         return void_type_node;
10920                       }
10921                   }
10922                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10923                          || COMPLETE_TYPE_P (complete_type (ctype)))
10924                   {
10925                     /* Have to move this code elsewhere in this function.
10926                        this code is used for i.e., typedef int A::M; M *pm;
10927
10928                        It is?  How? jason 10/2/94 */
10929
10930                     if (current_class_type)
10931                       {
10932                         cp_error ("cannot declare member `%T::%s' within `%T'",
10933                                   ctype, name, current_class_type);
10934                         return void_type_node;
10935                       }
10936                     type = build_offset_type (ctype, type);
10937                   }
10938                 else
10939                   {
10940                     incomplete_type_error (NULL_TREE, ctype);
10941                     return error_mark_node;
10942                   }
10943
10944                 declarator = sname;
10945               }
10946             else if (TREE_CODE (sname) == SCOPE_REF)
10947               my_friendly_abort (17);
10948             else
10949               {
10950               done_scoping:
10951                 declarator = TREE_OPERAND (declarator, 1);
10952                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10953                   /* In this case, we will deal with it later.  */
10954                   ;
10955                 else
10956                   {
10957                     if (TREE_CODE (type) == FUNCTION_TYPE)
10958                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10959                                                       TYPE_ARG_TYPES (type));
10960                     else
10961                       type = build_offset_type (ctype, type);
10962                   }
10963               }
10964           }
10965           break;
10966
10967         case BIT_NOT_EXPR:
10968           declarator = TREE_OPERAND (declarator, 0);
10969           break;
10970
10971         case RECORD_TYPE:
10972         case UNION_TYPE:
10973         case ENUMERAL_TYPE:
10974           declarator = NULL_TREE;
10975           break;
10976
10977         case ERROR_MARK:
10978           declarator = NULL_TREE;
10979           break;
10980
10981         default:
10982           my_friendly_abort (158);
10983         }
10984     }
10985
10986   /* See the comment for the TREE_LIST case, above.  */
10987   if (inner_attrs)
10988     {
10989       if (! ignore_attrs)
10990         decl_attributes (type, inner_attrs, NULL_TREE);
10991       else if (attrlist)
10992         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10993       else
10994         attrlist = build_tree_list (NULL_TREE, inner_attrs);
10995     }
10996
10997   /* Now TYPE has the actual type.  */
10998
10999   if (explicitp == 1 || (explicitp && friendp))
11000     {
11001       /* [dcl.fct.spec] The explicit specifier shall only be used in
11002          declarations of constructors within a class definition.  */
11003       error ("only declarations of constructors can be `explicit'");
11004       explicitp = 0;
11005     }
11006
11007   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11008     {
11009       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11010         {
11011           error ("non-member `%s' cannot be declared `mutable'", name);
11012           RIDBIT_RESET (RID_MUTABLE, specbits);
11013         }
11014       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11015         {
11016           error ("non-object member `%s' cannot be declared `mutable'", name);
11017           RIDBIT_RESET (RID_MUTABLE, specbits);
11018         }
11019       else if (TREE_CODE (type) == FUNCTION_TYPE
11020                || TREE_CODE (type) == METHOD_TYPE)
11021         {
11022           error ("function `%s' cannot be declared `mutable'", name);
11023           RIDBIT_RESET (RID_MUTABLE, specbits);
11024         }
11025       else if (staticp)
11026         {
11027           error ("static `%s' cannot be declared `mutable'", name);
11028           RIDBIT_RESET (RID_MUTABLE, specbits);
11029         }
11030       else if (type_quals & TYPE_QUAL_CONST)
11031         {
11032           error ("const `%s' cannot be declared `mutable'", name);
11033           RIDBIT_RESET (RID_MUTABLE, specbits);
11034         }
11035     }
11036
11037   if (declarator == NULL_TREE
11038       || TREE_CODE (declarator) == IDENTIFIER_NODE
11039       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11040           && (TREE_CODE (type) == FUNCTION_TYPE
11041               || TREE_CODE (type) == METHOD_TYPE)))
11042     /* OK */;
11043   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11044     {
11045       cp_error ("template-id `%D' used as a declarator", declarator);
11046       declarator = dname;
11047     }
11048   else
11049     /* Unexpected declarator format.  */
11050     my_friendly_abort (990210);
11051
11052   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11053
11054   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11055     {
11056       tree decl;
11057
11058       /* Note that the grammar rejects storage classes
11059          in typenames, fields or parameters.  */
11060       if (current_lang_name == lang_name_java)
11061         TYPE_FOR_JAVA (type) = 1;
11062
11063       if (decl_context == FIELD)
11064         {
11065           if (declarator == constructor_name (current_class_type))
11066             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11067                         declarator);
11068           decl = build_lang_decl (TYPE_DECL, declarator, type);
11069         }
11070       else
11071         {
11072           decl = build_decl (TYPE_DECL, declarator, type);
11073           if (!current_function_decl)
11074             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11075         }
11076
11077       /* If the user declares "typedef struct {...} foo" then the
11078          struct will have an anonymous name.  Fill that name in now.
11079          Nothing can refer to it, so nothing needs know about the name
11080          change.  */
11081       if (type != error_mark_node
11082           && declarator
11083           && TYPE_NAME (type)
11084           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11085           && TYPE_ANONYMOUS_P (type)
11086           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11087         {
11088           tree oldname = TYPE_NAME (type);
11089           tree t;
11090
11091           /* Replace the anonymous name with the real name everywhere.  */
11092           lookup_tag_reverse (type, declarator);
11093           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11094             if (TYPE_NAME (t) == oldname)
11095               TYPE_NAME (t) = decl;
11096
11097           if (TYPE_LANG_SPECIFIC (type))
11098             TYPE_WAS_ANONYMOUS (type) = 1;
11099
11100           /* If this is a typedef within a template class, the nested
11101              type is a (non-primary) template.  The name for the
11102              template needs updating as well.  */
11103           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11104             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11105               = TYPE_IDENTIFIER (type);
11106
11107           /* FIXME remangle member functions; member functions of a
11108              type with external linkage have external linkage.  */
11109         }
11110
11111       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11112         {
11113           cp_error_at ("typedef name may not be class-qualified", decl);
11114           return NULL_TREE;
11115         }
11116       else if (quals)
11117         {
11118           if (ctype == NULL_TREE)
11119             {
11120               if (TREE_CODE (type) != METHOD_TYPE)
11121                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11122               else
11123                 ctype = TYPE_METHOD_BASETYPE (type);
11124             }
11125           if (ctype != NULL_TREE)
11126             grok_method_quals (ctype, decl, quals);
11127         }
11128
11129       if (RIDBIT_SETP (RID_SIGNED, specbits)
11130           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11131         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11132
11133       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11134                       inlinep, friendp, raises != NULL_TREE);
11135
11136       if (initialized)
11137         error ("typedef declaration includes an initializer");
11138
11139       return decl;
11140     }
11141
11142   /* Detect the case of an array type of unspecified size
11143      which came, as such, direct from a typedef name.
11144      We must copy the type, so that each identifier gets
11145      a distinct type, so that each identifier's size can be
11146      controlled separately by its own initializer.  */
11147
11148   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11149       && TYPE_DOMAIN (type) == NULL_TREE)
11150     {
11151       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11152     }
11153
11154   /* If this is a type name (such as, in a cast or sizeof),
11155      compute the type and return it now.  */
11156
11157   if (decl_context == TYPENAME)
11158     {
11159       /* Note that the grammar rejects storage classes
11160          in typenames, fields or parameters.  */
11161       if (type_quals != TYPE_UNQUALIFIED)
11162         type_quals = TYPE_UNQUALIFIED;
11163
11164       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11165       if (friendp)
11166         {
11167           if (type_quals != TYPE_UNQUALIFIED)
11168             {
11169               cp_error ("type qualifiers specified for friend class declaration");
11170               type_quals = TYPE_UNQUALIFIED;
11171             }
11172           if (inlinep)
11173             {
11174               cp_error ("`inline' specified for friend class declaration");
11175               inlinep = 0;
11176             }
11177
11178           /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11179              But don't allow implicit typenames except with a class-key.  */
11180           if (!current_aggr && (TREE_CODE (type) != TYPENAME_TYPE
11181                                 || IMPLICIT_TYPENAME_P (type)))
11182             {
11183               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11184                 cp_pedwarn ("template parameters cannot be friends");
11185               else if (TREE_CODE (type) == TYPENAME_TYPE)
11186                 cp_pedwarn ("\
11187 friend declaration requires class-key, i.e. `friend class %T::%T'",
11188                             constructor_name (current_class_type),
11189                             TYPE_IDENTIFIER (type));
11190               else
11191                 cp_pedwarn ("\
11192 friend declaration requires class-key, i.e. `friend %#T'",
11193                             type);
11194             }
11195
11196           /* Only try to do this stuff if we didn't already give up.  */
11197           if (type != integer_type_node)
11198             {
11199               /* DR 209. The friendly class does not need to be accessible
11200                  in the scope of the class granting friendship. */
11201               skip_type_access_control ();
11202
11203               /* A friendly class?  */
11204               if (current_class_type)
11205                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11206               else
11207                 cp_error ("trying to make class `%T' a friend of global scope",
11208                           type);
11209
11210               type = void_type_node;
11211             }
11212         }
11213       else if (quals)
11214         {
11215           if (ctype == NULL_TREE)
11216             {
11217               if (TREE_CODE (type) != METHOD_TYPE)
11218                 cp_error ("invalid qualifiers on non-member function type");
11219               else
11220                 ctype = TYPE_METHOD_BASETYPE (type);
11221             }
11222           if (ctype)
11223             {
11224               tree dummy = build_decl (TYPE_DECL, declarator, type);
11225               grok_method_quals (ctype, dummy, quals);
11226               type = TREE_TYPE (dummy);
11227             }
11228         }
11229
11230       return type;
11231     }
11232   else if (declarator == NULL_TREE && decl_context != PARM
11233            && decl_context != CATCHPARM
11234            && TREE_CODE (type) != UNION_TYPE
11235            && ! bitfield)
11236     {
11237       cp_error ("abstract declarator `%T' used as declaration", type);
11238       declarator = make_anon_name ();
11239     }
11240
11241   /* `void' at top level (not within pointer)
11242      is allowed only in typedefs or type names.
11243      We don't complain about parms either, but that is because
11244      a better error message can be made later.  */
11245
11246   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11247     {
11248       if (! declarator)
11249         error ("unnamed variable or field declared void");
11250       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11251         {
11252           if (IDENTIFIER_OPNAME_P (declarator))
11253             my_friendly_abort (356);
11254           else
11255             error ("variable or field `%s' declared void", name);
11256         }
11257       else
11258         error ("variable or field declared void");
11259       type = integer_type_node;
11260     }
11261
11262   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11263      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11264
11265   if (decl_context == PARM || decl_context == CATCHPARM)
11266     {
11267       if (ctype || in_namespace)
11268         error ("cannot use `::' in parameter declaration");
11269
11270       /* A parameter declared as an array of T is really a pointer to T.
11271          One declared as a function is really a pointer to a function.
11272          One declared as a member is really a pointer to member.  */
11273
11274       if (TREE_CODE (type) == ARRAY_TYPE)
11275         {
11276           /* Transfer const-ness of array into that of type pointed to.  */
11277           type = build_pointer_type (TREE_TYPE (type));
11278           type_quals = TYPE_UNQUALIFIED;
11279         }
11280       else if (TREE_CODE (type) == FUNCTION_TYPE)
11281         type = build_pointer_type (type);
11282       else if (TREE_CODE (type) == OFFSET_TYPE)
11283         type = build_pointer_type (type);
11284     }
11285
11286   {
11287     register tree decl;
11288
11289     if (decl_context == PARM)
11290       {
11291         decl = build_decl (PARM_DECL, declarator, type);
11292
11293         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11294                         inlinep, friendp, raises != NULL_TREE);
11295
11296         /* Compute the type actually passed in the parmlist,
11297            for the case where there is no prototype.
11298            (For example, shorts and chars are passed as ints.)
11299            When there is a prototype, this is overridden later.  */
11300
11301         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11302       }
11303     else if (decl_context == FIELD)
11304       {
11305         if (type == error_mark_node)
11306           {
11307             /* Happens when declaring arrays of sizes which
11308                are error_mark_node, for example.  */
11309             decl = NULL_TREE;
11310           }
11311         else if (in_namespace && !friendp)
11312           {
11313             /* Something like struct S { int N::j; };  */
11314             cp_error ("invalid use of `::'");
11315             decl = NULL_TREE;
11316           }
11317         else if (TREE_CODE (type) == FUNCTION_TYPE)
11318           {
11319             int publicp = 0;
11320             tree function_context;
11321
11322             /* We catch the others as conflicts with the builtin
11323                typedefs.  */
11324             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11325               {
11326                 cp_error ("function `%D' cannot be declared friend",
11327                           declarator);
11328                 friendp = 0;
11329               }
11330
11331             if (friendp == 0)
11332               {
11333                 if (ctype == NULL_TREE)
11334                   ctype = current_class_type;
11335
11336                 if (ctype == NULL_TREE)
11337                   {
11338                     cp_error ("can't make `%D' into a method -- not in a class",
11339                               declarator);
11340                     return void_type_node;
11341                   }
11342
11343                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11344                    ARM 9.5 */
11345                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11346                   {
11347                     cp_error ("function `%D' declared virtual inside a union",
11348                               declarator);
11349                     return void_type_node;
11350                   }
11351
11352                 if (declarator == ansi_opname (NEW_EXPR)
11353                     || declarator == ansi_opname (VEC_NEW_EXPR)
11354                     || declarator == ansi_opname (DELETE_EXPR)
11355                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11356                   {
11357                     if (virtualp)
11358                       {
11359                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11360                                   declarator);
11361                         virtualp = 0;
11362                       }
11363                   }
11364                 else if (staticp < 2)
11365                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11366                                                   TYPE_ARG_TYPES (type));
11367               }
11368
11369             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11370             function_context = (ctype != NULL_TREE) ?
11371               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11372             publicp = (! friendp || ! staticp)
11373               && function_context == NULL_TREE;
11374             decl = grokfndecl (ctype, type,
11375                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11376                                ? declarator : dname,
11377                                declarator,
11378                                virtualp, flags, quals, raises,
11379                                friendp ? -1 : 0, friendp, publicp, inlinep,
11380                                funcdef_flag, template_count, in_namespace);
11381             if (decl == NULL_TREE)
11382               return decl;
11383 #if 0
11384             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11385             /* The decl and setting of decl_machine_attr is also turned off.  */
11386             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11387 #endif
11388
11389             /* [class.conv.ctor]
11390
11391                A constructor declared without the function-specifier
11392                explicit that can be called with a single parameter
11393                specifies a conversion from the type of its first
11394                parameter to the type of its class.  Such a constructor
11395                is called a converting constructor.  */
11396             if (explicitp == 2)
11397               DECL_NONCONVERTING_P (decl) = 1;
11398             else if (DECL_CONSTRUCTOR_P (decl))
11399               {
11400                 /* The constructor can be called with exactly one
11401                    parameter if there is at least one parameter, and
11402                    any subsequent parameters have default arguments.
11403                    Ignore any compiler-added parms.  */
11404                 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
11405
11406                 if (arg_types == void_list_node
11407                     || (arg_types
11408                         && TREE_CHAIN (arg_types)
11409                         && TREE_CHAIN (arg_types) != void_list_node
11410                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11411                   DECL_NONCONVERTING_P (decl) = 1;
11412               }
11413           }
11414         else if (TREE_CODE (type) == METHOD_TYPE)
11415           {
11416             /* We only get here for friend declarations of
11417                members of other classes.  */
11418             /* All method decls are public, so tell grokfndecl to set
11419                TREE_PUBLIC, also.  */
11420             decl = grokfndecl (ctype, type, declarator, declarator,
11421                                virtualp, flags, quals, raises,
11422                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11423                                template_count, in_namespace);
11424             if (decl == NULL_TREE)
11425               return NULL_TREE;
11426           }
11427         else if (!staticp && ! processing_template_decl
11428                  && !COMPLETE_TYPE_P (complete_type (type))
11429                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11430           {
11431             if (declarator)
11432               cp_error ("field `%D' has incomplete type", declarator);
11433             else
11434               cp_error ("name `%T' has incomplete type", type);
11435
11436             /* If we're instantiating a template, tell them which
11437                instantiation made the field's type be incomplete.  */
11438             if (current_class_type
11439                 && TYPE_NAME (current_class_type)
11440                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11441                 && declspecs && TREE_VALUE (declspecs)
11442                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11443               cp_error ("  in instantiation of template `%T'",
11444                         current_class_type);
11445
11446             type = error_mark_node;
11447             decl = NULL_TREE;
11448           }
11449         else
11450           {
11451             if (friendp)
11452               {
11453                 error ("`%s' is neither function nor member function; cannot be declared friend",
11454                        IDENTIFIER_POINTER (declarator));
11455                 friendp = 0;
11456               }
11457             decl = NULL_TREE;
11458           }
11459
11460         if (friendp)
11461           {
11462             /* Friends are treated specially.  */
11463             tree t = NULL_TREE;
11464
11465             /* DR 209. The friend does not need to be accessible at this
11466                point. */
11467             skip_type_access_control ();
11468
11469             if (ctype == current_class_type)
11470               warning ("member functions are implicitly friends of their class");
11471
11472             if (decl && DECL_NAME (decl))
11473               {
11474                 if (template_class_depth (current_class_type) == 0)
11475                   {
11476                     decl = check_explicit_specialization
11477                             (declarator, decl,
11478                              template_count, 2 * (funcdef_flag != 0) + 4);
11479                     if (decl == error_mark_node)
11480                       return error_mark_node;
11481                   }
11482
11483                 t = do_friend (ctype, declarator, decl,
11484                                last_function_parms, attrlist, flags, quals,
11485                                funcdef_flag);
11486               }
11487             if (t && funcdef_flag)
11488               return t;
11489             return void_type_node;
11490           }
11491
11492         /* Structure field.  It may not be a function, except for C++ */
11493
11494         if (decl == NULL_TREE)
11495           {
11496             if (initialized)
11497               {
11498                 if (!staticp)
11499                   {
11500                     /* An attempt is being made to initialize a non-static
11501                        member.  But, from [class.mem]:
11502
11503                        4 A member-declarator can contain a
11504                        constant-initializer only if it declares a static
11505                        member (_class.static_) of integral or enumeration
11506                        type, see _class.static.data_.
11507
11508                        This used to be relatively common practice, but
11509                        the rest of the compiler does not correctly
11510                        handle the initialization unless the member is
11511                        static so we make it static below.  */
11512                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11513                                 declarator);
11514                     cp_pedwarn ("making `%D' static", declarator);
11515                     staticp = 1;
11516                   }
11517
11518                 if (uses_template_parms (type))
11519                   /* We'll check at instantiation time.  */
11520                   ;
11521                 else if (check_static_variable_definition (declarator,
11522                                                            type))
11523                   /* If we just return the declaration, crashes
11524                      will sometimes occur.  We therefore return
11525                      void_type_node, as if this was a friend
11526                      declaration, to cause callers to completely
11527                      ignore this declaration.  */
11528                   return void_type_node;
11529               }
11530
11531             /* 9.2p13 [class.mem] */
11532             if (declarator == constructor_name (current_class_type)
11533                 /* The standard does not allow non-static data members
11534                    here either, but we agreed at the 10/99 meeting
11535                    to change that in TC 1 so that they are allowed in
11536                    classes with no user-defined constructors.  */
11537                 && staticp)
11538               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11539                           declarator);
11540
11541             if (staticp)
11542               {
11543                 /* C++ allows static class members.  All other work
11544                    for this is done by grokfield.  */
11545                 decl = build_lang_decl (VAR_DECL, declarator, type);
11546                 TREE_STATIC (decl) = 1;
11547                 /* In class context, 'static' means public access.  */
11548                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11549               }
11550             else
11551               {
11552                 decl = build_decl (FIELD_DECL, declarator, type);
11553                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11554                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11555                   {
11556                     DECL_MUTABLE_P (decl) = 1;
11557                     RIDBIT_RESET (RID_MUTABLE, specbits);
11558                   }
11559               }
11560
11561             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11562                             inlinep, friendp, raises != NULL_TREE);
11563           }
11564       }
11565     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11566       {
11567         tree original_name;
11568         int publicp = 0;
11569
11570         if (! declarator)
11571           return NULL_TREE;
11572
11573         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11574           original_name = dname;
11575         else
11576           original_name = declarator;
11577
11578         if (RIDBIT_SETP (RID_AUTO, specbits))
11579           error ("storage class `auto' invalid for function `%s'", name);
11580         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11581           error ("storage class `register' invalid for function `%s'", name);
11582
11583         /* Function declaration not at top level.
11584            Storage classes other than `extern' are not allowed
11585            and `extern' makes no difference.  */
11586         if (! toplevel_bindings_p ()
11587             && (RIDBIT_SETP (RID_STATIC, specbits)
11588                 || RIDBIT_SETP (RID_INLINE, specbits))
11589             && pedantic)
11590           {
11591             if (RIDBIT_SETP (RID_STATIC, specbits))
11592               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11593             else
11594               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11595           }
11596
11597         if (ctype == NULL_TREE)
11598           {
11599             if (virtualp)
11600               {
11601                 error ("virtual non-class function `%s'", name);
11602                 virtualp = 0;
11603               }
11604           }
11605         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11606           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11607                                           TYPE_ARG_TYPES (type));
11608
11609         /* Record presence of `static'.  */
11610         publicp = (ctype != NULL_TREE
11611                    || RIDBIT_SETP (RID_EXTERN, specbits)
11612                    || !RIDBIT_SETP (RID_STATIC, specbits));
11613
11614         decl = grokfndecl (ctype, type, original_name, declarator,
11615                            virtualp, flags, quals, raises,
11616                            1, friendp,
11617                            publicp, inlinep, funcdef_flag,
11618                            template_count, in_namespace);
11619         if (decl == NULL_TREE)
11620           return NULL_TREE;
11621
11622         if (staticp == 1)
11623           {
11624             int illegal_static = 0;
11625
11626             /* Don't allow a static member function in a class, and forbid
11627                declaring main to be static.  */
11628             if (TREE_CODE (type) == METHOD_TYPE)
11629               {
11630                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11631                 illegal_static = 1;
11632               }
11633             else if (current_function_decl)
11634               {
11635                 /* FIXME need arm citation */
11636                 error ("cannot declare static function inside another function");
11637                 illegal_static = 1;
11638               }
11639
11640             if (illegal_static)
11641               {
11642                 staticp = 0;
11643                 RIDBIT_RESET (RID_STATIC, specbits);
11644               }
11645           }
11646       }
11647     else
11648       {
11649         /* It's a variable.  */
11650
11651         /* An uninitialized decl with `extern' is a reference.  */
11652         decl = grokvardecl (type, declarator, &specbits,
11653                             initialized,
11654                             (type_quals & TYPE_QUAL_CONST) != 0,
11655                             in_namespace);
11656         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11657                         inlinep, friendp, raises != NULL_TREE);
11658
11659         if (ctype)
11660           {
11661             DECL_CONTEXT (decl) = ctype;
11662             if (staticp == 1)
11663               {
11664                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11665                 staticp = 0;
11666                 RIDBIT_RESET (RID_STATIC, specbits);
11667               }
11668             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11669               {
11670                 cp_error ("static member `%D' declared `register'", decl);
11671                 RIDBIT_RESET (RID_REGISTER, specbits);
11672               }
11673             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11674               {
11675                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11676                             decl);
11677                 RIDBIT_RESET (RID_EXTERN, specbits);
11678               }
11679           }
11680       }
11681
11682     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11683
11684     /* Record `register' declaration for warnings on &
11685        and in case doing stupid register allocation.  */
11686
11687     if (RIDBIT_SETP (RID_REGISTER, specbits))
11688       DECL_REGISTER (decl) = 1;
11689
11690     if (RIDBIT_SETP (RID_EXTERN, specbits))
11691       DECL_THIS_EXTERN (decl) = 1;
11692
11693     if (RIDBIT_SETP (RID_STATIC, specbits))
11694       DECL_THIS_STATIC (decl) = 1;
11695
11696     /* Record constancy and volatility.  There's no need to do this
11697        when processing a template; we'll do this for the instantiated
11698        declaration based on the type of DECL.  */
11699     if (!processing_template_decl)
11700       c_apply_type_quals_to_decl (type_quals, decl);
11701
11702     return decl;
11703   }
11704 }
11705 \f
11706 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11707    An empty exprlist is a parmlist.  An exprlist which
11708    contains only identifiers at the global level
11709    is a parmlist.  Otherwise, it is an exprlist.  */
11710
11711 int
11712 parmlist_is_exprlist (exprs)
11713      tree exprs;
11714 {
11715   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11716     return 0;
11717
11718   if (toplevel_bindings_p ())
11719     {
11720       /* At the global level, if these are all identifiers,
11721          then it is a parmlist.  */
11722       while (exprs)
11723         {
11724           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11725             return 1;
11726           exprs = TREE_CHAIN (exprs);
11727         }
11728       return 0;
11729     }
11730   return 1;
11731 }
11732
11733 /* Subroutine of start_function.  Ensure that each of the parameter
11734    types (as listed in PARMS) is complete, as is required for a
11735    function definition.  */
11736
11737 static void
11738 require_complete_types_for_parms (parms)
11739      tree parms;
11740 {
11741   for (; parms; parms = TREE_CHAIN (parms))
11742     {
11743       if (VOID_TYPE_P (TREE_TYPE (parms)))
11744         /* grokparms will have already issued an error */
11745         TREE_TYPE (parms) = error_mark_node;
11746       else if (complete_type_or_else (TREE_TYPE (parms), parms))
11747         layout_decl (parms, 0);
11748       else
11749         TREE_TYPE (parms) = error_mark_node;
11750     }
11751 }
11752
11753 /* Returns non-zero if T is a local variable.  */
11754
11755 int
11756 local_variable_p (t)
11757      tree t;
11758 {
11759   if ((TREE_CODE (t) == VAR_DECL
11760        /* A VAR_DECL with a context that is a _TYPE is a static data
11761           member.  */
11762        && !TYPE_P (CP_DECL_CONTEXT (t))
11763        /* Any other non-local variable must be at namespace scope.  */
11764        && !DECL_NAMESPACE_SCOPE_P (t))
11765       || (TREE_CODE (t) == PARM_DECL))
11766     return 1;
11767
11768   return 0;
11769 }
11770
11771 /* Returns non-zero if T is an automatic local variable or a label.
11772    (These are the declarations that need to be remapped when the code
11773    containing them is duplicated.)  */
11774
11775 int
11776 nonstatic_local_decl_p (t)
11777      tree t;
11778 {
11779   return ((local_variable_p (t) && !TREE_STATIC (t))
11780           || TREE_CODE (t) == LABEL_DECL
11781           || TREE_CODE (t) == RESULT_DECL);
11782 }
11783
11784 /* Like local_variable_p, but suitable for use as a tree-walking
11785    function.  */
11786
11787 static tree
11788 local_variable_p_walkfn (tp, walk_subtrees, data)
11789      tree *tp;
11790      int *walk_subtrees ATTRIBUTE_UNUSED;
11791      void *data ATTRIBUTE_UNUSED;
11792 {
11793   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11794           ? *tp : NULL_TREE);
11795 }
11796
11797 /* Check that ARG, which is a default-argument expression for a
11798    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11799    something goes wrong.  DECL may also be a _TYPE node, rather than a
11800    DECL, if there is no DECL available.  */
11801
11802 tree
11803 check_default_argument (decl, arg)
11804      tree decl;
11805      tree arg;
11806 {
11807   tree var;
11808   tree decl_type;
11809
11810   if (TREE_CODE (arg) == DEFAULT_ARG)
11811     /* We get a DEFAULT_ARG when looking at an in-class declaration
11812        with a default argument.  Ignore the argument for now; we'll
11813        deal with it after the class is complete.  */
11814     return arg;
11815
11816   if (processing_template_decl || uses_template_parms (arg))
11817     /* We don't do anything checking until instantiation-time.  Note
11818        that there may be uninstantiated arguments even for an
11819        instantiated function, since default arguments are not
11820        instantiated until they are needed.  */
11821     return arg;
11822
11823   if (TYPE_P (decl))
11824     {
11825       decl_type = decl;
11826       decl = NULL_TREE;
11827     }
11828   else
11829     decl_type = TREE_TYPE (decl);
11830
11831   if (arg == error_mark_node
11832       || decl == error_mark_node
11833       || TREE_TYPE (arg) == error_mark_node
11834       || decl_type == error_mark_node)
11835     /* Something already went wrong.  There's no need to check
11836        further.  */
11837     return error_mark_node;
11838
11839   /* [dcl.fct.default]
11840
11841      A default argument expression is implicitly converted to the
11842      parameter type.  */
11843   if (!TREE_TYPE (arg)
11844       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11845     {
11846       if (decl)
11847         cp_error ("default argument for `%#D' has type `%T'",
11848                   decl, TREE_TYPE (arg));
11849       else
11850         cp_error ("default argument for parameter of type `%T' has type `%T'",
11851                   decl_type, TREE_TYPE (arg));
11852
11853       return error_mark_node;
11854     }
11855
11856   /* [dcl.fct.default]
11857
11858      Local variables shall not be used in default argument
11859      expressions.
11860
11861      The keyword `this' shall not be used in a default argument of a
11862      member function.  */
11863   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
11864                                       NULL);
11865   if (var)
11866     {
11867       cp_error ("default argument `%E' uses local variable `%D'",
11868                 arg, var);
11869       return error_mark_node;
11870     }
11871
11872   /* All is well.  */
11873   return arg;
11874 }
11875
11876 /* Decode the list of parameter types for a function type.
11877    Given the list of things declared inside the parens,
11878    return a list of types.
11879
11880    We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
11881    flag. If unset, we append void_list_node. A parmlist declared
11882    as `(void)' is accepted as the empty parmlist.
11883
11884    Also set last_function_parms to the chain of PARM_DECLs.  */
11885
11886 static tree
11887 grokparms (first_parm)
11888      tree first_parm;
11889 {
11890   tree result = NULL_TREE;
11891   tree decls = NULL_TREE;
11892   int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
11893   tree parm, chain;
11894   int any_error = 0;
11895
11896   my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
11897
11898   for (parm = first_parm; parm != NULL_TREE; parm = chain)
11899     {
11900       tree type = NULL_TREE;
11901       register tree decl = TREE_VALUE (parm);
11902       tree init = TREE_PURPOSE (parm);
11903
11904       chain = TREE_CHAIN (parm);
11905       /* @@ weak defense against parse errors.  */
11906       if (TREE_CODE (decl) != VOID_TYPE
11907           && TREE_CODE (decl) != TREE_LIST)
11908         {
11909           /* Give various messages as the need arises.  */
11910           if (TREE_CODE (decl) == STRING_CST)
11911             cp_error ("invalid string constant `%E'", decl);
11912           else if (TREE_CODE (decl) == INTEGER_CST)
11913             error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11914           continue;
11915         }
11916
11917       if (parm == void_list_node)
11918         break;
11919
11920       decl = grokdeclarator (TREE_VALUE (decl), TREE_PURPOSE (decl),
11921                      PARM, init != NULL_TREE, NULL_TREE);
11922       if (! decl || TREE_TYPE (decl) == error_mark_node)
11923         continue;
11924
11925       type = TREE_TYPE (decl);
11926       if (VOID_TYPE_P (type))
11927         {
11928           if (same_type_p (type, void_type_node)
11929               && !DECL_NAME (decl) && !result && !chain && !ellipsis)
11930             /* this is a parmlist of `(void)', which is ok.  */
11931             break;
11932           incomplete_type_error (decl, type);
11933           /* It's not a good idea to actually create parameters of
11934              type `void'; other parts of the compiler assume that a
11935              void type terminates the parameter list.  */
11936           type = error_mark_node;
11937           TREE_TYPE (decl) = error_mark_node;
11938         }
11939
11940       if (type != error_mark_node)
11941         {
11942           /* Top-level qualifiers on the parameters are
11943              ignored for function types.  */
11944           type = TYPE_MAIN_VARIANT (type);
11945           if (TREE_CODE (type) == METHOD_TYPE)
11946             {
11947               cp_error ("parameter `%D' invalidly declared method type", decl);
11948               type = build_pointer_type (type);
11949               TREE_TYPE (decl) = type;
11950             }
11951           else if (TREE_CODE (type) == OFFSET_TYPE)
11952             {
11953               cp_error ("parameter `%D' invalidly declared offset type", decl);
11954               type = build_pointer_type (type);
11955               TREE_TYPE (decl) = type;
11956             }
11957           else if (abstract_virtuals_error (decl, type))
11958             any_error = 1;  /* Seems like a good idea. */
11959           else if (POINTER_TYPE_P (type))
11960             {
11961               /* [dcl.fct]/6, parameter types cannot contain pointers
11962                  (references) to arrays of unknown bound.  */
11963               tree t = TREE_TYPE (type);
11964               int ptr = TYPE_PTR_P (type);
11965
11966               while (1)
11967                 {
11968                   if (TYPE_PTR_P (t))
11969                     ptr = 1;
11970                   else if (TREE_CODE (t) != ARRAY_TYPE)
11971                     break;
11972                   else if (!TYPE_DOMAIN (t))
11973                     break;
11974                   t = TREE_TYPE (t);
11975                 }
11976               if (TREE_CODE (t) == ARRAY_TYPE)
11977                 cp_error ("parameter `%D' includes %s to array of unknown bound `%T'",
11978                           decl, ptr ? "pointer" : "reference", t);
11979             }
11980
11981           DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11982           if (PROMOTE_PROTOTYPES
11983               && INTEGRAL_TYPE_P (type)
11984               && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11985             DECL_ARG_TYPE (decl) = integer_type_node;
11986           if (!any_error && init)
11987             init = check_default_argument (decl, init);
11988           else
11989             init = NULL_TREE;
11990         }
11991
11992       TREE_CHAIN (decl) = decls;
11993       decls = decl;
11994       result = tree_cons (init, type, result);
11995     }
11996   decls = nreverse (decls);
11997   result = nreverse (result);
11998   if (!ellipsis)
11999     result = chainon (result, void_list_node);
12000   last_function_parms = decls;
12001
12002   return result;
12003 }
12004
12005 \f
12006 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12007    D's arguments allow it to be a copy constructor, or copy assignment
12008    operator.  */
12009
12010 int
12011 copy_args_p (d)
12012      tree d;
12013 {
12014   tree t;
12015
12016   if (!DECL_FUNCTION_MEMBER_P (d))
12017     return 0;
12018
12019   t = FUNCTION_FIRST_USER_PARMTYPE (d);
12020   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12021       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12022           == DECL_CONTEXT (d))
12023       && (TREE_CHAIN (t) == NULL_TREE
12024           || TREE_CHAIN (t) == void_list_node
12025           || TREE_PURPOSE (TREE_CHAIN (t))))
12026     return 1;
12027   return 0;
12028 }
12029
12030 /* These memoizing functions keep track of special properties which
12031    a class may have.  `grok_ctor_properties' notices whether a class
12032    has a constructor of the form X(X&), and also complains
12033    if the class has a constructor of the form X(X).
12034    `grok_op_properties' takes notice of the various forms of
12035    operator= which are defined, as well as what sorts of type conversion
12036    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12037
12038 int
12039 grok_ctor_properties (ctype, decl)
12040      tree ctype, decl;
12041 {
12042   tree parmtypes = FUNCTION_FIRST_USER_PARMTYPE (decl);
12043   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12044
12045   /* [class.copy]
12046
12047      A non-template constructor for class X is a copy constructor if
12048      its first parameter is of type X&, const X&, volatile X& or const
12049      volatile X&, and either there are no other parameters or else all
12050      other parameters have default arguments.  */
12051   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12052       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12053       && sufficient_parms_p (TREE_CHAIN (parmtypes))
12054       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12055            && is_member_template (DECL_TI_TEMPLATE (decl))))
12056     {
12057       TYPE_HAS_INIT_REF (ctype) = 1;
12058       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12059         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12060     }
12061   /* [class.copy]
12062
12063      A declaration of a constructor for a class X is ill-formed if its
12064      first parameter is of type (optionally cv-qualified) X and either
12065      there are no other parameters or else all other parameters have
12066      default arguments.
12067
12068      We *don't* complain about member template instantiations that
12069      have this form, though; they can occur as we try to decide what
12070      constructor to use during overload resolution.  Since overload
12071      resolution will never prefer such a constructor to the
12072      non-template copy constructor (which is either explicitly or
12073      implicitly defined), there's no need to worry about their
12074      existence.  Theoretically, they should never even be
12075      instantiated, but that's hard to forestall.  */
12076   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12077            && sufficient_parms_p (TREE_CHAIN (parmtypes))
12078            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12079                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12080     {
12081       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12082                 ctype, ctype);
12083       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12084       return 0;
12085     }
12086   else if (TREE_CODE (parmtype) == VOID_TYPE
12087            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12088     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12089
12090   return 1;
12091 }
12092
12093 /* An operator with this code is unary, but can also be binary.  */
12094
12095 static int
12096 ambi_op_p (code)
12097      enum tree_code code;
12098 {
12099   return (code == INDIRECT_REF
12100           || code == ADDR_EXPR
12101           || code == CONVERT_EXPR
12102           || code == NEGATE_EXPR
12103           || code == PREINCREMENT_EXPR
12104           || code == PREDECREMENT_EXPR);
12105 }
12106
12107 /* An operator with this name can only be unary.  */
12108
12109 static int
12110 unary_op_p (code)
12111      enum tree_code code;
12112 {
12113   return (code == TRUTH_NOT_EXPR
12114           || code == BIT_NOT_EXPR
12115           || code == COMPONENT_REF
12116           || code == TYPE_EXPR);
12117 }
12118
12119 /* Do a little sanity-checking on how they declared their operator.  */
12120
12121 void
12122 grok_op_properties (decl, virtualp, friendp)
12123      tree decl;
12124      int virtualp, friendp;
12125 {
12126   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12127   tree argtype;
12128   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12129   tree name = DECL_NAME (decl);
12130   enum tree_code operator_code;
12131   int arity;
12132
12133   /* Count the number of arguments.  */
12134   for (argtype = argtypes, arity = 0;
12135        argtype && argtype != void_list_node;
12136        argtype = TREE_CHAIN (argtype))
12137     ++arity;
12138
12139   if (current_class_type == NULL_TREE)
12140     friendp = 1;
12141
12142   if (DECL_CONV_FN_P (decl))
12143     operator_code = TYPE_EXPR;
12144   else
12145     do
12146       {
12147 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)       \
12148         if (ansi_opname (CODE) == name)                         \
12149           {                                                     \
12150             operator_code = CODE;                               \
12151             break;                                              \
12152           }                                                     \
12153         else if (ansi_assopname (CODE) == name)                 \
12154           {                                                     \
12155             operator_code = CODE;                               \
12156             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;              \
12157             break;                                              \
12158           }
12159
12160 #include "operators.def"
12161 #undef DEF_OPERATOR
12162
12163         my_friendly_abort (20000527);
12164       }
12165     while (0);
12166   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12167   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12168
12169   if (! friendp)
12170     {
12171       switch (operator_code)
12172         {
12173         case CALL_EXPR:
12174           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12175           break;
12176
12177         case ARRAY_REF:
12178           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12179           break;
12180
12181         case COMPONENT_REF:
12182         case MEMBER_REF:
12183           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12184           break;
12185
12186         case NEW_EXPR:
12187           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12188           break;
12189
12190         case DELETE_EXPR:
12191           TYPE_GETS_DELETE (current_class_type) |= 1;
12192           break;
12193
12194         case VEC_NEW_EXPR:
12195           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12196           break;
12197
12198         case VEC_DELETE_EXPR:
12199           TYPE_GETS_DELETE (current_class_type) |= 2;
12200           break;
12201
12202         default:
12203           break;
12204         }
12205     }
12206
12207   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12208     {
12209       /* When the compiler encounters the definition of A::operator new, it
12210          doesn't look at the class declaration to find out if it's static.  */
12211       if (methodp)
12212         revert_static_member_fn (decl);
12213
12214       TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12215     }
12216   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12217     {
12218       if (methodp)
12219         revert_static_member_fn (decl);
12220
12221       TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12222     }
12223   else
12224     {
12225       /* An operator function must either be a non-static member function
12226          or have at least one parameter of a class, a reference to a class,
12227          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12228       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12229         {
12230           if (operator_code == TYPE_EXPR
12231               || operator_code == CALL_EXPR
12232               || operator_code == COMPONENT_REF
12233               || operator_code == ARRAY_REF
12234               || operator_code == NOP_EXPR)
12235             cp_error ("`%D' must be a nonstatic member function", decl);
12236           else
12237             {
12238               tree p = argtypes;
12239
12240               if (DECL_STATIC_FUNCTION_P (decl))
12241                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12242
12243               if (p)
12244                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12245                   {
12246                     tree arg = TREE_VALUE (p);
12247                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12248                       arg = TREE_TYPE (arg);
12249
12250                     /* This lets bad template code slip through.  */
12251                     if (IS_AGGR_TYPE (arg)
12252                         || TREE_CODE (arg) == ENUMERAL_TYPE
12253                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12254                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12255                       goto foundaggr;
12256                   }
12257               cp_error
12258                 ("`%D' must have an argument of class or enumerated type",
12259                  decl);
12260             foundaggr:
12261               ;
12262             }
12263         }
12264
12265       if (operator_code == CALL_EXPR)
12266         return;                 /* No restrictions on args. */
12267
12268       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12269         {
12270           tree t = TREE_TYPE (name);
12271           if (! friendp)
12272             {
12273               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12274               const char *what = 0;
12275
12276               if (ref)
12277                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12278
12279               if (TREE_CODE (t) == VOID_TYPE)
12280                 what = "void";
12281               else if (t == current_class_type)
12282                 what = "the same type";
12283               /* Don't force t to be complete here.  */
12284               else if (IS_AGGR_TYPE (t)
12285                        && COMPLETE_TYPE_P (t)
12286                        && DERIVED_FROM_P (t, current_class_type))
12287                 what = "a base class";
12288
12289               if (what)
12290                 warning ("conversion to %s%s will never use a type conversion operator",
12291                          ref ? "a reference to " : "", what);
12292             }
12293         }
12294
12295       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12296           && operator_code == NOP_EXPR)
12297         {
12298           tree parmtype;
12299
12300           if (arity != 2 && methodp)
12301             {
12302               cp_error ("`%D' must take exactly one argument", decl);
12303               return;
12304             }
12305           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12306
12307           /* [class.copy]
12308
12309              A user-declared copy assignment operator X::operator= is
12310              a non-static non-template member function of class X with
12311              exactly one parameter of type X, X&, const X&, volatile
12312              X& or const volatile X&.  */
12313           if (copy_assignment_arg_p (parmtype, virtualp)
12314               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12315                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12316               && ! friendp)
12317             {
12318               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12319               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12320                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12321                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12322             }
12323         }
12324       else if (operator_code == COND_EXPR)
12325         {
12326           /* 13.4.0.3 */
12327           cp_error ("ISO C++ prohibits overloading operator ?:");
12328         }
12329       else if (ambi_op_p (operator_code))
12330         {
12331           if (arity == 1)
12332             /* We pick the one-argument operator codes by default, so
12333                we don't have to change anything.  */
12334             ;
12335           else if (arity == 2)
12336             {
12337               /* If we thought this was a unary operator, we now know
12338                  it to be a binary operator.  */
12339               switch (operator_code)
12340                 {
12341                 case INDIRECT_REF:
12342                   operator_code = MULT_EXPR;
12343                   break;
12344
12345                 case ADDR_EXPR:
12346                   operator_code = BIT_AND_EXPR;
12347                   break;
12348
12349                 case CONVERT_EXPR:
12350                   operator_code = PLUS_EXPR;
12351                   break;
12352
12353                 case NEGATE_EXPR:
12354                   operator_code = MINUS_EXPR;
12355                   break;
12356
12357                 case PREINCREMENT_EXPR:
12358                   operator_code = POSTINCREMENT_EXPR;
12359                   break;
12360
12361                 case PREDECREMENT_EXPR:
12362                   operator_code = POSTDECREMENT_EXPR;
12363                   break;
12364
12365                 default:
12366                   my_friendly_abort (20000527);
12367                 }
12368
12369               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12370
12371               if ((operator_code == POSTINCREMENT_EXPR
12372                    || operator_code == POSTDECREMENT_EXPR)
12373                   && ! processing_template_decl
12374                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12375                 {
12376                   if (methodp)
12377                     cp_error ("postfix `%D' must take `int' as its argument",
12378                               decl);
12379                   else
12380                     cp_error
12381                       ("postfix `%D' must take `int' as its second argument",
12382                        decl);
12383                 }
12384             }
12385           else
12386             {
12387               if (methodp)
12388                 cp_error ("`%D' must take either zero or one argument", decl);
12389               else
12390                 cp_error ("`%D' must take either one or two arguments", decl);
12391             }
12392
12393           /* More Effective C++ rule 6.  */
12394           if (warn_ecpp
12395               && (operator_code == POSTINCREMENT_EXPR
12396                   || operator_code == POSTDECREMENT_EXPR
12397                   || operator_code == PREINCREMENT_EXPR
12398                   || operator_code == PREDECREMENT_EXPR))
12399             {
12400               tree arg = TREE_VALUE (argtypes);
12401               tree ret = TREE_TYPE (TREE_TYPE (decl));
12402               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12403                 arg = TREE_TYPE (arg);
12404               arg = TYPE_MAIN_VARIANT (arg);
12405               if (operator_code == PREINCREMENT_EXPR
12406                   || operator_code == PREDECREMENT_EXPR)
12407                 {
12408                   if (TREE_CODE (ret) != REFERENCE_TYPE
12409                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12410                                        arg))
12411                     cp_warning ("prefix `%D' should return `%T'", decl,
12412                                 build_reference_type (arg));
12413                 }
12414               else
12415                 {
12416                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12417                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12418                 }
12419             }
12420         }
12421       else if (unary_op_p (operator_code))
12422         {
12423           if (arity != 1)
12424             {
12425               if (methodp)
12426                 cp_error ("`%D' must take `void'", decl);
12427               else
12428                 cp_error ("`%D' must take exactly one argument", decl);
12429             }
12430         }
12431       else /* if (binary_op_p (operator_code)) */
12432         {
12433           if (arity != 2)
12434             {
12435               if (methodp)
12436                 cp_error ("`%D' must take exactly one argument", decl);
12437               else
12438                 cp_error ("`%D' must take exactly two arguments", decl);
12439             }
12440
12441           /* More Effective C++ rule 7.  */
12442           if (warn_ecpp
12443               && (operator_code == TRUTH_ANDIF_EXPR
12444                   || operator_code == TRUTH_ORIF_EXPR
12445                   || operator_code == COMPOUND_EXPR))
12446             cp_warning ("user-defined `%D' always evaluates both arguments",
12447                         decl);
12448         }
12449
12450       /* Effective C++ rule 23.  */
12451       if (warn_ecpp
12452           && arity == 2
12453           && (operator_code == PLUS_EXPR
12454               || operator_code == MINUS_EXPR
12455               || operator_code == TRUNC_DIV_EXPR
12456               || operator_code == MULT_EXPR)
12457           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12458         cp_warning ("`%D' should return by value", decl);
12459
12460       /* 13.4.0.8 */
12461       for (; argtypes && argtypes != void_list_node;
12462           argtypes = TREE_CHAIN (argtypes))
12463         if (TREE_PURPOSE (argtypes))
12464           {
12465             TREE_PURPOSE (argtypes) = NULL_TREE;
12466             if (operator_code == POSTINCREMENT_EXPR
12467                 || operator_code == POSTDECREMENT_EXPR)
12468               {
12469                 if (pedantic)
12470                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12471               }
12472             else
12473               cp_error ("`%D' cannot have default arguments", decl);
12474           }
12475
12476     }
12477 }
12478 \f
12479 static const char *
12480 tag_name (code)
12481      enum tag_types code;
12482 {
12483   switch (code)
12484     {
12485     case record_type:
12486       return "struct";
12487     case class_type:
12488       return "class";
12489     case union_type:
12490       return "union ";
12491     case enum_type:
12492       return "enum";
12493     default:
12494       my_friendly_abort (981122);
12495     }
12496 }
12497
12498 /* Get the struct, enum or union (CODE says which) with tag NAME.
12499    Define the tag as a forward-reference if it is not defined.
12500
12501    C++: If a class derivation is given, process it here, and report
12502    an error if multiple derivation declarations are not identical.
12503
12504    If this is a definition, come in through xref_tag and only look in
12505    the current frame for the name (since C++ allows new names in any
12506    scope.)  */
12507
12508 tree
12509 xref_tag (code_type_node, name, globalize)
12510      tree code_type_node;
12511      tree name;
12512      int globalize;
12513 {
12514   enum tag_types tag_code;
12515   enum tree_code code;
12516   register tree ref, t;
12517   struct binding_level *b = current_binding_level;
12518   int got_type = 0;
12519   tree attributes = NULL_TREE;
12520   tree context = NULL_TREE;
12521
12522   /* If we are called from the parser, code_type_node will sometimes be a
12523      TREE_LIST.  This indicates that the user wrote
12524      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12525      use them later.  */
12526   if (TREE_CODE (code_type_node) == TREE_LIST)
12527     {
12528       attributes = TREE_PURPOSE (code_type_node);
12529       code_type_node = TREE_VALUE (code_type_node);
12530     }
12531
12532   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12533   switch (tag_code)
12534     {
12535     case record_type:
12536     case class_type:
12537       code = RECORD_TYPE;
12538       break;
12539     case union_type:
12540       code = UNION_TYPE;
12541       break;
12542     case enum_type:
12543       code = ENUMERAL_TYPE;
12544       break;
12545     default:
12546       my_friendly_abort (18);
12547     }
12548
12549   /* If a cross reference is requested, look up the type
12550      already defined for this tag and return it.  */
12551   if (TYPE_P (name))
12552     {
12553       t = name;
12554       name = TYPE_IDENTIFIER (t);
12555       got_type = 1;
12556     }
12557   else
12558     t = IDENTIFIER_TYPE_VALUE (name);
12559
12560   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12561   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12562     {
12563       static int explained;
12564       tree shadowed;
12565
12566       cp_warning ("`%s %T' declares a new type at namespace scope",
12567                   tag_name (tag_code), name);
12568       if (!explained++)
12569         cp_warning ("  names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'",
12570                     tag_name (tag_code),
12571                     constructor_name (current_class_type),
12572                     TYPE_IDENTIFIER (t));
12573
12574       /* We need to remove the class scope binding for the
12575          TYPENAME_TYPE as otherwise poplevel_class gets confused. */
12576       for (shadowed = b->class_shadowed;
12577            shadowed;
12578            shadowed = TREE_CHAIN (shadowed))
12579         if (TREE_TYPE (shadowed) == TYPE_NAME (t))
12580           {
12581             TREE_PURPOSE (shadowed) = NULL_TREE;
12582             break;
12583           }
12584     }
12585
12586   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12587       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12588     t = NULL_TREE;
12589
12590   if (! globalize)
12591     {
12592       /* If we know we are defining this tag, only look it up in
12593          this scope and don't try to find it as a type.  */
12594       ref = lookup_tag (code, name, b, 1);
12595     }
12596   else
12597     {
12598       if (t)
12599         {
12600           /* [dcl.type.elab] If the identifier resolves to a
12601              typedef-name or a template type-parameter, the
12602              elaborated-type-specifier is ill-formed.  */
12603           if (t != TYPE_MAIN_VARIANT (t)
12604               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12605             cp_pedwarn ("using typedef-name `%D' after `%s'",
12606                         TYPE_NAME (t), tag_name (tag_code));
12607           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12608             cp_error ("using template type parameter `%T' after `%s'",
12609                       t, tag_name (tag_code));
12610
12611           ref = t;
12612         }
12613       else
12614         ref = lookup_tag (code, name, b, 0);
12615
12616       if (! ref)
12617         {
12618           /* Try finding it as a type declaration.  If that wins,
12619              use it.  */
12620           ref = lookup_name (name, 1);
12621
12622           if (ref != NULL_TREE
12623               && processing_template_decl
12624               && DECL_CLASS_TEMPLATE_P (ref)
12625               && template_class_depth (current_class_type) == 0)
12626             /* Since GLOBALIZE is true, we're declaring a global
12627                template, so we want this type.  */
12628             ref = DECL_TEMPLATE_RESULT (ref);
12629
12630           if (ref && TREE_CODE (ref) == TYPE_DECL
12631               && TREE_CODE (TREE_TYPE (ref)) == code)
12632             ref = TREE_TYPE (ref);
12633           else
12634             ref = NULL_TREE;
12635         }
12636
12637       if (ref && current_class_type
12638           && template_class_depth (current_class_type)
12639           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12640         {
12641           /* Since GLOBALIZE is non-zero, we are not looking at a
12642              definition of this tag.  Since, in addition, we are currently
12643              processing a (member) template declaration of a template
12644              class, we must be very careful; consider:
12645
12646                template <class X>
12647                struct S1
12648
12649                template <class U>
12650                struct S2
12651                { template <class V>
12652                friend struct S1; };
12653
12654              Here, the S2::S1 declaration should not be confused with the
12655              outer declaration.  In particular, the inner version should
12656              have a template parameter of level 2, not level 1.  This
12657              would be particularly important if the member declaration
12658              were instead:
12659
12660                template <class V = U> friend struct S1;
12661
12662              say, when we should tsubst into `U' when instantiating
12663              S2.  On the other hand, when presented with:
12664
12665                  template <class T>
12666                  struct S1 {
12667                    template <class U>
12668                    struct S2 {};
12669                    template <class U>
12670                    friend struct S2;
12671                  };
12672
12673               we must find the inner binding eventually.  We
12674               accomplish this by making sure that the new type we
12675               create to represent this declaration has the right
12676               TYPE_CONTEXT.  */
12677           context = TYPE_CONTEXT (ref);
12678           ref = NULL_TREE;
12679         }
12680     }
12681
12682   if (! ref)
12683     {
12684       /* If no such tag is yet defined, create a forward-reference node
12685          and record it as the "definition".
12686          When a real declaration of this type is found,
12687          the forward-reference will be altered into a real type.  */
12688       if (code == ENUMERAL_TYPE)
12689         {
12690           cp_error ("use of enum `%#D' without previous declaration", name);
12691
12692           ref = make_node (ENUMERAL_TYPE);
12693
12694           /* Give the type a default layout like unsigned int
12695              to avoid crashing if it does not get defined.  */
12696           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12697           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12698           TYPE_USER_ALIGN (ref) = 0;
12699           TREE_UNSIGNED (ref) = 1;
12700           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12701           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12702           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12703
12704           /* Enable us to recognize when a type is created in class context.
12705              To do nested classes correctly, this should probably be cleared
12706              out when we leave this classes scope.  Currently this in only
12707              done in `start_enum'.  */
12708
12709           pushtag (name, ref, globalize);
12710         }
12711       else
12712         {
12713           struct binding_level *old_b = class_binding_level;
12714
12715           ref = make_aggr_type (code);
12716           TYPE_CONTEXT (ref) = context;
12717
12718 #ifdef NONNESTED_CLASSES
12719           /* Class types don't nest the way enums do.  */
12720           class_binding_level = (struct binding_level *)0;
12721 #endif
12722           pushtag (name, ref, globalize);
12723           class_binding_level = old_b;
12724         }
12725     }
12726   else
12727     {
12728       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12729         redeclare_class_template (ref, current_template_parms);
12730     }
12731
12732   /* Until the type is defined, tentatively accept whatever
12733      structure tag the user hands us.  */
12734   if (!COMPLETE_TYPE_P (ref)
12735       && ref != current_class_type
12736       /* Have to check this, in case we have contradictory tag info.  */
12737       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12738     {
12739       if (tag_code == class_type)
12740         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12741       else if (tag_code == record_type)
12742         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12743     }
12744
12745   TREE_TYPE (ref) = attributes;
12746
12747   return ref;
12748 }
12749
12750 tree
12751 xref_tag_from_type (old, id, globalize)
12752      tree old, id;
12753      int globalize;
12754 {
12755   tree code_type_node;
12756
12757   if (TREE_CODE (old) == RECORD_TYPE)
12758     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12759                       ? class_type_node : record_type_node);
12760   else
12761     code_type_node = union_type_node;
12762
12763   if (id == NULL_TREE)
12764     id = TYPE_IDENTIFIER (old);
12765
12766   return xref_tag (code_type_node, id, globalize);
12767 }
12768
12769 /* REF is a type (named NAME), for which we have just seen some
12770    baseclasses.  BINFO is a list of those baseclasses; the
12771    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12772    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12773    struct, or union.  */
12774
12775 void
12776 xref_basetypes (code_type_node, name, ref, binfo)
12777      tree code_type_node;
12778      tree name, ref;
12779      tree binfo;
12780 {
12781   /* In the declaration `A : X, Y, ... Z' we mark all the types
12782      (A, X, Y, ..., Z) so we can check for duplicates.  */
12783   tree binfos;
12784   tree base;
12785
12786   int i, len;
12787   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12788
12789   if (tag_code == union_type)
12790     {
12791       cp_error ("derived union `%T' invalid", ref);
12792       return;
12793     }
12794
12795   len = list_length (binfo);
12796
12797   /* First, make sure that any templates in base-classes are
12798      instantiated.  This ensures that if we call ourselves recursively
12799      we do not get confused about which classes are marked and which
12800      are not.  */
12801   for (base = binfo; base; base = TREE_CHAIN (base))
12802     complete_type (TREE_VALUE (base));
12803
12804   SET_CLASSTYPE_MARKED (ref);
12805   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12806
12807   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12808     {
12809       /* The base of a derived struct is public by default.  */
12810       int via_public
12811         = (TREE_PURPOSE (binfo) == access_public_node
12812            || TREE_PURPOSE (binfo) == access_public_virtual_node
12813            || (tag_code != class_type
12814                && (TREE_PURPOSE (binfo) == access_default_node
12815                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12816       int via_protected
12817         = (TREE_PURPOSE (binfo) == access_protected_node
12818            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12819       int via_virtual
12820         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12821            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12822            || TREE_PURPOSE (binfo) == access_public_virtual_node
12823            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12824       tree basetype = TREE_VALUE (binfo);
12825       tree base_binfo;
12826
12827       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12828         basetype = TREE_TYPE (basetype);
12829       if (!basetype
12830           || (TREE_CODE (basetype) != RECORD_TYPE
12831               && TREE_CODE (basetype) != TYPENAME_TYPE
12832               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12833               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
12834         {
12835           cp_error ("base type `%T' fails to be a struct or class type",
12836                     TREE_VALUE (binfo));
12837           continue;
12838         }
12839
12840       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12841
12842       /* This code replaces similar code in layout_basetypes.
12843          We put the complete_type first for implicit `typename'.  */
12844       if (!COMPLETE_TYPE_P (basetype)
12845           && ! (current_template_parms && uses_template_parms (basetype)))
12846         {
12847           cp_error ("base class `%T' has incomplete type", basetype);
12848           continue;
12849         }
12850       else
12851         {
12852           if (CLASSTYPE_MARKED (basetype))
12853             {
12854               if (basetype == ref)
12855                 cp_error ("recursive type `%T' undefined", basetype);
12856               else
12857                 cp_error ("duplicate base type `%T' invalid", basetype);
12858               continue;
12859             }
12860
12861           if (TYPE_FOR_JAVA (basetype)
12862               && (current_lang_depth () == 0))
12863             TYPE_FOR_JAVA (ref) = 1;
12864
12865           /* Note that the BINFO records which describe individual
12866              inheritances are *not* shared in the lattice!  They
12867              cannot be shared because a given baseclass may be
12868              inherited with different `accessibility' by different
12869              derived classes.  (Each BINFO record describing an
12870              individual inheritance contains flags which say what
12871              the `accessibility' of that particular inheritance is.)  */
12872
12873           base_binfo
12874             = make_binfo (size_zero_node, basetype,
12875                           CLASS_TYPE_P (basetype)
12876                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12877                           CLASS_TYPE_P (basetype)
12878                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12879
12880           TREE_VEC_ELT (binfos, i) = base_binfo;
12881           TREE_VIA_PUBLIC (base_binfo) = via_public;
12882           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12883           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12884           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12885
12886           /* We need to unshare the binfos now so that lookups during class
12887              definition work.  */
12888           unshare_base_binfos (base_binfo);
12889
12890           SET_CLASSTYPE_MARKED (basetype);
12891
12892           /* We are free to modify these bits because they are meaningless
12893              at top level, and BASETYPE is a top-level type.  */
12894           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12895             {
12896               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12897               /* Converting to a virtual base class requires looking
12898                  up the offset of the virtual base.  */
12899               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12900             }
12901
12902           if (CLASS_TYPE_P (basetype))
12903             {
12904               TYPE_HAS_NEW_OPERATOR (ref)
12905                 |= TYPE_HAS_NEW_OPERATOR (basetype);
12906               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12907                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12908               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12909               /* If the base-class uses multiple inheritance, so do we.  */
12910               TYPE_USES_MULTIPLE_INHERITANCE (ref)
12911                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12912               /* Likewise, if converting to a base of the base may require
12913                  code, then we may need to generate code to convert to a
12914                  base as well.  */
12915               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12916                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12917             }
12918
12919           i += 1;
12920         }
12921     }
12922   if (i)
12923     TREE_VEC_LENGTH (binfos) = i;
12924   else
12925     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12926
12927   if (i > 1)
12928     {
12929       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12930       /* If there is more than one non-empty they cannot be at the same
12931          address.  */
12932       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12933     }
12934
12935   /* Unmark all the types.  */
12936   while (--i >= 0)
12937     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12938   CLEAR_CLASSTYPE_MARKED (ref);
12939
12940   /* Now that we know all the base-classes, set up the list of virtual
12941      bases.  */
12942   get_vbase_types (ref);
12943 }
12944
12945 \f
12946 /* Begin compiling the definition of an enumeration type.
12947    NAME is its name (or null if anonymous).
12948    Returns the type object, as yet incomplete.
12949    Also records info about it so that build_enumerator
12950    may be used to declare the individual values as they are read.  */
12951
12952 tree
12953 start_enum (name)
12954      tree name;
12955 {
12956   register tree enumtype = NULL_TREE;
12957   struct binding_level *b = current_binding_level;
12958
12959   /* If this is the real definition for a previous forward reference,
12960      fill in the contents in the same object that used to be the
12961      forward reference.  */
12962
12963   if (name != NULL_TREE)
12964     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12965
12966   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12967     {
12968       cp_error ("multiple definition of `%#T'", enumtype);
12969       cp_error_at ("previous definition here", enumtype);
12970       /* Clear out TYPE_VALUES, and start again.  */
12971       TYPE_VALUES (enumtype) = NULL_TREE;
12972     }
12973   else
12974     {
12975       enumtype = make_node (ENUMERAL_TYPE);
12976       pushtag (name, enumtype, 0);
12977     }
12978
12979   if (current_class_type)
12980     TREE_ADDRESSABLE (b->tags) = 1;
12981
12982   GNU_xref_decl (current_function_decl, enumtype);
12983   return enumtype;
12984 }
12985
12986 /* After processing and defining all the values of an enumeration type,
12987    install their decls in the enumeration type and finish it off.
12988    ENUMTYPE is the type object and VALUES a list of name-value pairs.  */
12989
12990 void
12991 finish_enum (enumtype)
12992      tree enumtype;
12993 {
12994   tree pair;
12995   tree minnode;
12996   tree maxnode;
12997   tree t;
12998   bool unsignedp;
12999   int lowprec;
13000   int highprec;
13001   int precision;
13002
13003   /* We built up the VALUES in reverse order.  */
13004   TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
13005
13006   /* [dcl.enum]
13007
13008      Following the closing brace of an enum-specifier, each
13009      enumerator has the type of its enumeration.  Prior to the
13010      closing brace, the type of each enumerator is the type of
13011      its initializing value.  */
13012   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13013     TREE_TYPE (TREE_VALUE (pair)) = enumtype;
13014
13015   /* For a enum defined in a template, all further processing is
13016      postponed until the template is instantiated.  */
13017   if (processing_template_decl)
13018     {
13019       tree scope = current_scope ();
13020       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13021         add_stmt (build_min (TAG_DEFN, enumtype));
13022
13023
13024       return;
13025     }
13026
13027   /* Figure out what the minimum and maximum values of the enumerators
13028      are.  */
13029   if (TYPE_VALUES (enumtype))
13030     {
13031       minnode = maxnode = NULL_TREE;
13032
13033       for (pair = TYPE_VALUES (enumtype);
13034            pair;
13035            pair = TREE_CHAIN (pair))
13036         {
13037           tree value;
13038
13039           value = DECL_INITIAL (TREE_VALUE (pair));
13040
13041           if (!minnode)
13042             minnode = maxnode = value;
13043           else if (tree_int_cst_lt (maxnode, value))
13044             maxnode = value;
13045           else if (tree_int_cst_lt (value, minnode))
13046             minnode = value;
13047         }
13048     }
13049   else
13050     minnode = maxnode = integer_zero_node;
13051
13052   /* Compute the number of bits require to represent all values of the
13053      enumeration.  We must do this before the type of MINNODE and
13054      MAXNODE are transformed, since min_precision relies on the
13055      TREE_TYPE of the value it is passed.  */
13056   unsignedp = tree_int_cst_sgn (minnode) >= 0;
13057   lowprec = min_precision (minnode, unsignedp);
13058   highprec = min_precision (maxnode, unsignedp);
13059   precision = MAX (lowprec, highprec);
13060
13061   /* Set the TREE_TYPE for the values as well.  That's so that when we
13062      call decl_constant_value we get an entity of the right type (but
13063      with the constant value).  In addition, transform the TYPE_VALUES
13064      list to contain the values, rather than the CONST_DECLs for them.  */
13065   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13066     {
13067       tree value = DECL_INITIAL (TREE_VALUE (pair));
13068
13069       TREE_TYPE (value) = enumtype;
13070       TREE_VALUE (pair) = value;
13071     }
13072
13073   /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13074   TYPE_SIZE (enumtype) = NULL_TREE;
13075   TYPE_PRECISION (enumtype) = precision;
13076   if (unsignedp)
13077     fixup_unsigned_type (enumtype);
13078   else
13079     fixup_signed_type (enumtype);
13080
13081   if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13082     /* Use the width of the narrowest normal C type which is wide
13083        enough.  */
13084     TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13085                                                 (precision, 1));
13086   else
13087     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13088
13089   TYPE_SIZE (enumtype) = NULL_TREE;
13090   layout_type (enumtype);
13091
13092   /* Fix up all variant types of this enum type.  */
13093   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13094     {
13095       TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13096       TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
13097       TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
13098       TYPE_SIZE (t) = TYPE_SIZE (enumtype);
13099       TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
13100       TYPE_MODE (t) = TYPE_MODE (enumtype);
13101       TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
13102       TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
13103       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
13104       TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype);
13105     }
13106
13107   /* Finish debugging output for this type.  */
13108   rest_of_type_compilation (enumtype, namespace_bindings_p ());
13109 }
13110
13111 /* Build and install a CONST_DECL for an enumeration constant of the
13112    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13113    Assignment of sequential values by default is handled here.  */
13114
13115 void
13116 build_enumerator (name, value, enumtype)
13117      tree name;
13118      tree value;
13119      tree enumtype;
13120 {
13121   tree decl;
13122   tree context;
13123   tree type;
13124   tree values;
13125
13126   /* Remove no-op casts from the value.  */
13127   if (value)
13128     STRIP_TYPE_NOPS (value);
13129
13130   if (! processing_template_decl)
13131     {
13132       /* Validate and default VALUE.  */
13133       if (value != NULL_TREE)
13134         {
13135           value = decl_constant_value (value);
13136
13137           if (TREE_CODE (value) == INTEGER_CST)
13138             {
13139               value = default_conversion (value);
13140               constant_expression_warning (value);
13141             }
13142           else
13143             {
13144               cp_error ("enumerator value for `%D' not integer constant", name);
13145               value = NULL_TREE;
13146             }
13147         }
13148
13149       /* Default based on previous value.  */
13150       if (value == NULL_TREE && ! processing_template_decl)
13151         {
13152           tree prev_value;
13153
13154           if (TYPE_VALUES (enumtype))
13155             {
13156               /* The next value is the previous value ... */
13157               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13158               /* ... plus one.  */
13159               value = cp_build_binary_op (PLUS_EXPR,
13160                                           prev_value,
13161                                           integer_one_node);
13162
13163               if (tree_int_cst_lt (value, prev_value))
13164                 cp_error ("overflow in enumeration values at `%D'", name);
13165             }
13166           else
13167             value = integer_zero_node;
13168         }
13169
13170       /* Remove no-op casts from the value.  */
13171       if (value)
13172         STRIP_TYPE_NOPS (value);
13173 #if 0
13174       /* To fix MAX_VAL enum consts. (bkoz)  */
13175       TREE_TYPE (value) = integer_type_node;
13176 #endif
13177     }
13178
13179   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13180      Even in other cases, we will later (in finish_enum) be setting
13181      the type of VALUE.  But, we don't need to make a copy if this
13182      VALUE is one of the enumeration constants for this same
13183      enumeration type.  */
13184   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13185     if (TREE_VALUE (values) == value)
13186       break;
13187   /* If we didn't break out of the loop, then we do need a copy.  */
13188   if (!values && value)
13189     value = copy_node (value);
13190
13191   /* C++ associates enums with global, function, or class declarations.  */
13192   context = current_scope ();
13193
13194   /* Build the actual enumeration constant.  Note that the enumeration
13195     constants have the type of their initializers until the
13196     enumeration is complete:
13197
13198       [ dcl.enum ]
13199
13200       Following the closing brace of an enum-specifier, each enumer-
13201       ator has the type of its enumeration.  Prior to the closing
13202       brace, the type of each enumerator is the type of its
13203       initializing value.
13204
13205     In finish_enum we will reset the type.  Of course, if we're
13206     processing a template, there may be no value.   */
13207   type = value ? TREE_TYPE (value) : NULL_TREE;
13208
13209   if (context && context == current_class_type)
13210     /* This enum declaration is local to the class.  We need the full
13211        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13212     decl = build_lang_decl (CONST_DECL, name, type);
13213   else
13214     /* It's a global enum, or it's local to a function.  (Note local to
13215       a function could mean local to a class method.  */
13216     decl = build_decl (CONST_DECL, name, type);
13217
13218   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13219   DECL_INITIAL (decl) = value;
13220   TREE_READONLY (decl) = 1;
13221
13222   if (context && context == current_class_type)
13223     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13224       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13225       things like `S::i' later.)  */
13226     finish_member_declaration (decl);
13227   else
13228     {
13229       pushdecl (decl);
13230       GNU_xref_decl (current_function_decl, decl);
13231     }
13232
13233   /* Add this enumeration constant to the list for this type.  */
13234   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13235 }
13236
13237 \f
13238 /* We're defining DECL.  Make sure that it's type is OK.  */
13239
13240 static void
13241 check_function_type (decl, current_function_parms)
13242      tree decl;
13243      tree current_function_parms;
13244 {
13245   tree fntype = TREE_TYPE (decl);
13246   tree return_type = complete_type (TREE_TYPE (fntype));
13247
13248   /* In a function definition, arg types must be complete.  */
13249   require_complete_types_for_parms (current_function_parms);
13250
13251   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13252     {
13253       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13254
13255       /* Make it return void instead, but don't change the
13256          type of the DECL_RESULT, in case we have a named return value.  */
13257       if (TREE_CODE (fntype) == METHOD_TYPE)
13258         {
13259           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13260           TREE_TYPE (decl)
13261             = build_cplus_method_type (ctype,
13262                                        void_type_node,
13263                                        FUNCTION_ARG_CHAIN (decl));
13264         }
13265       else
13266         TREE_TYPE (decl)
13267           = build_function_type (void_type_node,
13268                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13269       TREE_TYPE (decl)
13270         = build_exception_variant (fntype,
13271                                    TYPE_RAISES_EXCEPTIONS (fntype));
13272     }
13273   else
13274     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13275 }
13276
13277 /* Create the FUNCTION_DECL for a function definition.
13278    DECLSPECS and DECLARATOR are the parts of the declaration;
13279    they describe the function's name and the type it returns,
13280    but twisted together in a fashion that parallels the syntax of C.
13281
13282    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13283    DECLARATOR is really the DECL for the function we are about to
13284    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13285    indicating that the function is an inline defined in-class.
13286
13287    This function creates a binding context for the function body
13288    as well as setting up the FUNCTION_DECL in current_function_decl.
13289
13290    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13291    (it defines a datum instead), we return 0, which tells
13292    yyparse to report a parse error.
13293
13294    For C++, we must first check whether that datum makes any sense.
13295    For example, "class A local_a(1,2);" means that variable local_a
13296    is an aggregate of type A, which should have a constructor
13297    applied to it with the argument list [1, 2].  */
13298
13299 int
13300 start_function (declspecs, declarator, attrs, flags)
13301      tree declspecs, declarator, attrs;
13302      int flags;
13303 {
13304   tree decl1;
13305   tree ctype = NULL_TREE;
13306   tree fntype;
13307   tree restype;
13308   extern int have_extern_spec;
13309   extern int used_extern_spec;
13310   int doing_friend = 0;
13311   struct binding_level *bl;
13312   tree current_function_parms;
13313
13314   /* Sanity check.  */
13315   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13316   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13317
13318   /* This should only be done once on the top most decl.  */
13319   if (have_extern_spec && !used_extern_spec)
13320     {
13321       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13322       used_extern_spec = 1;
13323     }
13324
13325   if (flags & SF_PRE_PARSED)
13326     {
13327       decl1 = declarator;
13328
13329       fntype = TREE_TYPE (decl1);
13330       if (TREE_CODE (fntype) == METHOD_TYPE)
13331         ctype = TYPE_METHOD_BASETYPE (fntype);
13332
13333       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13334          the (lexical) scope of the class in which it is defined.  */
13335       if (!ctype && DECL_FRIEND_P (decl1))
13336         {
13337           ctype = DECL_FRIEND_CONTEXT (decl1);
13338
13339           /* CTYPE could be null here if we're dealing with a template;
13340              for example, `inline friend float foo()' inside a template
13341              will have no CTYPE set.  */
13342           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13343             ctype = NULL_TREE;
13344           else
13345             doing_friend = 1;
13346         }
13347
13348       last_function_parms = DECL_ARGUMENTS (decl1);
13349       last_function_parm_tags = NULL_TREE;
13350     }
13351   else
13352     {
13353       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13354       /* If the declarator is not suitable for a function definition,
13355          cause a syntax error.  */
13356       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13357
13358       fntype = TREE_TYPE (decl1);
13359
13360       restype = TREE_TYPE (fntype);
13361       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13362         {
13363           cp_error ("semicolon missing after declaration of `%#T'", restype);
13364           shadow_tag (build_tree_list (NULL_TREE, restype));
13365           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13366           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13367             fntype = build_function_type (integer_type_node,
13368                                           TYPE_ARG_TYPES (fntype));
13369           else
13370             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13371                                               integer_type_node,
13372                                               TYPE_ARG_TYPES (fntype));
13373           TREE_TYPE (decl1) = fntype;
13374         }
13375
13376       if (TREE_CODE (fntype) == METHOD_TYPE)
13377         ctype = TYPE_METHOD_BASETYPE (fntype);
13378       else if (DECL_MAIN_P (decl1))
13379         {
13380           /* If this doesn't return integer_type, complain.  */
13381           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13382             {
13383               if (pedantic || warn_return_type)
13384                 pedwarn ("return type for `main' changed to `int'");
13385               TREE_TYPE (decl1) = fntype = default_function_type;
13386             }
13387         }
13388     }
13389
13390   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13391     /* This is a constructor, we must ensure that any default args
13392        introduced by this definition are propagated to the clones
13393        now. The clones are used directly in overload resolution.  */
13394     adjust_clone_args (decl1);
13395
13396   /* Sometimes we don't notice that a function is a static member, and
13397      build a METHOD_TYPE for it.  Fix that up now.  */
13398   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13399       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13400     {
13401       revert_static_member_fn (decl1);
13402       last_function_parms = TREE_CHAIN (last_function_parms);
13403       ctype = NULL_TREE;
13404     }
13405
13406   /* Warn if function was previously implicitly declared
13407      (but not if we warned then).  */
13408   if (! warn_implicit
13409       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13410     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13411
13412   /* Set up current_class_type, and enter the scope of the class, if
13413      appropriate.  */
13414   if (ctype)
13415     push_nested_class (ctype, 1);
13416   else if (DECL_STATIC_FUNCTION_P (decl1))
13417     push_nested_class (DECL_CONTEXT (decl1), 2);
13418
13419   /* Now that we have entered the scope of the class, we must restore
13420      the bindings for any template parameters surrounding DECL1, if it
13421      is an inline member template.  (Order is important; consider the
13422      case where a template parameter has the same name as a field of
13423      the class.)  It is not until after this point that
13424      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13425   if (flags & SF_INCLASS_INLINE)
13426     maybe_begin_member_template_processing (decl1);
13427
13428   /* Effective C++ rule 15.  */
13429   if (warn_ecpp
13430       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13431       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13432     cp_warning ("`operator=' should return a reference to `*this'");
13433
13434   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13435      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13436   if (!DECL_INITIAL (decl1))
13437     DECL_INITIAL (decl1) = error_mark_node;
13438
13439 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13440   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13441 #endif
13442
13443   /* This function exists in static storage.
13444      (This does not mean `static' in the C sense!)  */
13445   TREE_STATIC (decl1) = 1;
13446
13447   /* We must call push_template_decl after current_class_type is set
13448      up.  (If we are processing inline definitions after exiting a
13449      class scope, current_class_type will be NULL_TREE until set above
13450      by push_nested_class.)  */
13451   if (processing_template_decl)
13452     decl1 = push_template_decl (decl1);
13453
13454   /* We are now in the scope of the function being defined.  */
13455   current_function_decl = decl1;
13456
13457   /* Save the parm names or decls from this function's declarator
13458      where store_parm_decls will find them.  */
13459   current_function_parms = last_function_parms;
13460   current_function_parm_tags = last_function_parm_tags;
13461
13462   /* Make sure the parameter and return types are reasonable.  When
13463      you declare a function, these types can be incomplete, but they
13464      must be complete when you define the function.  */
13465   if (! processing_template_decl)
13466     check_function_type (decl1, current_function_parms);
13467
13468   /* Build the return declaration for the function.  */
13469   restype = TREE_TYPE (fntype);
13470   if (!processing_template_decl)
13471     {
13472       if (!DECL_RESULT (decl1))
13473         {
13474           DECL_RESULT (decl1)
13475             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13476           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13477                                       DECL_RESULT (decl1));
13478         }
13479     }
13480   else
13481     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13482     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13483
13484   /* Initialize RTL machinery.  We cannot do this until
13485      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13486      even when processing a template; this is how we get
13487      CFUN set up, and our per-function variables initialized.
13488      FIXME factor out the non-RTL stuff.  */
13489   bl = current_binding_level;
13490   init_function_start (decl1, input_filename, lineno);
13491   current_binding_level = bl;
13492
13493   /* Even though we're inside a function body, we still don't want to
13494      call expand_expr to calculate the size of a variable-sized array.
13495      We haven't necessarily assigned RTL to all variables yet, so it's
13496      not safe to try to expand expressions involving them.  */
13497   immediate_size_expand = 0;
13498   cfun->x_dont_save_pending_sizes_p = 1;
13499
13500   /* Start the statement-tree, start the tree now.  */
13501   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13502
13503   /* Let the user know we're compiling this function.  */
13504   announce_function (decl1);
13505
13506   /* Record the decl so that the function name is defined.
13507      If we already have a decl for this name, and it is a FUNCTION_DECL,
13508      use the old decl.  */
13509   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13510     {
13511       /* A specialization is not used to guide overload resolution.  */
13512       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13513           && ! DECL_FUNCTION_MEMBER_P (decl1))
13514         decl1 = pushdecl (decl1);
13515       else
13516         {
13517           /* We need to set the DECL_CONTEXT. */
13518           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13519             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13520           /* And make sure we have enough default args.  */
13521           check_default_args (decl1);
13522         }
13523       fntype = TREE_TYPE (decl1);
13524     }
13525
13526   /* Reset these in case the call to pushdecl changed them.  */
13527   current_function_decl = decl1;
13528   cfun->decl = decl1;
13529
13530   /* If we are (erroneously) defining a function that we have already
13531      defined before, wipe out what we knew before.  */
13532   if (!DECL_PENDING_INLINE_P (decl1)
13533       && DECL_SAVED_FUNCTION_DATA (decl1))
13534     {
13535       free (DECL_SAVED_FUNCTION_DATA (decl1));
13536       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13537     }
13538
13539   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13540     {
13541       /* We know that this was set up by `grokclassfn'.  We do not
13542          wait until `store_parm_decls', since evil parse errors may
13543          never get us to that point.  Here we keep the consistency
13544          between `current_class_type' and `current_class_ptr'.  */
13545       tree t = DECL_ARGUMENTS (decl1);
13546
13547       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13548                           162);
13549       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13550                           19990811);
13551
13552       cp_function_chain->x_current_class_ref
13553         = build_indirect_ref (t, NULL);
13554       cp_function_chain->x_current_class_ptr = t;
13555
13556       /* Constructors and destructors need to know whether they're "in
13557          charge" of initializing virtual base classes.  */
13558       t = TREE_CHAIN (t);
13559       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13560         {
13561           current_in_charge_parm = t;
13562           t = TREE_CHAIN (t);
13563         }
13564       if (DECL_HAS_VTT_PARM_P (decl1))
13565         {
13566           if (DECL_NAME (t) != vtt_parm_identifier)
13567             abort ();
13568           current_vtt_parm = t;
13569         }
13570     }
13571
13572   if (DECL_INTERFACE_KNOWN (decl1))
13573     {
13574       tree ctx = decl_function_context (decl1);
13575
13576       if (DECL_NOT_REALLY_EXTERN (decl1))
13577         DECL_EXTERNAL (decl1) = 0;
13578
13579       if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
13580           && TREE_PUBLIC (ctx))
13581         /* This is a function in a local class in an extern inline
13582            function.  */
13583         comdat_linkage (decl1);
13584     }
13585   /* If this function belongs to an interface, it is public.
13586      If it belongs to someone else's interface, it is also external.
13587      This only affects inlines and template instantiations.  */
13588   else if (interface_unknown == 0
13589            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13590                || flag_alt_external_templates))
13591     {
13592       if (DECL_DECLARED_INLINE_P (decl1)
13593           || DECL_TEMPLATE_INSTANTIATION (decl1)
13594           || processing_template_decl)
13595         {
13596           DECL_EXTERNAL (decl1)
13597             = (interface_only
13598                || (DECL_DECLARED_INLINE_P (decl1)
13599                    && ! flag_implement_inlines
13600                    && !DECL_VINDEX (decl1)));
13601
13602           /* For WIN32 we also want to put these in linkonce sections.  */
13603           maybe_make_one_only (decl1);
13604         }
13605       else
13606         DECL_EXTERNAL (decl1) = 0;
13607       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13608       DECL_INTERFACE_KNOWN (decl1) = 1;
13609     }
13610   else if (interface_unknown && interface_only
13611            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13612                || flag_alt_external_templates))
13613     {
13614       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13615          interface, we will have interface_only set but not
13616          interface_known.  In that case, we don't want to use the normal
13617          heuristics because someone will supply a #pragma implementation
13618          elsewhere, and deducing it here would produce a conflict.  */
13619       comdat_linkage (decl1);
13620       DECL_EXTERNAL (decl1) = 0;
13621       DECL_INTERFACE_KNOWN (decl1) = 1;
13622       DECL_DEFER_OUTPUT (decl1) = 1;
13623     }
13624   else
13625     {
13626       /* This is a definition, not a reference.
13627          So clear DECL_EXTERNAL.  */
13628       DECL_EXTERNAL (decl1) = 0;
13629
13630       if ((DECL_DECLARED_INLINE_P (decl1)
13631            || DECL_TEMPLATE_INSTANTIATION (decl1))
13632           && ! DECL_INTERFACE_KNOWN (decl1)
13633           /* Don't try to defer nested functions for now.  */
13634           && ! decl_function_context (decl1))
13635         DECL_DEFER_OUTPUT (decl1) = 1;
13636       else
13637         DECL_INTERFACE_KNOWN (decl1) = 1;
13638     }
13639
13640   pushlevel (0);
13641   current_binding_level->parm_flag = 1;
13642
13643   if (attrs)
13644     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13645
13646   /* Promote the value to int before returning it.  */
13647   if (c_promoting_integer_type_p (restype))
13648     restype = type_promotes_to (restype);
13649
13650   if (DECL_RESULT (decl1) == NULL_TREE)
13651     {
13652       DECL_RESULT (decl1)
13653         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13654       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13655       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13656     }
13657
13658   ++function_depth;
13659
13660   if (DECL_DESTRUCTOR_P (decl1))
13661     {
13662       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13663       DECL_CONTEXT (dtor_label) = current_function_decl;
13664     }
13665
13666   start_fname_decls ();
13667
13668   store_parm_decls (current_function_parms);
13669
13670   return 1;
13671 }
13672 \f
13673 /* Store the parameter declarations into the current function declaration.
13674    This is called after parsing the parameter declarations, before
13675    digesting the body of the function.
13676
13677    Also install to binding contour return value identifier, if any.  */
13678
13679 static void
13680 store_parm_decls (current_function_parms)
13681      tree current_function_parms;
13682 {
13683   register tree fndecl = current_function_decl;
13684   register tree parm;
13685   int parms_have_cleanups = 0;
13686   tree cleanups = NULL_TREE;
13687
13688   /* This is a list of types declared among parms in a prototype.  */
13689   tree parmtags = current_function_parm_tags;
13690
13691   /* This is a chain of any other decls that came in among the parm
13692      declarations.  If a parm is declared with  enum {foo, bar} x;
13693      then CONST_DECLs for foo and bar are put here.  */
13694   tree nonparms = NULL_TREE;
13695
13696   if (current_function_parms)
13697     {
13698       /* This case is when the function was defined with an ANSI prototype.
13699          The parms already have decls, so we need not do anything here
13700          except record them as in effect
13701          and complain if any redundant old-style parm decls were written.  */
13702
13703       tree specparms = current_function_parms;
13704       tree next;
13705
13706       /* Must clear this because it might contain TYPE_DECLs declared
13707              at class level.  */
13708       storedecls (NULL_TREE);
13709
13710       /* If we're doing semantic analysis, then we'll call pushdecl
13711              for each of these.  We must do them in reverse order so that
13712              they end in the correct forward order.  */
13713       specparms = nreverse (specparms);
13714
13715       for (parm = specparms; parm; parm = next)
13716         {
13717           next = TREE_CHAIN (parm);
13718           if (TREE_CODE (parm) == PARM_DECL)
13719             {
13720               tree cleanup;
13721
13722               if (DECL_NAME (parm) == NULL_TREE
13723                   || TREE_CODE (parm) != VOID_TYPE)
13724                 pushdecl (parm);
13725               else
13726                 cp_error ("parameter `%D' declared void", parm);
13727
13728               cleanup = (processing_template_decl
13729                          ? NULL_TREE
13730                          : maybe_build_cleanup (parm));
13731
13732               if (cleanup)
13733                 cleanups = tree_cons (parm, cleanup, cleanups);
13734             }
13735           else
13736             {
13737               /* If we find an enum constant or a type tag,
13738                  put it aside for the moment.  */
13739               TREE_CHAIN (parm) = NULL_TREE;
13740               nonparms = chainon (nonparms, parm);
13741             }
13742         }
13743
13744       /* Get the decls in their original chain order and record in the
13745          function.  This is all and only the PARM_DECLs that were
13746          pushed into scope by the loop above.  */
13747       DECL_ARGUMENTS (fndecl) = getdecls ();
13748       storetags (chainon (parmtags, gettags ()));
13749     }
13750   else
13751     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13752
13753   /* Now store the final chain of decls for the arguments
13754      as the decl-chain of the current lexical scope.
13755      Put the enumerators in as well, at the front so that
13756      DECL_ARGUMENTS is not modified.  */
13757   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13758
13759   /* Now that we have initialized the parms, we can start their
13760      cleanups.  We cannot do this before, since expand_decl_cleanup
13761      should not be called before the parm can be used.  */
13762   while (cleanups)
13763     {
13764       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13765                            TREE_VALUE (cleanups));
13766       cleanups = TREE_CHAIN (cleanups);
13767     }
13768
13769   /* Create a binding contour which can be used to catch
13770      cleanup-generated temporaries.  */
13771   if (parms_have_cleanups)
13772     pushlevel (0);
13773
13774   /* Do the starting of the exception specifications, if we have any.  */
13775   if (flag_exceptions && !processing_template_decl
13776       && flag_enforce_eh_specs
13777       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13778     current_eh_spec_block = begin_eh_spec_block ();
13779 }
13780
13781 \f
13782 /* We have finished doing semantic analysis on DECL, but have not yet
13783    generated RTL for its body.  Save away our current state, so that
13784    when we want to generate RTL later we know what to do.  */
13785
13786 static void
13787 save_function_data (decl)
13788      tree decl;
13789 {
13790   struct cp_language_function *f;
13791
13792   /* Save the language-specific per-function data so that we can
13793      get it back when we really expand this function.  */
13794   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13795                       19990908);
13796
13797   /* Make a copy.  */
13798   f = ((struct cp_language_function *)
13799        xmalloc (sizeof (struct cp_language_function)));
13800   memcpy (f, cp_function_chain, sizeof (struct cp_language_function));
13801   DECL_SAVED_FUNCTION_DATA (decl) = f;
13802
13803   /* Clear out the bits we don't need.  */
13804   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
13805   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
13806   f->x_named_label_uses = NULL;
13807   f->bindings = NULL;
13808   f->x_local_names = NULL;
13809
13810   /* When we get back here again, we will be expanding.  */
13811   f->x_expanding_p = 1;
13812
13813   /* If we've already decided that we cannot inline this function, we
13814      must remember that fact when we actually go to expand the
13815      function.  */
13816   if (current_function_cannot_inline)
13817     {
13818       f->cannot_inline = current_function_cannot_inline;
13819       DECL_INLINE (decl) = 0;
13820     }
13821 }
13822
13823 /* At the end of every constructor we generate to code to return
13824    `this'.  Do that now.  */
13825
13826 static void
13827 finish_constructor_body ()
13828 {
13829   /* Any return from a constructor will end up here.  */
13830   if (ctor_label)
13831     add_stmt (build_stmt (LABEL_STMT, ctor_label));
13832
13833   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13834      generate the return, rather than a goto to CTOR_LABEL.  */
13835   ctor_label = NULL_TREE;
13836   /* In check_return_expr we translate an empty return from a
13837      constructor to a return of `this'.  */
13838   finish_return_stmt (NULL_TREE);
13839   /* Mark the end of the constructor.  */
13840   add_stmt (build_stmt (CTOR_STMT));
13841 }
13842
13843 /* At the end of every destructor we generate code to restore virtual
13844    function tables to the values desired by base classes and to call
13845    to base class destructors.  Do that now.  */
13846
13847 static void
13848 finish_destructor_body ()
13849 {
13850   tree compound_stmt;
13851   tree exprstmt;
13852
13853   /* Create a block to contain all the extra code.  */
13854   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13855
13856   /* Any return from a destructor will end up here.  */
13857   add_stmt (build_stmt (LABEL_STMT, dtor_label));
13858
13859   /* Generate the code to call destructor on base class.  If this
13860      destructor belongs to a class with virtual functions, then set
13861      the virtual function table pointer to represent the type of our
13862      base class.  */
13863
13864   /* This side-effect makes call to `build_delete' generate the code
13865      we have to have at the end of this destructor.  `build_delete'
13866      will set the flag again.  */
13867   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13868
13869   exprstmt = build_delete (current_class_type,
13870                            current_class_ref,
13871                            sfk_base_destructor,
13872                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13873                            0);
13874
13875   if (exprstmt != error_mark_node
13876       && (TREE_CODE (exprstmt) != NOP_EXPR
13877           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13878           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13879     {
13880       if (exprstmt != void_zero_node)
13881         /* Don't call `expand_expr_stmt' if we're not going to do
13882            anything, since -Wall will give a diagnostic.  */
13883         finish_expr_stmt (exprstmt);
13884
13885       /* Run destructors for all virtual baseclasses.  */
13886       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13887         {
13888           tree vbases;
13889           tree if_stmt;
13890
13891           if_stmt = begin_if_stmt ();
13892           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13893                                       current_in_charge_parm,
13894                                       integer_two_node),
13895                                if_stmt);
13896
13897           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
13898           /* The CLASSTYPE_VBASECLASSES list is in initialization
13899              order, so we have to march through it in reverse order.  */
13900           for (vbases = nreverse (copy_list (vbases));
13901                vbases;
13902                vbases = TREE_CHAIN (vbases))
13903             {
13904               tree vbase = TREE_VALUE (vbases);
13905               tree base_type = BINFO_TYPE (vbase);
13906
13907               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (base_type))
13908                 {
13909                   tree base_ptr_type = build_pointer_type (base_type);
13910                   tree expr = current_class_ptr;
13911
13912                   /* Convert to the basetype here, as we know the layout is
13913                      fixed. What is more, if we let build_method_call do it,
13914                      it will use the vtable, which may have been clobbered
13915                      by the deletion of our primary base.  */
13916
13917                   expr = build1 (NOP_EXPR, base_ptr_type, expr);
13918                   expr = build (PLUS_EXPR, base_ptr_type, expr,
13919                                 BINFO_OFFSET (vbase));
13920                   expr = build_indirect_ref (expr, NULL);
13921                   expr = build_method_call (expr, base_dtor_identifier,
13922                                             NULL_TREE, vbase,
13923                                             LOOKUP_NORMAL);
13924                   finish_expr_stmt (expr);
13925                 }
13926             }
13927
13928           finish_then_clause (if_stmt);
13929           finish_if_stmt ();
13930         }
13931     }
13932
13933   /* In a virtual destructor, we must call delete.  */
13934   if (DECL_VIRTUAL_P (current_function_decl))
13935     {
13936       tree if_stmt;
13937       tree virtual_size = c_sizeof (current_class_type);
13938
13939       /* [class.dtor]
13940
13941          At the point of definition of a virtual destructor (including
13942          an implicit definition), non-placement operator delete shall
13943          be looked up in the scope of the destructor's class and if
13944          found shall be accessible and unambiguous.  */
13945       exprstmt = build_op_delete_call
13946         (DELETE_EXPR, current_class_ptr, virtual_size,
13947          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13948
13949       if_stmt = begin_if_stmt ();
13950       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13951                                   current_in_charge_parm,
13952                                   integer_one_node),
13953                            if_stmt);
13954       finish_expr_stmt (exprstmt);
13955       finish_then_clause (if_stmt);
13956       finish_if_stmt ();
13957     }
13958
13959   /* Close the block we started above.  */
13960   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13961 }
13962
13963 /* Finish up a function declaration and compile that function
13964    all the way to assembler language output.  The free the storage
13965    for the function definition.
13966
13967    FLAGS is a bitwise or of the following values:
13968      1 - CALL_POPLEVEL
13969        An extra call to poplevel (and expand_end_bindings) must be
13970        made to take care of the binding contour for the base
13971        initializers.  This is only relevant for constructors.
13972      2 - INCLASS_INLINE
13973        We just finished processing the body of an in-class inline
13974        function definition.  (This processing will have taken place
13975        after the class definition is complete.)  */
13976
13977 tree
13978 finish_function (flags)
13979      int flags;
13980 {
13981   register tree fndecl = current_function_decl;
13982   tree fntype, ctype = NULL_TREE;
13983   int call_poplevel = (flags & 1) != 0;
13984   int inclass_inline = (flags & 2) != 0;
13985   int nested;
13986
13987   /* When we get some parse errors, we can end up without a
13988      current_function_decl, so cope.  */
13989   if (fndecl == NULL_TREE)
13990     return error_mark_node;
13991
13992   nested = function_depth > 1;
13993   fntype = TREE_TYPE (fndecl);
13994
13995   /*  TREE_READONLY (fndecl) = 1;
13996       This caused &foo to be of type ptr-to-const-function
13997       which then got a warning when stored in a ptr-to-function variable.  */
13998
13999   my_friendly_assert (building_stmt_tree (), 20000911);
14000
14001   finish_fname_decls ();
14002
14003   /* For a cloned function, we've already got all the code we need;
14004      there's no need to add any extra bits.  */
14005   if (!DECL_CLONED_FUNCTION_P (fndecl))
14006     {
14007       if (DECL_CONSTRUCTOR_P (fndecl))
14008         {
14009           finish_constructor_body ();
14010           if (call_poplevel)
14011             do_poplevel ();
14012         }
14013       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14014         finish_destructor_body ();
14015       else if (DECL_MAIN_P (fndecl))
14016         {
14017           /* Make it so that `main' always returns 0 by default.  */
14018 #ifdef VMS
14019           finish_return_stmt (integer_one_node);
14020 #else
14021           finish_return_stmt (integer_zero_node);
14022 #endif
14023         }
14024
14025       /* Finish dealing with exception specifiers.  */
14026       if (flag_exceptions && !processing_template_decl
14027           && flag_enforce_eh_specs
14028           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14029         finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14030                               (TREE_TYPE (current_function_decl)),
14031                               current_eh_spec_block);
14032     }
14033
14034   /* If we're saving up tree structure, tie off the function now.  */
14035   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14036
14037   /* This must come after expand_function_end because cleanups might
14038      have declarations (from inline functions) that need to go into
14039      this function's blocks.  */
14040   if (current_binding_level->parm_flag != 1)
14041     my_friendly_abort (122);
14042   poplevel (1, 0, 1);
14043
14044   /* Remember that we were in class scope.  */
14045   if (current_class_name)
14046     ctype = current_class_type;
14047
14048   /* Must mark the RESULT_DECL as being in this function.  */
14049   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14050
14051   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14052      to the FUNCTION_DECL node itself.  */
14053   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14054
14055   /* Save away current state, if appropriate.  */
14056   if (!processing_template_decl)
14057     save_function_data (fndecl);
14058
14059   /* If this function calls `setjmp' it cannot be inlined.  When
14060      `longjmp' is called it is not guaranteed to restore the value of
14061      local variables that have been modified since the call to
14062      `setjmp'.  So, if were to inline this function into some caller
14063      `c', then when we `longjmp', we might not restore all variables
14064      in `c'.  (It might seem, at first blush, that there's no way for
14065      this function to modify local variables in `c', but their
14066      addresses may have been stored somewhere accessible to this
14067      function.)  */
14068   if (!processing_template_decl && calls_setjmp_p (fndecl))
14069     DECL_UNINLINABLE (fndecl) = 1;
14070
14071   /* Clear out memory we no longer need.  */
14072   free_after_parsing (cfun);
14073   /* Since we never call rest_of_compilation, we never clear
14074      CFUN.  Do so explicitly.  */
14075   free_after_compilation (cfun);
14076   cfun = NULL;
14077
14078   /* If this is a in-class inline definition, we may have to pop the
14079      bindings for the template parameters that we added in
14080      maybe_begin_member_template_processing when start_function was
14081      called.  */
14082   if (inclass_inline)
14083     maybe_end_member_template_processing ();
14084
14085   /* Leave the scope of the class.  */
14086   if (ctype)
14087     pop_nested_class ();
14088
14089   --function_depth;
14090
14091   /* Clean up.  */
14092   if (! nested)
14093     /* Let the error reporting routines know that we're outside a
14094        function.  For a nested function, this value is used in
14095        pop_cp_function_context and then reset via pop_function_context.  */
14096     current_function_decl = NULL_TREE;
14097
14098   return fndecl;
14099 }
14100 \f
14101 /* Create the FUNCTION_DECL for a function definition.
14102    DECLSPECS and DECLARATOR are the parts of the declaration;
14103    they describe the return type and the name of the function,
14104    but twisted together in a fashion that parallels the syntax of C.
14105
14106    This function creates a binding context for the function body
14107    as well as setting up the FUNCTION_DECL in current_function_decl.
14108
14109    Returns a FUNCTION_DECL on success.
14110
14111    If the DECLARATOR is not suitable for a function (it defines a datum
14112    instead), we return 0, which tells yyparse to report a parse error.
14113
14114    May return void_type_node indicating that this method is actually
14115    a friend.  See grokfield for more details.
14116
14117    Came here with a `.pushlevel' .
14118
14119    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14120    CHANGES TO CODE IN `grokfield'.  */
14121
14122 tree
14123 start_method (declspecs, declarator, attrlist)
14124      tree declarator, declspecs, attrlist;
14125 {
14126   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14127                                 attrlist);
14128
14129   /* Something too ugly to handle.  */
14130   if (fndecl == NULL_TREE)
14131     return NULL_TREE;
14132
14133   /* Pass friends other than inline friend functions back.  */
14134   if (fndecl == void_type_node)
14135     return fndecl;
14136
14137   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14138     /* Not a function, tell parser to report parse error.  */
14139     return NULL_TREE;
14140
14141   if (DECL_IN_AGGR_P (fndecl))
14142     {
14143       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14144         {
14145           if (DECL_CONTEXT (fndecl)
14146               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14147             cp_error ("`%D' is already defined in class `%T'", fndecl,
14148                       DECL_CONTEXT (fndecl));
14149         }
14150       return void_type_node;
14151     }
14152
14153   check_template_shadow (fndecl);
14154
14155   DECL_DECLARED_INLINE_P (fndecl) = 1;
14156
14157   if (flag_default_inline)
14158     DECL_INLINE (fndecl) = 1;
14159
14160   /* We process method specializations in finish_struct_1.  */
14161   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14162     fndecl = push_template_decl (fndecl);
14163
14164   if (! DECL_FRIEND_P (fndecl))
14165     {
14166       if (TREE_CHAIN (fndecl))
14167         {
14168           fndecl = copy_node (fndecl);
14169           TREE_CHAIN (fndecl) = NULL_TREE;
14170         }
14171
14172       if (DECL_CONSTRUCTOR_P (fndecl))
14173         {
14174           if (! grok_ctor_properties (current_class_type, fndecl))
14175             return void_type_node;
14176         }
14177       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14178         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14179     }
14180
14181   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14182
14183   /* Make a place for the parms */
14184   pushlevel (0);
14185   current_binding_level->parm_flag = 1;
14186
14187   DECL_IN_AGGR_P (fndecl) = 1;
14188   return fndecl;
14189 }
14190
14191 /* Go through the motions of finishing a function definition.
14192    We don't compile this method until after the whole class has
14193    been processed.
14194
14195    FINISH_METHOD must return something that looks as though it
14196    came from GROKFIELD (since we are defining a method, after all).
14197
14198    This is called after parsing the body of the function definition.
14199    STMTS is the chain of statements that makes up the function body.
14200
14201    DECL is the ..._DECL that `start_method' provided.  */
14202
14203 tree
14204 finish_method (decl)
14205      tree decl;
14206 {
14207   register tree fndecl = decl;
14208   tree old_initial;
14209
14210   register tree link;
14211
14212   if (decl == void_type_node)
14213     return decl;
14214
14215   old_initial = DECL_INITIAL (fndecl);
14216
14217   /* Undo the level for the parms (from start_method).
14218      This is like poplevel, but it causes nothing to be
14219      saved.  Saving information here confuses symbol-table
14220      output routines.  Besides, this information will
14221      be correctly output when this method is actually
14222      compiled.  */
14223
14224   /* Clear out the meanings of the local variables of this level;
14225      also record in each decl which block it belongs to.  */
14226
14227   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14228     {
14229       if (DECL_NAME (link) != NULL_TREE)
14230         pop_binding (DECL_NAME (link), link);
14231       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14232       DECL_CONTEXT (link) = NULL_TREE;
14233     }
14234
14235   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14236                       (HOST_WIDE_INT) current_binding_level->level_chain,
14237                       current_binding_level->parm_flag,
14238                       current_binding_level->keep);
14239
14240   poplevel (0, 0, 0);
14241
14242   DECL_INITIAL (fndecl) = old_initial;
14243
14244   /* We used to check if the context of FNDECL was different from
14245      current_class_type as another way to get inside here.  This didn't work
14246      for String.cc in libg++.  */
14247   if (DECL_FRIEND_P (fndecl))
14248     {
14249       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14250         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14251       decl = void_type_node;
14252     }
14253
14254   return decl;
14255 }
14256 \f
14257 /* Called when a new struct TYPE is defined.
14258    If this structure or union completes the type of any previous
14259    variable declaration, lay it out and output its rtl.  */
14260
14261 void
14262 hack_incomplete_structures (type)
14263      tree type;
14264 {
14265   tree *list;
14266   struct binding_level *level;
14267
14268   if (!type) /* Don't do this for class templates.  */
14269     return;
14270
14271   if (namespace_bindings_p ())
14272     {
14273       level = 0;
14274       list = &namespace_scope_incomplete;
14275     }
14276   else
14277     {
14278       level = innermost_nonclass_level ();
14279       list = &level->incomplete;
14280     }
14281
14282   while (1)
14283     {
14284       while (*list)
14285         {
14286           tree decl = TREE_VALUE (*list);
14287           if ((decl && TREE_TYPE (decl) == type)
14288               || (TREE_TYPE (decl)
14289                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14290                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14291             {
14292               int toplevel = toplevel_bindings_p ();
14293               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14294                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14295                 layout_type (TREE_TYPE (decl));
14296               layout_decl (decl, 0);
14297               rest_of_decl_compilation (decl, NULL, toplevel, 0);
14298               if (! toplevel)
14299                 {
14300                   tree cleanup;
14301                   expand_decl (decl);
14302                   cleanup = maybe_build_cleanup (decl);
14303                   expand_decl_init (decl);
14304                   if (! expand_decl_cleanup (decl, cleanup))
14305                     cp_error ("parser lost in parsing declaration of `%D'",
14306                               decl);
14307                 }
14308               *list = TREE_CHAIN (*list);
14309             }
14310           else
14311             list = &TREE_CHAIN (*list);
14312         }
14313
14314       /* Keep looking through artificial binding levels generated
14315          for local variables.  */
14316       if (level && level->keep == 2)
14317         {
14318           level = level->level_chain;
14319           list = &level->incomplete;
14320         }
14321       else
14322         break;
14323     }
14324 }
14325
14326 /* If DECL is of a type which needs a cleanup, build that cleanup
14327    here.  */
14328
14329 tree
14330 maybe_build_cleanup (decl)
14331      tree decl;
14332 {
14333   tree type = TREE_TYPE (decl);
14334
14335   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14336     {
14337       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14338       tree rval;
14339
14340       if (TREE_CODE (type) == ARRAY_TYPE)
14341         rval = decl;
14342       else
14343         {
14344           mark_addressable (decl);
14345           rval = build_unary_op (ADDR_EXPR, decl, 0);
14346         }
14347
14348       /* Optimize for space over speed here.  */
14349       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14350           || flag_expensive_optimizations)
14351         flags |= LOOKUP_NONVIRTUAL;
14352
14353       rval = build_delete (TREE_TYPE (rval), rval,
14354                            sfk_complete_destructor, flags, 0);
14355
14356       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14357           && ! TYPE_HAS_DESTRUCTOR (type))
14358         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14359                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14360
14361       return rval;
14362     }
14363   return 0;
14364 }
14365 \f
14366 /* When a stmt has been parsed, this function is called.  */
14367
14368 void
14369 finish_stmt ()
14370 {
14371   /* Always assume this statement was not an expression statement.  If
14372      it actually was an expression statement, its our callers
14373      responsibility to fix this up.  */
14374   last_expr_type = NULL_TREE;
14375 }
14376
14377 /* DECL was originally constructed as a non-static member function,
14378    but turned out to be static.  Update it accordingly.  */
14379
14380 void
14381 revert_static_member_fn (decl)
14382      tree decl;
14383 {
14384   tree tmp;
14385   tree function = TREE_TYPE (decl);
14386   tree args = TYPE_ARG_TYPES (function);
14387
14388   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14389       != TYPE_UNQUALIFIED)
14390     cp_error ("static member function `%#D' declared with type qualifiers",
14391               decl);
14392
14393   args = TREE_CHAIN (args);
14394   tmp = build_function_type (TREE_TYPE (function), args);
14395   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14396   tmp = build_exception_variant (tmp,
14397                                  TYPE_RAISES_EXCEPTIONS (function));
14398   TREE_TYPE (decl) = tmp;
14399   if (DECL_ARGUMENTS (decl))
14400     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14401   DECL_STATIC_FUNCTION_P (decl) = 1;
14402 }
14403
14404 /* Initialize the variables used during compilation of a C++
14405    function.  */
14406
14407 static void
14408 push_cp_function_context (f)
14409      struct function *f;
14410 {
14411   struct cp_language_function *p
14412     = ((struct cp_language_function *)
14413        xcalloc (1, sizeof (struct cp_language_function)));
14414   f->language = (struct language_function *) p;
14415
14416   /* It takes an explicit call to expand_body to generate RTL for a
14417      function.  */
14418   expanding_p = 0;
14419
14420   /* Whenever we start a new function, we destroy temporaries in the
14421      usual way.  */
14422   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14423 }
14424
14425 /* Free the language-specific parts of F, now that we've finished
14426    compiling the function.  */
14427
14428 static void
14429 pop_cp_function_context (f)
14430      struct function *f;
14431 {
14432   if (f->language)
14433     {
14434       struct cp_language_function *cp =
14435         (struct cp_language_function *) f->language;
14436       if (cp->x_local_names)
14437         VARRAY_FREE (cp->x_local_names);
14438       free (f->language);
14439     }
14440   f->language = 0;
14441 }
14442
14443 /* Mark P for GC.  */
14444
14445 static void
14446 mark_lang_function (p)
14447      struct cp_language_function *p;
14448 {
14449   if (!p)
14450     return;
14451
14452   mark_c_language_function (&p->base);
14453
14454   ggc_mark_tree (p->x_ctor_label);
14455   ggc_mark_tree (p->x_dtor_label);
14456   ggc_mark_tree (p->x_current_class_ptr);
14457   ggc_mark_tree (p->x_current_class_ref);
14458   ggc_mark_tree (p->x_eh_spec_block);
14459   ggc_mark_tree_varray (p->x_local_names);
14460
14461   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14462   mark_binding_level (&p->bindings);
14463 }
14464
14465 /* Mark the language-specific data in F for GC.  */
14466
14467 static void
14468 mark_cp_function_context (f)
14469      struct function *f;
14470 {
14471   mark_lang_function ((struct cp_language_function *) f->language);
14472 }
14473
14474 void
14475 lang_mark_tree (t)
14476      tree t;
14477 {
14478   enum tree_code code = TREE_CODE (t);
14479   if (code == IDENTIFIER_NODE)
14480     {
14481       struct lang_identifier *li = (struct lang_identifier *) t;
14482       struct lang_id2 *li2 = li->x;
14483       ggc_mark_tree (li->namespace_bindings);
14484       ggc_mark_tree (li->bindings);
14485       ggc_mark_tree (li->class_value);
14486       ggc_mark_tree (li->class_template_info);
14487
14488       if (li2)
14489         {
14490           ggc_mark_tree (li2->label_value);
14491           ggc_mark_tree (li2->implicit_decl);
14492           ggc_mark_tree (li2->error_locus);
14493         }
14494     }
14495   else if (code == CPLUS_BINDING)
14496     {
14497       if (BINDING_HAS_LEVEL_P (t))
14498         mark_binding_level (&BINDING_LEVEL (t));
14499       else
14500         ggc_mark_tree (BINDING_SCOPE (t));
14501       ggc_mark_tree (BINDING_VALUE (t));
14502     }
14503   else if (code == OVERLOAD)
14504     ggc_mark_tree (OVL_FUNCTION (t));
14505   else if (code == TEMPLATE_PARM_INDEX)
14506     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14507   else if (TREE_CODE_CLASS (code) == 'd')
14508     {
14509       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14510
14511       if (ld)
14512         {
14513           ggc_mark (ld);
14514           c_mark_lang_decl (&ld->decl_flags.base);
14515           if (!DECL_GLOBAL_CTOR_P (t)
14516               && !DECL_GLOBAL_DTOR_P (t)
14517               && !DECL_THUNK_P (t)
14518               && !DECL_DISCRIMINATOR_P (t))
14519             ggc_mark_tree (ld->decl_flags.u2.access);
14520           else if (DECL_THUNK_P (t))
14521             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14522           if (TREE_CODE (t) != NAMESPACE_DECL)
14523             ggc_mark_tree (ld->decl_flags.u.template_info);
14524           else
14525             mark_binding_level (&NAMESPACE_LEVEL (t));
14526           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14527             {
14528               ggc_mark_tree (ld->befriending_classes);
14529               ggc_mark_tree (ld->context);
14530               ggc_mark_tree (ld->cloned_function);
14531               ggc_mark_tree (ld->inlined_fns);
14532               if (TREE_CODE (t) == TYPE_DECL)
14533                 ggc_mark_tree (ld->u.sorted_fields);
14534               else if (TREE_CODE (t) == FUNCTION_DECL
14535                        && !DECL_PENDING_INLINE_P (t))
14536                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14537             }
14538         }
14539     }
14540   else if (TREE_CODE_CLASS (code) == 't')
14541     {
14542       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14543
14544       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14545                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14546         {
14547           ggc_mark (lt);
14548           ggc_mark_tree (lt->primary_base);
14549           ggc_mark_tree (lt->vfields);
14550           ggc_mark_tree (lt->vbases);
14551           ggc_mark_tree (lt->tags);
14552           ggc_mark_tree (lt->size);
14553           ggc_mark_tree (lt->pure_virtuals);
14554           ggc_mark_tree (lt->friend_classes);
14555           ggc_mark_tree (lt->rtti);
14556           ggc_mark_tree (lt->methods);
14557           ggc_mark_tree (lt->template_info);
14558           ggc_mark_tree (lt->befriending_classes);
14559         }
14560       else if (lt)
14561         /* In the case of pointer-to-member function types, the
14562            TYPE_LANG_SPECIFIC is really just a tree.  */
14563         ggc_mark_tree ((tree) lt);
14564     }
14565 }
14566
14567 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14568    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
14569
14570 tree
14571 identifier_global_value (t)
14572      tree t;
14573 {
14574   return IDENTIFIER_GLOBAL_VALUE (t);
14575 }
14576
14577 /* Build the void_list_node (void_type_node having been created).  */
14578 tree
14579 build_void_list_node ()
14580 {
14581   tree t = build_tree_list (NULL_TREE, void_type_node);
14582   TREE_PARMLIST (t) = 1;
14583   return t;
14584 }
14585
14586 static int
14587 cp_missing_noreturn_ok_p (decl)
14588      tree decl;
14589 {
14590   /* A missing noreturn is ok for the `main' function.  */
14591   return DECL_MAIN_P (decl);
14592 }