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 "tree-inline.h"
  39 #include "decl.h"
  40 #include "lex.h"
  41 #include "output.h"
  42 #include "except.h"
  43 #include "toplev.h"
  44 #include "../hash.h"
  45 #include "ggc.h"
  46 #include "tm_p.h"
  47 #include "target.h"
  48 #include "c-common.h"
  49
  50 extern const struct attribute_spec *lang_attribute_table;
  51
  52 #ifndef BOOL_TYPE_SIZE
  53 /* `bool' has size and alignment `1', on all platforms.  */
  54 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  55 #endif
  56
  57 static tree grokparms                           PARAMS ((tree));
  58 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  59
  60 static void push_binding_level PARAMS ((struct binding_level *, int,
  61                                       int));
  62 static void pop_binding_level PARAMS ((void));
  63 static void suspend_binding_level PARAMS ((void));
  64 static void resume_binding_level PARAMS ((struct binding_level *));
  65 static struct binding_level *make_binding_level PARAMS ((void));
  66 static void declare_namespace_level PARAMS ((void));
  67 static int decl_jump_unsafe PARAMS ((tree));
  68 static void storedecls PARAMS ((tree));
  69 static void require_complete_types_for_parms PARAMS ((tree));
  70 static int ambi_op_p PARAMS ((enum tree_code));
  71 static int unary_op_p PARAMS ((enum tree_code));
  72 static tree store_bindings PARAMS ((tree, tree));
  73 static tree lookup_tag_reverse PARAMS ((tree, tree));
  74 static tree obscure_complex_init PARAMS ((tree, tree));
  75 static tree lookup_name_real PARAMS ((tree, int, int, int));
  76 static void push_local_name PARAMS ((tree));
  77 static void warn_extern_redeclared_static PARAMS ((tree, tree));
  78 static tree grok_reference_init PARAMS ((tree, tree, tree));
  79 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
  80                               enum overload_flags, tree,
  81                               tree, int, int, int, int, int, int, tree));
  82 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
  83 static tree lookup_tag PARAMS ((enum tree_code, tree,
  84                               struct binding_level *, int));
  85 static void set_identifier_type_value_with_scope
  86         PARAMS ((tree, tree, struct binding_level *));
  87 static void record_unknown_type PARAMS ((tree, const char *));
  88 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
  89 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
  90 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
  91                                   int));
  92 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
  93 static void check_for_uninitialized_const_var PARAMS ((tree));
  94 static unsigned long typename_hash PARAMS ((hash_table_key));
  95 static bool typename_compare PARAMS ((hash_table_key, hash_table_key));
  96 static void push_binding PARAMS ((tree, tree, struct binding_level*));
  97 static int add_binding PARAMS ((tree, tree));
  98 static void pop_binding PARAMS ((tree, tree));
  99 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 100 static tree find_binding PARAMS ((tree, tree));
 101 static tree select_decl PARAMS ((tree, int));
 102 static int lookup_flags PARAMS ((int, int));
 103 static tree qualify_lookup PARAMS ((tree, int));
 104 static tree record_builtin_java_type PARAMS ((const char *, int));
 105 static const char *tag_name PARAMS ((enum tag_types code));
 106 static void find_class_binding_level PARAMS ((void));
 107 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 108 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 109 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 110 static int walk_globals_r PARAMS ((tree, void *));
 111 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 112 static tree make_label_decl PARAMS ((tree, int));
 113 static void use_label PARAMS ((tree));
 114 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 115                                            const char *, int));
 116 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 117 static void check_switch_goto PARAMS ((struct binding_level *));
 118 static void check_previous_gotos PARAMS ((tree));
 119 static void pop_label PARAMS ((tree, tree));
 120 static void pop_labels PARAMS ((tree));
 121 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 122 static void layout_var_decl PARAMS ((tree));
 123 static void maybe_commonize_var PARAMS ((tree));
 124 static tree check_initializer PARAMS ((tree, tree));
 125 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 126 static void push_cp_function_context PARAMS ((struct function *));
 127 static void pop_cp_function_context PARAMS ((struct function *));
 128 static void mark_binding_level PARAMS ((void *));
 129 static void mark_named_label_lists PARAMS ((void *, void *));
 130 static void mark_cp_function_context PARAMS ((struct function *));
 131 static void mark_saved_scope PARAMS ((void *));
 132 static void mark_lang_function PARAMS ((struct cp_language_function *));
 133 static void save_function_data PARAMS ((tree));
 134 static void check_function_type PARAMS ((tree, tree));
 135 static void destroy_local_var PARAMS ((tree));
 136 static void finish_constructor_body PARAMS ((void));
 137 static void finish_destructor_body PARAMS ((void));
 138 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 139 static tree get_atexit_node PARAMS ((void));
 140 static tree get_dso_handle_node PARAMS ((void));
 141 static tree start_cleanup_fn PARAMS ((void));
 142 static void end_cleanup_fn PARAMS ((void));
 143 static tree cp_make_fname_decl PARAMS ((tree, int));
 144 static void initialize_predefined_identifiers PARAMS ((void));
 145 static tree check_special_function_return_type
 146   PARAMS ((special_function_kind, tree, tree));
 147 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 148 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 149 static void store_parm_decls PARAMS ((tree));
 150 static int cp_missing_noreturn_ok_p PARAMS ((tree));
 151
 152 #if defined (DEBUG_CP_BINDING_LEVELS)
 153 static void indent PARAMS ((void));
 154 #endif
 155
 156 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 157 tree error_mark_list;
 158
 159 /* The following symbols are subsumed in the cp_global_trees array, and
 160    listed here individually for documentation purposes.
 161
 162    C++ extensions
 163         tree wchar_decl_node;
 164
 165         tree vtable_entry_type;
 166         tree delta_type_node;
 167         tree __t_desc_type_node;
 168         tree ti_desc_type_node;
 169         tree bltn_desc_type_node, ptr_desc_type_node;
 170         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 171         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 172         tree ptm_desc_type_node;
 173         tree base_desc_type_node;
 174
 175         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 176         tree unknown_type_node;
 177
 178    Array type `vtable_entry_type[]'
 179
 180         tree vtbl_type_node;
 181         tree vtbl_ptr_type_node;
 182
 183    Namespaces,
 184
 185         tree std_node;
 186         tree abi_node;
 187
 188    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 189    one that the user will declare, but sufficient to be called
 190    by routines that want to abort the program.
 191
 192         tree abort_fndecl;
 193
 194    The FUNCTION_DECL for the default `::operator delete'.
 195
 196         tree global_delete_fndecl;
 197
 198    Used by RTTI
 199         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 200         tree tinfo_var_id;
 201
 202 */
 203
 204 tree cp_global_trees[CPTI_MAX];
 205
 206 /* Indicates that there is a type value in some namespace, although
 207    that is not necessarily in scope at the moment.  */
 208
 209 static tree global_type_node;
 210
 211 /* Expect only namespace names now. */
 212 static int only_namespace_names;
 213
 214 /* Used only for jumps to as-yet undefined labels, since jumps to
 215    defined labels can have their validity checked immediately.  */
 216
 217 struct named_label_use_list
 218 {
 219   struct binding_level *binding_level;
 220   tree names_in_scope;
 221   tree label_decl;
 222   const char *filename_o_goto;
 223   int lineno_o_goto;
 224   struct named_label_use_list *next;
 225 };
 226
 227 #define named_label_uses cp_function_chain->x_named_label_uses
 228
 229 #define local_names cp_function_chain->x_local_names
 230
 231 /* A list of objects which have constructors or destructors
 232    which reside in the global scope.  The decl is stored in
 233    the TREE_VALUE slot and the initializer is stored
 234    in the TREE_PURPOSE slot.  */
 235 tree static_aggregates;
 236
 237 /* -- end of C++ */
 238
 239 /* A node for the integer constants 2, and 3.  */
 240
 241 tree integer_two_node, integer_three_node;
 242
 243 /* Similar, for last_function_parm_tags.  */
 244 tree last_function_parms;
 245
 246 /* A list of all LABEL_DECLs in the function that have names.  Here so
 247    we can clear out their names' definitions at the end of the
 248    function, and so we can check the validity of jumps to these labels.  */
 249
 250 struct named_label_list
 251 {
 252   struct binding_level *binding_level;
 253   tree names_in_scope;
 254   tree old_value;
 255   tree label_decl;
 256   tree bad_decls;
 257   struct named_label_list *next;
 258   unsigned int in_try_scope : 1;
 259   unsigned int in_catch_scope : 1;
 260 };
 261
 262 #define named_labels cp_function_chain->x_named_labels
 263
 264 /* Nonzero means use the ISO C94 dialect of C.  */
 265
 266 int flag_isoc94;
 267
 268 /* Nonzero means use the ISO C99 dialect of C.  */
 269
 270 int flag_isoc99;
 271
 272 /* Nonzero means we are a hosted implementation for code shared with C.  */
 273
 274 int flag_hosted = 1;
 275
 276 /* Nonzero means add default format_arg attributes for functions not
 277    in ISO C.  */
 278
 279 int flag_noniso_default_format_attributes = 1;
 280
 281 /* Nonzero if we want to conserve space in the .o files.  We do this
 282    by putting uninitialized data and runtime initialized data into
 283    .common instead of .data at the expense of not flagging multiple
 284    definitions.  */
 285 extern int flag_conserve_space;
 286 \f
 287 /* C and C++ flags are in decl2.c.  */
 288
 289 /* Flag used when debugging spew.c */
 290
 291 extern int spew_debug;
 292
 293 /* A expression of value 0 with the same precision as a sizetype
 294    node, but signed.  */
 295 tree signed_size_zero_node;
 296
 297 /* The name of the anonymous namespace, throughout this translation
 298    unit.  */
 299 tree anonymous_namespace_name;
 300
 301 /* The number of function bodies which we are currently processing.
 302    (Zero if we are at namespace scope, one inside the body of a
 303    function, two inside the body of a function in a local class, etc.)  */
 304 int function_depth;
 305 \f
 306 /* For each binding contour we allocate a binding_level structure
 307    which records the names defined in that contour.
 308    Contours include:
 309     0) the global one
 310     1) one for each function definition,
 311        where internal declarations of the parameters appear.
 312     2) one for each compound statement,
 313        to record its declarations.
 314
 315    The current meaning of a name can be found by searching the levels
 316    from the current one out to the global one.
 317
 318    Off to the side, may be the class_binding_level.  This exists only
 319    to catch class-local declarations.  It is otherwise nonexistent.
 320
 321    Also there may be binding levels that catch cleanups that must be
 322    run when exceptions occur.  Thus, to see whether a name is bound in
 323    the current scope, it is not enough to look in the
 324    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 325    instead.  */
 326
 327 /* Note that the information in the `names' component of the global contour
 328    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 329
 330 struct binding_level
 331   {
 332     /* A chain of _DECL nodes for all variables, constants, functions,
 333        and typedef types.  These are in the reverse of the order
 334        supplied.  There may be OVERLOADs on this list, too, but they
 335        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 336     tree names;
 337
 338     /* A list of structure, union and enum definitions, for looking up
 339        tag names.
 340        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 341        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 342        or ENUMERAL_TYPE node.
 343
 344        C++: the TREE_VALUE nodes can be simple types for
 345        component_bindings.  */
 346     tree tags;
 347
 348     /* A list of USING_DECL nodes. */
 349     tree usings;
 350
 351     /* A list of used namespaces. PURPOSE is the namespace,
 352        VALUE the common ancestor with this binding_level's namespace. */
 353     tree using_directives;
 354
 355     /* If this binding level is the binding level for a class, then
 356        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 357        is the name of an entity bound in the class.  The TREE_TYPE is
 358        the DECL bound by this name in the class.  */
 359     tree class_shadowed;
 360
 361     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 362        is used for all binding levels. In addition the TREE_VALUE is the
 363        IDENTIFIER_TYPE_VALUE before we entered the class.  */
 364     tree type_shadowed;
 365
 366     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 367        label in this scope.  The TREE_PURPOSE is the previous value of
 368        the IDENTIFIER_LABEL VALUE.  */
 369     tree shadowed_labels;
 370
 371     /* For each level (except not the global one),
 372        a chain of BLOCK nodes for all the levels
 373        that were entered and exited one level down.  */
 374     tree blocks;
 375
 376     /* The _TYPE node for this level, if parm_flag == 2.  */
 377     tree this_class;
 378
 379     /* The binding level which this one is contained in (inherits from).  */
 380     struct binding_level *level_chain;
 381
 382     /* List of decls in `names' that have incomplete
 383        structure or union types.  */
 384     tree incomplete;
 385
 386     /* List of VAR_DECLS saved from a previous for statement.
 387        These would be dead in ISO-conforming code, but might
 388        be referenced in ARM-era code.  These are stored in a
 389        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 390     tree dead_vars_from_for;
 391
 392     /* 1 for the level that holds the parameters of a function.
 393        2 for the level that holds a class declaration.  */
 394     unsigned parm_flag : 2;
 395
 396     /* 1 means make a BLOCK for this level regardless of all else.
 397        2 for temporary binding contours created by the compiler.  */
 398     unsigned keep : 2;
 399
 400     /* Nonzero if this level "doesn't exist" for tags.  */
 401     unsigned tag_transparent : 1;
 402
 403     /* Nonzero if this level can safely have additional
 404        cleanup-needing variables added to it.  */
 405     unsigned more_cleanups_ok : 1;
 406     unsigned have_cleanups : 1;
 407
 408     /* Nonzero if this scope is for storing the decls for template
 409        parameters and generic decls; these decls will be discarded and
 410        replaced with a TEMPLATE_DECL.  */
 411     unsigned template_parms_p : 1;
 412
 413     /* Nonzero if this scope corresponds to the `<>' in a
 414        `template <>' clause.  Whenever this flag is set,
 415        TEMPLATE_PARMS_P will be set as well.  */
 416     unsigned template_spec_p : 1;
 417
 418     /* This is set for a namespace binding level.  */
 419     unsigned namespace_p : 1;
 420
 421     /* True if this level is that of a for-statement where we need to
 422        worry about ambiguous (ARM or ISO) scope rules.  */
 423     unsigned is_for_scope : 1;
 424
 425     /* True if this level corresponds to a TRY block.  Currently this
 426        information is only available while building the tree structure.  */
 427     unsigned is_try_scope : 1;
 428
 429     /* True if this level corresponds to a CATCH block.  Currently this
 430        information is only available while building the tree structure.  */
 431     unsigned is_catch_scope : 1;
 432
 433     /* Three bits left for this word.  */
 434
 435 #if defined(DEBUG_CP_BINDING_LEVELS)
 436     /* Binding depth at which this level began.  */
 437     unsigned binding_depth;
 438 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 439   };
 440
 441 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 442
 443 /* The binding level currently in effect.  */
 444
 445 #define current_binding_level                   \
 446   (cfun && cp_function_chain->bindings          \
 447    ? cp_function_chain->bindings                \
 448    : scope_chain->bindings)
 449
 450 /* The binding level of the current class, if any.  */
 451
 452 #define class_binding_level scope_chain->class_bindings
 453
 454 /* A chain of binding_level structures awaiting reuse.  */
 455
 456 static struct binding_level *free_binding_level;
 457
 458 /* The outermost binding level, for names of file scope.
 459    This is created when the compiler is started and exists
 460    through the entire run.  */
 461
 462 static struct binding_level *global_binding_level;
 463
 464 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 465
 466 static int keep_next_level_flag;
 467
 468 #if defined(DEBUG_CP_BINDING_LEVELS)
 469 static int binding_depth = 0;
 470 static int is_class_level = 0;
 471
 472 static void
 473 indent ()
 474 {
 475   register unsigned i;
 476
 477   for (i = 0; i < binding_depth*2; i++)
 478     putc (' ', stderr);
 479 }
 480 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 481
 482 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 483
 484 static void
 485 push_binding_level (newlevel, tag_transparent, keep)
 486      struct binding_level *newlevel;
 487      int tag_transparent, keep;
 488 {
 489   /* Add this level to the front of the chain (stack) of levels that
 490      are active.  */
 491   memset ((char*) newlevel, 0, sizeof (struct binding_level));
 492   newlevel->level_chain = current_binding_level;
 493   current_binding_level = newlevel;
 494   newlevel->tag_transparent = tag_transparent;
 495   newlevel->more_cleanups_ok = 1;
 496
 497   newlevel->keep = keep;
 498 #if defined(DEBUG_CP_BINDING_LEVELS)
 499   newlevel->binding_depth = binding_depth;
 500   indent ();
 501   fprintf (stderr, "push %s level 0x%08x line %d\n",
 502            (is_class_level) ? "class" : "block", newlevel, lineno);
 503   is_class_level = 0;
 504   binding_depth++;
 505 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 506 }
 507
 508 /* Find the innermost enclosing class scope, and reset
 509    CLASS_BINDING_LEVEL appropriately.  */
 510
 511 static void
 512 find_class_binding_level ()
 513 {
 514   struct binding_level *level = current_binding_level;
 515
 516   while (level && level->parm_flag != 2)
 517     level = level->level_chain;
 518   if (level && level->parm_flag == 2)
 519     class_binding_level = level;
 520   else
 521     class_binding_level = 0;
 522 }
 523
 524 static void
 525 pop_binding_level ()
 526 {
 527   if (global_binding_level)
 528     {
 529       /* Cannot pop a level, if there are none left to pop.  */
 530       if (current_binding_level == global_binding_level)
 531         my_friendly_abort (123);
 532     }
 533   /* Pop the current level, and free the structure for reuse.  */
 534 #if defined(DEBUG_CP_BINDING_LEVELS)
 535   binding_depth--;
 536   indent ();
 537   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 538           (is_class_level) ? "class" : "block",
 539           current_binding_level, lineno);
 540   if (is_class_level != (current_binding_level == class_binding_level))
 541     {
 542       indent ();
 543       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 544     }
 545   is_class_level = 0;
 546 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 547   {
 548     register struct binding_level *level = current_binding_level;
 549     current_binding_level = current_binding_level->level_chain;
 550     level->level_chain = free_binding_level;
 551 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 552     if (level->binding_depth != binding_depth)
 553       abort ();
 554 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 555     free_binding_level = level;
 556     find_class_binding_level ();
 557   }
 558 }
 559
 560 static void
 561 suspend_binding_level ()
 562 {
 563   if (class_binding_level)
 564     current_binding_level = class_binding_level;
 565
 566   if (global_binding_level)
 567     {
 568       /* Cannot suspend a level, if there are none left to suspend.  */
 569       if (current_binding_level == global_binding_level)
 570         my_friendly_abort (123);
 571     }
 572   /* Suspend the current level.  */
 573 #if defined(DEBUG_CP_BINDING_LEVELS)
 574   binding_depth--;
 575   indent ();
 576   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 577           (is_class_level) ? "class" : "block",
 578           current_binding_level, lineno);
 579   if (is_class_level != (current_binding_level == class_binding_level))
 580     {
 581       indent ();
 582       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 583     }
 584   is_class_level = 0;
 585 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 586   current_binding_level = current_binding_level->level_chain;
 587   find_class_binding_level ();
 588 }
 589
 590 static void
 591 resume_binding_level (b)
 592      struct binding_level *b;
 593 {
 594   /* Resuming binding levels is meant only for namespaces,
 595      and those cannot nest into classes. */
 596   my_friendly_assert(!class_binding_level, 386);
 597   /* Also, resuming a non-directly nested namespace is a no-no.  */
 598   my_friendly_assert(b->level_chain == current_binding_level, 386);
 599   current_binding_level = b;
 600 #if defined(DEBUG_CP_BINDING_LEVELS)
 601   b->binding_depth = binding_depth;
 602   indent ();
 603   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 604            (is_class_level) ? "class" : "block", b, lineno);
 605   is_class_level = 0;
 606   binding_depth++;
 607 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 608 }
 609 \f
 610 /* Create a new `struct binding_level'.  */
 611
 612 static
 613 struct binding_level *
 614 make_binding_level ()
 615 {
 616   /* NOSTRICT */
 617   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 618 }
 619
 620 /* Nonzero if we are currently in the global binding level.  */
 621
 622 int
 623 global_bindings_p ()
 624 {
 625   return current_binding_level == global_binding_level;
 626 }
 627
 628 /* Return the innermost binding level that is not for a class scope.  */
 629
 630 static struct binding_level *
 631 innermost_nonclass_level ()
 632 {
 633   struct binding_level *b;
 634
 635   b = current_binding_level;
 636   while (b->parm_flag == 2)
 637     b = b->level_chain;
 638
 639   return b;
 640 }
 641
 642 /* Nonzero if we are currently in a toplevel binding level.  This
 643    means either the global binding level or a namespace in a toplevel
 644    binding level.  Since there are no non-toplevel namespace levels,
 645    this really means any namespace or template parameter level.  We
 646    also include a class whose context is toplevel.  */
 647
 648 int
 649 toplevel_bindings_p ()
 650 {
 651   struct binding_level *b = innermost_nonclass_level ();
 652
 653   return b->namespace_p || b->template_parms_p;
 654 }
 655
 656 /* Nonzero if this is a namespace scope, or if we are defining a class
 657    which is itself at namespace scope, or whose enclosing class is
 658    such a class, etc.  */
 659
 660 int
 661 namespace_bindings_p ()
 662 {
 663   struct binding_level *b = innermost_nonclass_level ();
 664
 665   return b->namespace_p;
 666 }
 667
 668 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 669    unconditionally.  Otherwise, use the normal logic to decide whether
 670    or not to create a BLOCK.  */
 671
 672 void
 673 keep_next_level (keep)
 674      int keep;
 675 {
 676   keep_next_level_flag = keep;
 677 }
 678
 679 /* Nonzero if the current level needs to have a BLOCK made.  */
 680
 681 int
 682 kept_level_p ()
 683 {
 684   return (current_binding_level->blocks != NULL_TREE
 685           || current_binding_level->keep
 686           || current_binding_level->names != NULL_TREE
 687           || (current_binding_level->tags != NULL_TREE
 688               && !current_binding_level->tag_transparent));
 689 }
 690
 691 static void
 692 declare_namespace_level ()
 693 {
 694   current_binding_level->namespace_p = 1;
 695 }
 696
 697 /* Returns non-zero if this scope was created to store template
 698    parameters.  */
 699
 700 int
 701 template_parm_scope_p ()
 702 {
 703   return current_binding_level->template_parms_p;
 704 }
 705
 706 /* Returns the kind of template specialization we are currently
 707    processing, given that it's declaration contained N_CLASS_SCOPES
 708    explicit scope qualifications.  */
 709
 710 tmpl_spec_kind
 711 current_tmpl_spec_kind (n_class_scopes)
 712      int n_class_scopes;
 713 {
 714   int n_template_parm_scopes = 0;
 715   int seen_specialization_p = 0;
 716   int innermost_specialization_p = 0;
 717   struct binding_level *b;
 718
 719   /* Scan through the template parameter scopes.  */
 720   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 721     {
 722       /* If we see a specialization scope inside a parameter scope,
 723          then something is wrong.  That corresponds to a declaration
 724          like:
 725
 726             template <class T> template <> ...
 727
 728          which is always illegal since [temp.expl.spec] forbids the
 729          specialization of a class member template if the enclosing
 730          class templates are not explicitly specialized as well.  */
 731       if (b->template_spec_p)
 732         {
 733           if (n_template_parm_scopes == 0)
 734             innermost_specialization_p = 1;
 735           else
 736             seen_specialization_p = 1;
 737         }
 738       else if (seen_specialization_p == 1)
 739         return tsk_invalid_member_spec;
 740
 741       ++n_template_parm_scopes;
 742     }
 743
 744   /* Handle explicit instantiations.  */
 745   if (processing_explicit_instantiation)
 746     {
 747       if (n_template_parm_scopes != 0)
 748         /* We've seen a template parameter list during an explicit
 749            instantiation.  For example:
 750
 751              template <class T> template void f(int);
 752
 753            This is erroneous.  */
 754         return tsk_invalid_expl_inst;
 755       else
 756         return tsk_expl_inst;
 757     }
 758
 759   if (n_template_parm_scopes < n_class_scopes)
 760     /* We've not seen enough template headers to match all the
 761        specialized classes present.  For example:
 762
 763          template <class T> void R<T>::S<T>::f(int);
 764
 765        This is illegal; there needs to be one set of template
 766        parameters for each class.  */
 767     return tsk_insufficient_parms;
 768   else if (n_template_parm_scopes == n_class_scopes)
 769     /* We're processing a non-template declaration (even though it may
 770        be a member of a template class.)  For example:
 771
 772          template <class T> void S<T>::f(int);
 773
 774        The `class T' maches the `S<T>', leaving no template headers
 775        corresponding to the `f'.  */
 776     return tsk_none;
 777   else if (n_template_parm_scopes > n_class_scopes + 1)
 778     /* We've got too many template headers.  For example:
 779
 780          template <> template <class T> void f (T);
 781
 782        There need to be more enclosing classes.  */
 783     return tsk_excessive_parms;
 784   else
 785     /* This must be a template.  It's of the form:
 786
 787          template <class T> template <class U> void S<T>::f(U);
 788
 789        This is a specialization if the innermost level was a
 790        specialization; otherwise it's just a definition of the
 791        template.  */
 792     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 793 }
 794
 795 void
 796 set_class_shadows (shadows)
 797      tree shadows;
 798 {
 799   class_binding_level->class_shadowed = shadows;
 800 }
 801
 802 /* Enter a new binding level.
 803    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 804    not for that of tags.  */
 805
 806 void
 807 pushlevel (tag_transparent)
 808      int tag_transparent;
 809 {
 810   struct binding_level *newlevel;
 811
 812   if (cfun && !doing_semantic_analysis_p ())
 813     return;
 814
 815   /* Reuse or create a struct for this binding level.  */
 816 #if defined(DEBUG_CP_BINDING_LEVELS)
 817   if (0)
 818 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 819   if (free_binding_level)
 820 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 821     {
 822       newlevel = free_binding_level;
 823       free_binding_level = free_binding_level->level_chain;
 824     }
 825   else
 826     newlevel = make_binding_level ();
 827
 828   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 829   GNU_xref_start_scope ((size_t) newlevel);
 830   keep_next_level_flag = 0;
 831 }
 832
 833 /* We're defining an object of type TYPE.  If it needs a cleanup, but
 834    we're not allowed to add any more objects with cleanups to the current
 835    scope, create a new binding level.  */
 836
 837 void
 838 maybe_push_cleanup_level (type)
 839      tree type;
 840 {
 841   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
 842       && current_binding_level->more_cleanups_ok == 0)
 843     {
 844       keep_next_level (2);
 845       pushlevel (1);
 846       clear_last_expr ();
 847       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
 848     }
 849 }
 850
 851 /* Enter a new scope.  The KIND indicates what kind of scope is being
 852    created.  */
 853
 854 void
 855 begin_scope (sk)
 856      scope_kind sk;
 857 {
 858   pushlevel (0);
 859
 860   switch (sk)
 861     {
 862     case sk_template_spec:
 863       current_binding_level->template_spec_p = 1;
 864       /* Fall through.  */
 865
 866     case sk_template_parms:
 867       current_binding_level->template_parms_p = 1;
 868       break;
 869
 870     default:
 871       my_friendly_abort (20000309);
 872     }
 873 }
 874
 875 /* Exit the current scope.  */
 876
 877 void
 878 finish_scope ()
 879 {
 880   poplevel (0, 0, 0);
 881 }
 882
 883 void
 884 note_level_for_for ()
 885 {
 886   current_binding_level->is_for_scope = 1;
 887 }
 888
 889 /* Record that the current binding level represents a try block.  */
 890
 891 void
 892 note_level_for_try ()
 893 {
 894   current_binding_level->is_try_scope = 1;
 895 }
 896
 897 /* Record that the current binding level represents a catch block.  */
 898
 899 void
 900 note_level_for_catch ()
 901 {
 902   current_binding_level->is_catch_scope = 1;
 903 }
 904
 905 /* For a binding between a name and an entity at a block scope,
 906    this is the `struct binding_level' for the block.  */
 907 #define BINDING_LEVEL(NODE) \
 908    (((struct tree_binding*)NODE)->scope.level)
 909
 910 /* A free list of CPLUS_BINDING nodes, connected by their
 911    TREE_CHAINs.  */
 912
 913 static tree free_bindings;
 914
 915 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 916    level at which this declaration is being bound.  */
 917
 918 static void
 919 push_binding (id, decl, level)
 920      tree id;
 921      tree decl;
 922      struct binding_level* level;
 923 {
 924   tree binding;
 925
 926   if (free_bindings)
 927     {
 928       binding = free_bindings;
 929       free_bindings = TREE_CHAIN (binding);
 930     }
 931   else
 932     binding = make_node (CPLUS_BINDING);
 933
 934   /* Now, fill in the binding information.  */
 935   BINDING_VALUE (binding) = decl;
 936   BINDING_TYPE (binding) = NULL_TREE;
 937   BINDING_LEVEL (binding) = level;
 938   INHERITED_VALUE_BINDING_P (binding) = 0;
 939   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 940   BINDING_HAS_LEVEL_P (binding) = 1;
 941
 942   /* And put it on the front of the list of bindings for ID.  */
 943   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 944   IDENTIFIER_BINDING (id) = binding;
 945 }
 946
 947 /* ID is already bound in the current scope.  But, DECL is an
 948    additional binding for ID in the same scope.  This is the `struct
 949    stat' hack whereby a non-typedef class-name or enum-name can be
 950    bound at the same level as some other kind of entity.  It's the
 951    responsibility of the caller to check that inserting this name is
 952    legal here.  Returns nonzero if the new binding was successful.  */
 953 static int
 954 add_binding (id, decl)
 955      tree id;
 956      tree decl;
 957 {
 958   tree binding = IDENTIFIER_BINDING (id);
 959   int ok = 1;
 960
 961   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 962     /* The new name is the type name.  */
 963     BINDING_TYPE (binding) = decl;
 964   else if (!BINDING_VALUE (binding))
 965     /* This situation arises when push_class_level_binding moves an
 966        inherited type-binding out of the way to make room for a new
 967        value binding.  */
 968     BINDING_VALUE (binding) = decl;
 969   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 970            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 971     {
 972       /* The old binding was a type name.  It was placed in
 973          BINDING_VALUE because it was thought, at the point it was
 974          declared, to be the only entity with such a name.  Move the
 975          type name into the type slot; it is now hidden by the new
 976          binding.  */
 977       BINDING_TYPE (binding) = BINDING_VALUE (binding);
 978       BINDING_VALUE (binding) = decl;
 979       INHERITED_VALUE_BINDING_P (binding) = 0;
 980     }
 981   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 982            && TREE_CODE (decl) == TYPE_DECL
 983            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
 984            && (same_type_p (TREE_TYPE (decl),
 985                             TREE_TYPE (BINDING_VALUE (binding)))
 986                /* If either type involves template parameters, we must
 987                   wait until instantiation.  */
 988                || uses_template_parms (TREE_TYPE (decl))
 989                || uses_template_parms (TREE_TYPE (BINDING_VALUE (binding)))))
 990     /* We have two typedef-names, both naming the same type to have
 991        the same name.  This is OK because of:
 992
 993          [dcl.typedef]
 994
 995          In a given scope, a typedef specifier can be used to redefine
 996          the name of any type declared in that scope to refer to the
 997          type to which it already refers.  */
 998     ok = 0;
 999   /* There can be two block-scope declarations of the same variable,
1000      so long as they are `extern' declarations.  */
1001   else if (TREE_CODE (decl) == VAR_DECL
1002            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1003            && DECL_EXTERNAL (decl)
1004            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1005     {
1006       duplicate_decls (decl, BINDING_VALUE (binding));
1007       ok = 0;
1008     }
1009   else
1010     {
1011       cp_error ("declaration of `%#D'", decl);
1012       cp_error_at ("conflicts with previous declaration `%#D'",
1013                    BINDING_VALUE (binding));
1014       ok = 0;
1015     }
1016
1017   return ok;
1018 }
1019
1020 /* Add DECL to the list of things declared in B.  */
1021
1022 static void
1023 add_decl_to_level (decl, b)
1024      tree decl;
1025      struct binding_level *b;
1026 {
1027   /* We build up the list in reverse order, and reverse it later if
1028      necessary.  */
1029   TREE_CHAIN (decl) = b->names;
1030   b->names = decl;
1031 }
1032
1033 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1034    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1035    doesn't really belong to this binding level, that it got here
1036    through a using-declaration.  */
1037
1038 void
1039 push_local_binding (id, decl, flags)
1040      tree id;
1041      tree decl;
1042      int flags;
1043 {
1044   struct binding_level *b;
1045
1046   /* Skip over any local classes.  This makes sense if we call
1047      push_local_binding with a friend decl of a local class.  */
1048   b = current_binding_level;
1049   while (b->parm_flag == 2)
1050     b = b->level_chain;
1051
1052   if (lookup_name_current_level (id))
1053     {
1054       /* Supplement the existing binding.  */
1055       if (!add_binding (id, decl))
1056         /* It didn't work.  Something else must be bound at this
1057            level.  Do not add DECL to the list of things to pop
1058            later.  */
1059         return;
1060     }
1061   else
1062     /* Create a new binding.  */
1063     push_binding (id, decl, b);
1064
1065   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1066     /* We must put the OVERLOAD into a TREE_LIST since the
1067        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1068        decls that got here through a using-declaration.  */
1069     decl = build_tree_list (NULL_TREE, decl);
1070
1071   /* And put DECL on the list of things declared by the current
1072      binding level.  */
1073   add_decl_to_level (decl, b);
1074 }
1075
1076 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1077    binding was successful.  */
1078
1079 int
1080 push_class_binding (id, decl)
1081      tree id;
1082      tree decl;
1083 {
1084   int result = 1;
1085   tree binding = IDENTIFIER_BINDING (id);
1086   tree context;
1087
1088   /* Note that we declared this value so that we can issue an error if
1089      this an illegal redeclaration of a name already used for some
1090      other purpose.  */
1091   note_name_declared_in_class (id, decl);
1092
1093   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1094     /* Supplement the existing binding.  */
1095     result = add_binding (id, decl);
1096   else
1097     /* Create a new binding.  */
1098     push_binding (id, decl, class_binding_level);
1099
1100   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1101      class-level declaration.  Note that we do not use DECL here
1102      because of the possibility of the `struct stat' hack; if DECL is
1103      a class-name or enum-name we might prefer a field-name, or some
1104      such.  */
1105   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1106
1107   /* If this is a binding from a base class, mark it as such.  */
1108   binding = IDENTIFIER_BINDING (id);
1109   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1110     {
1111       /* Any implicit typename must be from a base-class.  The
1112          context for an implicit typename declaration is always
1113          the derived class in which the lookup was done, so the checks
1114          based on the context of DECL below will not trigger.  */
1115       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1116         INHERITED_VALUE_BINDING_P (binding) = 1;
1117       else
1118         {
1119           if (TREE_CODE (decl) == OVERLOAD)
1120             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1121           else
1122             {
1123               my_friendly_assert (DECL_P (decl), 0);
1124               context = context_for_name_lookup (decl);
1125             }
1126
1127           if (is_properly_derived_from (current_class_type, context))
1128             INHERITED_VALUE_BINDING_P (binding) = 1;
1129           else
1130             INHERITED_VALUE_BINDING_P (binding) = 0;
1131         }
1132     }
1133   else if (BINDING_VALUE (binding) == decl)
1134     /* We only encounter a TREE_LIST when push_class_decls detects an
1135        ambiguity.  Such an ambiguity can be overridden by a definition
1136        in this class.  */
1137     INHERITED_VALUE_BINDING_P (binding) = 1;
1138
1139   return result;
1140 }
1141
1142 /* Remove the binding for DECL which should be the innermost binding
1143    for ID.  */
1144
1145 static void
1146 pop_binding (id, decl)
1147      tree id;
1148      tree decl;
1149 {
1150   tree binding;
1151
1152   if (id == NULL_TREE)
1153     /* It's easiest to write the loops that call this function without
1154        checking whether or not the entities involved have names.  We
1155        get here for such an entity.  */
1156     return;
1157
1158   /* Get the innermost binding for ID.  */
1159   binding = IDENTIFIER_BINDING (id);
1160
1161   /* The name should be bound.  */
1162   my_friendly_assert (binding != NULL_TREE, 0);
1163
1164   /* The DECL will be either the ordinary binding or the type
1165      binding for this identifier.  Remove that binding.  */
1166   if (BINDING_VALUE (binding) == decl)
1167     BINDING_VALUE (binding) = NULL_TREE;
1168   else if (BINDING_TYPE (binding) == decl)
1169     BINDING_TYPE (binding) = NULL_TREE;
1170   else
1171     my_friendly_abort (0);
1172
1173   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1174     {
1175       /* We're completely done with the innermost binding for this
1176          identifier.  Unhook it from the list of bindings.  */
1177       IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1178
1179       /* Add it to the free list.  */
1180       TREE_CHAIN (binding) = free_bindings;
1181       free_bindings = binding;
1182
1183       /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
1184          it.  */
1185       BINDING_LEVEL (binding) = NULL;
1186     }
1187 }
1188
1189 /* When a label goes out of scope, check to see if that label was used
1190    in a valid manner, and issue any appropriate warnings or errors.  */
1191
1192 static void
1193 pop_label (label, old_value)
1194      tree label;
1195      tree old_value;
1196 {
1197   if (!processing_template_decl && doing_semantic_analysis_p ())
1198     {
1199       if (DECL_INITIAL (label) == NULL_TREE)
1200         {
1201           cp_error_at ("label `%D' used but not defined", label);
1202           /* Avoid crashing later.  */
1203           define_label (input_filename, 1, DECL_NAME (label));
1204         }
1205       else if (warn_unused_label && !TREE_USED (label))
1206         cp_warning_at ("label `%D' defined but not used", label);
1207     }
1208
1209   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1210 }
1211
1212 /* At the end of a function, all labels declared within the function
1213    go out of scope.  BLOCK is the top-level block for the
1214    function.  */
1215
1216 static void
1217 pop_labels (block)
1218      tree block;
1219 {
1220   struct named_label_list *link;
1221
1222   /* Clear out the definitions of all label names, since their scopes
1223      end here.  */
1224   for (link = named_labels; link; link = link->next)
1225     {
1226       pop_label (link->label_decl, link->old_value);
1227       /* Put the labels into the "variables" of the top-level block,
1228          so debugger can see them.  */
1229       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1230       BLOCK_VARS (block) = link->label_decl;
1231     }
1232
1233   named_labels = NULL;
1234 }
1235
1236 /* Exit a binding level.
1237    Pop the level off, and restore the state of the identifier-decl mappings
1238    that were in effect when this level was entered.
1239
1240    If KEEP == 1, this level had explicit declarations, so
1241    and create a "block" (a BLOCK node) for the level
1242    to record its declarations and subblocks for symbol table output.
1243
1244    If FUNCTIONBODY is nonzero, this level is the body of a function,
1245    so create a block as if KEEP were set and also clear out all
1246    label names.
1247
1248    If REVERSE is nonzero, reverse the order of decls before putting
1249    them into the BLOCK.  */
1250
1251 tree
1252 poplevel (keep, reverse, functionbody)
1253      int keep;
1254      int reverse;
1255      int functionbody;
1256 {
1257   register tree link;
1258   /* The chain of decls was accumulated in reverse order.
1259      Put it into forward order, just for cleanliness.  */
1260   tree decls;
1261   int tmp = functionbody;
1262   int real_functionbody;
1263   tree tags;
1264   tree subblocks;
1265   tree block = NULL_TREE;
1266   tree decl;
1267   int leaving_for_scope;
1268
1269   if (cfun && !doing_semantic_analysis_p ())
1270     return NULL_TREE;
1271
1272   my_friendly_assert (current_binding_level->parm_flag != 2,
1273                       19990916);
1274
1275   real_functionbody = (current_binding_level->keep == 2
1276                        ? ((functionbody = 0), tmp) : functionbody);
1277   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1278   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1279
1280   my_friendly_assert (!current_binding_level->class_shadowed,
1281                       19990414);
1282
1283   /* We used to use KEEP == 2 to indicate that the new block should go
1284      at the beginning of the list of blocks at this binding level,
1285      rather than the end.  This hack is no longer used.  */
1286   my_friendly_assert (keep == 0 || keep == 1, 0);
1287
1288   GNU_xref_end_scope ((size_t) current_binding_level,
1289                       (size_t) current_binding_level->level_chain,
1290                       current_binding_level->parm_flag,
1291                       current_binding_level->keep);
1292
1293   if (current_binding_level->keep == 1)
1294     keep = 1;
1295
1296   /* Any uses of undefined labels, and any defined labels, now operate
1297      under constraints of next binding contour.  */
1298   if (cfun && !functionbody)
1299     {
1300       struct binding_level *level_chain;
1301       level_chain = current_binding_level->level_chain;
1302       if (level_chain)
1303         {
1304           struct named_label_use_list *uses;
1305           struct named_label_list *labels;
1306           for (labels = named_labels; labels; labels = labels->next)
1307             if (labels->binding_level == current_binding_level)
1308               {
1309                 tree decl;
1310                 if (current_binding_level->is_try_scope)
1311                   labels->in_try_scope = 1;
1312                 if (current_binding_level->is_catch_scope)
1313                   labels->in_catch_scope = 1;
1314                 for (decl = labels->names_in_scope; decl;
1315                      decl = TREE_CHAIN (decl))
1316                   if (decl_jump_unsafe (decl))
1317                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1318                                                    labels->bad_decls);
1319                 labels->binding_level = level_chain;
1320                 labels->names_in_scope = level_chain->names;
1321               }
1322
1323           for (uses = named_label_uses; uses; uses = uses->next)
1324             if (uses->binding_level == current_binding_level)
1325               {
1326                 uses->binding_level = level_chain;
1327                 uses->names_in_scope = level_chain->names;
1328               }
1329         }
1330     }
1331
1332   /* Get the decls in the order they were written.
1333      Usually current_binding_level->names is in reverse order.
1334      But parameter decls were previously put in forward order.  */
1335
1336   if (reverse)
1337     current_binding_level->names
1338       = decls = nreverse (current_binding_level->names);
1339   else
1340     decls = current_binding_level->names;
1341
1342   /* Output any nested inline functions within this block
1343      if they weren't already output.  */
1344   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1345     if (TREE_CODE (decl) == FUNCTION_DECL
1346         && ! TREE_ASM_WRITTEN (decl)
1347         && DECL_INITIAL (decl) != NULL_TREE
1348         && TREE_ADDRESSABLE (decl)
1349         && decl_function_context (decl) == current_function_decl)
1350       {
1351         /* If this decl was copied from a file-scope decl
1352            on account of a block-scope extern decl,
1353            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1354         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1355           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1356         else
1357           {
1358             push_function_context ();
1359             output_inline_function (decl);
1360             pop_function_context ();
1361           }
1362       }
1363
1364   /* When not in function-at-a-time mode, expand_end_bindings will
1365      warn about unused variables.  But, in function-at-a-time mode
1366      expand_end_bindings is not passed the list of variables in the
1367      current scope, and therefore no warning is emitted.  So, we
1368      explicitly warn here.  */
1369   if (!processing_template_decl)
1370     warn_about_unused_variables (getdecls ());
1371
1372   /* If there were any declarations or structure tags in that level,
1373      or if this level is a function body,
1374      create a BLOCK to record them for the life of this function.  */
1375   block = NULL_TREE;
1376   if (keep == 1 || functionbody)
1377     block = make_node (BLOCK);
1378   if (block != NULL_TREE)
1379     {
1380       BLOCK_VARS (block) = decls;
1381       BLOCK_SUBBLOCKS (block) = subblocks;
1382     }
1383
1384   /* In each subblock, record that this is its superior.  */
1385   if (keep >= 0)
1386     for (link = subblocks; link; link = TREE_CHAIN (link))
1387       BLOCK_SUPERCONTEXT (link) = block;
1388
1389   /* We still support the old for-scope rules, whereby the variables
1390      in a for-init statement were in scope after the for-statement
1391      ended.  We only use the new rules in flag_new_for_scope is
1392      nonzero.  */
1393   leaving_for_scope
1394     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1395
1396   /* Remove declarations for all the DECLs in this level.  */
1397   for (link = decls; link; link = TREE_CHAIN (link))
1398     {
1399       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1400           && DECL_NAME (link))
1401         {
1402           tree outer_binding
1403             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1404           tree ns_binding;
1405
1406           if (!outer_binding)
1407             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1408           else
1409             ns_binding = NULL_TREE;
1410
1411           if (outer_binding
1412               && (BINDING_LEVEL (outer_binding)
1413                   == current_binding_level->level_chain))
1414             /* We have something like:
1415
1416                  int i;
1417                  for (int i; ;);
1418
1419                and we are leaving the `for' scope.  There's no reason to
1420                keep the binding of the inner `i' in this case.  */
1421             pop_binding (DECL_NAME (link), link);
1422           else if ((outer_binding
1423                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1424                         == TYPE_DECL))
1425                    || (ns_binding
1426                        && TREE_CODE (ns_binding) == TYPE_DECL))
1427             /* Here, we have something like:
1428
1429                  typedef int I;
1430
1431                  void f () {
1432                    for (int I; ;);
1433                  }
1434
1435                We must pop the for-scope binding so we know what's a
1436                type and what isn't.  */
1437             pop_binding (DECL_NAME (link), link);
1438           else
1439             {
1440               /* Mark this VAR_DECL as dead so that we can tell we left it
1441                  there only for backward compatibility.  */
1442               DECL_DEAD_FOR_LOCAL (link) = 1;
1443
1444               /* Keep track of what should of have happenned when we
1445                  popped the binding.  */
1446               if (outer_binding && BINDING_VALUE (outer_binding))
1447                 DECL_SHADOWED_FOR_VAR (link)
1448                   = BINDING_VALUE (outer_binding);
1449
1450               /* Add it to the list of dead variables in the next
1451                  outermost binding to that we can remove these when we
1452                  leave that binding.  */
1453               current_binding_level->level_chain->dead_vars_from_for
1454                 = tree_cons (NULL_TREE, link,
1455                              current_binding_level->level_chain->
1456                              dead_vars_from_for);
1457
1458               /* Although we don't pop the CPLUS_BINDING, we do clear
1459                  its BINDING_LEVEL since the level is going away now.  */
1460               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1461                 = 0;
1462             }
1463         }
1464       else
1465         {
1466           /* Remove the binding.  */
1467           decl = link;
1468           if (TREE_CODE (decl) == TREE_LIST)
1469             decl = TREE_VALUE (decl);
1470           if (DECL_P (decl))
1471             pop_binding (DECL_NAME (decl), decl);
1472           else if (TREE_CODE (decl) == OVERLOAD)
1473             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1474           else
1475             my_friendly_abort (0);
1476         }
1477     }
1478
1479   /* Remove declarations for any `for' variables from inner scopes
1480      that we kept around.  */
1481   for (link = current_binding_level->dead_vars_from_for;
1482        link; link = TREE_CHAIN (link))
1483     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1484
1485   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1486   for (link = current_binding_level->type_shadowed;
1487        link; link = TREE_CHAIN (link))
1488     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1489
1490   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1491   for (link = current_binding_level->shadowed_labels;
1492        link;
1493        link = TREE_CHAIN (link))
1494     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1495
1496   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1497      list if a `using' declaration put them there.  The debugging
1498      back-ends won't understand OVERLOAD, so we remove them here.
1499      Because the BLOCK_VARS are (temporarily) shared with
1500      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1501      popped all the bindings.  */
1502   if (block)
1503     {
1504       tree* d;
1505
1506       for (d = &BLOCK_VARS (block); *d; )
1507         {
1508           if (TREE_CODE (*d) == TREE_LIST)
1509             *d = TREE_CHAIN (*d);
1510           else
1511             d = &TREE_CHAIN (*d);
1512         }
1513     }
1514
1515   /* If the level being exited is the top level of a function,
1516      check over all the labels.  */
1517   if (functionbody)
1518     {
1519       /* Since this is the top level block of a function, the vars are
1520          the function's parameters.  Don't leave them in the BLOCK
1521          because they are found in the FUNCTION_DECL instead.  */
1522       BLOCK_VARS (block) = 0;
1523       pop_labels (block);
1524     }
1525
1526   tmp = current_binding_level->keep;
1527
1528   pop_binding_level ();
1529   if (functionbody)
1530     DECL_INITIAL (current_function_decl) = block;
1531   else if (block)
1532     current_binding_level->blocks
1533       = chainon (current_binding_level->blocks, block);
1534
1535   /* If we did not make a block for the level just exited,
1536      any blocks made for inner levels
1537      (since they cannot be recorded as subblocks in that level)
1538      must be carried forward so they will later become subblocks
1539      of something else.  */
1540   else if (subblocks)
1541     current_binding_level->blocks
1542       = chainon (current_binding_level->blocks, subblocks);
1543
1544   /* Each and every BLOCK node created here in `poplevel' is important
1545      (e.g. for proper debugging information) so if we created one
1546      earlier, mark it as "used".  */
1547   if (block)
1548     TREE_USED (block) = 1;
1549
1550   /* Take care of compiler's internal binding structures.  */
1551   if (tmp == 2)
1552     {
1553       tree scope_stmts;
1554
1555       scope_stmts
1556         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1557       if (block)
1558         {
1559           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1560           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1561         }
1562
1563       block = poplevel (keep, reverse, functionbody);
1564     }
1565
1566   return block;
1567 }
1568
1569 /* Delete the node BLOCK from the current binding level.
1570    This is used for the block inside a stmt expr ({...})
1571    so that the block can be reinserted where appropriate.  */
1572
1573 void
1574 delete_block (block)
1575      tree block;
1576 {
1577   tree t;
1578   if (current_binding_level->blocks == block)
1579     current_binding_level->blocks = TREE_CHAIN (block);
1580   for (t = current_binding_level->blocks; t;)
1581     {
1582       if (TREE_CHAIN (t) == block)
1583         TREE_CHAIN (t) = TREE_CHAIN (block);
1584       else
1585         t = TREE_CHAIN (t);
1586     }
1587   TREE_CHAIN (block) = NULL_TREE;
1588   /* Clear TREE_USED which is always set by poplevel.
1589      The flag is set again if insert_block is called.  */
1590   TREE_USED (block) = 0;
1591 }
1592
1593 /* Insert BLOCK at the end of the list of subblocks of the
1594    current binding level.  This is used when a BIND_EXPR is expanded,
1595    to handle the BLOCK node inside the BIND_EXPR.  */
1596
1597 void
1598 insert_block (block)
1599      tree block;
1600 {
1601   TREE_USED (block) = 1;
1602   current_binding_level->blocks
1603     = chainon (current_binding_level->blocks, block);
1604 }
1605
1606 /* Set the BLOCK node for the innermost scope
1607    (the one we are currently in).  */
1608
1609 void
1610 set_block (block)
1611     tree block ATTRIBUTE_UNUSED;
1612 {
1613   /* The RTL expansion machinery requires us to provide this callback,
1614      but it is not applicable in function-at-a-time mode.  */
1615   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1616 }
1617
1618 /* Do a pushlevel for class declarations.  */
1619
1620 void
1621 pushlevel_class ()
1622 {
1623   register struct binding_level *newlevel;
1624
1625   /* Reuse or create a struct for this binding level.  */
1626 #if defined(DEBUG_CP_BINDING_LEVELS)
1627   if (0)
1628 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1629   if (free_binding_level)
1630 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1631     {
1632       newlevel = free_binding_level;
1633       free_binding_level = free_binding_level->level_chain;
1634     }
1635   else
1636     newlevel = make_binding_level ();
1637
1638 #if defined(DEBUG_CP_BINDING_LEVELS)
1639   is_class_level = 1;
1640 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1641
1642   push_binding_level (newlevel, 0, 0);
1643
1644   class_binding_level = current_binding_level;
1645   class_binding_level->parm_flag = 2;
1646   class_binding_level->this_class = current_class_type;
1647 }
1648
1649 /* ...and a poplevel for class declarations.  */
1650
1651 void
1652 poplevel_class ()
1653 {
1654   register struct binding_level *level = class_binding_level;
1655   tree shadowed;
1656
1657   my_friendly_assert (level != 0, 354);
1658
1659   /* If we're leaving a toplevel class, don't bother to do the setting
1660      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1661      shouldn't even be used when current_class_type isn't set, and second,
1662      if we don't touch it here, we're able to use the cache effect if the
1663      next time we're entering a class scope, it is the same class.  */
1664   if (current_class_depth != 1)
1665     {
1666       struct binding_level* b;
1667
1668       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1669       for (shadowed = level->class_shadowed;
1670            shadowed;
1671            shadowed = TREE_CHAIN (shadowed))
1672         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1673
1674       /* Find the next enclosing class, and recreate
1675          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1676       b = level->level_chain;
1677       while (b && b->parm_flag != 2)
1678         b = b->level_chain;
1679
1680       if (b)
1681         for (shadowed = b->class_shadowed;
1682              shadowed;
1683              shadowed = TREE_CHAIN (shadowed))
1684           {
1685             tree t;
1686
1687             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1688             while (t && BINDING_LEVEL (t) != b)
1689               t = TREE_CHAIN (t);
1690
1691             if (t)
1692               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1693                 = BINDING_VALUE (t);
1694           }
1695     }
1696   else
1697     /* Remember to save what IDENTIFIER's were bound in this scope so we
1698        can recover from cache misses.  */
1699     {
1700       previous_class_type = current_class_type;
1701       previous_class_values = class_binding_level->class_shadowed;
1702     }
1703   for (shadowed = level->type_shadowed;
1704        shadowed;
1705        shadowed = TREE_CHAIN (shadowed))
1706     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1707
1708   /* Remove the bindings for all of the class-level declarations.  */
1709   for (shadowed = level->class_shadowed;
1710        shadowed;
1711        shadowed = TREE_CHAIN (shadowed))
1712     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1713
1714   GNU_xref_end_scope ((size_t) class_binding_level,
1715                       (size_t) class_binding_level->level_chain,
1716                       class_binding_level->parm_flag,
1717                       class_binding_level->keep);
1718
1719   /* Now, pop out of the binding level which we created up in the
1720      `pushlevel_class' routine.  */
1721 #if defined(DEBUG_CP_BINDING_LEVELS)
1722   is_class_level = 1;
1723 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1724
1725   pop_binding_level ();
1726 }
1727
1728 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1729    for any names in enclosing classes.  */
1730
1731 void
1732 clear_identifier_class_values ()
1733 {
1734   tree t;
1735
1736   if (!class_binding_level)
1737     return;
1738
1739   for (t = class_binding_level->class_shadowed;
1740        t;
1741        t = TREE_CHAIN (t))
1742     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1743 }
1744
1745 /* Returns non-zero if T is a virtual function table.  */
1746
1747 int
1748 vtable_decl_p (t, data)
1749      tree t;
1750      void *data ATTRIBUTE_UNUSED;
1751 {
1752   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1753 }
1754
1755 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1756    functions.  */
1757
1758 int
1759 vtype_decl_p (t, data)
1760      tree t;
1761      void *data ATTRIBUTE_UNUSED;
1762 {
1763   return (TREE_CODE (t) == TYPE_DECL
1764           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1765           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1766 }
1767
1768 /* Return the declarations that are members of the namespace NS.  */
1769
1770 tree
1771 cp_namespace_decls (ns)
1772      tree ns;
1773 {
1774   return NAMESPACE_LEVEL (ns)->names;
1775 }
1776
1777 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1778    itself, calling F for each.  The DATA is passed to F as well.  */
1779
1780 static int
1781 walk_namespaces_r (namespace, f, data)
1782      tree namespace;
1783      walk_namespaces_fn f;
1784      void *data;
1785 {
1786   tree current;
1787   int result = 0;
1788
1789   result |= (*f) (namespace, data);
1790
1791   for (current = cp_namespace_decls (namespace);
1792        current;
1793        current = TREE_CHAIN (current))
1794     {
1795       if (TREE_CODE (current) != NAMESPACE_DECL
1796           || DECL_NAMESPACE_ALIAS (current))
1797         continue;
1798
1799       /* We found a namespace.  */
1800       result |= walk_namespaces_r (current, f, data);
1801     }
1802
1803   return result;
1804 }
1805
1806 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1807    F as well.  */
1808
1809 int
1810 walk_namespaces (f, data)
1811      walk_namespaces_fn f;
1812      void *data;
1813 {
1814   return walk_namespaces_r (global_namespace, f, data);
1815 }
1816
1817 struct walk_globals_data {
1818   walk_globals_pred p;
1819   walk_globals_fn f;
1820   void *data;
1821 };
1822
1823 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1824    for which P returns non-zero, call F with its address.  If any call
1825    to F returns a non-zero value, return a non-zero value.  */
1826
1827 static int
1828 walk_globals_r (namespace, data)
1829      tree namespace;
1830      void *data;
1831 {
1832   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1833   walk_globals_pred p = wgd->p;
1834   walk_globals_fn f = wgd->f;
1835   void *d = wgd->data;
1836   tree *t;
1837   int result = 0;
1838
1839   t = &NAMESPACE_LEVEL (namespace)->names;
1840
1841   while (*t)
1842     {
1843       tree glbl = *t;
1844
1845       if ((*p) (glbl, d))
1846         result |= (*f) (t, d);
1847
1848       /* If F changed *T, then *T still points at the next item to
1849          examine.  */
1850       if (*t == glbl)
1851         t = &TREE_CHAIN (*t);
1852     }
1853
1854   return result;
1855 }
1856
1857 /* Walk the global declarations.  Whenever one is found for which P
1858    returns non-zero, call F with its address.  If any call to F
1859    returns a non-zero value, return a non-zero value.  */
1860
1861 int
1862 walk_globals (p, f, data)
1863      walk_globals_pred p;
1864      walk_globals_fn f;
1865      void *data;
1866 {
1867   struct walk_globals_data wgd;
1868   wgd.p = p;
1869   wgd.f = f;
1870   wgd.data = data;
1871
1872   return walk_namespaces (walk_globals_r, &wgd);
1873 }
1874
1875 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1876    DATA is non-NULL, this is the last time we will call
1877    wrapup_global_declarations for this NAMESPACE.  */
1878
1879 int
1880 wrapup_globals_for_namespace (namespace, data)
1881      tree namespace;
1882      void *data;
1883 {
1884   tree globals = cp_namespace_decls (namespace);
1885   int len = list_length (globals);
1886   tree *vec = (tree *) alloca (sizeof (tree) * len);
1887   int i;
1888   int result;
1889   tree decl;
1890   int last_time = (data != 0);
1891
1892   if (last_time && namespace == global_namespace)
1893     /* Let compile_file handle the global namespace.  */
1894     return 0;
1895
1896   /* Process the decls in reverse order--earliest first.
1897      Put them into VEC from back to front, then take out from front.  */
1898   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1899     vec[len - i - 1] = decl;
1900
1901   if (last_time)
1902     {
1903       check_global_declarations (vec, len);
1904       return 0;
1905     }
1906
1907   /* Temporarily mark vtables as external.  That prevents
1908      wrapup_global_declarations from writing them out; we must process
1909      them ourselves in finish_vtable_vardecl.  */
1910   for (i = 0; i < len; ++i)
1911     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1912       {
1913         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1914         DECL_EXTERNAL (vec[i]) = 1;
1915       }
1916
1917   /* Write out any globals that need to be output.  */
1918   result = wrapup_global_declarations (vec, len);
1919
1920   /* Undo the hack to DECL_EXTERNAL above.  */
1921   for (i = 0; i < len; ++i)
1922     if (vtable_decl_p (vec[i], /*data=*/0)
1923         && DECL_NOT_REALLY_EXTERN (vec[i]))
1924       {
1925         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1926         DECL_EXTERNAL (vec[i]) = 0;
1927       }
1928
1929   return result;
1930 }
1931
1932 \f
1933 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1934
1935 static void
1936 mark_binding_level (arg)
1937      void *arg;
1938 {
1939   struct binding_level *lvl = *(struct binding_level **)arg;
1940
1941   for (; lvl; lvl = lvl->level_chain)
1942     {
1943       ggc_mark_tree (lvl->names);
1944       ggc_mark_tree (lvl->tags);
1945       ggc_mark_tree (lvl->usings);
1946       ggc_mark_tree (lvl->using_directives);
1947       ggc_mark_tree (lvl->class_shadowed);
1948       ggc_mark_tree (lvl->type_shadowed);
1949       ggc_mark_tree (lvl->shadowed_labels);
1950       ggc_mark_tree (lvl->blocks);
1951       ggc_mark_tree (lvl->this_class);
1952       ggc_mark_tree (lvl->incomplete);
1953       ggc_mark_tree (lvl->dead_vars_from_for);
1954     }
1955 }
1956
1957 static void
1958 mark_named_label_lists (labs, uses)
1959      void *labs;
1960      void *uses;
1961 {
1962   struct named_label_list *l = *(struct named_label_list **)labs;
1963   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
1964
1965   for (; l; l = l->next)
1966     {
1967       ggc_mark (l);
1968       mark_binding_level (l->binding_level);
1969       ggc_mark_tree (l->old_value);
1970       ggc_mark_tree (l->label_decl);
1971       ggc_mark_tree (l->bad_decls);
1972     }
1973
1974   for (; u; u = u->next)
1975     ggc_mark (u);
1976 }
1977 \f
1978 /* For debugging.  */
1979 static int no_print_functions = 0;
1980 static int no_print_builtins = 0;
1981
1982 void
1983 print_binding_level (lvl)
1984      struct binding_level *lvl;
1985 {
1986   tree t;
1987   int i = 0, len;
1988   fprintf (stderr, " blocks=");
1989   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1990   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
1991            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
1992   if (lvl->tag_transparent)
1993     fprintf (stderr, " tag-transparent");
1994   if (lvl->more_cleanups_ok)
1995     fprintf (stderr, " more-cleanups-ok");
1996   if (lvl->have_cleanups)
1997     fprintf (stderr, " have-cleanups");
1998   fprintf (stderr, "\n");
1999   if (lvl->names)
2000     {
2001       fprintf (stderr, " names:\t");
2002       /* We can probably fit 3 names to a line?  */
2003       for (t = lvl->names; t; t = TREE_CHAIN (t))
2004         {
2005           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2006             continue;
2007           if (no_print_builtins
2008               && (TREE_CODE (t) == TYPE_DECL)
2009               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2010             continue;
2011
2012           /* Function decls tend to have longer names.  */
2013           if (TREE_CODE (t) == FUNCTION_DECL)
2014             len = 3;
2015           else
2016             len = 2;
2017           i += len;
2018           if (i > 6)
2019             {
2020               fprintf (stderr, "\n\t");
2021               i = len;
2022             }
2023           print_node_brief (stderr, "", t, 0);
2024           if (t == error_mark_node)
2025             break;
2026         }
2027       if (i)
2028         fprintf (stderr, "\n");
2029     }
2030   if (lvl->tags)
2031     {
2032       fprintf (stderr, " tags:\t");
2033       i = 0;
2034       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2035         {
2036           if (TREE_PURPOSE (t) == NULL_TREE)
2037             len = 3;
2038           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2039             len = 2;
2040           else
2041             len = 4;
2042           i += len;
2043           if (i > 5)
2044             {
2045               fprintf (stderr, "\n\t");
2046               i = len;
2047             }
2048           if (TREE_PURPOSE (t) == NULL_TREE)
2049             {
2050               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2051               fprintf (stderr, ">");
2052             }
2053           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2054             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2055           else
2056             {
2057               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2058               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2059               fprintf (stderr, ">");
2060             }
2061         }
2062       if (i)
2063         fprintf (stderr, "\n");
2064     }
2065   if (lvl->class_shadowed)
2066     {
2067       fprintf (stderr, " class-shadowed:");
2068       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2069         {
2070           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2071         }
2072       fprintf (stderr, "\n");
2073     }
2074   if (lvl->type_shadowed)
2075     {
2076       fprintf (stderr, " type-shadowed:");
2077       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2078         {
2079           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2080         }
2081       fprintf (stderr, "\n");
2082     }
2083 }
2084
2085 void
2086 print_other_binding_stack (stack)
2087      struct binding_level *stack;
2088 {
2089   struct binding_level *level;
2090   for (level = stack; level != global_binding_level; level = level->level_chain)
2091     {
2092       fprintf (stderr, "binding level ");
2093       fprintf (stderr, HOST_PTR_PRINTF, level);
2094       fprintf (stderr, "\n");
2095       print_binding_level (level);
2096     }
2097 }
2098
2099 void
2100 print_binding_stack ()
2101 {
2102   struct binding_level *b;
2103   fprintf (stderr, "current_binding_level=");
2104   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2105   fprintf (stderr, "\nclass_binding_level=");
2106   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2107   fprintf (stderr, "\nglobal_binding_level=");
2108   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2109   fprintf (stderr, "\n");
2110   if (class_binding_level)
2111     {
2112       for (b = class_binding_level; b; b = b->level_chain)
2113         if (b == current_binding_level)
2114           break;
2115       if (b)
2116         b = class_binding_level;
2117       else
2118         b = current_binding_level;
2119     }
2120   else
2121     b = current_binding_level;
2122   print_other_binding_stack (b);
2123   fprintf (stderr, "global:\n");
2124   print_binding_level (global_binding_level);
2125 }
2126
2127 /* Namespace binding access routines: The namespace_bindings field of
2128    the identifier is polymorphic, with three possible values:
2129    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2130    indicating the BINDING_VALUE of global_namespace. */
2131
2132 /* Check whether the a binding for the name to scope is known.
2133    Assumes that the bindings of the name are already a list
2134    of bindings. Returns the binding found, or NULL_TREE. */
2135
2136 static tree
2137 find_binding (name, scope)
2138      tree name;
2139      tree scope;
2140 {
2141   tree iter, prev = NULL_TREE;
2142
2143   scope = ORIGINAL_NAMESPACE (scope);
2144
2145   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2146        iter = TREE_CHAIN (iter))
2147     {
2148       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2149       if (BINDING_SCOPE (iter) == scope)
2150         {
2151           /* Move binding found to the front of the list, so
2152              subsequent lookups will find it faster. */
2153           if (prev)
2154             {
2155               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2156               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2157               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2158             }
2159           return iter;
2160         }
2161       prev = iter;
2162     }
2163   return NULL_TREE;
2164 }
2165
2166 /* Always returns a binding for name in scope. If the
2167    namespace_bindings is not a list, convert it to one first.
2168    If no binding is found, make a new one. */
2169
2170 tree
2171 binding_for_name (name, scope)
2172      tree name;
2173      tree scope;
2174 {
2175   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2176   tree result;
2177
2178   scope = ORIGINAL_NAMESPACE (scope);
2179
2180   if (b && TREE_CODE (b) != CPLUS_BINDING)
2181     {
2182       /* Get rid of optimization for global scope. */
2183       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2184       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2185       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2186     }
2187   if (b && (result = find_binding (name, scope)))
2188     return result;
2189   /* Not found, make a new one. */
2190   result = make_node (CPLUS_BINDING);
2191   TREE_CHAIN (result) = b;
2192   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2193   BINDING_SCOPE (result) = scope;
2194   BINDING_TYPE (result) = NULL_TREE;
2195   BINDING_VALUE (result) = NULL_TREE;
2196   return result;
2197 }
2198
2199 /* Return the binding value for name in scope, considering that
2200    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2201
2202 tree
2203 namespace_binding (name, scope)
2204      tree name;
2205      tree scope;
2206 {
2207   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2208   if (b == NULL_TREE)
2209     return NULL_TREE;
2210   if (scope == NULL_TREE)
2211     scope = global_namespace;
2212   if (TREE_CODE (b) != CPLUS_BINDING)
2213     return (scope == global_namespace) ? b : NULL_TREE;
2214   name = find_binding (name,scope);
2215   if (name == NULL_TREE)
2216     return name;
2217   return BINDING_VALUE (name);
2218 }
2219
2220 /* Set the binding value for name in scope. If modifying the binding
2221    of global_namespace is attempted, try to optimize it. */
2222
2223 void
2224 set_namespace_binding (name, scope, val)
2225      tree name;
2226      tree scope;
2227      tree val;
2228 {
2229   tree b;
2230
2231   if (scope == NULL_TREE)
2232     scope = global_namespace;
2233
2234   if (scope == global_namespace)
2235     {
2236       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2237       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2238         {
2239           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2240           return;
2241         }
2242     }
2243   b = binding_for_name (name, scope);
2244   BINDING_VALUE (b) = val;
2245 }
2246
2247 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2248    select a name that is unique to this compilation unit.  */
2249
2250 void
2251 push_namespace (name)
2252      tree name;
2253 {
2254   tree d = NULL_TREE;
2255   int need_new = 1;
2256   int implicit_use = 0;
2257   int global = 0;
2258   if (!global_namespace)
2259     {
2260       /* This must be ::. */
2261       my_friendly_assert (name == get_identifier ("::"), 377);
2262       global = 1;
2263     }
2264   else if (!name)
2265     {
2266       /* The name of anonymous namespace is unique for the translation
2267          unit.  */
2268       if (!anonymous_namespace_name)
2269         anonymous_namespace_name = get_file_function_name ('N');
2270       name = anonymous_namespace_name;
2271       d = IDENTIFIER_NAMESPACE_VALUE (name);
2272       if (d)
2273         /* Reopening anonymous namespace.  */
2274         need_new = 0;
2275       implicit_use = 1;
2276     }
2277   else
2278     {
2279       /* Check whether this is an extended namespace definition. */
2280       d = IDENTIFIER_NAMESPACE_VALUE (name);
2281       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2282         {
2283           need_new = 0;
2284           if (DECL_NAMESPACE_ALIAS (d))
2285             {
2286               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2287                         d, DECL_NAMESPACE_ALIAS (d));
2288               d = DECL_NAMESPACE_ALIAS (d);
2289             }
2290         }
2291     }
2292
2293   if (need_new)
2294     {
2295       /* Make a new namespace, binding the name to it. */
2296       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2297       /* The global namespace is not pushed, and the global binding
2298          level is set elsewhere.  */
2299       if (!global)
2300         {
2301           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2302           d = pushdecl (d);
2303           pushlevel (0);
2304           declare_namespace_level ();
2305           NAMESPACE_LEVEL (d) = current_binding_level;
2306         }
2307     }
2308   else
2309     resume_binding_level (NAMESPACE_LEVEL (d));
2310
2311   if (implicit_use)
2312     do_using_directive (d);
2313   /* Enter the name space. */
2314   current_namespace = d;
2315 }
2316
2317 /* Pop from the scope of the current namespace.  */
2318
2319 void
2320 pop_namespace ()
2321 {
2322   my_friendly_assert (current_namespace != global_namespace, 20010801);
2323   current_namespace = CP_DECL_CONTEXT (current_namespace);
2324   /* The binding level is not popped, as it might be re-opened later.  */
2325   suspend_binding_level ();
2326 }
2327
2328 /* Push into the scope of the namespace NS, even if it is deeply
2329    nested within another namespace.  */
2330
2331 void
2332 push_nested_namespace (ns)
2333      tree ns;
2334 {
2335   if (ns == global_namespace)
2336     push_to_top_level ();
2337   else
2338     {
2339       push_nested_namespace (CP_DECL_CONTEXT (ns));
2340       push_namespace (DECL_NAME (ns));
2341     }
2342 }
2343
2344 /* Pop back from the scope of the namespace NS, which was previously
2345    entered with push_nested_namespace.  */
2346
2347 void
2348 pop_nested_namespace (ns)
2349      tree ns;
2350 {
2351   while (ns != global_namespace)
2352     {
2353       pop_namespace ();
2354       ns = CP_DECL_CONTEXT (ns);
2355     }
2356
2357   pop_from_top_level ();
2358 }
2359
2360 \f
2361 /* Subroutines for reverting temporarily to top-level for instantiation
2362    of templates and such.  We actually need to clear out the class- and
2363    local-value slots of all identifiers, so that only the global values
2364    are at all visible.  Simply setting current_binding_level to the global
2365    scope isn't enough, because more binding levels may be pushed.  */
2366 struct saved_scope *scope_chain;
2367
2368 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2369
2370 static void
2371 mark_saved_scope (arg)
2372      void *arg;
2373 {
2374   struct saved_scope *t = *(struct saved_scope **)arg;
2375   while (t)
2376     {
2377       mark_binding_level (&t->class_bindings);
2378       ggc_mark_tree (t->old_bindings);
2379       ggc_mark_tree (t->old_namespace);
2380       ggc_mark_tree (t->decl_ns_list);
2381       ggc_mark_tree (t->class_name);
2382       ggc_mark_tree (t->class_type);
2383       ggc_mark_tree (t->access_specifier);
2384       ggc_mark_tree (t->function_decl);
2385       if (t->lang_base)
2386         ggc_mark_tree_varray (t->lang_base);
2387       ggc_mark_tree (t->lang_name);
2388       ggc_mark_tree (t->template_parms);
2389       ggc_mark_tree (t->x_previous_class_type);
2390       ggc_mark_tree (t->x_previous_class_values);
2391       ggc_mark_tree (t->x_saved_tree);
2392       ggc_mark_tree (t->incomplete);
2393       ggc_mark_tree (t->lookups);
2394
2395       mark_stmt_tree (&t->x_stmt_tree);
2396       mark_binding_level (&t->bindings);
2397       t = t->prev;
2398     }
2399 }
2400
2401 static tree
2402 store_bindings (names, old_bindings)
2403      tree names, old_bindings;
2404 {
2405   tree t;
2406   tree search_bindings = old_bindings;
2407
2408   for (t = names; t; t = TREE_CHAIN (t))
2409     {
2410       tree binding, t1, id;
2411
2412       if (TREE_CODE (t) == TREE_LIST)
2413         id = TREE_PURPOSE (t);
2414       else
2415         id = DECL_NAME (t);
2416
2417       if (!id
2418           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2419              we have no IDENTIFIER_BINDING if we have left the class
2420              scope, but cached the class-level declarations.  */
2421           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2422         continue;
2423
2424       for (t1 = search_bindings; t1; t1 = TREE_CHAIN (t1))
2425         if (TREE_VEC_ELT (t1, 0) == id)
2426           goto skip_it;
2427
2428       my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2429       binding = make_tree_vec (4);
2430       TREE_VEC_ELT (binding, 0) = id;
2431       TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2432       TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2433       TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2434       IDENTIFIER_BINDING (id) = NULL_TREE;
2435       IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2436       TREE_CHAIN (binding) = old_bindings;
2437       old_bindings = binding;
2438     skip_it:
2439       ;
2440     }
2441   return old_bindings;
2442 }
2443
2444 void
2445 maybe_push_to_top_level (pseudo)
2446      int pseudo;
2447 {
2448   struct saved_scope *s;
2449   struct binding_level *b;
2450   tree old_bindings;
2451   int need_pop;
2452
2453   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2454
2455   b = scope_chain ? current_binding_level : 0;
2456
2457   /* If we're in the middle of some function, save our state.  */
2458   if (cfun)
2459     {
2460       need_pop = 1;
2461       push_function_context_to (NULL_TREE);
2462     }
2463   else
2464     need_pop = 0;
2465
2466   old_bindings = NULL_TREE;
2467   if (scope_chain && previous_class_type)
2468     old_bindings = store_bindings (previous_class_values, old_bindings);
2469
2470   /* Have to include global_binding_level, because class-level decls
2471      aren't listed anywhere useful.  */
2472   for (; b; b = b->level_chain)
2473     {
2474       tree t;
2475
2476       /* Template IDs are inserted into the global level. If they were
2477          inserted into namespace level, finish_file wouldn't find them
2478          when doing pending instantiations. Therefore, don't stop at
2479          namespace level, but continue until :: .  */
2480       if (b == global_binding_level || (pseudo && b->template_parms_p))
2481         break;
2482
2483       old_bindings = store_bindings (b->names, old_bindings);
2484       /* We also need to check class_shadowed to save class-level type
2485          bindings, since pushclass doesn't fill in b->names.  */
2486       if (b->parm_flag == 2)
2487         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2488
2489       /* Unwind type-value slots back to top level.  */
2490       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2491         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2492     }
2493   s->prev = scope_chain;
2494   s->old_bindings = old_bindings;
2495   s->bindings = b;
2496   s->need_pop_function_context = need_pop;
2497   s->function_decl = current_function_decl;
2498
2499   scope_chain = s;
2500   current_function_decl = NULL_TREE;
2501   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2502   current_lang_name = lang_name_cplusplus;
2503   current_namespace = global_namespace;
2504 }
2505
2506 void
2507 push_to_top_level ()
2508 {
2509   maybe_push_to_top_level (0);
2510 }
2511
2512 void
2513 pop_from_top_level ()
2514 {
2515   struct saved_scope *s = scope_chain;
2516   tree t;
2517
2518   /* Clear out class-level bindings cache.  */
2519   if (previous_class_type)
2520     invalidate_class_lookup_cache ();
2521
2522   VARRAY_FREE (current_lang_base);
2523
2524   scope_chain = s->prev;
2525   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2526     {
2527       tree id = TREE_VEC_ELT (t, 0);
2528
2529       SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2530       IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2531       IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2532     }
2533
2534   /* If we were in the middle of compiling a function, restore our
2535      state.  */
2536   if (s->need_pop_function_context)
2537     pop_function_context_from (NULL_TREE);
2538   current_function_decl = s->function_decl;
2539
2540   free (s);
2541 }
2542 \f
2543 /* Push a definition of struct, union or enum tag "name".
2544    into binding_level "b".   "type" should be the type node,
2545    We assume that the tag "name" is not already defined.
2546
2547    Note that the definition may really be just a forward reference.
2548    In that case, the TYPE_SIZE will be a NULL_TREE.
2549
2550    C++ gratuitously puts all these tags in the name space.  */
2551
2552 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2553    record the shadowed value for this binding contour.  TYPE is
2554    the type that ID maps to.  */
2555
2556 static void
2557 set_identifier_type_value_with_scope (id, type, b)
2558      tree id;
2559      tree type;
2560      struct binding_level *b;
2561 {
2562   if (!b->namespace_p)
2563     {
2564       /* Shadow the marker, not the real thing, so that the marker
2565          gets restored later. */
2566       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2567       b->type_shadowed
2568         = tree_cons (id, old_type_value, b->type_shadowed);
2569     }
2570   else
2571     {
2572       tree binding = binding_for_name (id, current_namespace);
2573       BINDING_TYPE (binding) = type;
2574       /* Store marker instead of real type. */
2575       type = global_type_node;
2576     }
2577   SET_IDENTIFIER_TYPE_VALUE (id, type);
2578 }
2579
2580 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2581
2582 void
2583 set_identifier_type_value (id, type)
2584      tree id;
2585      tree type;
2586 {
2587   set_identifier_type_value_with_scope (id, type, current_binding_level);
2588 }
2589
2590 /* Return the type associated with id. */
2591
2592 tree
2593 identifier_type_value (id)
2594      tree id;
2595 {
2596   /* There is no type with that name, anywhere. */
2597   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2598     return NULL_TREE;
2599   /* This is not the type marker, but the real thing. */
2600   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2601     return REAL_IDENTIFIER_TYPE_VALUE (id);
2602   /* Have to search for it. It must be on the global level, now.
2603      Ask lookup_name not to return non-types. */
2604   id = lookup_name_real (id, 2, 1, 0);
2605   if (id)
2606     return TREE_TYPE (id);
2607   return NULL_TREE;
2608 }
2609
2610 /* Pop off extraneous binding levels left over due to syntax errors.
2611
2612    We don't pop past namespaces, as they might be valid.  */
2613
2614 void
2615 pop_everything ()
2616 {
2617 #ifdef DEBUG_CP_BINDING_LEVELS
2618   fprintf (stderr, "XXX entering pop_everything ()\n");
2619 #endif
2620   while (!toplevel_bindings_p ())
2621     {
2622       if (current_binding_level->parm_flag == 2)
2623         pop_nested_class ();
2624       else
2625         poplevel (0, 0, 0);
2626     }
2627 #ifdef DEBUG_CP_BINDING_LEVELS
2628   fprintf (stderr, "XXX leaving pop_everything ()\n");
2629 #endif
2630 }
2631
2632 /* The type TYPE is being declared.  If it is a class template, or a
2633    specialization of a class template, do any processing required and
2634    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2635    being declared a friend.  B is the binding level at which this TYPE
2636    should be bound.
2637
2638    Returns the TYPE_DECL for TYPE, which may have been altered by this
2639    processing.  */
2640
2641 static tree
2642 maybe_process_template_type_declaration (type, globalize, b)
2643      tree type;
2644      int globalize;
2645      struct binding_level* b;
2646 {
2647   tree decl = TYPE_NAME (type);
2648
2649   if (processing_template_parmlist)
2650     /* You can't declare a new template type in a template parameter
2651        list.  But, you can declare a non-template type:
2652
2653          template <class A*> struct S;
2654
2655        is a forward-declaration of `A'.  */
2656     ;
2657   else
2658     {
2659       maybe_check_template_type (type);
2660
2661       my_friendly_assert (IS_AGGR_TYPE (type)
2662                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2663
2664
2665       if (processing_template_decl)
2666         {
2667           /* This may change after the call to
2668              push_template_decl_real, but we want the original value.  */
2669           tree name = DECL_NAME (decl);
2670
2671           decl = push_template_decl_real (decl, globalize);
2672           /* If the current binding level is the binding level for the
2673              template parameters (see the comment in
2674              begin_template_parm_list) and the enclosing level is a class
2675              scope, and we're not looking at a friend, push the
2676              declaration of the member class into the class scope.  In the
2677              friend case, push_template_decl will already have put the
2678              friend into global scope, if appropriate.  */
2679           if (TREE_CODE (type) != ENUMERAL_TYPE
2680               && !globalize && b->template_parms_p
2681               && b->level_chain->parm_flag == 2)
2682             {
2683               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2684               /* Put this tag on the list of tags for the class, since
2685                  that won't happen below because B is not the class
2686                  binding level, but is instead the pseudo-global level.  */
2687               b->level_chain->tags =
2688                 tree_cons (name, type, b->level_chain->tags);
2689               if (!COMPLETE_TYPE_P (current_class_type))
2690                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2691             }
2692         }
2693     }
2694
2695   return decl;
2696 }
2697
2698 /* In C++, you don't have to write `struct S' to refer to `S'; you
2699    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2700    if the user had written `typedef struct S S'.  Create and return
2701    the TYPE_DECL for TYPE.  */
2702
2703 tree
2704 create_implicit_typedef (name, type)
2705      tree name;
2706      tree type;
2707 {
2708   tree decl;
2709
2710   decl = build_decl (TYPE_DECL, name, type);
2711   DECL_ARTIFICIAL (decl) = 1;
2712   /* There are other implicit type declarations, like the one *within*
2713      a class that allows you to write `S::S'.  We must distinguish
2714      amongst these.  */
2715   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2716   TYPE_NAME (type) = decl;
2717
2718   return decl;
2719 }
2720
2721 /* Remember a local name for name-mangling purposes.  */
2722
2723 static void
2724 push_local_name (decl)
2725      tree decl;
2726 {
2727   size_t i, nelts;
2728   tree t, name;
2729
2730   if (!local_names)
2731     VARRAY_TREE_INIT (local_names, 8, "local_names");
2732
2733   name = DECL_NAME (decl);
2734
2735   nelts = VARRAY_ACTIVE_SIZE (local_names);
2736   for (i = 0; i < nelts; i++)
2737     {
2738       t = VARRAY_TREE (local_names, i);
2739       if (DECL_NAME (t) == name)
2740         {
2741           if (!DECL_LANG_SPECIFIC (decl))
2742             retrofit_lang_decl (decl);
2743           if (DECL_LANG_SPECIFIC (t))
2744             DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
2745           else
2746             DECL_DISCRIMINATOR (decl) = 1;
2747
2748           VARRAY_TREE (local_names, i) = decl;
2749           return;
2750         }
2751     }
2752
2753   VARRAY_PUSH_TREE (local_names, decl);
2754 }
2755
2756 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2757    Normally put it into the inner-most non-tag-transparent scope,
2758    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2759    The latter is needed for implicit declarations.  */
2760
2761 void
2762 pushtag (name, type, globalize)
2763      tree name, type;
2764      int globalize;
2765 {
2766   register struct binding_level *b;
2767
2768   b = current_binding_level;
2769   while (b->tag_transparent
2770          || (b->parm_flag == 2
2771              && (globalize
2772                  /* We may be defining a new type in the initializer
2773                     of a static member variable. We allow this when
2774                     not pedantic, and it is particularly useful for
2775                     type punning via an anonymous union. */
2776                  || COMPLETE_TYPE_P (b->this_class))))
2777     b = b->level_chain;
2778
2779   b->tags = tree_cons (name, type, b->tags);
2780
2781   if (name)
2782     {
2783       /* Do C++ gratuitous typedefing.  */
2784       if (IDENTIFIER_TYPE_VALUE (name) != type)
2785         {
2786           register tree d = NULL_TREE;
2787           int in_class = 0;
2788           tree context = TYPE_CONTEXT (type);
2789
2790           if (! context)
2791             {
2792               tree cs = current_scope ();
2793
2794               if (! globalize)
2795                 context = cs;
2796               else if (cs != NULL_TREE && TYPE_P (cs))
2797                 /* When declaring a friend class of a local class, we want
2798                    to inject the newly named class into the scope
2799                    containing the local class, not the namespace scope.  */
2800                 context = decl_function_context (get_type_decl (cs));
2801             }
2802           if (!context)
2803             context = current_namespace;
2804
2805           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2806               || b->parm_flag == 2)
2807             in_class = 1;
2808
2809           if (current_lang_name == lang_name_java)
2810             TYPE_FOR_JAVA (type) = 1;
2811
2812           d = create_implicit_typedef (name, type);
2813           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2814           if (! in_class)
2815             set_identifier_type_value_with_scope (name, type, b);
2816
2817           d = maybe_process_template_type_declaration (type,
2818                                                        globalize, b);
2819
2820           if (b->parm_flag == 2)
2821             {
2822               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2823                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2824                    class.  But if it's a member template class, we
2825                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2826                    is done later.  */
2827                 finish_member_declaration (d);
2828               else
2829                 pushdecl_class_level (d);
2830             }
2831           else
2832             d = pushdecl_with_scope (d, b);
2833
2834           /* FIXME what if it gets a name from typedef?  */
2835           if (ANON_AGGRNAME_P (name))
2836             DECL_IGNORED_P (d) = 1;
2837
2838           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2839
2840           /* If this is a local class, keep track of it.  We need this
2841              information for name-mangling, and so that it is possible to find
2842              all function definitions in a translation unit in a convenient
2843              way.  (It's otherwise tricky to find a member function definition
2844              it's only pointed to from within a local class.)  */
2845           if (TYPE_CONTEXT (type)
2846               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2847               && !processing_template_decl)
2848             VARRAY_PUSH_TREE (local_classes, type);
2849         }
2850       if (b->parm_flag == 2)
2851         {
2852           if (!COMPLETE_TYPE_P (current_class_type))
2853             CLASSTYPE_TAGS (current_class_type) = b->tags;
2854         }
2855     }
2856
2857   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2858     /* Use the canonical TYPE_DECL for this node.  */
2859     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2860   else
2861     {
2862       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2863          will be the tagged type we just added to the current
2864          binding level.  This fake NULL-named TYPE_DECL node helps
2865          dwarfout.c to know when it needs to output a
2866          representation of a tagged type, and it also gives us a
2867          convenient place to record the "scope start" address for
2868          the tagged type.  */
2869
2870       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2871       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2872     }
2873 }
2874
2875 /* Counter used to create anonymous type names.  */
2876
2877 static int anon_cnt = 0;
2878
2879 /* Return an IDENTIFIER which can be used as a name for
2880    anonymous structs and unions.  */
2881
2882 tree
2883 make_anon_name ()
2884 {
2885   char buf[32];
2886
2887   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2888   return get_identifier (buf);
2889 }
2890
2891 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2892    This keeps dbxout from getting confused.  */
2893
2894 void
2895 clear_anon_tags ()
2896 {
2897   register struct binding_level *b;
2898   register tree tags;
2899   static int last_cnt = 0;
2900
2901   /* Fast out if no new anon names were declared.  */
2902   if (last_cnt == anon_cnt)
2903     return;
2904
2905   b = current_binding_level;
2906   while (b->tag_transparent)
2907     b = b->level_chain;
2908   tags = b->tags;
2909   while (tags)
2910     {
2911       /* A NULL purpose means we have already processed all tags
2912          from here to the end of the list.  */
2913       if (TREE_PURPOSE (tags) == NULL_TREE)
2914         break;
2915       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2916         TREE_PURPOSE (tags) = NULL_TREE;
2917       tags = TREE_CHAIN (tags);
2918     }
2919   last_cnt = anon_cnt;
2920 }
2921 \f
2922 /* Subroutine of duplicate_decls: return truthvalue of whether
2923    or not types of these decls match.
2924
2925    For C++, we must compare the parameter list so that `int' can match
2926    `int&' in a parameter position, but `int&' is not confused with
2927    `const int&'.  */
2928
2929 int
2930 decls_match (newdecl, olddecl)
2931      tree newdecl, olddecl;
2932 {
2933   int types_match;
2934
2935   if (newdecl == olddecl)
2936     return 1;
2937
2938   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2939     /* If the two DECLs are not even the same kind of thing, we're not
2940        interested in their types.  */
2941     return 0;
2942
2943   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2944     {
2945       tree f1 = TREE_TYPE (newdecl);
2946       tree f2 = TREE_TYPE (olddecl);
2947       tree p1 = TYPE_ARG_TYPES (f1);
2948       tree p2 = TYPE_ARG_TYPES (f2);
2949
2950       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2951           && ! (DECL_EXTERN_C_P (newdecl)
2952                 && DECL_EXTERN_C_P (olddecl)))
2953         return 0;
2954
2955       if (TREE_CODE (f1) != TREE_CODE (f2))
2956         return 0;
2957
2958       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2959         {
2960           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
2961               && (DECL_BUILT_IN (olddecl)
2962 #ifndef NO_IMPLICIT_EXTERN_C
2963                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
2964                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
2965 #endif
2966               ))
2967             {
2968               types_match = self_promoting_args_p (p1);
2969               if (p1 == void_list_node)
2970                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2971             }
2972 #ifndef NO_IMPLICIT_EXTERN_C
2973           else if (p1 == NULL_TREE
2974                    && (DECL_EXTERN_C_P (olddecl)
2975                        && DECL_IN_SYSTEM_HEADER (olddecl)
2976                        && !DECL_CLASS_SCOPE_P (olddecl))
2977                    && (DECL_EXTERN_C_P (newdecl)
2978                        && DECL_IN_SYSTEM_HEADER (newdecl)
2979                        && !DECL_CLASS_SCOPE_P (newdecl)))
2980             {
2981               types_match = self_promoting_args_p (p2);
2982               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2983             }
2984 #endif
2985           else
2986             types_match = compparms (p1, p2);
2987         }
2988       else
2989         types_match = 0;
2990     }
2991   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2992     {
2993       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2994                                 DECL_TEMPLATE_PARMS (olddecl)))
2995         return 0;
2996
2997       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
2998           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
2999         return 0;
3000
3001       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3002         types_match = 1;
3003       else
3004         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3005                                    DECL_TEMPLATE_RESULT (newdecl));
3006     }
3007   else
3008     {
3009       if (TREE_TYPE (newdecl) == error_mark_node)
3010         types_match = TREE_TYPE (olddecl) == error_mark_node;
3011       else if (TREE_TYPE (olddecl) == NULL_TREE)
3012         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3013       else if (TREE_TYPE (newdecl) == NULL_TREE)
3014         types_match = 0;
3015       else
3016         types_match = comptypes (TREE_TYPE (newdecl),
3017                                  TREE_TYPE (olddecl),
3018                                  COMPARE_REDECLARATION);
3019     }
3020
3021   return types_match;
3022 }
3023
3024 /* If NEWDECL is `static' and an `extern' was seen previously,
3025    warn about it.  OLDDECL is the previous declaration.
3026
3027    Note that this does not apply to the C++ case of declaring
3028    a variable `extern const' and then later `const'.
3029
3030    Don't complain about built-in functions, since they are beyond
3031    the user's control.  */
3032
3033 static void
3034 warn_extern_redeclared_static (newdecl, olddecl)
3035      tree newdecl, olddecl;
3036 {
3037   static const char *const explicit_extern_static_warning
3038     = "`%D' was declared `extern' and later `static'";
3039   static const char *const implicit_extern_static_warning
3040     = "`%D' was declared implicitly `extern' and later `static'";
3041
3042   tree name;
3043
3044   if (TREE_CODE (newdecl) == TYPE_DECL
3045       || TREE_CODE (newdecl) == TEMPLATE_DECL
3046       || TREE_CODE (newdecl) == CONST_DECL)
3047     return;
3048
3049   /* Don't get confused by static member functions; that's a different
3050      use of `static'.  */
3051   if (TREE_CODE (newdecl) == FUNCTION_DECL
3052       && DECL_STATIC_FUNCTION_P (newdecl))
3053     return;
3054
3055   /* If the old declaration was `static', or the new one isn't, then
3056      then everything is OK.  */
3057   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3058     return;
3059
3060   /* It's OK to declare a builtin function as `static'.  */
3061   if (TREE_CODE (olddecl) == FUNCTION_DECL
3062       && DECL_ARTIFICIAL (olddecl))
3063     return;
3064
3065   name = DECL_ASSEMBLER_NAME (newdecl);
3066   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3067               ? implicit_extern_static_warning
3068               : explicit_extern_static_warning, newdecl);
3069   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3070 }
3071
3072 /* Handle when a new declaration NEWDECL has the same name as an old
3073    one OLDDECL in the same binding contour.  Prints an error message
3074    if appropriate.
3075
3076    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3077    Otherwise, return 0.  */
3078
3079 int
3080 duplicate_decls (newdecl, olddecl)
3081      tree newdecl, olddecl;
3082 {
3083   unsigned olddecl_uid = DECL_UID (olddecl);
3084   int olddecl_friend = 0, types_match = 0;
3085   int new_defines_function = 0;
3086
3087   if (newdecl == olddecl)
3088     return 1;
3089
3090   types_match = decls_match (newdecl, olddecl);
3091
3092   /* If either the type of the new decl or the type of the old decl is an
3093      error_mark_node, then that implies that we have already issued an
3094      error (earlier) for some bogus type specification, and in that case,
3095      it is rather pointless to harass the user with yet more error message
3096      about the same declaration, so just pretend the types match here.  */
3097   if (TREE_TYPE (newdecl) == error_mark_node
3098       || TREE_TYPE (olddecl) == error_mark_node)
3099     types_match = 1;
3100
3101   if (DECL_P (olddecl)
3102       && TREE_CODE (newdecl) == FUNCTION_DECL
3103       && TREE_CODE (olddecl) == FUNCTION_DECL
3104       && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
3105     {
3106       if (DECL_DECLARED_INLINE_P (newdecl)
3107           && DECL_UNINLINABLE (newdecl)
3108           && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
3109         /* Already warned elsewhere.  */;
3110       else if (DECL_DECLARED_INLINE_P (olddecl)
3111                && DECL_UNINLINABLE (olddecl)
3112                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
3113         /* Already warned.  */;
3114       else if (DECL_DECLARED_INLINE_P (newdecl)
3115                && DECL_UNINLINABLE (olddecl)
3116                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
3117         {
3118           warning_with_decl (newdecl,
3119                              "function `%s' redeclared as inline");
3120           warning_with_decl (olddecl,
3121                              "previous declaration of function `%s' with attribute noinline");
3122         }
3123       else if (DECL_DECLARED_INLINE_P (olddecl)
3124                && DECL_UNINLINABLE (newdecl)
3125                && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
3126         {
3127           warning_with_decl (newdecl,
3128                              "function `%s' redeclared with attribute noinline");
3129           warning_with_decl (olddecl,
3130                              "previous declaration of function `%s' was inline");
3131         }
3132     }
3133
3134   /* Check for redeclaration and other discrepancies. */
3135   if (TREE_CODE (olddecl) == FUNCTION_DECL
3136       && DECL_ARTIFICIAL (olddecl))
3137     {
3138       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3139         {
3140           /* If you declare a built-in or predefined function name as static,
3141              the old definition is overridden, but optionally warn this was a
3142              bad choice of name.  */
3143           if (! TREE_PUBLIC (newdecl))
3144             {
3145               if (warn_shadow)
3146                 cp_warning ("shadowing %s function `%#D'",
3147                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3148                             olddecl);
3149               /* Discard the old built-in function.  */
3150               return 0;
3151             }
3152           /* If the built-in is not ansi, then programs can override
3153              it even globally without an error.  */
3154           else if (! DECL_BUILT_IN (olddecl))
3155             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3156                         olddecl, newdecl);
3157           else
3158             {
3159               cp_error ("declaration of `%#D'", newdecl);
3160               cp_error ("conflicts with built-in declaration `%#D'",
3161                         olddecl);
3162             }
3163           return 0;
3164         }
3165       else if (!types_match)
3166         {
3167           if ((DECL_EXTERN_C_P (newdecl)
3168                && DECL_EXTERN_C_P (olddecl))
3169               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3170                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3171             {
3172               /* A near match; override the builtin.  */
3173
3174               if (TREE_PUBLIC (newdecl))
3175                 {
3176                   cp_warning ("new declaration `%#D'", newdecl);
3177                   cp_warning ("ambiguates built-in declaration `%#D'",
3178                               olddecl);
3179                 }
3180               else if (warn_shadow)
3181                 cp_warning ("shadowing %s function `%#D'",
3182                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3183                             olddecl);
3184             }
3185           else
3186             /* Discard the old built-in function.  */
3187             return 0;
3188         }
3189
3190       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3191         {
3192           /* If a builtin function is redeclared as `static', merge
3193              the declarations, but make the original one static.  */
3194           DECL_THIS_STATIC (olddecl) = 1;
3195           TREE_PUBLIC (olddecl) = 0;
3196
3197           /* Make the old declaration consistent with the new one so
3198              that all remnants of the builtin-ness of this function
3199              will be banished.  */
3200           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3201           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3202           COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3203           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3204                                        newdecl);
3205         }
3206     }
3207   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3208     {
3209       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3210            && TREE_CODE (newdecl) != TYPE_DECL
3211            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3212                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3213           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3214               && TREE_CODE (olddecl) != TYPE_DECL
3215               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3216                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3217                         == TYPE_DECL))))
3218         {
3219           /* We do nothing special here, because C++ does such nasty
3220              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3221              get shadowed, and know that if we need to find a TYPE_DECL
3222              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3223              slot of the identifier.  */
3224           return 0;
3225         }
3226
3227       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3228            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3229           || (TREE_CODE (olddecl) == FUNCTION_DECL
3230               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3231         return 0;
3232
3233       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3234       if (TREE_CODE (olddecl) == TREE_LIST)
3235         olddecl = TREE_VALUE (olddecl);
3236       cp_error_at ("previous declaration of `%#D'", olddecl);
3237
3238       /* New decl is completely inconsistent with the old one =>
3239          tell caller to replace the old one.  */
3240
3241       return 0;
3242     }
3243   else if (!types_match)
3244     {
3245       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3246         /* These are certainly not duplicate declarations; they're
3247            from different scopes.  */
3248         return 0;
3249
3250       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3251         {
3252           /* The name of a class template may not be declared to refer to
3253              any other template, class, function, object, namespace, value,
3254              or type in the same scope.  */
3255           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3256               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3257             {
3258               cp_error ("declaration of template `%#D'", newdecl);
3259               cp_error_at ("conflicts with previous declaration `%#D'",
3260                            olddecl);
3261             }
3262           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3263                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3264                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3265                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3266                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3267                                            DECL_TEMPLATE_PARMS (olddecl)))
3268             {
3269               cp_error ("new declaration `%#D'", newdecl);
3270               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3271             }
3272           return 0;
3273         }
3274       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3275         {
3276           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3277             {
3278               cp_error ("declaration of C function `%#D' conflicts with",
3279                         newdecl);
3280               cp_error_at ("previous declaration `%#D' here", olddecl);
3281             }
3282           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3283                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3284             {
3285               cp_error ("new declaration `%#D'", newdecl);
3286               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3287             }
3288           else
3289             return 0;
3290         }
3291
3292       /* Already complained about this, so don't do so again.  */
3293       else if (current_class_type == NULL_TREE
3294           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3295         {
3296           cp_error ("conflicting types for `%#D'", newdecl);
3297           cp_error_at ("previous declaration as `%#D'", olddecl);
3298         }
3299     }
3300   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3301             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3302                  && (!DECL_TEMPLATE_INFO (newdecl)
3303                      || (DECL_TI_TEMPLATE (newdecl)
3304                          != DECL_TI_TEMPLATE (olddecl))))
3305                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3306                     && (!DECL_TEMPLATE_INFO (olddecl)
3307                         || (DECL_TI_TEMPLATE (olddecl)
3308                             != DECL_TI_TEMPLATE (newdecl))))))
3309     /* It's OK to have a template specialization and a non-template
3310        with the same type, or to have specializations of two
3311        different templates with the same type.  Note that if one is a
3312        specialization, and the other is an instantiation of the same
3313        template, that we do not exit at this point.  That situation
3314        can occur if we instantiate a template class, and then
3315        specialize one of its methods.  This situation is legal, but
3316        the declarations must be merged in the usual way.  */
3317     return 0;
3318   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3319            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3320                 && !DECL_USE_TEMPLATE (newdecl))
3321                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3322                    && !DECL_USE_TEMPLATE (olddecl))))
3323     /* One of the declarations is a template instantiation, and the
3324        other is not a template at all.  That's OK.  */
3325     return 0;
3326   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3327            && DECL_NAMESPACE_ALIAS (newdecl)
3328            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3329     /* Redeclaration of namespace alias, ignore it. */
3330     return 1;
3331   else
3332     {
3333       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3334       if (errmsg)
3335         {
3336           cp_error (errmsg, newdecl);
3337           if (DECL_NAME (olddecl) != NULL_TREE)
3338             cp_error_at ((DECL_INITIAL (olddecl)
3339                           && namespace_bindings_p ())
3340                          ? "`%#D' previously defined here"
3341                          : "`%#D' previously declared here", olddecl);
3342         }
3343       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3344                && DECL_INITIAL (olddecl) != NULL_TREE
3345                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3346                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3347         {
3348           /* Prototype decl follows defn w/o prototype.  */
3349           cp_warning_at ("prototype for `%#D'", newdecl);
3350           cp_warning_at ("follows non-prototype definition here", olddecl);
3351         }
3352       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3353                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3354         {
3355           /* extern "C" int foo ();
3356              int foo () { bar (); }
3357              is OK.  */
3358           if (current_lang_depth () == 0)
3359             SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3360           else
3361             {
3362               cp_error_at ("previous declaration of `%#D' with %L linkage",
3363                            olddecl, DECL_LANGUAGE (olddecl));
3364               cp_error ("conflicts with new declaration with %L linkage",
3365                         DECL_LANGUAGE (newdecl));
3366             }
3367         }
3368
3369       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3370         ;
3371       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3372         {
3373           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3374           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3375           int i = 1;
3376
3377           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3378             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3379
3380           for (; t1 && t1 != void_list_node;
3381                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3382             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3383               {
3384                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3385                                            TREE_PURPOSE (t2)))
3386                   {
3387                     if (pedantic)
3388                       {
3389                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3390                                     i, newdecl);
3391                         cp_pedwarn_at ("after previous specification in `%#D'",
3392                                        olddecl);
3393                       }
3394                   }
3395                 else
3396                   {
3397                     cp_error ("default argument given for parameter %d of `%#D'",
3398                               i, newdecl);
3399                     cp_error_at ("after previous specification in `%#D'",
3400                                  olddecl);
3401                   }
3402               }
3403
3404           if (DECL_DECLARED_INLINE_P (newdecl)
3405               && ! DECL_DECLARED_INLINE_P (olddecl)
3406               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3407             {
3408               cp_warning ("`%#D' was used before it was declared inline",
3409                           newdecl);
3410               cp_warning_at ("previous non-inline declaration here",
3411                              olddecl);
3412             }
3413         }
3414     }
3415
3416   /* If new decl is `static' and an `extern' was seen previously,
3417      warn about it.  */
3418   warn_extern_redeclared_static (newdecl, olddecl);
3419
3420   /* We have committed to returning 1 at this point.  */
3421   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3422     {
3423       /* Now that functions must hold information normally held
3424          by field decls, there is extra work to do so that
3425          declaration information does not get destroyed during
3426          definition.  */
3427       if (DECL_VINDEX (olddecl))
3428         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3429       if (DECL_VIRTUAL_CONTEXT (olddecl))
3430         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3431       if (DECL_CONTEXT (olddecl))
3432         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3433       if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3434         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3435       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3436       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3437       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3438       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3439       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3440       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3441       if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
3442         SET_OVERLOADED_OPERATOR_CODE
3443           (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
3444       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3445
3446       /* Optionally warn about more than one declaration for the same
3447          name, but don't warn about a function declaration followed by a
3448          definition.  */
3449       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3450           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3451           /* Don't warn about extern decl followed by definition. */
3452           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3453           /* Don't warn about friends, let add_friend take care of it. */
3454           && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
3455         {
3456           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3457           cp_warning_at ("previous declaration of `%D'", olddecl);
3458         }
3459     }
3460
3461   /* Deal with C++: must preserve virtual function table size.  */
3462   if (TREE_CODE (olddecl) == TYPE_DECL)
3463     {
3464       register tree newtype = TREE_TYPE (newdecl);
3465       register tree oldtype = TREE_TYPE (olddecl);
3466
3467       if (newtype != error_mark_node && oldtype != error_mark_node
3468           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3469         {
3470           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3471           CLASSTYPE_FRIEND_CLASSES (newtype)
3472             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3473         }
3474
3475       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3476     }
3477
3478   /* Copy all the DECL_... slots specified in the new decl
3479      except for any that we copy here from the old type.  */
3480   DECL_ATTRIBUTES (newdecl)
3481     = (*targetm.merge_decl_attributes) (olddecl, newdecl);
3482
3483   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3484     {
3485       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3486       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3487         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3488                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3489
3490       /* If the new declaration is a definition, update the file and
3491          line information on the declaration.  */
3492       if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
3493           && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
3494         {
3495           DECL_SOURCE_LINE (olddecl)
3496             = DECL_SOURCE_LINE (DECL_TEMPLATE_RESULT (olddecl))
3497             = DECL_SOURCE_LINE (newdecl);
3498           DECL_SOURCE_FILE (olddecl)
3499             = DECL_SOURCE_FILE (DECL_TEMPLATE_RESULT (olddecl))
3500             = DECL_SOURCE_FILE (newdecl);
3501         }
3502
3503       return 1;
3504     }
3505
3506   if (types_match)
3507     {
3508       /* Automatically handles default parameters.  */
3509       tree oldtype = TREE_TYPE (olddecl);
3510       tree newtype;
3511
3512       /* Merge the data types specified in the two decls.  */
3513       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3514
3515       /* If common_type produces a non-typedef type, just use the old type.  */
3516       if (TREE_CODE (newdecl) == TYPE_DECL
3517           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3518         newtype = oldtype;
3519
3520       if (TREE_CODE (newdecl) == VAR_DECL)
3521         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3522       /* Do this after calling `common_type' so that default
3523          parameters don't confuse us.  */
3524       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3525           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3526               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3527         {
3528           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3529                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3530           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3531                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3532
3533           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3534               && DECL_SOURCE_LINE (olddecl) != 0
3535               && flag_exceptions
3536               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3537                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3538             {
3539               cp_error ("declaration of `%F' throws different exceptions",
3540                         newdecl);
3541               cp_error_at ("than previous declaration `%F'", olddecl);
3542             }
3543         }
3544       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3545
3546       /* Lay the type out, unless already done.  */
3547       if (! same_type_p (newtype, oldtype)
3548           && TREE_TYPE (newdecl) != error_mark_node
3549           && !(processing_template_decl && uses_template_parms (newdecl)))
3550         layout_type (TREE_TYPE (newdecl));
3551
3552       if ((TREE_CODE (newdecl) == VAR_DECL
3553            || TREE_CODE (newdecl) == PARM_DECL
3554            || TREE_CODE (newdecl) == RESULT_DECL
3555            || TREE_CODE (newdecl) == FIELD_DECL
3556            || TREE_CODE (newdecl) == TYPE_DECL)
3557           && !(processing_template_decl && uses_template_parms (newdecl)))
3558         layout_decl (newdecl, 0);
3559
3560       /* Merge the type qualifiers.  */
3561       if (TREE_READONLY (newdecl))
3562         TREE_READONLY (olddecl) = 1;
3563       if (TREE_THIS_VOLATILE (newdecl))
3564         TREE_THIS_VOLATILE (olddecl) = 1;
3565
3566       /* Merge the initialization information.  */
3567       if (DECL_INITIAL (newdecl) == NULL_TREE
3568           && DECL_INITIAL (olddecl) != NULL_TREE)
3569         {
3570           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3571           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3572           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3573           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3574               && DECL_LANG_SPECIFIC (newdecl)
3575               && DECL_LANG_SPECIFIC (olddecl))
3576             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3577         }
3578
3579       /* Merge the section attribute.
3580          We want to issue an error if the sections conflict but that must be
3581          done later in decl_attributes since we are called before attributes
3582          are assigned.  */
3583       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3584         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3585
3586       /* Keep the old rtl since we can safely use it.  */
3587       COPY_DECL_RTL (olddecl, newdecl);
3588
3589       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3590         {
3591           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3592             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3593           DECL_NO_LIMIT_STACK (newdecl)
3594             |= DECL_NO_LIMIT_STACK (olddecl);
3595         }
3596     }
3597   /* If cannot merge, then use the new type and qualifiers,
3598      and don't preserve the old rtl.  */
3599   else
3600     {
3601       /* Clean out any memory we had of the old declaration.  */
3602       tree oldstatic = value_member (olddecl, static_aggregates);
3603       if (oldstatic)
3604         TREE_VALUE (oldstatic) = error_mark_node;
3605
3606       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3607       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3608       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3609       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3610     }
3611
3612   /* Merge the storage class information.  */
3613   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3614   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3615   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3616   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3617   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3618   if (! DECL_EXTERNAL (olddecl))
3619     DECL_EXTERNAL (newdecl) = 0;
3620
3621   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3622     {
3623       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3624       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3625       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3626       DECL_TEMPLATE_INSTANTIATED (newdecl)
3627         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3628       /* Don't really know how much of the language-specific
3629          values we should copy from old to new.  */
3630       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3631       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3632       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3633       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3634       DECL_INITIALIZED_IN_CLASS_P (newdecl)
3635         |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
3636       olddecl_friend = DECL_FRIEND_P (olddecl);
3637
3638       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3639       if (TREE_CODE (newdecl) == FUNCTION_DECL
3640           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3641         DECL_BEFRIENDING_CLASSES (newdecl)
3642           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3643                      DECL_BEFRIENDING_CLASSES (olddecl));
3644     }
3645
3646   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3647     {
3648       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3649           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3650         {
3651           /* If newdecl is not a specialization, then it is not a
3652              template-related function at all.  And that means that we
3653              shoud have exited above, returning 0.  */
3654           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3655                               0);
3656
3657           if (TREE_USED (olddecl))
3658             /* From [temp.expl.spec]:
3659
3660                If a template, a member template or the member of a class
3661                template is explicitly specialized then that
3662                specialization shall be declared before the first use of
3663                that specialization that would cause an implicit
3664                instantiation to take place, in every translation unit in
3665                which such a use occurs.  */
3666             cp_error ("explicit specialization of %D after first use",
3667                       olddecl);
3668
3669           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3670         }
3671       DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
3672
3673       /* If either decl says `inline', this fn is inline, unless its
3674          definition was passed already.  */
3675       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3676         DECL_INLINE (olddecl) = 1;
3677       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3678
3679       DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
3680         = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
3681
3682       /* Preserve abstractness on cloned [cd]tors.  */
3683       DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
3684
3685       if (! types_match)
3686         {
3687           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3688           COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
3689           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3690         }
3691       if (! types_match || new_defines_function)
3692         {
3693           /* These need to be copied so that the names are available.
3694              Note that if the types do match, we'll preserve inline
3695              info and other bits, but if not, we won't.  */
3696           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3697           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3698         }
3699       if (new_defines_function)
3700         /* If defining a function declared with other language
3701            linkage, use the previously declared language linkage.  */
3702         SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3703       else if (types_match)
3704         {
3705           /* If redeclaring a builtin function, and not a definition,
3706              it stays built in.  */
3707           if (DECL_BUILT_IN (olddecl))
3708             {
3709               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3710               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3711               /* If we're keeping the built-in definition, keep the rtl,
3712                  regardless of declaration matches.  */
3713               SET_DECL_RTL (newdecl, DECL_RTL (olddecl));
3714             }
3715           else
3716             DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
3717
3718           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3719           /* Don't clear out the arguments if we're redefining a function.  */
3720           if (DECL_ARGUMENTS (olddecl))
3721             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3722         }
3723     }
3724   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3725     NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3726
3727   /* Now preserve various other info from the definition.  */
3728   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3729   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3730   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3731   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3732
3733   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3734     {
3735       int function_size;
3736
3737       function_size = sizeof (struct tree_decl);
3738
3739       memcpy ((char *) olddecl + sizeof (struct tree_common),
3740               (char *) newdecl + sizeof (struct tree_common),
3741               function_size - sizeof (struct tree_common));
3742
3743       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3744         {
3745           /* If newdecl is a template instantiation, it is possible that
3746              the following sequence of events has occurred:
3747
3748              o A friend function was declared in a class template.  The
3749              class template was instantiated.
3750
3751              o The instantiation of the friend declaration was
3752              recorded on the instantiation list, and is newdecl.
3753
3754              o Later, however, instantiate_class_template called pushdecl
3755              on the newdecl to perform name injection.  But, pushdecl in
3756              turn called duplicate_decls when it discovered that another
3757              declaration of a global function with the same name already
3758              existed.
3759
3760              o Here, in duplicate_decls, we decided to clobber newdecl.
3761
3762              If we're going to do that, we'd better make sure that
3763              olddecl, and not newdecl, is on the list of
3764              instantiations so that if we try to do the instantiation
3765              again we won't get the clobbered declaration.  */
3766
3767           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3768           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3769
3770           for (; decls; decls = TREE_CHAIN (decls))
3771             if (TREE_VALUE (decls) == newdecl)
3772               TREE_VALUE (decls) = olddecl;
3773         }
3774     }
3775   else
3776     {
3777       memcpy ((char *) olddecl + sizeof (struct tree_common),
3778               (char *) newdecl + sizeof (struct tree_common),
3779               sizeof (struct tree_decl) - sizeof (struct tree_common)
3780               + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3781     }
3782
3783   DECL_UID (olddecl) = olddecl_uid;
3784   if (olddecl_friend)
3785     DECL_FRIEND_P (olddecl) = 1;
3786
3787   /* NEWDECL contains the merged attribute lists.
3788      Update OLDDECL to be the same.  */
3789   DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
3790
3791   return 1;
3792 }
3793
3794 /* Record a decl-node X as belonging to the current lexical scope.
3795    Check for errors (such as an incompatible declaration for the same
3796    name already seen in the same scope).
3797
3798    Returns either X or an old decl for the same name.
3799    If an old decl is returned, it may have been smashed
3800    to agree with what X says.  */
3801
3802 tree
3803 pushdecl (x)
3804      tree x;
3805 {
3806   register tree t;
3807   register tree name;
3808   int need_new_binding;
3809
3810   /* We shouldn't be calling pushdecl when we're generating RTL for a
3811      function that we already did semantic analysis on previously.  */
3812   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3813                       19990913);
3814
3815   need_new_binding = 1;
3816
3817   if (DECL_TEMPLATE_PARM_P (x))
3818     /* Template parameters have no context; they are not X::T even
3819        when declared within a class or namespace.  */
3820     ;
3821   else
3822     {
3823       if (current_function_decl && x != current_function_decl
3824           /* A local declaration for a function doesn't constitute
3825              nesting.  */
3826           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3827           /* A local declaration for an `extern' variable is in the
3828              scope of the current namespace, not the current
3829              function.  */
3830           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3831           && !DECL_CONTEXT (x))
3832         DECL_CONTEXT (x) = current_function_decl;
3833
3834       /* If this is the declaration for a namespace-scope function,
3835          but the declaration itself is in a local scope, mark the
3836          declaration.  */
3837       if (TREE_CODE (x) == FUNCTION_DECL
3838           && DECL_NAMESPACE_SCOPE_P (x)
3839           && current_function_decl
3840           && x != current_function_decl)
3841         DECL_LOCAL_FUNCTION_P (x) = 1;
3842     }
3843
3844   name = DECL_NAME (x);
3845   if (name)
3846     {
3847       int different_binding_level = 0;
3848
3849       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3850         name = TREE_OPERAND (name, 0);
3851
3852       /* In case this decl was explicitly namespace-qualified, look it
3853          up in its namespace context.  */
3854       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3855           && namespace_bindings_p ())
3856         t = namespace_binding (name, DECL_CONTEXT (x));
3857       else
3858         t = lookup_name_current_level (name);
3859
3860       /* [basic.link] If there is a visible declaration of an entity
3861          with linkage having the same name and type, ignoring entities
3862          declared outside the innermost enclosing namespace scope, the
3863          block scope declaration declares that same entity and
3864          receives the linkage of the previous declaration.  */
3865       if (! t && current_function_decl && x != current_function_decl
3866           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3867           && DECL_EXTERNAL (x))
3868         {
3869           /* Look in block scope.  */
3870           t = IDENTIFIER_VALUE (name);
3871           /* Or in the innermost namespace.  */
3872           if (! t)
3873             t = namespace_binding (name, DECL_CONTEXT (x));
3874           /* Does it have linkage?  Note that if this isn't a DECL, it's an
3875              OVERLOAD, which is OK.  */
3876           if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3877             t = NULL_TREE;
3878           if (t)
3879             different_binding_level = 1;
3880         }
3881
3882       /* If we are declaring a function, and the result of name-lookup
3883          was an OVERLOAD, look for an overloaded instance that is
3884          actually the same as the function we are declaring.  (If
3885          there is one, we have to merge our declaration with the
3886          previous declaration.)  */
3887       if (t && TREE_CODE (t) == OVERLOAD)
3888         {
3889           tree match;
3890
3891           if (TREE_CODE (x) == FUNCTION_DECL)
3892             for (match = t; match; match = OVL_NEXT (match))
3893               {
3894                 if (decls_match (OVL_CURRENT (match), x))
3895                   break;
3896               }
3897           else
3898             /* Just choose one.  */
3899             match = t;
3900
3901           if (match)
3902             t = OVL_CURRENT (match);
3903           else
3904             t = NULL_TREE;
3905         }
3906
3907       if (t == error_mark_node)
3908         {
3909           /* error_mark_node is 0 for a while during initialization!  */
3910           t = NULL_TREE;
3911           cp_error_at ("`%#D' used prior to declaration", x);
3912         }
3913       else if (t != NULL_TREE)
3914         {
3915           if (different_binding_level)
3916             {
3917               if (decls_match (x, t))
3918                 /* The standard only says that the local extern
3919                    inherits linkage from the previous decl; in
3920                    particular, default args are not shared.  It would
3921                    be nice to propagate inlining info, though.  FIXME.  */
3922                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3923             }
3924           else if (TREE_CODE (t) == PARM_DECL)
3925             {
3926               if (DECL_CONTEXT (t) == NULL_TREE)
3927                 /* This is probaby caused by too many errors, but calling
3928                    abort will say that if errors have occurred.  */
3929                 abort ();
3930
3931               /* Check for duplicate params.  */
3932               if (duplicate_decls (x, t))
3933                 return t;
3934             }
3935           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3936                     || DECL_FUNCTION_TEMPLATE_P (x))
3937                    && is_overloaded_fn (t))
3938             /* Don't do anything just yet. */;
3939           else if (t == wchar_decl_node)
3940             {
3941               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3942                 cp_pedwarn ("redeclaration of `wchar_t' as `%T'",
3943                             TREE_TYPE (x));
3944
3945               /* Throw away the redeclaration.  */
3946               return t;
3947             }
3948           else if (TREE_CODE (t) != TREE_CODE (x))
3949             {
3950               if (duplicate_decls (x, t))
3951                 return t;
3952             }
3953           else if (duplicate_decls (x, t))
3954             {
3955               if (TREE_CODE (t) == TYPE_DECL)
3956                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3957               else if (TREE_CODE (t) == FUNCTION_DECL)
3958                 check_default_args (t);
3959
3960               return t;
3961             }
3962           else if (DECL_MAIN_P (x))
3963             {
3964               /* A redeclaration of main, but not a duplicate of the
3965                  previous one.
3966
3967                  [basic.start.main]
3968
3969                  This function shall not be overloaded.  */
3970               cp_error_at ("invalid redeclaration of `%D'", t);
3971               cp_error ("as `%D'", x);
3972               /* We don't try to push this declaration since that
3973                  causes a crash.  */
3974               return x;
3975             }
3976         }
3977
3978       check_template_shadow (x);
3979
3980       /* If this is a function conjured up by the backend, massage it
3981          so it looks friendly.  */
3982       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3983         {
3984           retrofit_lang_decl (x);
3985           SET_DECL_LANGUAGE (x, lang_c);
3986         }
3987
3988       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3989         {
3990           t = push_overloaded_decl (x, PUSH_LOCAL);
3991           if (t != x)
3992             return t;
3993           if (!namespace_bindings_p ())
3994             /* We do not need to create a binding for this name;
3995                push_overloaded_decl will have already done so if
3996                necessary.  */
3997             need_new_binding = 0;
3998         }
3999       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
4000         {
4001           t = push_overloaded_decl (x, PUSH_GLOBAL);
4002           if (t == x)
4003             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
4004           return t;
4005         }
4006
4007       /* If declaring a type as a typedef, copy the type (unless we're
4008          at line 0), and install this TYPE_DECL as the new type's typedef
4009          name.  See the extensive comment in ../c-decl.c (pushdecl). */
4010       if (TREE_CODE (x) == TYPE_DECL)
4011         {
4012           tree type = TREE_TYPE (x);
4013           if (DECL_SOURCE_LINE (x) == 0)
4014             {
4015               if (TYPE_NAME (type) == 0)
4016                 TYPE_NAME (type) = x;
4017             }
4018           else if (type != error_mark_node && TYPE_NAME (type) != x
4019                    /* We don't want to copy the type when all we're
4020                       doing is making a TYPE_DECL for the purposes of
4021                       inlining.  */
4022                    && (!TYPE_NAME (type)
4023                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
4024             {
4025               DECL_ORIGINAL_TYPE (x) = type;
4026               type = build_type_copy (type);
4027               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4028               TYPE_NAME (type) = x;
4029               TREE_TYPE (x) = type;
4030             }
4031
4032           if (type != error_mark_node
4033               && TYPE_NAME (type)
4034               && TYPE_IDENTIFIER (type))
4035             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4036                                                   current_binding_level);
4037
4038         }
4039
4040       /* Multiple external decls of the same identifier ought to match.
4041
4042          We get warnings about inline functions where they are defined.
4043          We get warnings about other functions from push_overloaded_decl.
4044
4045          Avoid duplicate warnings where they are used.  */
4046       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4047         {
4048           tree decl;
4049
4050           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4051           if (decl && TREE_CODE (decl) == OVERLOAD)
4052             decl = OVL_FUNCTION (decl);
4053
4054           if (decl && decl != error_mark_node
4055               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4056               /* If different sort of thing, we already gave an error.  */
4057               && TREE_CODE (decl) == TREE_CODE (x)
4058               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4059             {
4060               cp_pedwarn ("type mismatch with previous external decl", x);
4061               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4062             }
4063         }
4064
4065       /* This name is new in its binding level.
4066          Install the new declaration and return it.  */
4067       if (namespace_bindings_p ())
4068         {
4069           /* Install a global value.  */
4070
4071           /* If the first global decl has external linkage,
4072              warn if we later see static one.  */
4073           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4074             TREE_PUBLIC (name) = 1;
4075
4076           /* Bind the name for the entity.  */
4077           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4078                 && t != NULL_TREE)
4079               && (TREE_CODE (x) == TYPE_DECL
4080                   || TREE_CODE (x) == VAR_DECL
4081                   || TREE_CODE (x) == NAMESPACE_DECL
4082                   || TREE_CODE (x) == CONST_DECL
4083                   || TREE_CODE (x) == TEMPLATE_DECL))
4084             SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
4085
4086           /* Don't forget if the function was used via an implicit decl.  */
4087           if (IDENTIFIER_IMPLICIT_DECL (name)
4088               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4089             TREE_USED (x) = 1;
4090
4091           /* Don't forget if its address was taken in that way.  */
4092           if (IDENTIFIER_IMPLICIT_DECL (name)
4093               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4094             TREE_ADDRESSABLE (x) = 1;
4095
4096           /* Warn about mismatches against previous implicit decl.  */
4097           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4098               /* If this real decl matches the implicit, don't complain.  */
4099               && ! (TREE_CODE (x) == FUNCTION_DECL
4100                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4101             cp_warning
4102               ("`%D' was previously implicitly declared to return `int'", x);
4103
4104           /* If new decl is `static' and an `extern' was seen previously,
4105              warn about it.  */
4106           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4107             warn_extern_redeclared_static (x, t);
4108         }
4109       else
4110         {
4111           /* Here to install a non-global value.  */
4112           tree oldlocal = IDENTIFIER_VALUE (name);
4113           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4114
4115           if (need_new_binding)
4116             {
4117               push_local_binding (name, x, 0);
4118               /* Because push_local_binding will hook X on to the
4119                  current_binding_level's name list, we don't want to
4120                  do that again below.  */
4121               need_new_binding = 0;
4122             }
4123
4124           /* If this is a TYPE_DECL, push it into the type value slot.  */
4125           if (TREE_CODE (x) == TYPE_DECL)
4126             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4127                                                   current_binding_level);
4128
4129           /* Clear out any TYPE_DECL shadowed by a namespace so that
4130              we won't think this is a type.  The C struct hack doesn't
4131              go through namespaces.  */
4132           if (TREE_CODE (x) == NAMESPACE_DECL)
4133             set_identifier_type_value_with_scope (name, NULL_TREE,
4134                                                   current_binding_level);
4135
4136           if (oldlocal)
4137             {
4138               tree d = oldlocal;
4139
4140               while (oldlocal
4141                      && TREE_CODE (oldlocal) == VAR_DECL
4142                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4143                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4144
4145               if (oldlocal == NULL_TREE)
4146                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4147             }
4148
4149           /* If this is an extern function declaration, see if we
4150              have a global definition or declaration for the function.  */
4151           if (oldlocal == NULL_TREE
4152               && DECL_EXTERNAL (x)
4153               && oldglobal != NULL_TREE
4154               && TREE_CODE (x) == FUNCTION_DECL
4155               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4156             {
4157               /* We have one.  Their types must agree.  */
4158               if (decls_match (x, oldglobal))
4159                 /* OK */;
4160               else
4161                 {
4162                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4163                   cp_warning_at ("global declaration `%#D'", oldglobal);
4164                 }
4165             }
4166           /* If we have a local external declaration,
4167              and no file-scope declaration has yet been seen,
4168              then if we later have a file-scope decl it must not be static.  */
4169           if (oldlocal == NULL_TREE
4170               && oldglobal == NULL_TREE
4171               && DECL_EXTERNAL (x)
4172               && TREE_PUBLIC (x))
4173             TREE_PUBLIC (name) = 1;
4174
4175           /* Warn if shadowing an argument at the top level of the body.  */
4176           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4177               /* Inline decls shadow nothing.  */
4178               && !DECL_FROM_INLINE (x)
4179               && TREE_CODE (oldlocal) == PARM_DECL)
4180             {
4181               bool err = false;
4182
4183               /* Don't complain if it's from an enclosing function.  */
4184               if (DECL_CONTEXT (oldlocal) == current_function_decl
4185                   && TREE_CODE (x) != PARM_DECL)
4186                 {
4187                   /* Go to where the parms should be and see if we find
4188                      them there.  */
4189                   struct binding_level *b = current_binding_level->level_chain;
4190
4191                   if (cleanup_label)
4192                     b = b->level_chain;
4193
4194                   /* ARM $8.3 */
4195                   if (b->parm_flag == 1)
4196                     {
4197                       cp_error ("declaration of `%#D' shadows a parameter",
4198                                 name);
4199                       err = true;
4200                     }
4201                 }
4202
4203               if (warn_shadow && !err)
4204                 shadow_warning ("a parameter", name, oldlocal);
4205             }
4206
4207           /* Maybe warn if shadowing something else.  */
4208           else if (warn_shadow && !DECL_EXTERNAL (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 (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4215                        && current_class_ptr
4216                        && !TREE_STATIC (name))
4217                 cp_warning ("declaration of `%s' shadows a member of `this'",
4218                             IDENTIFIER_POINTER (name));
4219               else if (oldlocal != NULL_TREE
4220                        && TREE_CODE (oldlocal) == VAR_DECL)
4221                 shadow_warning ("a previous local", name, oldlocal);
4222               else if (oldglobal != NULL_TREE
4223                        && TREE_CODE (oldglobal) == VAR_DECL)
4224                 /* XXX shadow warnings in outer-more namespaces */
4225                 shadow_warning ("a global declaration", name, oldglobal);
4226             }
4227         }
4228
4229       if (TREE_CODE (x) == FUNCTION_DECL)
4230         check_default_args (x);
4231
4232       /* Keep count of variables in this level with incomplete type.  */
4233       if (TREE_CODE (x) == VAR_DECL
4234           && TREE_TYPE (x) != error_mark_node
4235           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4236                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4237               /* RTTI TD entries are created while defining the type_info.  */
4238               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4239                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4240         {
4241           if (namespace_bindings_p ())
4242             namespace_scope_incomplete
4243               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4244           else
4245             current_binding_level->incomplete
4246               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4247         }
4248     }
4249
4250   if (need_new_binding)
4251     add_decl_to_level (x,
4252                        DECL_NAMESPACE_SCOPE_P (x)
4253                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4254                        : current_binding_level);
4255
4256   return x;
4257 }
4258
4259 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4260    caller to set DECL_CONTEXT properly.  */
4261
4262 static tree
4263 pushdecl_with_scope (x, level)
4264      tree x;
4265      struct binding_level *level;
4266 {
4267   register struct binding_level *b;
4268   tree function_decl = current_function_decl;
4269
4270   current_function_decl = NULL_TREE;
4271   if (level->parm_flag == 2)
4272     {
4273       b = class_binding_level;
4274       class_binding_level = level;
4275       pushdecl_class_level (x);
4276       class_binding_level = b;
4277     }
4278   else
4279     {
4280       b = current_binding_level;
4281       current_binding_level = level;
4282       x = pushdecl (x);
4283       current_binding_level = b;
4284     }
4285   current_function_decl = function_decl;
4286   return x;
4287 }
4288
4289 /* Like pushdecl, only it places X in the current namespace,
4290    if appropriate.  */
4291
4292 tree
4293 pushdecl_namespace_level (x)
4294      tree x;
4295 {
4296   register struct binding_level *b = current_binding_level;
4297   register tree t;
4298
4299   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4300
4301   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4302      what we want.  */
4303   if (TREE_CODE (x) == TYPE_DECL)
4304     {
4305       tree name = DECL_NAME (x);
4306       tree newval;
4307       tree *ptr = (tree *)0;
4308       for (; b != global_binding_level; b = b->level_chain)
4309         {
4310           tree shadowed = b->type_shadowed;
4311           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4312             if (TREE_PURPOSE (shadowed) == name)
4313               {
4314                 ptr = &TREE_VALUE (shadowed);
4315                 /* Can't break out of the loop here because sometimes
4316                    a binding level will have duplicate bindings for
4317                    PT names.  It's gross, but I haven't time to fix it.  */
4318               }
4319         }
4320       newval = TREE_TYPE (x);
4321       if (ptr == (tree *)0)
4322         {
4323           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4324              up here if this is changed to an assertion.  --KR  */
4325           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4326         }
4327       else
4328         {
4329           *ptr = newval;
4330         }
4331     }
4332   return t;
4333 }
4334
4335 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4336    if appropriate.  */
4337
4338 tree
4339 pushdecl_top_level (x)
4340      tree x;
4341 {
4342   push_to_top_level ();
4343   x = pushdecl_namespace_level (x);
4344   pop_from_top_level ();
4345   return x;
4346 }
4347
4348 /* Make the declaration of X appear in CLASS scope.  */
4349
4350 void
4351 pushdecl_class_level (x)
4352      tree x;
4353 {
4354   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4355      scope looks for the pre-mangled name.  */
4356   register tree name;
4357
4358   if (TREE_CODE (x) == OVERLOAD)
4359     x = OVL_CURRENT (x);
4360   name = DECL_NAME (x);
4361
4362   if (name)
4363     {
4364       push_class_level_binding (name, x);
4365       if (TREE_CODE (x) == TYPE_DECL)
4366         set_identifier_type_value (name, TREE_TYPE (x));
4367     }
4368   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4369     {
4370       tree f;
4371
4372       for (f = TYPE_FIELDS (TREE_TYPE (x));
4373            f;
4374            f = TREE_CHAIN (f))
4375         pushdecl_class_level (f);
4376     }
4377 }
4378
4379 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4380    DECL, or a modified version thereof.  */
4381
4382 tree
4383 maybe_push_decl (decl)
4384      tree decl;
4385 {
4386   tree type = TREE_TYPE (decl);
4387
4388   /* Add this decl to the current binding level, but not if it comes
4389      from another scope, e.g. a static member variable.  TEM may equal
4390      DECL or it may be a previous decl of the same name.  */
4391   if (decl == error_mark_node
4392       || (TREE_CODE (decl) != PARM_DECL
4393           && DECL_CONTEXT (decl) != NULL_TREE
4394           /* Definitions of namespace members outside their namespace are
4395              possible. */
4396           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4397       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4398       || TREE_CODE (type) == UNKNOWN_TYPE
4399       /* The declaration of a template specialization does not affect
4400          the functions available for overload resolution, so we do not
4401          call pushdecl.  */
4402       || (TREE_CODE (decl) == FUNCTION_DECL
4403           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4404     return decl;
4405   else
4406     return pushdecl (decl);
4407 }
4408
4409 /* Make the declaration(s) of X appear in CLASS scope
4410    under the name NAME.  */
4411
4412 void
4413 push_class_level_binding (name, x)
4414      tree name;
4415      tree x;
4416 {
4417   tree binding;
4418   /* The class_binding_level will be NULL if x is a template
4419      parameter name in a member template.  */
4420   if (!class_binding_level)
4421     return;
4422
4423   /* Make sure that this new member does not have the same name
4424      as a template parameter.  */
4425   if (TYPE_BEING_DEFINED (current_class_type))
4426     check_template_shadow (x);
4427
4428   /* If this declaration shadows a declaration from an enclosing
4429      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4430      we leave this class.  Record the shadowed declaration here.  */
4431   binding = IDENTIFIER_BINDING (name);
4432   if (binding
4433       && ((TREE_CODE (x) == OVERLOAD
4434            && BINDING_VALUE (binding)
4435            && is_overloaded_fn (BINDING_VALUE (binding)))
4436           || INHERITED_VALUE_BINDING_P (binding)))
4437     {
4438       tree shadow;
4439       tree old_decl;
4440
4441       /* If the old binding was from a base class, and was for a tag
4442          name, slide it over to make room for the new binding.  The
4443          old binding is still visible if explicitly qualified with a
4444          class-key.  */
4445       if (INHERITED_VALUE_BINDING_P (binding)
4446           && BINDING_VALUE (binding)
4447           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4448           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4449           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4450         {
4451           old_decl = BINDING_TYPE (binding);
4452           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4453           BINDING_VALUE (binding) = NULL_TREE;
4454           INHERITED_VALUE_BINDING_P (binding) = 0;
4455         }
4456       else
4457         old_decl = BINDING_VALUE (binding);
4458
4459       /* Find the previous binding of name on the class-shadowed
4460          list, and update it.  */
4461       for (shadow = class_binding_level->class_shadowed;
4462            shadow;
4463            shadow = TREE_CHAIN (shadow))
4464         if (TREE_PURPOSE (shadow) == name
4465             && TREE_TYPE (shadow) == old_decl)
4466           {
4467             BINDING_VALUE (binding) = x;
4468             INHERITED_VALUE_BINDING_P (binding) = 0;
4469             TREE_TYPE (shadow) = x;
4470             IDENTIFIER_CLASS_VALUE (name) = x;
4471             return;
4472           }
4473     }
4474
4475   /* If we didn't replace an existing binding, put the binding on the
4476      stack of bindings for the identifier, and update the shadowed list.  */
4477   if (push_class_binding (name, x))
4478     {
4479       class_binding_level->class_shadowed
4480         = tree_cons (name, NULL,
4481                      class_binding_level->class_shadowed);
4482       /* Record the value we are binding NAME to so that we can know
4483          what to pop later.  */
4484       TREE_TYPE (class_binding_level->class_shadowed) = x;
4485     }
4486 }
4487
4488 /* Insert another USING_DECL into the current binding level, returning
4489    this declaration. If this is a redeclaration, do nothing, and
4490    return NULL_TREE if this not in namespace scope (in namespace
4491    scope, a using decl might extend any previous bindings).  */
4492
4493 tree
4494 push_using_decl (scope, name)
4495      tree scope;
4496      tree name;
4497 {
4498   tree decl;
4499
4500   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4501   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4502   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4503     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4504       break;
4505   if (decl)
4506     return namespace_bindings_p () ? decl : NULL_TREE;
4507   decl = build_lang_decl (USING_DECL, name, void_type_node);
4508   DECL_INITIAL (decl) = scope;
4509   TREE_CHAIN (decl) = current_binding_level->usings;
4510   current_binding_level->usings = decl;
4511   return decl;
4512 }
4513
4514 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4515    changed (i.e. there was already a directive), or the fresh
4516    TREE_LIST otherwise.  */
4517
4518 tree
4519 push_using_directive (used)
4520      tree used;
4521 {
4522   tree ud = current_binding_level->using_directives;
4523   tree iter, ancestor;
4524
4525   /* Check if we already have this. */
4526   if (purpose_member (used, ud) != NULL_TREE)
4527     return NULL_TREE;
4528
4529   /* Recursively add all namespaces used. */
4530   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4531     push_using_directive (TREE_PURPOSE (iter));
4532
4533   ancestor = namespace_ancestor (current_decl_namespace (), used);
4534   ud = current_binding_level->using_directives;
4535   ud = tree_cons (used, ancestor, ud);
4536   current_binding_level->using_directives = ud;
4537   return ud;
4538 }
4539
4540 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4541    other definitions already in place.  We get around this by making
4542    the value of the identifier point to a list of all the things that
4543    want to be referenced by that name.  It is then up to the users of
4544    that name to decide what to do with that list.
4545
4546    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4547    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4548
4549    FLAGS is a bitwise-or of the following values:
4550      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4551                  namespace scope.
4552      PUSH_USING: DECL is being pushed as the result of a using
4553                  declaration.
4554
4555    The value returned may be a previous declaration if we guessed wrong
4556    about what language DECL should belong to (C or C++).  Otherwise,
4557    it's always DECL (and never something that's not a _DECL).  */
4558
4559 tree
4560 push_overloaded_decl (decl, flags)
4561      tree decl;
4562      int flags;
4563 {
4564   tree name = DECL_NAME (decl);
4565   tree old;
4566   tree new_binding;
4567   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4568
4569   if (doing_global)
4570     old = namespace_binding (name, DECL_CONTEXT (decl));
4571   else
4572     old = lookup_name_current_level (name);
4573
4574   if (old)
4575     {
4576       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4577         {
4578           tree t = TREE_TYPE (old);
4579           if (IS_AGGR_TYPE (t) && warn_shadow
4580               && (! DECL_IN_SYSTEM_HEADER (decl)
4581                   || ! DECL_IN_SYSTEM_HEADER (old)))
4582             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4583           old = NULL_TREE;
4584         }
4585       else if (is_overloaded_fn (old))
4586         {
4587           tree tmp;
4588
4589           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4590             {
4591               tree fn = OVL_CURRENT (tmp);
4592
4593               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4594                   && !(flags & PUSH_USING)
4595                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4596                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4597                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4598                           decl, fn);
4599
4600               if (duplicate_decls (decl, fn))
4601                 return fn;
4602             }
4603         }
4604       else if (old == error_mark_node)
4605         /* Ignore the undefined symbol marker.  */
4606         old = NULL_TREE;
4607       else
4608         {
4609           cp_error_at ("previous non-function declaration `%#D'", old);
4610           cp_error ("conflicts with function declaration `%#D'", decl);
4611           return decl;
4612         }
4613     }
4614
4615   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4616     {
4617       if (old && TREE_CODE (old) != OVERLOAD)
4618         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4619       else
4620         new_binding = ovl_cons (decl, old);
4621       if (flags & PUSH_USING)
4622         OVL_USED (new_binding) = 1;
4623     }
4624   else
4625     /* NAME is not ambiguous.  */
4626     new_binding = decl;
4627
4628   if (doing_global)
4629     set_namespace_binding (name, current_namespace, new_binding);
4630   else
4631     {
4632       /* We only create an OVERLOAD if there was a previous binding at
4633          this level, or if decl is a template. In the former case, we
4634          need to remove the old binding and replace it with the new
4635          binding.  We must also run through the NAMES on the binding
4636          level where the name was bound to update the chain.  */
4637
4638       if (TREE_CODE (new_binding) == OVERLOAD && old)
4639         {
4640           tree *d;
4641
4642           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4643                *d;
4644                d = &TREE_CHAIN (*d))
4645             if (*d == old
4646                 || (TREE_CODE (*d) == TREE_LIST
4647                     && TREE_VALUE (*d) == old))
4648               {
4649                 if (TREE_CODE (*d) == TREE_LIST)
4650                   /* Just replace the old binding with the new.  */
4651                   TREE_VALUE (*d) = new_binding;
4652                 else
4653                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4654                   *d = tree_cons (NULL_TREE, new_binding,
4655                                   TREE_CHAIN (*d));
4656
4657                 /* And update the CPLUS_BINDING node.  */
4658                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4659                   = new_binding;
4660                 return decl;
4661               }
4662
4663           /* We should always find a previous binding in this case.  */
4664           my_friendly_abort (0);
4665         }
4666
4667       /* Install the new binding.  */
4668       push_local_binding (name, new_binding, flags);
4669     }
4670
4671   return decl;
4672 }
4673 \f
4674 /* Generate an implicit declaration for identifier FUNCTIONID
4675    as a function of type int ().  Print a warning if appropriate.  */
4676
4677 tree
4678 implicitly_declare (functionid)
4679      tree functionid;
4680 {
4681   register tree decl;
4682
4683   /* We used to reuse an old implicit decl here,
4684      but this loses with inline functions because it can clobber
4685      the saved decl chains.  */
4686   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4687
4688   DECL_EXTERNAL (decl) = 1;
4689   TREE_PUBLIC (decl) = 1;
4690
4691   /* ISO standard says implicit declarations are in the innermost block.
4692      So we record the decl in the standard fashion.  */
4693   pushdecl (decl);
4694   rest_of_decl_compilation (decl, NULL, 0, 0);
4695
4696   if (warn_implicit
4697       /* Only one warning per identifier.  */
4698       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4699     {
4700       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4701     }
4702
4703   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4704
4705   return decl;
4706 }
4707
4708 /* Return zero if the declaration NEWDECL is valid
4709    when the declaration OLDDECL (assumed to be for the same name)
4710    has already been seen.
4711    Otherwise return an error message format string with a %s
4712    where the identifier should go.  */
4713
4714 static const char *
4715 redeclaration_error_message (newdecl, olddecl)
4716      tree newdecl, olddecl;
4717 {
4718   if (TREE_CODE (newdecl) == TYPE_DECL)
4719     {
4720       /* Because C++ can put things into name space for free,
4721          constructs like "typedef struct foo { ... } foo"
4722          would look like an erroneous redeclaration.  */
4723       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4724         return 0;
4725       else
4726         return "redefinition of `%#D'";
4727     }
4728   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4729     {
4730       /* If this is a pure function, its olddecl will actually be
4731          the original initialization to `0' (which we force to call
4732          abort()).  Don't complain about redefinition in this case.  */
4733       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4734         return 0;
4735
4736       /* If both functions come from different namespaces, this is not
4737          a redeclaration - this is a conflict with a used function. */
4738       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4739           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4740         return "`%D' conflicts with used function";
4741
4742       /* We'll complain about linkage mismatches in
4743          warn_extern_redeclared_static.  */
4744
4745       /* Defining the same name twice is no good.  */
4746       if (DECL_INITIAL (olddecl) != NULL_TREE
4747           && DECL_INITIAL (newdecl) != NULL_TREE)
4748         {
4749           if (DECL_NAME (olddecl) == NULL_TREE)
4750             return "`%#D' not declared in class";
4751           else
4752             return "redefinition of `%#D'";
4753         }
4754       return 0;
4755     }
4756   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4757     {
4758       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4759            && (DECL_TEMPLATE_RESULT (newdecl)
4760                != DECL_TEMPLATE_RESULT (olddecl))
4761            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4762            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4763           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4764               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4765               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4766         return "redefinition of `%#D'";
4767       return 0;
4768     }
4769   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4770     {
4771       /* Objects declared at top level:  */
4772       /* If at least one is a reference, it's ok.  */
4773       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4774         return 0;
4775       /* Reject two definitions.  */
4776       return "redefinition of `%#D'";
4777     }
4778   else
4779     {
4780       /* Objects declared with block scope:  */
4781       /* Reject two definitions, and reject a definition
4782          together with an external reference.  */
4783       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4784         return "redeclaration of `%#D'";
4785       return 0;
4786     }
4787 }
4788 \f
4789 /* Create a new label, named ID.  */
4790
4791 static tree
4792 make_label_decl (id, local_p)
4793      tree id;
4794      int local_p;
4795 {
4796   tree decl;
4797
4798   decl = build_decl (LABEL_DECL, id, void_type_node);
4799   if (expanding_p)
4800     /* Make sure every label has an rtx.  */
4801     label_rtx (decl);
4802
4803   DECL_CONTEXT (decl) = current_function_decl;
4804   DECL_MODE (decl) = VOIDmode;
4805   C_DECLARED_LABEL_FLAG (decl) = local_p;
4806
4807   /* Say where one reference is to the label, for the sake of the
4808      error if it is not defined.  */
4809   DECL_SOURCE_LINE (decl) = lineno;
4810   DECL_SOURCE_FILE (decl) = input_filename;
4811
4812   /* Record the fact that this identifier is bound to this label.  */
4813   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4814
4815   return decl;
4816 }
4817
4818 /* Record this label on the list of used labels so that we can check
4819    at the end of the function to see whether or not the label was
4820    actually defined, and so we can check when the label is defined whether
4821    this use is valid.  */
4822
4823 static void
4824 use_label (decl)
4825      tree decl;
4826 {
4827   if (named_label_uses == NULL
4828       || named_label_uses->names_in_scope != current_binding_level->names
4829       || named_label_uses->label_decl != decl)
4830     {
4831       struct named_label_use_list *new_ent;
4832       new_ent = ((struct named_label_use_list *)
4833                  ggc_alloc (sizeof (struct named_label_use_list)));
4834       new_ent->label_decl = decl;
4835       new_ent->names_in_scope = current_binding_level->names;
4836       new_ent->binding_level = current_binding_level;
4837       new_ent->lineno_o_goto = lineno;
4838       new_ent->filename_o_goto = input_filename;
4839       new_ent->next = named_label_uses;
4840       named_label_uses = new_ent;
4841     }
4842 }
4843
4844 /* Look for a label named ID in the current function.  If one cannot
4845    be found, create one.  (We keep track of used, but undefined,
4846    labels, and complain about them at the end of a function.)  */
4847
4848 tree
4849 lookup_label (id)
4850      tree id;
4851 {
4852   tree decl;
4853   struct named_label_list *ent;
4854
4855   /* You can't use labels at global scope.  */
4856   if (current_function_decl == NULL_TREE)
4857     {
4858       error ("label `%s' referenced outside of any function",
4859              IDENTIFIER_POINTER (id));
4860       return NULL_TREE;
4861     }
4862
4863   /* See if we've already got this label.  */
4864   decl = IDENTIFIER_LABEL_VALUE (id);
4865   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4866     return decl;
4867
4868   /* Record this label on the list of labels used in this function.
4869      We do this before calling make_label_decl so that we get the
4870      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4871   ent = ((struct named_label_list *)
4872          ggc_alloc_cleared (sizeof (struct named_label_list)));
4873   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4874   ent->next = named_labels;
4875   named_labels = ent;
4876
4877   /* We need a new label.  */
4878   decl = make_label_decl (id, /*local_p=*/0);
4879
4880   /* Now fill in the information we didn't have before.  */
4881   ent->label_decl = decl;
4882
4883   return decl;
4884 }
4885
4886 /* Declare a local label named ID.  */
4887
4888 tree
4889 declare_local_label (id)
4890      tree id;
4891 {
4892   tree decl;
4893
4894   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4895      this scope we can restore the old value of
4896      IDENTIFIER_TYPE_VALUE.  */
4897   current_binding_level->shadowed_labels
4898     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4899                  current_binding_level->shadowed_labels);
4900   /* Look for the label.  */
4901   decl = make_label_decl (id, /*local_p=*/1);
4902   /* Now fill in the information we didn't have before.  */
4903   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4904
4905   return decl;
4906 }
4907
4908 /* Returns nonzero if it is ill-formed to jump past the declaration of
4909    DECL.  Returns 2 if it's also a real problem.  */
4910
4911 static int
4912 decl_jump_unsafe (decl)
4913      tree decl;
4914 {
4915   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4916     return 0;
4917
4918   if (DECL_INITIAL (decl) == NULL_TREE
4919       && pod_type_p (TREE_TYPE (decl)))
4920     return 0;
4921
4922   /* This is really only important if we're crossing an initialization.
4923      The POD stuff is just pedantry; why should it matter if the class
4924      contains a field of pointer to member type?  */
4925   if (DECL_INITIAL (decl)
4926       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4927     return 2;
4928   return 1;
4929 }
4930
4931 /* Check that a single previously seen jump to a newly defined label
4932    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4933    the jump context; NAMES are the names in scope in LEVEL at the jump
4934    context; FILE and LINE are the source position of the jump or 0.  */
4935
4936 static void
4937 check_previous_goto_1 (decl, level, names, file, line)
4938      tree decl;
4939      struct binding_level *level;
4940      tree names;
4941      const char *file;
4942      int line;
4943 {
4944   int identified = 0;
4945   int saw_eh = 0;
4946   struct binding_level *b = current_binding_level;
4947   for (; b; b = b->level_chain)
4948     {
4949       tree new_decls = b->names;
4950       tree old_decls = (b == level ? names : NULL_TREE);
4951       for (; new_decls != old_decls;
4952            new_decls = TREE_CHAIN (new_decls))
4953         {
4954           int problem = decl_jump_unsafe (new_decls);
4955           if (! problem)
4956             continue;
4957
4958           if (! identified)
4959             {
4960               if (decl)
4961                 cp_pedwarn ("jump to label `%D'", decl);
4962               else
4963                 pedwarn ("jump to case label");
4964
4965               if (file)
4966                 pedwarn_with_file_and_line (file, line, "  from here");
4967               identified = 1;
4968             }
4969
4970           if (problem > 1)
4971             cp_error_at ("  crosses initialization of `%#D'",
4972                          new_decls);
4973           else
4974             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4975                            new_decls);
4976         }
4977
4978       if (b == level)
4979         break;
4980       if ((b->is_try_scope || b->is_catch_scope) && ! saw_eh)
4981         {
4982           if (! identified)
4983             {
4984               if (decl)
4985                 cp_pedwarn ("jump to label `%D'", decl);
4986               else
4987                 pedwarn ("jump to case label");
4988
4989               if (file)
4990                 pedwarn_with_file_and_line (file, line, "  from here");
4991               identified = 1;
4992             }
4993           if (b->is_try_scope)
4994             error ("  enters try block");
4995           else
4996             error ("  enters catch block");
4997           saw_eh = 1;
4998         }
4999     }
5000 }
5001
5002 static void
5003 check_previous_goto (use)
5004      struct named_label_use_list *use;
5005 {
5006   check_previous_goto_1 (use->label_decl, use->binding_level,
5007                          use->names_in_scope, use->filename_o_goto,
5008                          use->lineno_o_goto);
5009 }
5010
5011 static void
5012 check_switch_goto (level)
5013      struct binding_level *level;
5014 {
5015   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
5016 }
5017
5018 /* Check that any previously seen jumps to a newly defined label DECL
5019    are OK.  Called by define_label.  */
5020
5021 static void
5022 check_previous_gotos (decl)
5023      tree decl;
5024 {
5025   struct named_label_use_list **usep;
5026
5027   if (! TREE_USED (decl))
5028     return;
5029
5030   for (usep = &named_label_uses; *usep; )
5031     {
5032       struct named_label_use_list *use = *usep;
5033       if (use->label_decl == decl)
5034         {
5035           check_previous_goto (use);
5036           *usep = use->next;
5037         }
5038       else
5039         usep = &(use->next);
5040     }
5041 }
5042
5043 /* Check that a new jump to a label DECL is OK.  Called by
5044    finish_goto_stmt.  */
5045
5046 void
5047 check_goto (decl)
5048      tree decl;
5049 {
5050   int identified = 0;
5051   tree bad;
5052   struct named_label_list *lab;
5053
5054   /* We can't know where a computed goto is jumping.  So we assume
5055      that it's OK.  */
5056   if (! DECL_P (decl))
5057     return;
5058
5059   /* If the label hasn't been defined yet, defer checking.  */
5060   if (! DECL_INITIAL (decl))
5061     {
5062       use_label (decl);
5063       return;
5064     }
5065
5066   for (lab = named_labels; lab; lab = lab->next)
5067     if (decl == lab->label_decl)
5068       break;
5069
5070   /* If the label is not on named_labels it's a gcc local label, so
5071      it must be in an outer scope, so jumping to it is always OK.  */
5072   if (lab == 0)
5073     return;
5074
5075   if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
5076       && !identified)
5077     {
5078       cp_pedwarn_at ("jump to label `%D'", decl);
5079       pedwarn ("  from here");
5080       identified = 1;
5081     }
5082
5083   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5084     {
5085       tree b = TREE_VALUE (bad);
5086       int u = decl_jump_unsafe (b);
5087
5088       if (u > 1 && DECL_ARTIFICIAL (b))
5089         /* Can't skip init of __exception_info.  */
5090         cp_error_at ("  enters catch block", b);
5091       else if (u > 1)
5092         cp_error_at ("  skips initialization of `%#D'", b);
5093       else
5094         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5095     }
5096
5097   if (lab->in_try_scope)
5098     error ("  enters try block");
5099   else if (lab->in_catch_scope)
5100     error ("  enters catch block");
5101 }
5102
5103 /* Define a label, specifying the location in the source file.
5104    Return the LABEL_DECL node for the label, if the definition is valid.
5105    Otherwise return 0.  */
5106
5107 tree
5108 define_label (filename, line, name)
5109      const char *filename;
5110      int line;
5111      tree name;
5112 {
5113   tree decl = lookup_label (name);
5114   struct named_label_list *ent;
5115   register struct binding_level *p;
5116
5117   for (ent = named_labels; ent; ent = ent->next)
5118     if (ent->label_decl == decl)
5119       break;
5120
5121   /* After labels, make any new cleanups in the function go into their
5122      own new (temporary) binding contour.  */
5123   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5124     p->more_cleanups_ok = 0;
5125
5126   if (name == get_identifier ("wchar_t"))
5127     cp_pedwarn ("label named wchar_t");
5128
5129   if (DECL_INITIAL (decl) != NULL_TREE)
5130     {
5131       cp_error ("duplicate label `%D'", decl);
5132       return 0;
5133     }
5134   else
5135     {
5136       /* Mark label as having been defined.  */
5137       DECL_INITIAL (decl) = error_mark_node;
5138       /* Say where in the source.  */
5139       DECL_SOURCE_FILE (decl) = filename;
5140       DECL_SOURCE_LINE (decl) = line;
5141       if (ent)
5142         {
5143           ent->names_in_scope = current_binding_level->names;
5144           ent->binding_level = current_binding_level;
5145         }
5146       check_previous_gotos (decl);
5147       return decl;
5148     }
5149 }
5150
5151 struct cp_switch
5152 {
5153   struct binding_level *level;
5154   struct cp_switch *next;
5155   /* The SWITCH_STMT being built.  */
5156   tree switch_stmt;
5157   /* A splay-tree mapping the low element of a case range to the high
5158      element, or NULL_TREE if there is no high element.  Used to
5159      determine whether or not a new case label duplicates an old case
5160      label.  We need a tree, rather than simply a hash table, because
5161      of the GNU case range extension.  */
5162   splay_tree cases;
5163 };
5164
5165 /* A stack of the currently active switch statements.  The innermost
5166    switch statement is on the top of the stack.  There is no need to
5167    mark the stack for garbage collection because it is only active
5168    during the processing of the body of a function, and we never
5169    collect at that point.  */
5170
5171 static struct cp_switch *switch_stack;
5172
5173 /* Called right after a switch-statement condition is parsed.
5174    SWITCH_STMT is the switch statement being parsed.  */
5175
5176 void
5177 push_switch (switch_stmt)
5178      tree switch_stmt;
5179 {
5180   struct cp_switch *p
5181     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5182   p->level = current_binding_level;
5183   p->next = switch_stack;
5184   p->switch_stmt = switch_stmt;
5185   p->cases = splay_tree_new (case_compare, NULL, NULL);
5186   switch_stack = p;
5187 }
5188
5189 void
5190 pop_switch ()
5191 {
5192   struct cp_switch *cs;
5193
5194   cs = switch_stack;
5195   splay_tree_delete (cs->cases);
5196   switch_stack = switch_stack->next;
5197   free (cs);
5198 }
5199
5200 /* Note that we've seen a definition of a case label, and complain if this
5201    is a bad place for one.  */
5202
5203 tree
5204 finish_case_label (low_value, high_value)
5205      tree low_value;
5206      tree high_value;
5207 {
5208   tree cond, r;
5209   register struct binding_level *p;
5210
5211   if (! switch_stack)
5212     {
5213       if (high_value)
5214         error ("case label not within a switch statement");
5215       else if (low_value)
5216         cp_error ("case label `%E' not within a switch statement",
5217                   low_value);
5218       else
5219         error ("`default' label not within a switch statement");
5220       return NULL_TREE;
5221     }
5222
5223   if (processing_template_decl)
5224     {
5225       tree label;
5226
5227       /* For templates, just add the case label; we'll do semantic
5228          analysis at instantiation-time.  */
5229       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5230       return add_stmt (build_case_label (low_value, high_value, label));
5231     }
5232
5233   /* Find the condition on which this switch statement depends.  */
5234   cond = SWITCH_COND (switch_stack->switch_stmt);
5235   if (cond && TREE_CODE (cond) == TREE_LIST)
5236     cond = TREE_VALUE (cond);
5237
5238   r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5239   if (r == error_mark_node)
5240     r = NULL_TREE;
5241
5242   check_switch_goto (switch_stack->level);
5243
5244   /* After labels, make any new cleanups in the function go into their
5245      own new (temporary) binding contour.  */
5246   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5247     p->more_cleanups_ok = 0;
5248
5249   return r;
5250 }
5251 \f
5252 /* Return the list of declarations of the current level.
5253    Note that this list is in reverse order unless/until
5254    you nreverse it; and when you do nreverse it, you must
5255    store the result back using `storedecls' or you will lose.  */
5256
5257 tree
5258 getdecls ()
5259 {
5260   return current_binding_level->names;
5261 }
5262
5263 /* Return the list of type-tags (for structs, etc) of the current level.  */
5264
5265 tree
5266 gettags ()
5267 {
5268   return current_binding_level->tags;
5269 }
5270
5271 /* Store the list of declarations of the current level.
5272    This is done for the parameter declarations of a function being defined,
5273    after they are modified in the light of any missing parameters.  */
5274
5275 static void
5276 storedecls (decls)
5277      tree decls;
5278 {
5279   current_binding_level->names = decls;
5280 }
5281
5282 /* Similarly, store the list of tags of the current level.  */
5283
5284 void
5285 storetags (tags)
5286      tree tags;
5287 {
5288   current_binding_level->tags = tags;
5289 }
5290 \f
5291 /* Given NAME, an IDENTIFIER_NODE,
5292    return the structure (or union or enum) definition for that name.
5293    Searches binding levels from BINDING_LEVEL up to the global level.
5294    If THISLEVEL_ONLY is nonzero, searches only the specified context
5295    (but skips any tag-transparent contexts to find one that is
5296    meaningful for tags).
5297    FORM says which kind of type the caller wants;
5298    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5299    If the wrong kind of type is found, and it's not a template, an error is
5300    reported.  */
5301
5302 static tree
5303 lookup_tag (form, name, binding_level, thislevel_only)
5304      enum tree_code form;
5305      tree name;
5306      struct binding_level *binding_level;
5307      int thislevel_only;
5308 {
5309   register struct binding_level *level;
5310   /* Non-zero if, we should look past a template parameter level, even
5311      if THISLEVEL_ONLY.  */
5312   int allow_template_parms_p = 1;
5313
5314   for (level = binding_level; level; level = level->level_chain)
5315     {
5316       register tree tail;
5317       if (ANON_AGGRNAME_P (name))
5318         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5319           {
5320             /* There's no need for error checking here, because
5321                anon names are unique throughout the compilation.  */
5322             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5323               return TREE_VALUE (tail);
5324           }
5325       else if (level->namespace_p)
5326         /* Do namespace lookup. */
5327         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5328           {
5329             tree old = binding_for_name (name, tail);
5330
5331             /* If we just skipped past a template parameter level,
5332                even though THISLEVEL_ONLY, and we find a template
5333                class declaration, then we use the _TYPE node for the
5334                template.  See the example below.  */
5335             if (thislevel_only && !allow_template_parms_p
5336                 && old && BINDING_VALUE (old)
5337                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5338               old = TREE_TYPE (BINDING_VALUE (old));
5339             else
5340               old = BINDING_TYPE (old);
5341
5342             /* If it has an original type, it is a typedef, and we
5343                should not return it.  */
5344             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5345               old = NULL_TREE;
5346             if (old && TREE_CODE (old) != form
5347                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5348               {
5349                 cp_error ("`%#D' redeclared as %C", old, form);
5350                 return NULL_TREE;
5351               }
5352             if (old)
5353               return old;
5354             if (thislevel_only || tail == global_namespace)
5355               return NULL_TREE;
5356           }
5357       else
5358         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5359           {
5360             if (TREE_PURPOSE (tail) == name)
5361               {
5362                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5363                 /* Should tighten this up; it'll probably permit
5364                    UNION_TYPE and a struct template, for example.  */
5365                 if (code != form
5366                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5367                   {
5368                     /* Definition isn't the kind we were looking for.  */
5369                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5370                               form);
5371                     return NULL_TREE;
5372                   }
5373                 return TREE_VALUE (tail);
5374               }
5375           }
5376       if (thislevel_only && ! level->tag_transparent)
5377         {
5378           if (level->template_parms_p && allow_template_parms_p)
5379             {
5380               /* We must deal with cases like this:
5381
5382                    template <class T> struct S;
5383                    template <class T> struct S {};
5384
5385                  When looking up `S', for the second declaration, we
5386                  would like to find the first declaration.  But, we
5387                  are in the pseudo-global level created for the
5388                  template parameters, rather than the (surrounding)
5389                  namespace level.  Thus, we keep going one more level,
5390                  even though THISLEVEL_ONLY is non-zero.  */
5391               allow_template_parms_p = 0;
5392               continue;
5393             }
5394           else
5395             return NULL_TREE;
5396         }
5397     }
5398   return NULL_TREE;
5399 }
5400
5401 #if 0
5402 void
5403 set_current_level_tags_transparency (tags_transparent)
5404      int tags_transparent;
5405 {
5406   current_binding_level->tag_transparent = tags_transparent;
5407 }
5408 #endif
5409
5410 /* Given a type, find the tag that was defined for it and return the tag name.
5411    Otherwise return 0.  However, the value can never be 0
5412    in the cases in which this is used.
5413
5414    C++: If NAME is non-zero, this is the new name to install.  This is
5415    done when replacing anonymous tags with real tag names.  */
5416
5417 static tree
5418 lookup_tag_reverse (type, name)
5419      tree type;
5420      tree name;
5421 {
5422   register struct binding_level *level;
5423
5424   for (level = current_binding_level; level; level = level->level_chain)
5425     {
5426       register tree tail;
5427       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5428         {
5429           if (TREE_VALUE (tail) == type)
5430             {
5431               if (name)
5432                 TREE_PURPOSE (tail) = name;
5433               return TREE_PURPOSE (tail);
5434             }
5435         }
5436     }
5437   return NULL_TREE;
5438 }
5439 \f
5440 /* Look up NAME in the NAMESPACE.  */
5441
5442 tree
5443 lookup_namespace_name (namespace, name)
5444      tree namespace, name;
5445 {
5446   tree val;
5447   tree template_id = NULL_TREE;
5448
5449   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5450
5451   if (TREE_CODE (name) == NAMESPACE_DECL)
5452     /* This happens for A::B<int> when B is a namespace. */
5453     return name;
5454   else if (TREE_CODE (name) == TEMPLATE_DECL)
5455     {
5456       /* This happens for A::B where B is a template, and there are no
5457          template arguments.  */
5458       cp_error ("invalid use of `%D'", name);
5459       return error_mark_node;
5460     }
5461
5462   namespace = ORIGINAL_NAMESPACE (namespace);
5463
5464   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5465     {
5466       template_id = name;
5467       name = TREE_OPERAND (name, 0);
5468       if (TREE_CODE (name) == OVERLOAD)
5469         name = DECL_NAME (OVL_CURRENT (name));
5470       else if (DECL_P (name))
5471         name = DECL_NAME (name);
5472     }
5473
5474   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5475
5476   val = make_node (CPLUS_BINDING);
5477   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5478     return error_mark_node;
5479
5480   if (BINDING_VALUE (val))
5481     {
5482       val = BINDING_VALUE (val);
5483
5484       if (template_id)
5485         {
5486           if (DECL_CLASS_TEMPLATE_P (val))
5487             val = lookup_template_class (val,
5488                                          TREE_OPERAND (template_id, 1),
5489                                          /*in_decl=*/NULL_TREE,
5490                                          /*context=*/NULL_TREE,
5491                                          /*entering_scope=*/0,
5492                                          /*complain=*/1);
5493           else if (DECL_FUNCTION_TEMPLATE_P (val)
5494                    || TREE_CODE (val) == OVERLOAD)
5495             val = lookup_template_function (val,
5496                                             TREE_OPERAND (template_id, 1));
5497           else
5498             {
5499               cp_error ("`%D::%D' is not a template",
5500                         namespace, name);
5501               return error_mark_node;
5502             }
5503         }
5504
5505       /* If we have a single function from a using decl, pull it out.  */
5506       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5507         val = OVL_FUNCTION (val);
5508       return val;
5509     }
5510
5511   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5512   return error_mark_node;
5513 }
5514
5515 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5516
5517 static unsigned long
5518 typename_hash (k)
5519      hash_table_key k;
5520 {
5521   unsigned long hash;
5522   tree t;
5523
5524   t = (tree) k;
5525   hash = (((unsigned long) TYPE_CONTEXT (t))
5526           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5527
5528   return hash;
5529 }
5530
5531 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5532
5533 static bool
5534 typename_compare (k1, k2)
5535      hash_table_key k1;
5536      hash_table_key k2;
5537 {
5538   tree t1;
5539   tree t2;
5540   tree d1;
5541   tree d2;
5542
5543   t1 = (tree) k1;
5544   t2 = (tree) k2;
5545   d1 = TYPE_NAME (t1);
5546   d2 = TYPE_NAME (t2);
5547
5548   return (DECL_NAME (d1) == DECL_NAME (d2)
5549           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5550           && ((TREE_TYPE (t1) != NULL_TREE)
5551               == (TREE_TYPE (t2) != NULL_TREE))
5552           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5553           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5554 }
5555
5556 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5557    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5558    is non-NULL, this type is being created by the implicit typename
5559    extension, and BASE_TYPE is a type named `t' in some base class of
5560    `T' which depends on template parameters.
5561
5562    Returns the new TYPENAME_TYPE.  */
5563
5564 tree
5565 build_typename_type (context, name, fullname, base_type)
5566      tree context;
5567      tree name;
5568      tree fullname;
5569      tree base_type;
5570 {
5571   tree t;
5572   tree d;
5573   struct hash_entry *e;
5574
5575   static struct hash_table ht;
5576
5577   if (!ht.table)
5578     {
5579       static struct hash_table *h = &ht;
5580
5581       hash_table_init (&ht, &hash_newfunc, &typename_hash, &typename_compare);
5582       ggc_add_tree_hash_table_root (&h, 1);
5583     }
5584
5585   /* Build the TYPENAME_TYPE.  */
5586   t = make_aggr_type (TYPENAME_TYPE);
5587   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5588   TYPENAME_TYPE_FULLNAME (t) = fullname;
5589   TREE_TYPE (t) = base_type;
5590
5591   /* Build the corresponding TYPE_DECL.  */
5592   d = build_decl (TYPE_DECL, name, t);
5593   TYPE_NAME (TREE_TYPE (d)) = d;
5594   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5595   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5596   DECL_ARTIFICIAL (d) = 1;
5597
5598   /* See if we already have this type.  */
5599   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5600   if (e)
5601     t = (tree) e->key;
5602   else
5603     /* Insert the type into the table.  */
5604     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5605
5606   return t;
5607 }
5608
5609 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5610    unless an error occurs, in which case error_mark_node is returned.
5611    If COMPLAIN zero, don't complain about any errors that occur.  */
5612
5613 tree
5614 make_typename_type (context, name, complain)
5615      tree context, name;
5616      int complain;
5617 {
5618   tree fullname;
5619
5620   if (TYPE_P (name))
5621     {
5622       if (!(TYPE_LANG_SPECIFIC (name)
5623             && (CLASSTYPE_IS_TEMPLATE (name)
5624                 || CLASSTYPE_USE_TEMPLATE (name))))
5625         name = TYPE_IDENTIFIER (name);
5626       else
5627         /* Create a TEMPLATE_ID_EXPR for the type.  */
5628         name = build_nt (TEMPLATE_ID_EXPR,
5629                          CLASSTYPE_TI_TEMPLATE (name),
5630                          CLASSTYPE_TI_ARGS (name));
5631     }
5632   else if (TREE_CODE (name) == TYPE_DECL)
5633     name = DECL_NAME (name);
5634
5635   fullname = name;
5636
5637   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5638     {
5639       name = TREE_OPERAND (name, 0);
5640       if (TREE_CODE (name) == TEMPLATE_DECL)
5641         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5642     }
5643   if (TREE_CODE (name) == TEMPLATE_DECL)
5644     {
5645       cp_error ("`%D' used without template parameters", name);
5646       return error_mark_node;
5647     }
5648   if (TREE_CODE (name) != IDENTIFIER_NODE)
5649     my_friendly_abort (2000);
5650
5651   if (TREE_CODE (context) == NAMESPACE_DECL)
5652     {
5653       /* We can get here from typename_sub0 in the explicit_template_type
5654          expansion.  Just fail.  */
5655       if (complain)
5656         cp_error ("no class template named `%#T' in `%#T'",
5657                   name, context);
5658       return error_mark_node;
5659     }
5660
5661   if (! uses_template_parms (context)
5662       || currently_open_class (context))
5663     {
5664       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5665         {
5666           tree tmpl = NULL_TREE;
5667           if (IS_AGGR_TYPE (context))
5668             tmpl = lookup_field (context, name, 0, 0);
5669           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5670             {
5671               if (complain)
5672                 cp_error ("no class template named `%#T' in `%#T'",
5673                           name, context);
5674               return error_mark_node;
5675             }
5676
5677           return lookup_template_class (tmpl,
5678                                         TREE_OPERAND (fullname, 1),
5679                                         NULL_TREE, context,
5680                                         /*entering_scope=*/0,
5681                                         /*complain=*/1);
5682         }
5683       else
5684         {
5685           tree t;
5686
5687           if (!IS_AGGR_TYPE (context))
5688             {
5689               if (complain)
5690                 cp_error ("no type named `%#T' in `%#T'", name, context);
5691               return error_mark_node;
5692             }
5693
5694           t = lookup_field (context, name, 0, 1);
5695           if (t)
5696             return TREE_TYPE (t);
5697         }
5698     }
5699
5700   /* If the CONTEXT is not a template type, then either the field is
5701      there now or its never going to be.  */
5702   if (!uses_template_parms (context))
5703     {
5704       if (complain)
5705         cp_error ("no type named `%#T' in `%#T'", name, context);
5706       return error_mark_node;
5707     }
5708
5709
5710   return build_typename_type (context, name, fullname,  NULL_TREE);
5711 }
5712
5713 /* Resolve `CONTEXT::template NAME'.  Returns an appropriate type,
5714    unless an error occurs, in which case error_mark_node is returned.
5715    If COMPLAIN zero, don't complain about any errors that occur.  */
5716
5717 tree
5718 make_unbound_class_template (context, name, complain)
5719      tree context, name;
5720      int complain;
5721 {
5722   tree t;
5723   tree d;
5724
5725   if (TYPE_P (name))
5726     name = TYPE_IDENTIFIER (name);
5727   else if (DECL_P (name))
5728     name = DECL_NAME (name);
5729   if (TREE_CODE (name) != IDENTIFIER_NODE)
5730     my_friendly_abort (20010902);
5731
5732   if (!uses_template_parms (context)
5733       || currently_open_class (context))
5734     {
5735       tree tmpl = NULL_TREE;
5736
5737       if (IS_AGGR_TYPE (context))
5738         tmpl = lookup_field (context, name, 0, 0);
5739
5740       if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5741         {
5742           if (complain)
5743             cp_error ("no class template named `%#T' in `%#T'", name, context);
5744           return error_mark_node;
5745         }
5746
5747       if (!enforce_access (context, tmpl))
5748         return error_mark_node;
5749
5750       return tmpl;
5751     }
5752
5753   /* Build the UNBOUND_CLASS_TEMPLATE.  */
5754   t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
5755   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5756   TREE_TYPE (t) = NULL_TREE;
5757
5758   /* Build the corresponding TEMPLATE_DECL.  */
5759   d = build_decl (TEMPLATE_DECL, name, t);
5760   TYPE_NAME (TREE_TYPE (d)) = d;
5761   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5762   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5763   DECL_ARTIFICIAL (d) = 1;
5764
5765   return t;
5766 }
5767
5768 /* Select the right _DECL from multiple choices. */
5769
5770 static tree
5771 select_decl (binding, flags)
5772      tree binding;
5773      int flags;
5774 {
5775   tree val;
5776   val = BINDING_VALUE (binding);
5777
5778   /* When we implicitly declare some builtin entity, we mark it
5779      DECL_ANTICIPATED, so that we know to ignore it until it is
5780      really declared.  */
5781   if (val && DECL_P (val)
5782       && DECL_LANG_SPECIFIC (val)
5783       && DECL_ANTICIPATED (val))
5784     return NULL_TREE;
5785
5786   if (LOOKUP_NAMESPACES_ONLY (flags))
5787     {
5788       /* We are not interested in types. */
5789       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5790         return val;
5791       return NULL_TREE;
5792     }
5793
5794   /* If we could have a type and
5795      we have nothing or we need a type and have none.  */
5796   if (BINDING_TYPE (binding)
5797       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5798                    && TREE_CODE (val) != TYPE_DECL)))
5799     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5800   /* Don't return non-types if we really prefer types. */
5801   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5802            && (TREE_CODE (val) != TEMPLATE_DECL
5803                || !DECL_CLASS_TEMPLATE_P (val)))
5804     val = NULL_TREE;
5805
5806   return val;
5807 }
5808
5809 /* Unscoped lookup of a global: iterate over current namespaces,
5810    considering using-directives.  If SPACESP is non-NULL, store a list
5811    of the namespaces we've considered in it.  */
5812
5813 tree
5814 unqualified_namespace_lookup (name, flags, spacesp)
5815      tree name;
5816      int flags;
5817      tree *spacesp;
5818 {
5819   tree b = make_node (CPLUS_BINDING);
5820   tree initial = current_decl_namespace ();
5821   tree scope = initial;
5822   tree siter;
5823   struct binding_level *level;
5824   tree val = NULL_TREE;
5825
5826   if (spacesp)
5827     *spacesp = NULL_TREE;
5828
5829   for (; !val; scope = CP_DECL_CONTEXT (scope))
5830     {
5831       if (spacesp)
5832         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5833       val = binding_for_name (name, scope);
5834
5835       /* Initialize binding for this context. */
5836       BINDING_VALUE (b) = BINDING_VALUE (val);
5837       BINDING_TYPE (b) = BINDING_TYPE (val);
5838
5839       /* Add all _DECLs seen through local using-directives. */
5840       for (level = current_binding_level;
5841            !level->namespace_p;
5842            level = level->level_chain)
5843         if (!lookup_using_namespace (name, b, level->using_directives,
5844                                      scope, flags, spacesp))
5845           /* Give up because of error. */
5846           return error_mark_node;
5847
5848       /* Add all _DECLs seen through global using-directives. */
5849       /* XXX local and global using lists should work equally. */
5850       siter = initial;
5851       while (1)
5852         {
5853           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5854                                        scope, flags, spacesp))
5855             /* Give up because of error. */
5856             return error_mark_node;
5857           if (siter == scope) break;
5858           siter = CP_DECL_CONTEXT (siter);
5859         }
5860
5861       val = select_decl (b, flags);
5862       if (scope == global_namespace)
5863         break;
5864     }
5865   return val;
5866 }
5867
5868 /* Combine prefer_type and namespaces_only into flags.  */
5869
5870 static int
5871 lookup_flags (prefer_type, namespaces_only)
5872   int prefer_type, namespaces_only;
5873 {
5874   if (namespaces_only)
5875     return LOOKUP_PREFER_NAMESPACES;
5876   if (prefer_type > 1)
5877     return LOOKUP_PREFER_TYPES;
5878   if (prefer_type > 0)
5879     return LOOKUP_PREFER_BOTH;
5880   return 0;
5881 }
5882
5883 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5884    ignore it or not.  Subroutine of lookup_name_real.  */
5885
5886 static tree
5887 qualify_lookup (val, flags)
5888      tree val;
5889      int flags;
5890 {
5891   if (val == NULL_TREE)
5892     return val;
5893   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5894     return val;
5895   if ((flags & LOOKUP_PREFER_TYPES)
5896       && (TREE_CODE (val) == TYPE_DECL
5897           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5898               && DECL_CLASS_TEMPLATE_P (val))))
5899     return val;
5900   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5901     return NULL_TREE;
5902   return val;
5903 }
5904
5905 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5906    that.  */
5907
5908 static void
5909 warn_about_implicit_typename_lookup (typename, binding)
5910      tree typename;
5911      tree binding;
5912 {
5913   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5914   tree name = DECL_NAME (typename);
5915
5916   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5917          && CLASSTYPE_TEMPLATE_INFO (subtype)
5918          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5919       && ! (TREE_CODE (binding) == TYPE_DECL
5920             && same_type_p (TREE_TYPE (binding), subtype)))
5921     {
5922       cp_warning ("lookup of `%D' finds `%#D'",
5923                   name, binding);
5924       cp_warning ("  instead of `%D' from dependent base class",
5925                   typename);
5926       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5927                   constructor_name (current_class_type), name);
5928     }
5929 }
5930
5931 /* Look up NAME in the current binding level and its superiors in the
5932    namespace of variables, functions and typedefs.  Return a ..._DECL
5933    node of some kind representing its definition if there is only one
5934    such declaration, or return a TREE_LIST with all the overloaded
5935    definitions if there are many, or return 0 if it is undefined.
5936
5937    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5938    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5939    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5940    Otherwise we prefer non-TYPE_DECLs.
5941
5942    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5943    using IDENTIFIER_CLASS_VALUE.  */
5944
5945 static tree
5946 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5947      tree name;
5948      int prefer_type, nonclass, namespaces_only;
5949 {
5950   tree t;
5951   tree val = NULL_TREE;
5952   int yylex = 0;
5953   tree from_obj = NULL_TREE;
5954   int flags;
5955   int val_is_implicit_typename = 0;
5956
5957   /* Hack: copy flag set by parser, if set. */
5958   if (only_namespace_names)
5959     namespaces_only = 1;
5960
5961   if (prefer_type == -2)
5962     {
5963       extern int looking_for_typename;
5964       tree type = NULL_TREE;
5965
5966       yylex = 1;
5967       prefer_type = looking_for_typename;
5968
5969       flags = lookup_flags (prefer_type, namespaces_only);
5970       /* If the next thing is '<', class templates are types. */
5971       if (looking_for_template)
5972         flags |= LOOKUP_TEMPLATES_EXPECTED;
5973
5974       if (got_scope)
5975         type = got_scope;
5976       else if (got_object != error_mark_node)
5977         type = got_object;
5978
5979       if (type)
5980         {
5981           if (type == error_mark_node)
5982             return error_mark_node;
5983           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5984             type = TREE_TYPE (type);
5985
5986           if (TYPE_P (type))
5987             type = complete_type (type);
5988
5989           if (TREE_CODE (type) == VOID_TYPE)
5990             type = global_namespace;
5991           if (TREE_CODE (type) == NAMESPACE_DECL)
5992             {
5993               val = make_node (CPLUS_BINDING);
5994               flags |= LOOKUP_COMPLAIN;
5995               if (!qualified_lookup_using_namespace (name, type, val, flags))
5996                 return NULL_TREE;
5997               val = select_decl (val, flags);
5998             }
5999           else if (! IS_AGGR_TYPE (type)
6000                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
6001                    || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
6002                    || TREE_CODE (type) == TYPENAME_TYPE)
6003             /* Someone else will give an error about this if needed.  */
6004             val = NULL_TREE;
6005           else if (type == current_class_type)
6006             val = IDENTIFIER_CLASS_VALUE (name);
6007           else
6008             {
6009               val = lookup_member (type, name, 0, prefer_type);
6010               type_access_control (type, val);
6011
6012               /* Restore the containing TYPENAME_TYPE if we looked
6013                  through it before.  */
6014               if (got_scope && got_scope != type
6015                   && val && TREE_CODE (val) == TYPE_DECL
6016                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
6017                 TYPE_CONTEXT (TREE_TYPE (val)) = got_scope;
6018             }
6019         }
6020       else
6021         val = NULL_TREE;
6022
6023       if (got_scope)
6024         goto done;
6025       else if (got_object && val)
6026         {
6027           from_obj = val;
6028           val = NULL_TREE;
6029         }
6030     }
6031   else
6032     {
6033       flags = lookup_flags (prefer_type, namespaces_only);
6034       /* If we're not parsing, we need to complain. */
6035       flags |= LOOKUP_COMPLAIN;
6036     }
6037
6038   /* First, look in non-namespace scopes.  */
6039
6040   if (current_class_type == NULL_TREE)
6041     nonclass = 1;
6042
6043   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
6044     {
6045       tree binding;
6046
6047       if (!LOCAL_BINDING_P (t) && nonclass)
6048         /* We're not looking for class-scoped bindings, so keep going.  */
6049         continue;
6050
6051       /* If this is the kind of thing we're looking for, we're done.  */
6052       if (qualify_lookup (BINDING_VALUE (t), flags))
6053         binding = BINDING_VALUE (t);
6054       else if ((flags & LOOKUP_PREFER_TYPES)
6055                && qualify_lookup (BINDING_TYPE (t), flags))
6056         binding = BINDING_TYPE (t);
6057       else
6058         binding = NULL_TREE;
6059
6060       /* Handle access control on types from enclosing or base classes.  */
6061       if (binding && ! yylex
6062           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
6063         type_access_control (BINDING_LEVEL (t)->this_class, binding);
6064
6065       if (binding
6066           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
6067         {
6068           if (val_is_implicit_typename && !yylex)
6069             warn_about_implicit_typename_lookup (val, binding);
6070           val = binding;
6071           val_is_implicit_typename
6072             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
6073           if (!val_is_implicit_typename)
6074             break;
6075         }
6076     }
6077
6078   /* Now lookup in namespace scopes.  */
6079   if (!val || val_is_implicit_typename)
6080     {
6081       t = unqualified_namespace_lookup (name, flags, 0);
6082       if (t)
6083         {
6084           if (val_is_implicit_typename && !yylex)
6085             warn_about_implicit_typename_lookup (val, t);
6086           val = t;
6087         }
6088     }
6089
6090  done:
6091   if (val)
6092     {
6093       /* This should only warn about types used in qualified-ids.  */
6094       if (from_obj && from_obj != val)
6095         {
6096           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
6097               && TREE_CODE (val) == TYPE_DECL
6098               && ! same_type_p (TREE_TYPE (from_obj), TREE_TYPE (val)))
6099             cp_pedwarn ("\
6100 lookup of `%D' in the scope of `%#T' (`%#D') \
6101 does not match lookup in the current scope (`%#D')",
6102                         name, got_object, from_obj, val);
6103
6104           /* We don't change val to from_obj if got_object depends on
6105              template parms because that breaks implicit typename for
6106              destructor calls.  */
6107           if (! uses_template_parms (got_object))
6108             val = from_obj;
6109         }
6110
6111       /* If we have a single function from a using decl, pull it out.  */
6112       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6113         val = OVL_FUNCTION (val);
6114     }
6115   else if (from_obj)
6116     val = from_obj;
6117
6118   return val;
6119 }
6120
6121 tree
6122 lookup_name_nonclass (name)
6123      tree name;
6124 {
6125   return lookup_name_real (name, 0, 1, 0);
6126 }
6127
6128 tree
6129 lookup_function_nonclass (name, args)
6130      tree name;
6131      tree args;
6132 {
6133   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6134 }
6135
6136 tree
6137 lookup_name_namespace_only (name)
6138      tree name;
6139 {
6140   /* type-or-namespace, nonclass, namespace_only */
6141   return lookup_name_real (name, 1, 1, 1);
6142 }
6143
6144 tree
6145 lookup_name (name, prefer_type)
6146      tree name;
6147      int prefer_type;
6148 {
6149   return lookup_name_real (name, prefer_type, 0, 0);
6150 }
6151
6152 /* Similar to `lookup_name' but look only in the innermost non-class
6153    binding level.  */
6154
6155 tree
6156 lookup_name_current_level (name)
6157      tree name;
6158 {
6159   struct binding_level *b;
6160   tree t = NULL_TREE;
6161
6162   b = current_binding_level;
6163   while (b->parm_flag == 2)
6164     b = b->level_chain;
6165
6166   if (b->namespace_p)
6167     {
6168       t = IDENTIFIER_NAMESPACE_VALUE (name);
6169
6170       /* extern "C" function() */
6171       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6172         t = TREE_VALUE (t);
6173     }
6174   else if (IDENTIFIER_BINDING (name)
6175            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6176     {
6177       while (1)
6178         {
6179           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6180             return IDENTIFIER_VALUE (name);
6181
6182           if (b->keep == 2)
6183             b = b->level_chain;
6184           else
6185             break;
6186         }
6187     }
6188
6189   return t;
6190 }
6191
6192 /* Like lookup_name_current_level, but for types.  */
6193
6194 tree
6195 lookup_type_current_level (name)
6196      tree name;
6197 {
6198   register tree t = NULL_TREE;
6199
6200   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6201
6202   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6203       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6204     {
6205       struct binding_level *b = current_binding_level;
6206       while (1)
6207         {
6208           if (purpose_member (name, b->type_shadowed))
6209             return REAL_IDENTIFIER_TYPE_VALUE (name);
6210           if (b->keep == 2)
6211             b = b->level_chain;
6212           else
6213             break;
6214         }
6215     }
6216
6217   return t;
6218 }
6219
6220 void
6221 begin_only_namespace_names ()
6222 {
6223   only_namespace_names = 1;
6224 }
6225
6226 void
6227 end_only_namespace_names ()
6228 {
6229   only_namespace_names = 0;
6230 }
6231 \f
6232 /* Push the declarations of builtin types into the namespace.
6233    RID_INDEX is the index of the builtin type
6234    in the array RID_POINTERS.  NAME is the name used when looking
6235    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6236
6237 void
6238 record_builtin_type (rid_index, name, type)
6239      enum rid rid_index;
6240      const char *name;
6241      tree type;
6242 {
6243   tree rname = NULL_TREE, tname = NULL_TREE;
6244   tree tdecl = NULL_TREE;
6245
6246   if ((int) rid_index < (int) RID_MAX)
6247     rname = ridpointers[(int) rid_index];
6248   if (name)
6249     tname = get_identifier (name);
6250
6251   TYPE_BUILT_IN (type) = 1;
6252
6253   if (tname)
6254     {
6255       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6256       set_identifier_type_value (tname, NULL_TREE);
6257       if ((int) rid_index < (int) RID_MAX)
6258         /* Built-in types live in the global namespace. */
6259         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6260     }
6261   if (rname != NULL_TREE)
6262     {
6263       if (tname != NULL_TREE)
6264         {
6265           set_identifier_type_value (rname, NULL_TREE);
6266           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6267         }
6268       else
6269         {
6270           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6271           set_identifier_type_value (rname, NULL_TREE);
6272         }
6273     }
6274 }
6275
6276 /* Record one of the standard Java types.
6277  * Declare it as having the given NAME.
6278  * If SIZE > 0, it is the size of one of the integral types;
6279  * otherwise it is the negative of the size of one of the other types.  */
6280
6281 static tree
6282 record_builtin_java_type (name, size)
6283      const char *name;
6284      int size;
6285 {
6286   tree type, decl;
6287   if (size > 0)
6288     type = make_signed_type (size);
6289   else if (size > -32)
6290     { /* "__java_char" or ""__java_boolean". */
6291       type = make_unsigned_type (-size);
6292       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6293     }
6294   else
6295     { /* "__java_float" or ""__java_double". */
6296       type = make_node (REAL_TYPE);
6297       TYPE_PRECISION (type) = - size;
6298       layout_type (type);
6299     }
6300   record_builtin_type (RID_MAX, name, type);
6301   decl = TYPE_NAME (type);
6302
6303   /* Suppress generate debug symbol entries for these types,
6304      since for normal C++ they are just clutter.
6305      However, push_lang_context undoes this if extern "Java" is seen. */
6306   DECL_IGNORED_P (decl) = 1;
6307
6308   TYPE_FOR_JAVA (type) = 1;
6309   return type;
6310 }
6311
6312 /* Push a type into the namespace so that the back-ends ignore it. */
6313
6314 static void
6315 record_unknown_type (type, name)
6316      tree type;
6317      const char *name;
6318 {
6319   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6320   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6321   DECL_IGNORED_P (decl) = 1;
6322   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6323   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6324   TYPE_ALIGN (type) = 1;
6325   TYPE_USER_ALIGN (type) = 0;
6326   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6327 }
6328
6329 /* An string for which we should create an IDENTIFIER_NODE at
6330    startup.  */
6331
6332 typedef struct predefined_identifier
6333 {
6334   /* The name of the identifier.  */
6335   const char *const name;
6336   /* The place where the IDENTIFIER_NODE should be stored.  */
6337   tree *const node;
6338   /* Non-zero if this is the name of a constructor or destructor.  */
6339   const int ctor_or_dtor_p;
6340 } predefined_identifier;
6341
6342 /* Create all the predefined identifiers.  */
6343
6344 static void
6345 initialize_predefined_identifiers ()
6346 {
6347   const predefined_identifier *pid;
6348
6349   /* A table of identifiers to create at startup.  */
6350   static const predefined_identifier predefined_identifiers[] = {
6351     { "C++", &lang_name_cplusplus, 0 },
6352     { "C", &lang_name_c, 0 },
6353     { "Java", &lang_name_java, 0 },
6354     { CTOR_NAME, &ctor_identifier, 1 },
6355     { "__base_ctor", &base_ctor_identifier, 1 },
6356     { "__comp_ctor", &complete_ctor_identifier, 1 },
6357     { DTOR_NAME, &dtor_identifier, 1 },
6358     { "__comp_dtor", &complete_dtor_identifier, 1 },
6359     { "__base_dtor", &base_dtor_identifier, 1 },
6360     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6361     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6362     { "nelts", &nelts_identifier, 0 },
6363     { THIS_NAME, &this_identifier, 0 },
6364     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6365     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6366     { "_vptr", &vptr_identifier, 0 },
6367     { "__vtt_parm", &vtt_parm_identifier, 0 },
6368     { "std", &std_identifier, 0 },
6369     { NULL, NULL, 0 }
6370   };
6371
6372   for (pid = predefined_identifiers; pid->name; ++pid)
6373     {
6374       *pid->node = get_identifier (pid->name);
6375       if (pid->ctor_or_dtor_p)
6376         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6377     }
6378 }
6379
6380 /* Create the predefined scalar types of C,
6381    and some nodes representing standard constants (0, 1, (void *)0).
6382    Initialize the global binding level.
6383    Make definitions for built-in primitive functions.  */
6384
6385 void
6386 cxx_init_decl_processing ()
6387 {
6388   tree void_ftype;
6389   tree void_ftype_ptr;
6390
6391   /* Create all the identifiers we need.  */
6392   initialize_predefined_identifiers ();
6393
6394   /* Fill in back-end hooks.  */
6395   init_lang_status = &push_cp_function_context;
6396   free_lang_status = &pop_cp_function_context;
6397   mark_lang_status = &mark_cp_function_context;
6398   lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
6399
6400   cp_parse_init ();
6401   init_decl2 ();
6402   init_pt ();
6403
6404   /* Create the global variables.  */
6405   push_to_top_level ();
6406
6407   /* Enter the global namespace. */
6408   my_friendly_assert (global_namespace == NULL_TREE, 375);
6409   push_namespace (get_identifier ("::"));
6410   global_namespace = current_namespace;
6411   current_lang_name = NULL_TREE;
6412
6413   /* Adjust various flags based on command-line settings.  */
6414   if (! flag_permissive && ! pedantic)
6415     flag_pedantic_errors = 1;
6416   if (!flag_no_inline)
6417     {
6418       flag_inline_trees = 1;
6419       flag_no_inline = 1;
6420     }
6421   if (flag_inline_functions)
6422     {
6423       flag_inline_trees = 2;
6424       flag_inline_functions = 0;
6425     }
6426
6427   /* In C++, we never create builtin functions whose name does not
6428      begin with `__'.  Users should be using headers to get prototypes
6429      in C++.  It would be nice if we could warn when `-fbuiltin' is
6430      used explicitly, but we do not have that information.  */
6431   flag_no_builtin = 1;
6432
6433   /* Initially, C.  */
6434   current_lang_name = lang_name_c;
6435
6436   current_function_decl = NULL_TREE;
6437   current_binding_level = NULL_BINDING_LEVEL;
6438   free_binding_level = NULL_BINDING_LEVEL;
6439
6440   build_common_tree_nodes (flag_signed_char);
6441
6442   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6443   TREE_TYPE (error_mark_list) = error_mark_node;
6444
6445   /* Make the binding_level structure for global names.  */
6446   pushlevel (0);
6447   global_binding_level = current_binding_level;
6448   /* The global level is the namespace level of ::.  */
6449   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6450   declare_namespace_level ();
6451
6452   /* Create the `std' namespace.  */
6453   push_namespace (std_identifier);
6454   std_node = current_namespace;
6455   pop_namespace ();
6456
6457   lang_attribute_table = cp_attribute_table;
6458
6459   c_common_nodes_and_builtins ();
6460
6461   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6462   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6463   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6464   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6465   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6466   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6467   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6468   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6469
6470   integer_two_node = build_int_2 (2, 0);
6471   TREE_TYPE (integer_two_node) = integer_type_node;
6472   integer_three_node = build_int_2 (3, 0);
6473   TREE_TYPE (integer_three_node) = integer_type_node;
6474
6475   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6476   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6477   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6478   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6479   TYPE_PRECISION (boolean_type_node) = 1;
6480   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6481   boolean_false_node = build_int_2 (0, 0);
6482   TREE_TYPE (boolean_false_node) = boolean_type_node;
6483   boolean_true_node = build_int_2 (1, 0);
6484   TREE_TYPE (boolean_true_node) = boolean_type_node;
6485
6486   signed_size_zero_node = build_int_2 (0, 0);
6487   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6488
6489   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6490
6491 #if 0
6492   record_builtin_type (RID_MAX, NULL, string_type_node);
6493 #endif
6494
6495   delta_type_node = ptrdiff_type_node;
6496   vtable_index_type = ptrdiff_type_node;
6497
6498   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6499   lang_type_promotes_to = convert_type_from_ellipsis;
6500
6501   void_ftype = build_function_type (void_type_node, void_list_node);
6502   void_ftype_ptr = build_function_type (void_type_node,
6503                                         tree_cons (NULL_TREE,
6504                                                    ptr_type_node,
6505                                                    void_list_node));
6506   void_ftype_ptr
6507     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6508
6509   /* C++ extensions */
6510
6511   unknown_type_node = make_node (UNKNOWN_TYPE);
6512   record_unknown_type (unknown_type_node, "unknown type");
6513
6514   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6515   TREE_TYPE (unknown_type_node) = unknown_type_node;
6516
6517   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6518      result.  */
6519   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6520   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6521
6522   {
6523     /* Make sure we get a unique function type, so we can give
6524        its pointer type a name.  (This wins for gdb.) */
6525     tree vfunc_type = make_node (FUNCTION_TYPE);
6526     TREE_TYPE (vfunc_type) = integer_type_node;
6527     TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6528     layout_type (vfunc_type);
6529
6530     vtable_entry_type = build_pointer_type (vfunc_type);
6531   }
6532   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6533
6534   vtbl_type_node
6535     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6536   layout_type (vtbl_type_node);
6537   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6538   record_builtin_type (RID_MAX, NULL, vtbl_type_node);
6539   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6540   layout_type (vtbl_ptr_type_node);
6541   record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
6542
6543   push_namespace (get_identifier ("__cxxabiv1"));
6544   abi_node = current_namespace;
6545   pop_namespace ();
6546
6547   global_type_node = make_node (LANG_TYPE);
6548   record_unknown_type (global_type_node, "global type");
6549
6550   /* Now, C++.  */
6551   current_lang_name = lang_name_cplusplus;
6552
6553   {
6554     tree bad_alloc_type_node, newtype, deltype;
6555     tree ptr_ftype_sizetype;
6556
6557     push_namespace (std_identifier);
6558     bad_alloc_type_node = xref_tag
6559       (class_type_node, get_identifier ("bad_alloc"), 1);
6560     pop_namespace ();
6561     ptr_ftype_sizetype
6562       = build_function_type (ptr_type_node,
6563                              tree_cons (NULL_TREE,
6564                                         c_size_type_node,
6565                                         void_list_node));
6566     newtype = build_exception_variant
6567       (ptr_ftype_sizetype, add_exception_specifier
6568        (NULL_TREE, bad_alloc_type_node, -1));
6569     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6570     push_cp_library_fn (NEW_EXPR, newtype);
6571     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6572     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6573     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6574   }
6575
6576   abort_fndecl
6577     = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
6578
6579   /* Perform other language dependent initializations.  */
6580   init_class_processing ();
6581   init_init_processing ();
6582   init_search_processing ();
6583   init_rtti_processing ();
6584
6585   if (flag_exceptions)
6586     init_exception_processing ();
6587
6588   if (! supports_one_only ())
6589     flag_weak = 0;
6590
6591   make_fname_decl = cp_make_fname_decl;
6592   start_fname_decls ();
6593
6594   /* Show we use EH for cleanups.  */
6595   using_eh_for_cleanups ();
6596
6597   /* Maintain consistency.  Perhaps we should just complain if they
6598      say -fwritable-strings?  */
6599   if (flag_writable_strings)
6600     flag_const_strings = 0;
6601
6602   /* Add GC roots for all of our global variables.  */
6603   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6604   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6605   ggc_add_tree_root (&integer_three_node, 1);
6606   ggc_add_tree_root (&integer_two_node, 1);
6607   ggc_add_tree_root (&signed_size_zero_node, 1);
6608   ggc_add_tree_root (&size_one_node, 1);
6609   ggc_add_tree_root (&size_zero_node, 1);
6610   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6611                 mark_binding_level);
6612   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6613   ggc_add_tree_root (&static_ctors, 1);
6614   ggc_add_tree_root (&static_dtors, 1);
6615   ggc_add_tree_root (&lastiddecl, 1);
6616
6617   ggc_add_tree_root (&last_function_parms, 1);
6618   ggc_add_tree_root (&error_mark_list, 1);
6619
6620   ggc_add_tree_root (&global_namespace, 1);
6621   ggc_add_tree_root (&global_type_node, 1);
6622   ggc_add_tree_root (&anonymous_namespace_name, 1);
6623
6624   ggc_add_tree_root (&got_object, 1);
6625   ggc_add_tree_root (&got_scope, 1);
6626
6627   ggc_add_tree_root (&current_lang_name, 1);
6628   ggc_add_tree_root (&static_aggregates, 1);
6629   ggc_add_tree_root (&free_bindings, 1);
6630 }
6631
6632 /* Generate an initializer for a function naming variable from
6633    NAME. NAME may be NULL, in which case we generate a special
6634    ERROR_MARK node which should be replaced later. */
6635
6636 tree
6637 cp_fname_init (name)
6638      const char *name;
6639 {
6640   tree domain = NULL_TREE;
6641   tree type;
6642   tree init = NULL_TREE;
6643   size_t length = 0;
6644
6645   if (name)
6646     {
6647       length = strlen (name);
6648       domain = build_index_type (size_int (length));
6649       init = build_string (length + 1, name);
6650     }
6651
6652   type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
6653   type = build_cplus_array_type (type, domain);
6654
6655   if (init)
6656     TREE_TYPE (init) = type;
6657   else
6658     /* We don't know the value until instantiation time. Make
6659        something which will be digested now, but replaced later. */
6660     init = build (ERROR_MARK, type);
6661
6662   return init;
6663 }
6664
6665 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6666    decl, NAME is the initialization string and TYPE_DEP indicates whether
6667    NAME depended on the type of the function. We make use of that to detect
6668    __PRETTY_FUNCTION__ inside a template fn. This is being done
6669    lazily at the point of first use, so we musn't push the decl now.  */
6670
6671 static tree
6672 cp_make_fname_decl (id, type_dep)
6673      tree id;
6674      int type_dep;
6675 {
6676   const char *const name = (type_dep && processing_template_decl
6677                       ? NULL : fname_as_string (type_dep));
6678   tree init = cp_fname_init (name);
6679   tree decl = build_decl (VAR_DECL, id, TREE_TYPE (init));
6680
6681   /* As we don't push the decl here, we must set the context. */
6682   DECL_CONTEXT (decl) = current_function_decl;
6683   DECL_PRETTY_FUNCTION_P (decl) = type_dep;
6684
6685   TREE_STATIC (decl) = 1;
6686   TREE_READONLY (decl) = 1;
6687   DECL_ARTIFICIAL (decl) = 1;
6688   DECL_INITIAL (decl) = init;
6689
6690   TREE_USED (decl) = 1;
6691
6692   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6693
6694   return decl;
6695 }
6696
6697 /* Entry point for the benefit of c_common_nodes_and_builtins.
6698
6699    Make a definition for a builtin function named NAME and whose data type
6700    is TYPE.  TYPE should be a function type with argument types.
6701
6702    CLASS and CODE tell later passes how to compile calls to this function.
6703    See tree.h for possible values.
6704
6705    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6706    the name to be called if we can't opencode the function.  */
6707
6708 tree
6709 builtin_function (name, type, code, class, libname)
6710      const char *name;
6711      tree type;
6712      int code;
6713      enum built_in_class class;
6714      const char *libname;
6715 {
6716   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6717   DECL_BUILT_IN_CLASS (decl) = class;
6718   DECL_FUNCTION_CODE (decl) = code;
6719
6720   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6721
6722   /* All builtins that don't begin with an `_' should go in the `std'
6723      namespace.  */
6724   if (name[0] != '_')
6725     {
6726       push_namespace (std_identifier);
6727       DECL_CONTEXT (decl) = std_node;
6728     }
6729   pushdecl (decl);
6730   if (name[0] != '_')
6731     pop_namespace ();
6732
6733   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6734      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6735      function in the namespace.  */
6736   if (libname)
6737     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
6738   make_decl_rtl (decl, NULL);
6739
6740   /* Warn if a function in the namespace for users
6741      is used without an occasion to consider it declared.  */
6742   if (name[0] != '_' || name[1] != '_')
6743     DECL_ANTICIPATED (decl) = 1;
6744
6745   /* Possibly apply some default attributes to this built-in function.  */
6746   decl_attributes (&decl, NULL_TREE, 0);
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
6871 /* Apply default attributes to a function, if a system function with default
6872    attributes.  */
6873
6874 void
6875 insert_default_attributes (decl)
6876      tree decl;
6877 {
6878   if (!DECL_EXTERN_C_FUNCTION_P (decl))
6879     return;
6880   if (!TREE_PUBLIC (decl))
6881     return;
6882   c_common_insert_default_attributes (decl);
6883 }
6884 \f
6885 /* When we call finish_struct for an anonymous union, we create
6886    default copy constructors and such.  But, an anonymous union
6887    shouldn't have such things; this function undoes the damage to the
6888    anonymous union type T.
6889
6890    (The reason that we create the synthesized methods is that we don't
6891    distinguish `union { int i; }' from `typedef union { int i; } U'.
6892    The first is an anonymous union; the second is just an ordinary
6893    union type.)  */
6894
6895 void
6896 fixup_anonymous_aggr (t)
6897      tree t;
6898 {
6899   tree *q;
6900
6901   /* Wipe out memory of synthesized methods */
6902   TYPE_HAS_CONSTRUCTOR (t) = 0;
6903   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6904   TYPE_HAS_INIT_REF (t) = 0;
6905   TYPE_HAS_CONST_INIT_REF (t) = 0;
6906   TYPE_HAS_ASSIGN_REF (t) = 0;
6907   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6908
6909   /* Splice the implicitly generated functions out of the TYPE_METHODS
6910      list.  */
6911   q = &TYPE_METHODS (t);
6912   while (*q)
6913     {
6914       if (DECL_ARTIFICIAL (*q))
6915         *q = TREE_CHAIN (*q);
6916       else
6917         q = &TREE_CHAIN (*q);
6918     }
6919
6920   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6921   if (TYPE_METHODS (t))
6922     cp_error_at ("an anonymous union cannot have function members", t);
6923
6924   /* Anonymous aggregates cannot have fields with ctors, dtors or complex
6925      assignment operators (because they cannot have these methods themselves).
6926      For anonymous unions this is already checked because they are not allowed
6927      in any union, otherwise we have to check it.  */
6928   if (TREE_CODE (t) != UNION_TYPE)
6929     {
6930       tree field, type;
6931
6932       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
6933         if (TREE_CODE (field) == FIELD_DECL)
6934           {
6935             type = TREE_TYPE (field);
6936             if (CLASS_TYPE_P (type))
6937               {
6938                 if (TYPE_NEEDS_CONSTRUCTING (type))
6939                   cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
6940                                field);
6941                 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6942                   cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
6943                                field);
6944                 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
6945                   cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
6946                                field);
6947               }
6948           }
6949     }
6950 }
6951
6952 /* Make sure that a declaration with no declarator is well-formed, i.e.
6953    just defines a tagged type or anonymous union.
6954
6955    Returns the type defined, if any.  */
6956
6957 tree
6958 check_tag_decl (declspecs)
6959      tree declspecs;
6960 {
6961   int found_type = 0;
6962   int saw_friend = 0;
6963   int saw_typedef = 0;
6964   tree ob_modifier = NULL_TREE;
6965   register tree link;
6966   register tree t = NULL_TREE;
6967
6968   for (link = declspecs; link; link = TREE_CHAIN (link))
6969     {
6970       register tree value = TREE_VALUE (link);
6971
6972       if (TYPE_P (value)
6973           || TREE_CODE (value) == TYPE_DECL
6974           || (TREE_CODE (value) == IDENTIFIER_NODE
6975               && IDENTIFIER_GLOBAL_VALUE (value)
6976               && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value)) == TYPE_DECL))
6977         {
6978           ++found_type;
6979
6980           if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
6981             {
6982               if (! in_system_header)
6983                 cp_pedwarn ("redeclaration of C++ built-in type `%T'", value);
6984               return NULL_TREE;
6985             }
6986
6987           if (TYPE_P (value)
6988               && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
6989                   || TREE_CODE (value) == ENUMERAL_TYPE))
6990             {
6991               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6992               t = value;
6993             }
6994         }
6995       else if (value == ridpointers[(int) RID_TYPEDEF])
6996         saw_typedef = 1;
6997       else if (value == ridpointers[(int) RID_FRIEND])
6998         {
6999           if (current_class_type == NULL_TREE
7000               || current_scope () != current_class_type)
7001             ob_modifier = value;
7002           else
7003             saw_friend = 1;
7004         }
7005       else if (value == ridpointers[(int) RID_STATIC]
7006                || value == ridpointers[(int) RID_EXTERN]
7007                || value == ridpointers[(int) RID_AUTO]
7008                || value == ridpointers[(int) RID_REGISTER]
7009                || value == ridpointers[(int) RID_INLINE]
7010                || value == ridpointers[(int) RID_VIRTUAL]
7011                || value == ridpointers[(int) RID_CONST]
7012                || value == ridpointers[(int) RID_VOLATILE]
7013                || value == ridpointers[(int) RID_EXPLICIT])
7014         ob_modifier = value;
7015     }
7016
7017   if (found_type > 1)
7018     error ("multiple types in one declaration");
7019
7020   if (t == NULL_TREE && ! saw_friend)
7021     pedwarn ("declaration does not declare anything");
7022
7023   /* Check for an anonymous union.  */
7024   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7025            && TYPE_ANONYMOUS_P (t))
7026     {
7027       /* 7/3 In a simple-declaration, the optional init-declarator-list
7028          can be omitted only when declaring a class (clause 9) or
7029          enumeration (7.2), that is, when the decl-specifier-seq contains
7030          either a class-specifier, an elaborated-type-specifier with
7031          a class-key (9.1), or an enum-specifier.  In these cases and
7032          whenever a class-specifier or enum-specifier is present in the
7033          decl-specifier-seq, the identifiers in these specifiers are among
7034          the names being declared by the declaration (as class-name,
7035          enum-names, or enumerators, depending on the syntax).  In such
7036          cases, and except for the declaration of an unnamed bit-field (9.6),
7037          the decl-specifier-seq shall introduce one or more names into the
7038          program, or shall redeclare a name introduced by a previous
7039          declaration.  [Example:
7040              enum { };            // ill-formed
7041              typedef class { };   // ill-formed
7042          --end example]  */
7043       if (saw_typedef)
7044         {
7045           error ("missing type-name in typedef-declaration");
7046           return NULL_TREE;
7047         }
7048       /* Anonymous unions are objects, so they can have specifiers.  */;
7049       SET_ANON_AGGR_TYPE_P (t);
7050
7051       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7052         pedwarn ("ISO C++ prohibits anonymous structs");
7053     }
7054
7055   else if (ob_modifier)
7056     {
7057       if (ob_modifier == ridpointers[(int) RID_INLINE]
7058           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7059         cp_error ("`%D' can only be specified for functions", ob_modifier);
7060       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7061         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7062       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7063         cp_error ("`%D' can only be specified for constructors",
7064                   ob_modifier);
7065       else
7066         cp_error ("`%D' can only be specified for objects and functions",
7067                   ob_modifier);
7068     }
7069
7070   return t;
7071 }
7072
7073 /* Called when a declaration is seen that contains no names to declare.
7074    If its type is a reference to a structure, union or enum inherited
7075    from a containing scope, shadow that tag name for the current scope
7076    with a forward reference.
7077    If its type defines a new named structure or union
7078    or defines an enum, it is valid but we need not do anything here.
7079    Otherwise, it is an error.
7080
7081    C++: may have to grok the declspecs to learn about static,
7082    complain for anonymous unions.  */
7083
7084 void
7085 shadow_tag (declspecs)
7086      tree declspecs;
7087 {
7088   tree t = check_tag_decl (declspecs);
7089
7090   if (t)
7091     maybe_process_partial_specialization (t);
7092
7093   /* This is where the variables in an anonymous union are
7094      declared.  An anonymous union declaration looks like:
7095      union { ... } ;
7096      because there is no declarator after the union, the parser
7097      sends that declaration here.  */
7098   if (t && ANON_AGGR_TYPE_P (t))
7099     {
7100       fixup_anonymous_aggr (t);
7101
7102       if (TYPE_FIELDS (t))
7103         {
7104           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7105                                       NULL);
7106           finish_anon_union (decl);
7107         }
7108     }
7109 }
7110 \f
7111 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7112
7113 tree
7114 groktypename (typename)
7115      tree typename;
7116 {
7117   if (TREE_CODE (typename) != TREE_LIST)
7118     return typename;
7119   return grokdeclarator (TREE_VALUE (typename),
7120                          TREE_PURPOSE (typename),
7121                          TYPENAME, 0, NULL);
7122 }
7123
7124 /* Decode a declarator in an ordinary declaration or data definition.
7125    This is called as soon as the type information and variable name
7126    have been parsed, before parsing the initializer if any.
7127    Here we create the ..._DECL node, fill in its type,
7128    and put it on the list of decls for the current context.
7129    The ..._DECL node is returned as the value.
7130
7131    Exception: for arrays where the length is not specified,
7132    the type is left null, to be filled in by `cp_finish_decl'.
7133
7134    Function definitions do not come here; they go to start_function
7135    instead.  However, external and forward declarations of functions
7136    do go through here.  Structure field declarations are done by
7137    grokfield and not through here.  */
7138
7139 tree
7140 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7141      tree declarator, declspecs;
7142      int initialized;
7143      tree attributes, prefix_attributes;
7144 {
7145   tree decl;
7146   register tree type, tem;
7147   tree context;
7148   extern int have_extern_spec;
7149   extern int used_extern_spec;
7150
7151 #if 0
7152   /* See code below that used this.  */
7153   int init_written = initialized;
7154 #endif
7155
7156   /* This should only be done once on the top most decl.  */
7157   if (have_extern_spec && !used_extern_spec)
7158     {
7159       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7160                              declspecs);
7161       used_extern_spec = 1;
7162     }
7163
7164   attributes = chainon (attributes, prefix_attributes);
7165
7166   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7167                          &attributes);
7168
7169   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7170     return NULL_TREE;
7171
7172   type = TREE_TYPE (decl);
7173
7174   if (type == error_mark_node)
7175     return NULL_TREE;
7176
7177   context = DECL_CONTEXT (decl);
7178
7179   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7180       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7181     {
7182       /* When parsing the initializer, lookup should use the object's
7183          namespace. */
7184       push_decl_namespace (context);
7185     }
7186
7187   /* We are only interested in class contexts, later. */
7188   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7189     context = NULL_TREE;
7190
7191   if (initialized)
7192     /* Is it valid for this decl to have an initializer at all?
7193        If not, set INITIALIZED to zero, which will indirectly
7194        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7195     switch (TREE_CODE (decl))
7196       {
7197       case TYPE_DECL:
7198         /* typedef foo = bar  means give foo the same type as bar.
7199            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7200            Any other case of an initialization in a TYPE_DECL is an error.  */
7201         if (pedantic || list_length (declspecs) > 1)
7202           {
7203             cp_error ("typedef `%D' is initialized", decl);
7204             initialized = 0;
7205           }
7206         break;
7207
7208       case FUNCTION_DECL:
7209         cp_error ("function `%#D' is initialized like a variable", decl);
7210         initialized = 0;
7211         break;
7212
7213       default:
7214         break;
7215       }
7216
7217   if (initialized)
7218     {
7219       if (! toplevel_bindings_p ()
7220           && DECL_EXTERNAL (decl))
7221         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7222                     decl);
7223       DECL_EXTERNAL (decl) = 0;
7224       if (toplevel_bindings_p ())
7225         TREE_STATIC (decl) = 1;
7226
7227       /* Tell `pushdecl' this is an initialized decl
7228          even though we don't yet have the initializer expression.
7229          Also tell `cp_finish_decl' it may store the real initializer.  */
7230       DECL_INITIAL (decl) = error_mark_node;
7231     }
7232
7233   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7234   cplus_decl_attributes (&decl, attributes, 0);
7235
7236   if (TREE_CODE (decl) == FUNCTION_DECL
7237       && DECL_DECLARED_INLINE_P (decl)
7238       && DECL_UNINLINABLE (decl)
7239       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
7240     warning_with_decl (decl,
7241                        "inline function `%s' given attribute noinline");
7242
7243   if (context && COMPLETE_TYPE_P (complete_type (context)))
7244     {
7245       push_nested_class (context, 2);
7246
7247       if (TREE_CODE (decl) == VAR_DECL)
7248         {
7249           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7250           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7251             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7252           else
7253             {
7254               if (DECL_CONTEXT (field) != context)
7255                 {
7256                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7257                               DECL_CONTEXT (field), DECL_NAME (decl),
7258                               context, DECL_NAME (decl));
7259                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7260                 }
7261               /* Static data member are tricky; an in-class initialization
7262                  still doesn't provide a definition, so the in-class
7263                  declaration will have DECL_EXTERNAL set, but will have an
7264                  initialization.  Thus, duplicate_decls won't warn
7265                  about this situation, and so we check here.  */
7266               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7267                 cp_error ("duplicate initialization of %D", decl);
7268               if (duplicate_decls (decl, field))
7269                 decl = field;
7270             }
7271         }
7272       else
7273         {
7274           tree field = check_classfn (context, decl);
7275           if (field && duplicate_decls (decl, field))
7276             decl = field;
7277         }
7278
7279       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7280       DECL_IN_AGGR_P (decl) = 0;
7281       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7282           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7283         {
7284           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7285           /* [temp.expl.spec] An explicit specialization of a static data
7286              member of a template is a definition if the declaration
7287              includes an initializer; otherwise, it is a declaration.
7288
7289              We check for processing_specialization so this only applies
7290              to the new specialization syntax.  */
7291           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7292             DECL_EXTERNAL (decl) = 1;
7293         }
7294
7295       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7296         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7297                     decl);
7298     }
7299
7300   /* Enter this declaration into the symbol table.  */
7301   tem = maybe_push_decl (decl);
7302
7303   if (processing_template_decl)
7304     tem = push_template_decl (tem);
7305
7306 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7307   /* Tell the back-end to use or not use .common as appropriate.  If we say
7308      -fconserve-space, we want this to save .data space, at the expense of
7309      wrong semantics.  If we say -fno-conserve-space, we want this to
7310      produce errors about redefs; to do this we force variables into the
7311      data segment.  */
7312   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7313 #endif
7314
7315   if (! processing_template_decl)
7316     start_decl_1 (tem);
7317
7318   return tem;
7319 }
7320
7321 void
7322 start_decl_1 (decl)
7323      tree decl;
7324 {
7325   tree type = TREE_TYPE (decl);
7326   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7327
7328   if (type == error_mark_node)
7329     return;
7330
7331   maybe_push_cleanup_level (type);
7332
7333   if (initialized)
7334     /* Is it valid for this decl to have an initializer at all?
7335        If not, set INITIALIZED to zero, which will indirectly
7336        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7337     {
7338       /* Don't allow initializations for incomplete types except for
7339          arrays which might be completed by the initialization.  */
7340       if (COMPLETE_TYPE_P (complete_type (type)))
7341         ;                       /* A complete type is ok.  */
7342       else if (TREE_CODE (type) != ARRAY_TYPE)
7343         {
7344           cp_error ("variable `%#D' has initializer but incomplete type",
7345                     decl);
7346           initialized = 0;
7347           type = TREE_TYPE (decl) = error_mark_node;
7348         }
7349       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7350         {
7351           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7352             cp_error ("elements of array `%#D' have incomplete type", decl);
7353           /* else we already gave an error in start_decl.  */
7354           initialized = 0;
7355         }
7356     }
7357
7358   if (!initialized
7359       && TREE_CODE (decl) != TYPE_DECL
7360       && TREE_CODE (decl) != TEMPLATE_DECL
7361       && type != error_mark_node
7362       && IS_AGGR_TYPE (type)
7363       && ! DECL_EXTERNAL (decl))
7364     {
7365       if ((! processing_template_decl || ! uses_template_parms (type))
7366           && !COMPLETE_TYPE_P (complete_type (type)))
7367         {
7368           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7369                  decl);
7370           /* Change the type so that assemble_variable will give
7371              DECL an rtl we can live with: (mem (const_int 0)).  */
7372           type = TREE_TYPE (decl) = error_mark_node;
7373         }
7374       else
7375         {
7376           /* If any base type in the hierarchy of TYPE needs a constructor,
7377              then we set initialized to 1.  This way any nodes which are
7378              created for the purposes of initializing this aggregate
7379              will live as long as it does.  This is necessary for global
7380              aggregates which do not have their initializers processed until
7381              the end of the file.  */
7382           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7383         }
7384     }
7385
7386   if (! initialized)
7387     DECL_INITIAL (decl) = NULL_TREE;
7388 }
7389
7390 /* Handle initialization of references.
7391    These three arguments are from `cp_finish_decl', and have the
7392    same meaning here that they do there.
7393
7394    Quotes on semantics can be found in ARM 8.4.3.  */
7395
7396 static tree
7397 grok_reference_init (decl, type, init)
7398      tree decl, type, init;
7399 {
7400   tree tmp;
7401
7402   if (init == NULL_TREE)
7403     {
7404       if ((DECL_LANG_SPECIFIC (decl) == 0
7405            || DECL_IN_AGGR_P (decl) == 0)
7406           && ! DECL_THIS_EXTERN (decl))
7407         cp_error ("`%D' declared as reference but not initialized", decl);
7408       return NULL_TREE;
7409     }
7410
7411   if (init == error_mark_node)
7412     return NULL_TREE;
7413
7414   if (TREE_CODE (init) == CONSTRUCTOR)
7415     {
7416       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7417       return NULL_TREE;
7418     }
7419
7420   if (TREE_CODE (init) == TREE_LIST)
7421     init = build_compound_expr (init);
7422
7423   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7424     init = convert_from_reference (init);
7425
7426   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7427       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7428     {
7429       /* Note: default conversion is only called in very special cases.  */
7430       init = default_conversion (init);
7431     }
7432
7433   /* Convert INIT to the reference type TYPE.  This may involve the
7434      creation of a temporary, whose lifetime must be the same as that
7435      of the reference.  If so, a DECL_STMT for the temporary will be
7436      added just after the DECL_STMT for DECL.  That's why we don't set
7437      DECL_INITIAL for local references (instead assigning to them
7438      explicitly); we need to allow the temporary to be initialized
7439      first.  */
7440   tmp = convert_to_reference
7441     (type, init, CONV_IMPLICIT,
7442      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7443      decl);
7444
7445   if (tmp == error_mark_node)
7446     return NULL_TREE;
7447   else if (tmp == NULL_TREE)
7448     {
7449       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7450       return NULL_TREE;
7451     }
7452
7453   if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
7454     return tmp;
7455
7456   DECL_INITIAL (decl) = tmp;
7457
7458   return NULL_TREE;
7459 }
7460
7461 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7462    mucking with forces it does not comprehend (i.e. initialization with a
7463    constructor).  If we are at global scope and won't go into COMMON, fill
7464    it in with a dummy CONSTRUCTOR to force the variable into .data;
7465    otherwise we can use error_mark_node.  */
7466
7467 static tree
7468 obscure_complex_init (decl, init)
7469      tree decl, init;
7470 {
7471   if (! flag_no_inline && TREE_STATIC (decl))
7472     {
7473       if (extract_init (decl, init))
7474         return NULL_TREE;
7475     }
7476
7477 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7478   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7479     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7480                                  NULL_TREE);
7481   else
7482 #endif
7483     DECL_INITIAL (decl) = error_mark_node;
7484
7485   return init;
7486 }
7487
7488 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7489    array until we finish parsing the initializer.  If that's the
7490    situation we're in, update DECL accordingly.  */
7491
7492 static void
7493 maybe_deduce_size_from_array_init (decl, init)
7494      tree decl;
7495      tree init;
7496 {
7497   tree type = TREE_TYPE (decl);
7498
7499   if (TREE_CODE (type) == ARRAY_TYPE
7500       && TYPE_DOMAIN (type) == NULL_TREE
7501       && TREE_CODE (decl) != TYPE_DECL)
7502     {
7503       /* do_default is really a C-ism to deal with tentative definitions.
7504          But let's leave it here to ease the eventual merge.  */
7505       int do_default = !DECL_EXTERNAL (decl);
7506       tree initializer = init ? init : DECL_INITIAL (decl);
7507       int failure = complete_array_type (type, initializer, do_default);
7508
7509       if (failure == 1)
7510         cp_error ("initializer fails to determine size of `%D'", decl);
7511
7512       if (failure == 2)
7513         {
7514           if (do_default)
7515             cp_error ("array size missing in `%D'", decl);
7516           /* If a `static' var's size isn't known, make it extern as
7517              well as static, so it does not get allocated.  If it's not
7518              `static', then don't mark it extern; finish_incomplete_decl
7519              will give it a default size and it will get allocated.  */
7520           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7521             DECL_EXTERNAL (decl) = 1;
7522         }
7523
7524       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7525           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7526                               integer_zero_node))
7527         cp_error ("zero-size array `%D'", decl);
7528
7529       layout_decl (decl, 0);
7530     }
7531 }
7532
7533 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7534    any appropriate error messages regarding the layout.  */
7535
7536 static void
7537 layout_var_decl (decl)
7538      tree decl;
7539 {
7540   tree type = TREE_TYPE (decl);
7541 #if 0
7542   tree ttype = target_type (type);
7543 #endif
7544
7545   /* If we haven't already layed out this declaration, do so now.
7546      Note that we must not call complete type for an external object
7547      because it's type might involve templates that we are not
7548      supposed to isntantiate yet.  (And it's perfectly legal to say
7549      `extern X x' for some incomplete type `X'.)  */
7550   if (!DECL_EXTERNAL (decl))
7551     complete_type (type);
7552   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7553     layout_decl (decl, 0);
7554
7555   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7556     {
7557       /* An automatic variable with an incomplete type: that is an error.
7558          Don't talk about array types here, since we took care of that
7559          message in grokdeclarator.  */
7560       cp_error ("storage size of `%D' isn't known", decl);
7561       TREE_TYPE (decl) = error_mark_node;
7562     }
7563 #if 0
7564   /* Keep this code around in case we later want to control debug info
7565      based on whether a type is "used".  (jason 1999-11-11) */
7566
7567   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7568     /* Let debugger know it should output info for this type.  */
7569     note_debug_info_needed (ttype);
7570
7571   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7572     note_debug_info_needed (DECL_CONTEXT (decl));
7573 #endif
7574
7575   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7576       && DECL_SIZE (decl) != NULL_TREE
7577       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7578     {
7579       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7580         constant_expression_warning (DECL_SIZE (decl));
7581       else
7582         cp_error ("storage size of `%D' isn't constant", decl);
7583     }
7584
7585   if (TREE_STATIC (decl)
7586       && !DECL_ARTIFICIAL (decl)
7587       && current_function_decl
7588       && DECL_CONTEXT (decl) == current_function_decl)
7589     push_local_name (decl);
7590 }
7591
7592 /* If a local static variable is declared in an inline function, or if
7593    we have a weak definition, we must endeavor to create only one
7594    instance of the variable at link-time.  */
7595
7596 static void
7597 maybe_commonize_var (decl)
7598      tree decl;
7599 {
7600   /* Static data in a function with comdat linkage also has comdat
7601      linkage.  */
7602   if (TREE_STATIC (decl)
7603       /* Don't mess with __FUNCTION__.  */
7604       && ! DECL_ARTIFICIAL (decl)
7605       && current_function_decl
7606       && DECL_CONTEXT (decl) == current_function_decl
7607       && (DECL_DECLARED_INLINE_P (current_function_decl)
7608           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7609       && TREE_PUBLIC (current_function_decl))
7610     {
7611       /* If flag_weak, we don't need to mess with this, as we can just
7612          make the function weak, and let it refer to its unique local
7613          copy.  This works because we don't allow the function to be
7614          inlined.  */
7615       if (! flag_weak)
7616         {
7617           if (DECL_INTERFACE_KNOWN (current_function_decl))
7618             {
7619               TREE_PUBLIC (decl) = 1;
7620               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7621             }
7622           else if (DECL_INITIAL (decl) == NULL_TREE
7623                    || DECL_INITIAL (decl) == error_mark_node)
7624             {
7625               TREE_PUBLIC (decl) = 1;
7626               DECL_COMMON (decl) = 1;
7627             }
7628           /* else we lose. We can only do this if we can use common,
7629              which we can't if it has been initialized.  */
7630
7631           if (!TREE_PUBLIC (decl))
7632             {
7633               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7634               cp_warning_at ("  you can work around this by removing the initializer", decl);
7635             }
7636         }
7637       else
7638         comdat_linkage (decl);
7639     }
7640   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7641     /* Set it up again; we might have set DECL_INITIAL since the last
7642        time.  */
7643     comdat_linkage (decl);
7644 }
7645
7646 /* Issue an error message if DECL is an uninitialized const variable.  */
7647
7648 static void
7649 check_for_uninitialized_const_var (decl)
7650      tree decl;
7651 {
7652   tree type = TREE_TYPE (decl);
7653
7654   /* ``Unless explicitly declared extern, a const object does not have
7655      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7656      7.1.6 */
7657   if (TREE_CODE (decl) == VAR_DECL
7658       && TREE_CODE (type) != REFERENCE_TYPE
7659       && CP_TYPE_CONST_P (type)
7660       && !TYPE_NEEDS_CONSTRUCTING (type)
7661       && !DECL_INITIAL (decl))
7662     cp_error ("uninitialized const `%D'", decl);
7663 }
7664
7665 /* Verify INIT (the initializer for DECL), and record the
7666    initialization in DECL_INITIAL, if appropriate.  Returns a new
7667    value for INIT.  */
7668
7669 static tree
7670 check_initializer (decl, init)
7671      tree decl;
7672      tree init;
7673 {
7674   tree type;
7675
7676   if (TREE_CODE (decl) == FIELD_DECL)
7677     return init;
7678
7679   type = TREE_TYPE (decl);
7680
7681   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7682   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7683     init = NULL_TREE;
7684
7685   /* Check the initializer.  */
7686   if (init)
7687     {
7688       /* Things that are going to be initialized need to have complete
7689          type.  */
7690       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7691
7692       if (type == error_mark_node)
7693         /* We will have already complained.  */
7694         init = NULL_TREE;
7695       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7696         {
7697           cp_error ("variable-sized object `%D' may not be initialized", decl);
7698           init = NULL_TREE;
7699         }
7700       else if (TREE_CODE (type) == ARRAY_TYPE
7701                && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7702         {
7703           cp_error ("elements of array `%#D' have incomplete type", decl);
7704           init = NULL_TREE;
7705         }
7706       else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
7707         {
7708           cp_error ("`%D' has incomplete type", decl);
7709           TREE_TYPE (decl) = error_mark_node;
7710           init = NULL_TREE;
7711         }
7712     }
7713
7714   if (TREE_CODE (decl) == CONST_DECL)
7715     {
7716       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7717
7718       DECL_INITIAL (decl) = init;
7719
7720       my_friendly_assert (init != NULL_TREE, 149);
7721       init = NULL_TREE;
7722     }
7723   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7724     {
7725       init = grok_reference_init (decl, type, init);
7726       if (init)
7727         init = obscure_complex_init (decl, init);
7728     }
7729   else if (init)
7730     {
7731       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7732         {
7733           if (TREE_CODE (type) == ARRAY_TYPE)
7734             init = digest_init (type, init, (tree *) 0);
7735           else if (TREE_CODE (init) == CONSTRUCTOR
7736                    && TREE_HAS_CONSTRUCTOR (init))
7737             {
7738               if (TYPE_NON_AGGREGATE_CLASS (type))
7739                 {
7740                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7741                             decl);
7742                   init = error_mark_node;
7743                 }
7744               else
7745                 goto dont_use_constructor;
7746             }
7747         }
7748       else
7749         {
7750         dont_use_constructor:
7751           if (TREE_CODE (init) != TREE_VEC)
7752             init = store_init_value (decl, init);
7753         }
7754
7755       if (init)
7756         /* We must hide the initializer so that expand_decl
7757            won't try to do something it does not understand.  */
7758         init = obscure_complex_init (decl, init);
7759     }
7760   else if (DECL_EXTERNAL (decl))
7761     ;
7762   else if (TYPE_P (type)
7763            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7764     {
7765       tree core_type = strip_array_types (type);
7766
7767       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7768         {
7769           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7770             cp_error ("structure `%D' with uninitialized const members", decl);
7771           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7772             cp_error ("structure `%D' with uninitialized reference members",
7773                       decl);
7774         }
7775
7776       check_for_uninitialized_const_var (decl);
7777
7778       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7779         init = obscure_complex_init (decl, NULL_TREE);
7780
7781     }
7782   else
7783     check_for_uninitialized_const_var (decl);
7784
7785   return init;
7786 }
7787
7788 /* If DECL is not a local variable, give it RTL.  */
7789
7790 static void
7791 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7792      tree decl;
7793      tree init;
7794      const char *asmspec;
7795 {
7796   int toplev = toplevel_bindings_p ();
7797   int defer_p;
7798
7799   /* Handle non-variables up front.  */
7800   if (TREE_CODE (decl) != VAR_DECL)
7801     {
7802       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7803       return;
7804     }
7805
7806   /* If we see a class member here, it should be a static data
7807      member.  */
7808   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7809     {
7810       my_friendly_assert (TREE_STATIC (decl), 19990828);
7811       /* An in-class declaration of a static data member should be
7812          external; it is only a declaration, and not a definition.  */
7813       if (init == NULL_TREE)
7814         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7815     }
7816
7817   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7818   if (asmspec)
7819     {
7820       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
7821       /* The `register' keyword, when used together with an
7822          asm-specification, indicates that the variable should be
7823          placed in a particular register.  */
7824       if (DECL_REGISTER (decl))
7825         DECL_C_HARD_REGISTER (decl) = 1;
7826     }
7827
7828   /* We don't create any RTL for local variables.  */
7829   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7830     return;
7831
7832   /* We defer emission of local statics until the corresponding
7833      DECL_STMT is expanded.  */
7834   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7835
7836   /* We try to defer namespace-scope static constants so that they are
7837      not emitted into the object file unncessarily.  */
7838   if (!DECL_VIRTUAL_P (decl)
7839       && TREE_READONLY (decl)
7840       && DECL_INITIAL (decl) != NULL_TREE
7841       && DECL_INITIAL (decl) != error_mark_node
7842       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7843       && toplev
7844       && !TREE_PUBLIC (decl))
7845     {
7846       /* Fool with the linkage according to #pragma interface.  */
7847       if (!interface_unknown)
7848         {
7849           TREE_PUBLIC (decl) = 1;
7850           DECL_EXTERNAL (decl) = interface_only;
7851         }
7852
7853       defer_p = 1;
7854     }
7855
7856   /* If we're deferring the variable, we only need to make RTL if
7857      there's an ASMSPEC.  Otherwise, we'll lazily create it later when
7858      we need it.  (There's no way to lazily create RTL for things that
7859      have assembly specs because the information about the specifier
7860      isn't stored in the tree, yet)  */
7861   if (defer_p && asmspec)
7862     make_decl_rtl (decl, asmspec);
7863   /* If we're not deferring, go ahead and assemble the variable.  */
7864   else if (!defer_p)
7865     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7866 }
7867
7868 /* The old ARM scoping rules injected variables declared in the
7869    initialization statement of a for-statement into the surrounding
7870    scope.  We support this usage, in order to be backward-compatible.
7871    DECL is a just-declared VAR_DECL; if necessary inject its
7872    declaration into the surrounding scope.  */
7873
7874 void
7875 maybe_inject_for_scope_var (decl)
7876      tree decl;
7877 {
7878   if (!DECL_NAME (decl))
7879     return;
7880
7881   if (current_binding_level->is_for_scope)
7882     {
7883       struct binding_level *outer
7884         = current_binding_level->level_chain;
7885
7886       /* Check to see if the same name is already bound at the outer
7887          level, either because it was directly declared, or because a
7888          dead for-decl got preserved.  In either case, the code would
7889          not have been valid under the ARM scope rules, so clear
7890          is_for_scope for the current_binding_level.
7891
7892          Otherwise, we need to preserve the temp slot for decl to last
7893          into the outer binding level.  */
7894
7895       tree outer_binding
7896         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7897
7898       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7899           && (TREE_CODE (BINDING_VALUE (outer_binding))
7900               == VAR_DECL)
7901           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7902         {
7903           BINDING_VALUE (outer_binding)
7904             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7905           current_binding_level->is_for_scope = 0;
7906         }
7907       else if (DECL_IN_MEMORY_P (decl))
7908         preserve_temp_slots (DECL_RTL (decl));
7909     }
7910 }
7911
7912 /* Generate code to initialize DECL (a local variable).  */
7913
7914 void
7915 initialize_local_var (decl, init, flags)
7916      tree decl;
7917      tree init;
7918      int flags;
7919 {
7920   tree type = TREE_TYPE (decl);
7921
7922   /* If the type is bogus, don't bother initializing the variable.  */
7923   if (type == error_mark_node)
7924     return;
7925
7926   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7927     {
7928       /* If we used it already as memory, it must stay in memory.  */
7929       DECL_INITIAL (decl) = NULL_TREE;
7930       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7931     }
7932
7933   /* Local statics are handled differently from ordinary automatic
7934      variables.  */
7935   if (TREE_STATIC (decl))
7936     {
7937       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7938           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7939         expand_static_init (decl, init);
7940       return;
7941     }
7942
7943   if (DECL_SIZE (decl) && type != error_mark_node)
7944     {
7945       int already_used;
7946
7947       /* Compute and store the initial value.  */
7948       already_used = TREE_USED (decl) || TREE_USED (type);
7949
7950       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7951         {
7952           int saved_stmts_are_full_exprs_p;
7953
7954           my_friendly_assert (building_stmt_tree (), 20000906);
7955           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7956           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
7957           finish_expr_stmt (build_aggr_init (decl, init, flags));
7958           current_stmt_tree ()->stmts_are_full_exprs_p =
7959             saved_stmts_are_full_exprs_p;
7960         }
7961
7962       /* Set this to 0 so we can tell whether an aggregate which was
7963          initialized was ever used.  Don't do this if it has a
7964          destructor, so we don't complain about the 'resource
7965          allocation is initialization' idiom.  Now set
7966          attribute((unused)) on types so decls of that type will be
7967          marked used. (see TREE_USED, above.)  */
7968       if (TYPE_NEEDS_CONSTRUCTING (type)
7969           && ! already_used
7970           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7971           && DECL_NAME (decl))
7972         TREE_USED (decl) = 0;
7973       else if (already_used)
7974         TREE_USED (decl) = 1;
7975     }
7976 }
7977
7978 /* Generate code to destroy DECL (a local variable).  */
7979
7980 static void
7981 destroy_local_var (decl)
7982      tree decl;
7983 {
7984   tree type = TREE_TYPE (decl);
7985   tree cleanup;
7986
7987   /* Only variables get cleaned up.  */
7988   if (TREE_CODE (decl) != VAR_DECL)
7989     return;
7990
7991   /* And only things with destructors need cleaning up.  */
7992   if (type == error_mark_node
7993       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7994     return;
7995
7996   if (TREE_CODE (decl) == VAR_DECL &&
7997       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7998     /* We don't clean up things that aren't defined in this
7999        translation unit, or that need a static cleanup.  The latter
8000        are handled by finish_file.  */
8001     return;
8002
8003   /* Compute the cleanup.  */
8004   cleanup = maybe_build_cleanup (decl);
8005
8006   /* Record the cleanup required for this declaration.  */
8007   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
8008       && cleanup)
8009     finish_decl_cleanup (decl, cleanup);
8010 }
8011
8012 /* Finish processing of a declaration;
8013    install its line number and initial value.
8014    If the length of an array type is not known before,
8015    it must be determined now, from the initial value, or it is an error.
8016
8017    INIT holds the value of an initializer that should be allowed to escape
8018    the normal rules.
8019
8020    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8021    if the (init) syntax was used.  */
8022
8023 void
8024 cp_finish_decl (decl, init, asmspec_tree, flags)
8025      tree decl, init;
8026      tree asmspec_tree;
8027      int flags;
8028 {
8029   register tree type;
8030   tree ttype = NULL_TREE;
8031   const char *asmspec = NULL;
8032   int was_readonly = 0;
8033
8034   if (! decl)
8035     {
8036       if (init)
8037         error ("assignment (not initialization) in declaration");
8038       return;
8039     }
8040
8041   /* If a name was specified, get the string.  */
8042   if (asmspec_tree)
8043       asmspec = TREE_STRING_POINTER (asmspec_tree);
8044
8045   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8046     {
8047       cp_error ("cannot initialize `%D' to namespace `%D'",
8048                 decl, init);
8049       init = NULL_TREE;
8050     }
8051
8052   if (current_class_type
8053       && CP_DECL_CONTEXT (decl) == current_class_type
8054       && TYPE_BEING_DEFINED (current_class_type)
8055       && (DECL_INITIAL (decl) || init))
8056     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
8057
8058   if (TREE_CODE (decl) == VAR_DECL
8059       && DECL_CONTEXT (decl)
8060       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8061       && DECL_CONTEXT (decl) != current_namespace
8062       && init)
8063     {
8064       /* Leave the namespace of the object. */
8065       pop_decl_namespace ();
8066     }
8067
8068   type = TREE_TYPE (decl);
8069
8070   if (type == error_mark_node)
8071     return;
8072
8073   if (TYPE_HAS_MUTABLE_P (type))
8074     TREE_READONLY (decl) = 0;
8075
8076   if (processing_template_decl)
8077     {
8078       /* Add this declaration to the statement-tree.  */
8079       if (at_function_scope_p ()
8080           && TREE_CODE (decl) != RESULT_DECL)
8081         add_decl_stmt (decl);
8082
8083       if (init && DECL_INITIAL (decl))
8084         DECL_INITIAL (decl) = init;
8085       goto finish_end0;
8086     }
8087
8088   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8089   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8090
8091   /* Take care of TYPE_DECLs up front.  */
8092   if (TREE_CODE (decl) == TYPE_DECL)
8093     {
8094       if (init && DECL_INITIAL (decl))
8095         {
8096           /* typedef foo = bar; store the type of bar as the type of foo.  */
8097           TREE_TYPE (decl) = type = TREE_TYPE (init);
8098           DECL_INITIAL (decl) = init = NULL_TREE;
8099         }
8100       if (type != error_mark_node
8101           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8102         {
8103           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8104             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8105           set_identifier_type_value (DECL_NAME (decl), type);
8106           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8107         }
8108       GNU_xref_decl (current_function_decl, decl);
8109
8110       /* If we have installed this as the canonical typedef for this
8111          type, and that type has not been defined yet, delay emitting
8112          the debug information for it, as we will emit it later.  */
8113       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8114           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8115         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8116
8117       rest_of_decl_compilation (decl, NULL,
8118                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8119       goto finish_end;
8120     }
8121
8122   if (TREE_CODE (decl) != FUNCTION_DECL)
8123     ttype = target_type (type);
8124
8125   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8126       && TYPE_NEEDS_CONSTRUCTING (type))
8127     {
8128       /* Currently, GNU C++ puts constants in text space, making them
8129          impossible to initialize.  In the future, one would hope for
8130          an operating system which understood the difference between
8131          initialization and the running of a program.  */
8132       was_readonly = 1;
8133       TREE_READONLY (decl) = 0;
8134     }
8135
8136   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8137     {
8138       /* This must override the asm specifier which was placed by
8139          grokclassfn.  Lay this out fresh.  */
8140       SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
8141       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8142       make_decl_rtl (decl, asmspec);
8143     }
8144
8145   /* Deduce size of array from initialization, if not already known.  */
8146   init = check_initializer (decl, init);
8147   maybe_deduce_size_from_array_init (decl, init);
8148
8149   GNU_xref_decl (current_function_decl, decl);
8150
8151   /* Add this declaration to the statement-tree.  This needs to happen
8152      after the call to check_initializer so that the DECL_STMT for a
8153      reference temp is added before the DECL_STMT for the reference itself.  */
8154   if (building_stmt_tree ()
8155       && at_function_scope_p ()
8156       && TREE_CODE (decl) != RESULT_DECL)
8157     add_decl_stmt (decl);
8158
8159   if (TREE_CODE (decl) == VAR_DECL)
8160     layout_var_decl (decl);
8161
8162   /* Output the assembler code and/or RTL code for variables and functions,
8163      unless the type is an undefined structure or union.
8164      If not, it will get done when the type is completed.  */
8165   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8166       || TREE_CODE (decl) == RESULT_DECL)
8167     {
8168       if (TREE_CODE (decl) == VAR_DECL)
8169         maybe_commonize_var (decl);
8170
8171       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8172
8173       if (TREE_CODE (type) == FUNCTION_TYPE
8174           || TREE_CODE (type) == METHOD_TYPE)
8175         abstract_virtuals_error (decl,
8176                                  strip_array_types (TREE_TYPE (type)));
8177       else
8178         abstract_virtuals_error (decl, strip_array_types (type));
8179
8180       if (TREE_CODE (decl) == FUNCTION_DECL)
8181         ;
8182       else if (DECL_EXTERNAL (decl)
8183                && ! (DECL_LANG_SPECIFIC (decl)
8184                      && DECL_NOT_REALLY_EXTERN (decl)))
8185         {
8186           if (init)
8187             DECL_INITIAL (decl) = init;
8188         }
8189       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8190         {
8191           /* This is a local declaration.  */
8192           if (doing_semantic_analysis_p ())
8193             maybe_inject_for_scope_var (decl);
8194           /* Initialize the local variable.  But, if we're building a
8195              statement-tree, we'll do the initialization when we
8196              expand the tree.  */
8197           if (processing_template_decl)
8198             {
8199               if (init || DECL_INITIAL (decl) == error_mark_node)
8200                 DECL_INITIAL (decl) = init;
8201             }
8202           else
8203             {
8204               /* If we're not building RTL, then we need to do so
8205                  now.  */
8206               my_friendly_assert (building_stmt_tree (), 20000906);
8207               /* Initialize the variable.  */
8208               initialize_local_var (decl, init, flags);
8209               /* Clean up the variable.  */
8210               destroy_local_var (decl);
8211             }
8212         }
8213       else if (TREE_STATIC (decl) && type != error_mark_node)
8214         {
8215           /* Cleanups for static variables are handled by `finish_file'.  */
8216           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8217               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8218             expand_static_init (decl, init);
8219         }
8220     finish_end0:
8221
8222       /* Undo call to `pushclass' that was done in `start_decl'
8223          due to initialization of qualified member variable.
8224          I.e., Foo::x = 10;  */
8225       {
8226         tree context = CP_DECL_CONTEXT (decl);
8227         if (context
8228             && TYPE_P (context)
8229             && (TREE_CODE (decl) == VAR_DECL
8230                 /* We also have a pushclass done that we need to undo here
8231                    if we're at top level and declare a method.  */
8232                 || TREE_CODE (decl) == FUNCTION_DECL)
8233             /* If size hasn't been set, we're still defining it,
8234                and therefore inside the class body; don't pop
8235                the binding level..  */
8236             && COMPLETE_TYPE_P (context)
8237             && context == current_class_type)
8238           pop_nested_class ();
8239       }
8240     }
8241
8242  finish_end:
8243
8244   if (was_readonly)
8245     TREE_READONLY (decl) = 1;
8246 }
8247
8248 /* This is here for a midend callback from c-common.c */
8249
8250 void
8251 finish_decl (decl, init, asmspec_tree)
8252      tree decl, init;
8253      tree asmspec_tree;
8254 {
8255   cp_finish_decl (decl, init, asmspec_tree, 0);
8256 }
8257
8258 /* Returns a declaration for a VAR_DECL as if:
8259
8260      extern "C" TYPE NAME;
8261
8262    had been seen.  Used to create compiler-generated global
8263    variables.  */
8264
8265 tree
8266 declare_global_var (name, type)
8267      tree name;
8268      tree type;
8269 {
8270   tree decl;
8271
8272   push_to_top_level ();
8273   decl = build_decl (VAR_DECL, name, type);
8274   TREE_PUBLIC (decl) = 1;
8275   DECL_EXTERNAL (decl) = 1;
8276   DECL_ARTIFICIAL (decl) = 1;
8277   pushdecl (decl);
8278   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8279   pop_from_top_level ();
8280
8281   return decl;
8282 }
8283
8284 /* Returns a pointer to the `atexit' function.  Note that if
8285    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8286    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8287
8288 static tree
8289 get_atexit_node ()
8290 {
8291   tree atexit_fndecl;
8292   tree arg_types;
8293   tree fn_type;
8294   tree fn_ptr_type;
8295   const char *name;
8296
8297   if (atexit_node)
8298     return atexit_node;
8299
8300   if (flag_use_cxa_atexit)
8301     {
8302       /* The declaration for `__cxa_atexit' is:
8303
8304            int __cxa_atexit (void (*)(void *), void *, void *)
8305
8306          We build up the argument types and then then function type
8307          itself.  */
8308
8309       /* First, build the pointer-to-function type for the first
8310          argument.  */
8311       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8312       fn_type = build_function_type (void_type_node, arg_types);
8313       fn_ptr_type = build_pointer_type (fn_type);
8314       /* Then, build the rest of the argument types.  */
8315       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8316       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8317       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8318       /* And the final __cxa_atexit type.  */
8319       fn_type = build_function_type (integer_type_node, arg_types);
8320       fn_ptr_type = build_pointer_type (fn_type);
8321       name = "__cxa_atexit";
8322     }
8323   else
8324     {
8325       /* The declaration for `atexit' is:
8326
8327            int atexit (void (*)());
8328
8329          We build up the argument types and then then function type
8330          itself.  */
8331       fn_type = build_function_type (void_type_node, void_list_node);
8332       fn_ptr_type = build_pointer_type (fn_type);
8333       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8334       /* Build the final atexit type.  */
8335       fn_type = build_function_type (integer_type_node, arg_types);
8336       name = "atexit";
8337     }
8338
8339   /* Now, build the function declaration.  */
8340   push_lang_context (lang_name_c);
8341   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8342   mark_used (atexit_fndecl);
8343   pop_lang_context ();
8344   atexit_node = default_conversion (atexit_fndecl);
8345
8346   return atexit_node;
8347 }
8348
8349 /* Returns the __dso_handle VAR_DECL.  */
8350
8351 static tree
8352 get_dso_handle_node ()
8353 {
8354   if (dso_handle_node)
8355     return dso_handle_node;
8356
8357   /* Declare the variable.  */
8358   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8359                                         ptr_type_node);
8360
8361   return dso_handle_node;
8362 }
8363
8364 /* Begin a new function with internal linkage whose job will be simply
8365    to destroy some particular variable.  */
8366
8367 static tree
8368 start_cleanup_fn ()
8369 {
8370   static int counter = 0;
8371   int old_interface_unknown = interface_unknown;
8372   char name[32];
8373   tree parmtypes;
8374   tree fntype;
8375   tree fndecl;
8376
8377   push_to_top_level ();
8378
8379   /* No need to mangle this.  */
8380   push_lang_context (lang_name_c);
8381
8382   interface_unknown = 1;
8383
8384   /* Build the parameter-types.  */
8385   parmtypes = void_list_node;
8386   /* Functions passed to __cxa_atexit take an additional parameter.
8387      We'll just ignore it.  After we implement the new calling
8388      convention for destructors, we can eliminate the use of
8389      additional cleanup functions entirely in the -fnew-abi case.  */
8390   if (flag_use_cxa_atexit)
8391     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8392   /* Build the function type itself.  */
8393   fntype = build_function_type (void_type_node, parmtypes);
8394   /* Build the name of the function.  */
8395   sprintf (name, "__tcf_%d", counter++);
8396   /* Build the function declaration.  */
8397   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8398   /* It's a function with internal linkage, generated by the
8399      compiler.  */
8400   TREE_PUBLIC (fndecl) = 0;
8401   DECL_ARTIFICIAL (fndecl) = 1;
8402   /* Make the function `inline' so that it is only emitted if it is
8403      actually needed.  It is unlikely that it will be inlined, since
8404      it is only called via a function pointer, but we avoid unncessary
8405      emissions this way.  */
8406   DECL_INLINE (fndecl) = 1;
8407   /* Build the parameter.  */
8408   if (flag_use_cxa_atexit)
8409     {
8410       tree parmdecl;
8411
8412       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8413       DECL_CONTEXT (parmdecl) = fndecl;
8414       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8415       TREE_USED (parmdecl) = 1;
8416       DECL_ARGUMENTS (fndecl) = parmdecl;
8417     }
8418
8419   pushdecl (fndecl);
8420   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8421   do_pushlevel ();
8422
8423   interface_unknown = old_interface_unknown;
8424
8425   pop_lang_context ();
8426
8427   return current_function_decl;
8428 }
8429
8430 /* Finish the cleanup function begun by start_cleanup_fn.  */
8431
8432 static void
8433 end_cleanup_fn ()
8434 {
8435   do_poplevel ();
8436
8437   expand_body (finish_function (0));
8438
8439   pop_from_top_level ();
8440 }
8441
8442 /* Generate code to handle the destruction of DECL, an object with
8443    static storage duration.  */
8444
8445 void
8446 register_dtor_fn (decl)
8447      tree decl;
8448 {
8449   tree cleanup;
8450   tree compound_stmt;
8451   tree args;
8452   tree fcall;
8453
8454   int saved_flag_access_control;
8455
8456   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8457     return;
8458
8459   /* Call build_cleanup before we enter the anonymous function so that
8460      any access checks will be done relative to the current scope,
8461      rather than the scope of the anonymous function.  */
8462   build_cleanup (decl);
8463
8464   /* Now start the function.  */
8465   cleanup = start_cleanup_fn ();
8466
8467   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8468      to the original function, rather than the anonymous one.  That
8469      will make the back-end think that nested functions are in use,
8470      which causes confusion.  */
8471   saved_flag_access_control = flag_access_control;
8472   flag_access_control = 0;
8473   fcall = build_cleanup (decl);
8474   flag_access_control = saved_flag_access_control;
8475
8476   /* Create the body of the anonymous function.  */
8477   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8478   finish_expr_stmt (fcall);
8479   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8480   end_cleanup_fn ();
8481
8482   /* Call atexit with the cleanup function.  */
8483   mark_addressable (cleanup);
8484   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8485   if (flag_use_cxa_atexit)
8486     {
8487       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8488       args = tree_cons (NULL_TREE, null_pointer_node, args);
8489       args = tree_cons (NULL_TREE, cleanup, args);
8490     }
8491   else
8492     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8493   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8494 }
8495
8496 void
8497 expand_static_init (decl, init)
8498      tree decl;
8499      tree init;
8500 {
8501   tree oldstatic = value_member (decl, static_aggregates);
8502
8503   if (oldstatic)
8504     {
8505       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8506         cp_error ("multiple initializations given for `%D'", decl);
8507     }
8508   else if (! toplevel_bindings_p ())
8509     {
8510       /* Emit code to perform this initialization but once.  */
8511       tree if_stmt;
8512       tree then_clause;
8513       tree assignment;
8514       tree guard;
8515       tree guard_init;
8516
8517       /* Emit code to perform this initialization but once.  This code
8518          looks like:
8519
8520            static int guard = 0;
8521            if (!guard) {
8522              // Do initialization.
8523              guard = 1;
8524              // Register variable for destruction at end of program.
8525            }
8526
8527          Note that the `temp' variable is only set to 1 *after* the
8528          initialization is complete.  This ensures that an exception,
8529          thrown during the construction, will cause the variable to
8530          reinitialized when we pass through this code again, as per:
8531
8532            [stmt.dcl]
8533
8534            If the initialization exits by throwing an exception, the
8535            initialization is not complete, so it will be tried again
8536            the next time control enters the declaration.
8537
8538          In theory, this process should be thread-safe, too; multiple
8539          threads should not be able to initialize the variable more
8540          than once.  We don't yet attempt to ensure thread-safety.  */
8541
8542       /* Create the guard variable.  */
8543       guard = get_guard (decl);
8544
8545       /* Begin the conditional initialization.  */
8546       if_stmt = begin_if_stmt ();
8547       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8548       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8549
8550       /* Do the initialization itself.  */
8551       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8552           || (init && TREE_CODE (init) == TREE_LIST))
8553         assignment = build_aggr_init (decl, init, 0);
8554       else if (init)
8555         /* The initialization we're doing here is just a bitwise
8556            copy.  */
8557         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8558       else
8559         assignment = NULL_TREE;
8560
8561       /* Once the assignment is complete, set TEMP to 1.  Since the
8562          construction of the static object is complete at this point,
8563          we want to make sure TEMP is set to 1 even if a temporary
8564          constructed during the initialization throws an exception
8565          when it is destroyed.  So, we combine the initialization and
8566          the assignment to TEMP into a single expression, ensuring
8567          that when we call finish_expr_stmt the cleanups will not be
8568          run until after TEMP is set to 1.  */
8569       guard_init = set_guard (guard);
8570       if (assignment)
8571         {
8572           assignment = tree_cons (NULL_TREE, assignment,
8573                                   build_tree_list (NULL_TREE,
8574                                                    guard_init));
8575           assignment = build_compound_expr (assignment);
8576         }
8577       else
8578         assignment = guard_init;
8579       finish_expr_stmt (assignment);
8580
8581       /* Use atexit to register a function for destroying this static
8582          variable.  */
8583       register_dtor_fn (decl);
8584
8585       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8586       finish_then_clause (if_stmt);
8587       finish_if_stmt ();
8588     }
8589   else
8590     static_aggregates = tree_cons (init, decl, static_aggregates);
8591 }
8592
8593 /* Finish the declaration of a catch-parameter.  */
8594
8595 tree
8596 start_handler_parms (declspecs, declarator)
8597      tree declspecs;
8598      tree declarator;
8599 {
8600   tree decl;
8601   if (declspecs)
8602     {
8603       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8604                              1, NULL);
8605       if (decl == NULL_TREE)
8606         error ("invalid catch parameter");
8607     }
8608   else
8609     decl = NULL_TREE;
8610
8611   return decl;
8612 }
8613
8614 \f
8615 /* Make TYPE a complete type based on INITIAL_VALUE.
8616    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8617    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8618
8619 int
8620 complete_array_type (type, initial_value, do_default)
8621      tree type, initial_value;
8622      int do_default;
8623 {
8624   register tree maxindex = NULL_TREE;
8625   int value = 0;
8626
8627   if (initial_value)
8628     {
8629       /* An array of character type can be initialized from a
8630          brace-enclosed string constant.  */
8631       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8632           && TREE_CODE (initial_value) == CONSTRUCTOR
8633           && CONSTRUCTOR_ELTS (initial_value)
8634           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8635               == STRING_CST)
8636           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8637         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8638
8639       /* Note MAXINDEX is really the maximum index, one less than the
8640          size.  */
8641       if (TREE_CODE (initial_value) == STRING_CST)
8642         {
8643           int eltsize
8644             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8645           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8646                                    / eltsize) - 1, 0);
8647         }
8648       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8649         {
8650           tree elts = CONSTRUCTOR_ELTS (initial_value);
8651
8652           maxindex = ssize_int (-1);
8653           for (; elts; elts = TREE_CHAIN (elts))
8654             {
8655               if (TREE_PURPOSE (elts))
8656                 maxindex = TREE_PURPOSE (elts);
8657               else
8658                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8659             }
8660           maxindex = copy_node (maxindex);
8661         }
8662       else
8663         {
8664           /* Make an error message unless that happened already.  */
8665           if (initial_value != error_mark_node)
8666             value = 1;
8667           else
8668             initial_value = NULL_TREE;
8669
8670           /* Prevent further error messages.  */
8671           maxindex = build_int_2 (0, 0);
8672         }
8673     }
8674
8675   if (!maxindex)
8676     {
8677       if (do_default)
8678         maxindex = build_int_2 (0, 0);
8679       value = 2;
8680     }
8681
8682   if (maxindex)
8683     {
8684       tree itype;
8685       tree domain;
8686
8687       domain = build_index_type (maxindex);
8688       TYPE_DOMAIN (type) = domain;
8689
8690       if (! TREE_TYPE (maxindex))
8691         TREE_TYPE (maxindex) = domain;
8692       if (initial_value)
8693         itype = TREE_TYPE (initial_value);
8694       else
8695         itype = NULL;
8696       if (itype && !TYPE_DOMAIN (itype))
8697         TYPE_DOMAIN (itype) = domain;
8698       /* The type of the main variant should never be used for arrays
8699          of different sizes.  It should only ever be completed with the
8700          size of the array.  */
8701       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8702         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8703     }
8704
8705   /* Lay out the type now that we can get the real answer.  */
8706
8707   layout_type (type);
8708
8709   return value;
8710 }
8711 \f
8712 /* Return zero if something is declared to be a member of type
8713    CTYPE when in the context of CUR_TYPE.  STRING is the error
8714    message to print in that case.  Otherwise, quietly return 1.  */
8715
8716 static int
8717 member_function_or_else (ctype, cur_type, flags)
8718      tree ctype, cur_type;
8719      enum overload_flags flags;
8720 {
8721   if (ctype && ctype != cur_type)
8722     {
8723       if (flags == DTOR_FLAG)
8724         cp_error ("destructor for alien class `%T' cannot be a member",
8725                   ctype);
8726       else
8727         cp_error ("constructor for alien class `%T' cannot be a member",
8728                   ctype);
8729       return 0;
8730     }
8731   return 1;
8732 }
8733 \f
8734 /* Subroutine of `grokdeclarator'.  */
8735
8736 /* Generate errors possibly applicable for a given set of specifiers.
8737    This is for ARM $7.1.2.  */
8738
8739 static void
8740 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8741      tree object;
8742      const char *type;
8743      int virtualp, quals, friendp, raises, inlinep;
8744 {
8745   if (virtualp)
8746     cp_error ("`%D' declared as a `virtual' %s", object, type);
8747   if (inlinep)
8748     cp_error ("`%D' declared as an `inline' %s", object, type);
8749   if (quals)
8750     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8751               object, type);
8752   if (friendp)
8753     cp_error_at ("`%D' declared as a friend", object);
8754   if (raises
8755       && (TREE_CODE (object) == TYPE_DECL
8756           || (!TYPE_PTRFN_P (TREE_TYPE (object))
8757               && !TYPE_REFFN_P (TREE_TYPE (object))
8758               && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
8759     cp_error_at ("`%D' declared with an exception specification", object);
8760 }
8761
8762 /* CTYPE is class type, or null if non-class.
8763    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8764    or METHOD_TYPE.
8765    DECLARATOR is the function's name.
8766    VIRTUALP is truthvalue of whether the function is virtual or not.
8767    FLAGS are to be passed through to `grokclassfn'.
8768    QUALS are qualifiers indicating whether the function is `const'
8769    or `volatile'.
8770    RAISES is a list of exceptions that this function can raise.
8771    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8772    not look, and -1 if we should not call `grokclassfn' at all.
8773
8774    Returns `NULL_TREE' if something goes wrong, after issuing
8775    applicable error messages.  */
8776
8777 static tree
8778 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8779             raises, check, friendp, publicp, inlinep, funcdef_flag,
8780             template_count, in_namespace)
8781      tree ctype, type;
8782      tree declarator;
8783      tree orig_declarator;
8784      int virtualp;
8785      enum overload_flags flags;
8786      tree quals, raises;
8787      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8788      tree in_namespace;
8789 {
8790   tree decl;
8791   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8792   int has_default_arg = 0;
8793   tree t;
8794
8795   if (raises)
8796     type = build_exception_variant (type, raises);
8797
8798   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8799   /* Propagate volatile out from type to decl. */
8800   if (TYPE_VOLATILE (type))
8801     TREE_THIS_VOLATILE (decl) = 1;
8802
8803   /* If this decl has namespace scope, set that up.  */
8804   if (in_namespace)
8805     set_decl_namespace (decl, in_namespace, friendp);
8806   else if (!ctype)
8807     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8808
8809   /* `main' and builtins have implicit 'C' linkage.  */
8810   if ((MAIN_NAME_P (declarator)
8811        || (IDENTIFIER_LENGTH (declarator) > 10
8812            && IDENTIFIER_POINTER (declarator)[0] == '_'
8813            && IDENTIFIER_POINTER (declarator)[1] == '_'
8814            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8815       && current_lang_name == lang_name_cplusplus
8816       && ctype == NULL_TREE
8817       /* NULL_TREE means global namespace.  */
8818       && DECL_CONTEXT (decl) == NULL_TREE)
8819     SET_DECL_LANGUAGE (decl, lang_c);
8820
8821   /* Should probably propagate const out from type to decl I bet (mrs).  */
8822   if (staticp)
8823     {
8824       DECL_STATIC_FUNCTION_P (decl) = 1;
8825       DECL_CONTEXT (decl) = ctype;
8826     }
8827
8828   if (ctype)
8829     DECL_CONTEXT (decl) = ctype;
8830
8831   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8832     {
8833       if (processing_template_decl)
8834         error ("cannot declare `::main' to be a template");
8835       if (inlinep)
8836         error ("cannot declare `::main' to be inline");
8837       if (!publicp)
8838         error ("cannot declare `::main' to be static");
8839       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8840                         integer_type_node))
8841         error ("`main' must return `int'");
8842       inlinep = 0;
8843       publicp = 1;
8844     }
8845
8846   /* Members of anonymous types and local classes have no linkage; make
8847      them internal.  */
8848   /* FIXME what if it gets a name from typedef?  */
8849   if (ctype && (TYPE_ANONYMOUS_P (ctype)
8850                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8851     publicp = 0;
8852
8853   if (publicp)
8854     {
8855       /* [basic.link]: A name with no linkage (notably, the name of a class
8856          or enumeration declared in a local scope) shall not be used to
8857          declare an entity with linkage.
8858
8859          Only check this for public decls for now.  */
8860       t = no_linkage_check (TREE_TYPE (decl));
8861       if (t)
8862         {
8863           if (TYPE_ANONYMOUS_P (t))
8864             {
8865               if (DECL_EXTERN_C_P (decl))
8866                 /* Allow this; it's pretty common in C.  */;
8867               else
8868                 {
8869                   cp_pedwarn ("non-local function `%#D' uses anonymous type",
8870                               decl);
8871                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
8872                     cp_pedwarn_at ("\
8873 `%#D' does not refer to the unqualified type, so it is not used for linkage",
8874                                 TYPE_NAME (t));
8875                 }
8876             }
8877           else
8878             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8879                         decl, t);
8880         }
8881     }
8882
8883   TREE_PUBLIC (decl) = publicp;
8884   if (! publicp)
8885     {
8886       DECL_INTERFACE_KNOWN (decl) = 1;
8887       DECL_NOT_REALLY_EXTERN (decl) = 1;
8888     }
8889
8890   /* If the declaration was declared inline, mark it as such.  */
8891   if (inlinep)
8892     DECL_DECLARED_INLINE_P (decl) = 1;
8893   /* We inline functions that are explicitly declared inline, or, when
8894      the user explicitly asks us to, all functions.  */
8895   if (DECL_DECLARED_INLINE_P (decl) || flag_inline_trees == 2)
8896     DECL_INLINE (decl) = 1;
8897
8898   DECL_EXTERNAL (decl) = 1;
8899   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8900     {
8901       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8902                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8903       quals = NULL_TREE;
8904     }
8905
8906   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8907     grok_op_properties (decl, friendp);
8908
8909   if (ctype && decl_function_context (decl))
8910     DECL_NO_STATIC_CHAIN (decl) = 1;
8911
8912   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8913     if (TREE_PURPOSE (t)
8914         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8915       {
8916         has_default_arg = 1;
8917         break;
8918       }
8919
8920   if (friendp
8921       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8922     {
8923       if (funcdef_flag)
8924         cp_error
8925           ("defining explicit specialization `%D' in friend declaration",
8926            orig_declarator);
8927       else
8928         {
8929           tree fns = TREE_OPERAND (orig_declarator, 0);
8930           tree args = TREE_OPERAND (orig_declarator, 1);
8931
8932           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8933             {
8934               /* Something like `template <class T> friend void f<T>()'.  */
8935               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8936                         orig_declarator);
8937               return NULL_TREE;
8938             }
8939
8940
8941           /* A friend declaration of the form friend void f<>().  Record
8942              the information in the TEMPLATE_ID_EXPR.  */
8943           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8944
8945           if (TREE_CODE (fns) == COMPONENT_REF)
8946             {
8947               /* Due to bison parser ickiness, we will have already looked
8948                  up an operator_name or PFUNCNAME within the current class
8949                  (see template_id in parse.y). If the current class contains
8950                  such a name, we'll get a COMPONENT_REF here. Undo that. */
8951
8952               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
8953                                   == current_class_type, 20001120);
8954               fns = TREE_OPERAND (fns, 1);
8955             }
8956           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
8957                               || TREE_CODE (fns) == LOOKUP_EXPR
8958                               || TREE_CODE (fns) == OVERLOAD, 20001120);
8959           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
8960
8961           if (has_default_arg)
8962             {
8963               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8964                         decl);
8965               return NULL_TREE;
8966             }
8967
8968           if (inlinep)
8969             {
8970               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8971                         decl);
8972               return NULL_TREE;
8973             }
8974         }
8975     }
8976
8977   if (has_default_arg)
8978     add_defarg_fn (decl);
8979
8980   if (funcdef_flag)
8981     /* Make the init_value nonzero so pushdecl knows this is not
8982        tentative.  error_mark_node is replaced later with the BLOCK.  */
8983     DECL_INITIAL (decl) = error_mark_node;
8984
8985   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8986     TREE_NOTHROW (decl) = 1;
8987
8988   /* Caller will do the rest of this.  */
8989   if (check < 0)
8990     return decl;
8991
8992   if (flags == NO_SPECIAL && ctype && constructor_name (ctype) == declarator)
8993     DECL_CONSTRUCTOR_P (decl) = 1;
8994
8995   /* Function gets the ugly name, field gets the nice one.  This call
8996      may change the type of the function (because of default
8997      parameters)!  */
8998   if (ctype != NULL_TREE)
8999     grokclassfn (ctype, decl, flags, quals);
9000
9001   decl = check_explicit_specialization (orig_declarator, decl,
9002                                         template_count,
9003                                         2 * (funcdef_flag != 0) +
9004                                         4 * (friendp != 0));
9005   if (decl == error_mark_node)
9006     return NULL_TREE;
9007
9008   if (ctype != NULL_TREE
9009       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9010       && check)
9011     {
9012       tree old_decl;
9013
9014       old_decl = check_classfn (ctype, decl);
9015
9016       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9017         /* Because grokfndecl is always supposed to return a
9018            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9019            here.  We depend on our callers to figure out that its
9020            really a template that's being returned.  */
9021         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9022
9023       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9024           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9025         {
9026           /* Remove the `this' parm added by grokclassfn.
9027              XXX Isn't this done in start_function, too?  */
9028           revert_static_member_fn (decl);
9029           last_function_parms = TREE_CHAIN (last_function_parms);
9030         }
9031       if (old_decl && DECL_ARTIFICIAL (old_decl))
9032         cp_error ("definition of implicitly-declared `%D'", old_decl);
9033
9034       if (old_decl)
9035         {
9036           /* Since we've smashed OLD_DECL to its
9037              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9038           if (TREE_CODE (decl) == TEMPLATE_DECL)
9039             decl = DECL_TEMPLATE_RESULT (decl);
9040
9041           /* Attempt to merge the declarations.  This can fail, in
9042              the case of some illegal specialization declarations.  */
9043           if (!duplicate_decls (decl, old_decl))
9044             cp_error ("no `%#D' member function declared in class `%T'",
9045                       decl, ctype);
9046           return old_decl;
9047         }
9048     }
9049
9050   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9051     return NULL_TREE;
9052
9053   if (ctype == NULL_TREE || check)
9054     return decl;
9055
9056   if (virtualp)
9057     DECL_VIRTUAL_P (decl) = 1;
9058
9059   return decl;
9060 }
9061
9062 static tree
9063 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9064      tree type;
9065      tree declarator;
9066      RID_BIT_TYPE *specbits_in;
9067      int initialized;
9068      int constp;
9069      tree in_namespace;
9070 {
9071   tree decl;
9072   RID_BIT_TYPE specbits;
9073
9074   specbits = *specbits_in;
9075
9076   if (TREE_CODE (type) == OFFSET_TYPE)
9077     {
9078       /* If you declare a static member so that it
9079          can be initialized, the code will reach here.  */
9080       tree basetype = TYPE_OFFSET_BASETYPE (type);
9081       type = TREE_TYPE (type);
9082       decl = build_lang_decl (VAR_DECL, declarator, type);
9083       DECL_CONTEXT (decl) = basetype;
9084     }
9085   else
9086     {
9087       tree context;
9088
9089       if (in_namespace)
9090         context = in_namespace;
9091       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9092         context = current_namespace;
9093       else
9094         context = NULL_TREE;
9095
9096       /* For namespace-scope variables, declared in a template, we
9097          need the full lang_decl.  The same is true for
9098          namespace-scope variables that do not have C++ language
9099          linkage.  */
9100       if (context
9101           && (processing_template_decl
9102               || current_lang_name != lang_name_cplusplus))
9103         decl = build_lang_decl (VAR_DECL, declarator, type);
9104       else
9105         decl = build_decl (VAR_DECL, declarator, type);
9106
9107       if (context)
9108         set_decl_namespace (decl, context, 0);
9109
9110       context = DECL_CONTEXT (decl);
9111       if (declarator && context && current_lang_name != lang_name_c)
9112         /* We can't mangle lazily here because we don't have any
9113            way to recover whether or not a variable was `extern
9114            "C"' later.  */
9115         mangle_decl (decl);
9116     }
9117
9118   if (in_namespace)
9119     set_decl_namespace (decl, in_namespace, 0);
9120
9121   if (RIDBIT_SETP (RID_EXTERN, specbits))
9122     {
9123       DECL_THIS_EXTERN (decl) = 1;
9124       DECL_EXTERNAL (decl) = !initialized;
9125     }
9126
9127   /* In class context, static means one per class,
9128      public access, and static storage.  */
9129   if (DECL_CLASS_SCOPE_P (decl))
9130     {
9131       TREE_PUBLIC (decl) = 1;
9132       TREE_STATIC (decl) = 1;
9133       DECL_EXTERNAL (decl) = 0;
9134     }
9135   /* At top level, either `static' or no s.c. makes a definition
9136      (perhaps tentative), and absence of `static' makes it public.  */
9137   else if (toplevel_bindings_p ())
9138     {
9139       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9140                             && (DECL_THIS_EXTERN (decl) || ! constp));
9141       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9142     }
9143   /* Not at top level, only `static' makes a static definition.  */
9144   else
9145     {
9146       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9147       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9148     }
9149
9150   if (TREE_PUBLIC (decl))
9151     {
9152       /* [basic.link]: A name with no linkage (notably, the name of a class
9153          or enumeration declared in a local scope) shall not be used to
9154          declare an entity with linkage.
9155
9156          Only check this for public decls for now.  */
9157       tree t = no_linkage_check (TREE_TYPE (decl));
9158       if (t)
9159         {
9160           if (TYPE_ANONYMOUS_P (t))
9161             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9162           else
9163             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9164                         decl, t);
9165         }
9166     }
9167
9168   return decl;
9169 }
9170
9171 /* Create and return a canonical pointer to member function type, for
9172    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9173
9174 tree
9175 build_ptrmemfunc_type (type)
9176      tree type;
9177 {
9178   tree fields[4];
9179   tree t;
9180   tree unqualified_variant = NULL_TREE;
9181
9182   if (type == error_mark_node)
9183     return type;
9184
9185   /* If a canonical type already exists for this type, use it.  We use
9186      this method instead of type_hash_canon, because it only does a
9187      simple equality check on the list of field members.  */
9188
9189   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9190     return t;
9191
9192   /* Make sure that we always have the unqualified pointer-to-member
9193      type first.  */
9194   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9195     unqualified_variant
9196       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9197
9198   t = make_aggr_type (RECORD_TYPE);
9199   /* Let the front-end know this is a pointer to member function...  */
9200   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9201   /* ... and not really an aggregate.  */
9202   SET_IS_AGGR_TYPE (t, 0);
9203
9204   fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9205   fields[1] = build_decl (FIELD_DECL, delta_identifier,
9206                           delta_type_node);
9207   finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9208
9209   /* Zap out the name so that the back-end will give us the debugging
9210      information for this anonymous RECORD_TYPE.  */
9211   TYPE_NAME (t) = NULL_TREE;
9212
9213   /* If this is not the unqualified form of this pointer-to-member
9214      type, set the TYPE_MAIN_VARIANT for this type to be the
9215      unqualified type.  Since they are actually RECORD_TYPEs that are
9216      not variants of each other, we must do this manually.  */
9217   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9218     {
9219       t = build_qualified_type (t, cp_type_quals (type));
9220       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9221       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9222       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9223     }
9224
9225   /* Cache this pointer-to-member type so that we can find it again
9226      later.  */
9227   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9228
9229   /* Seems to be wanted.  */
9230   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9231
9232   return t;
9233 }
9234
9235 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9236    Check to see that the definition is valid.  Issue appropriate error
9237    messages.  Return 1 if the definition is particularly bad, or 0
9238    otherwise.  */
9239
9240 int
9241 check_static_variable_definition (decl, type)
9242      tree decl;
9243      tree type;
9244 {
9245   /* Motion 10 at San Diego: If a static const integral data member is
9246      initialized with an integral constant expression, the initializer
9247      may appear either in the declaration (within the class), or in
9248      the definition, but not both.  If it appears in the class, the
9249      member is a member constant.  The file-scope definition is always
9250      required.  */
9251   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9252     {
9253       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9254                 type);
9255       /* If we just return the declaration, crashes will sometimes
9256          occur.  We therefore return void_type_node, as if this was a
9257          friend declaration, to cause callers to completely ignore
9258          this declaration.  */
9259       return 1;
9260     }
9261   else if (!CP_TYPE_CONST_P (type))
9262     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9263               decl);
9264   else if (pedantic && !INTEGRAL_TYPE_P (type))
9265     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9266
9267   return 0;
9268 }
9269
9270 /* Given the SIZE (i.e., number of elements) in an array, compute an
9271    appropriate index type for the array.  If non-NULL, NAME is the
9272    name of the thing being declared.  */
9273
9274 tree
9275 compute_array_index_type (name, size)
9276      tree name;
9277      tree size;
9278 {
9279   tree itype;
9280
9281   /* If this involves a template parameter, it will be a constant at
9282      instantiation time, but we don't know what the value is yet.
9283      Even if no template parameters are involved, we may an expression
9284      that is not a constant; we don't even simplify `1 + 2' when
9285      processing a template.  */
9286   if (processing_template_decl)
9287     {
9288       /* Resolve a qualified reference to an enumerator or static
9289          const data member of ours.  */
9290       if (TREE_CODE (size) == SCOPE_REF
9291           && TREE_OPERAND (size, 0) == current_class_type)
9292         {
9293           tree t = lookup_field (current_class_type,
9294                                  TREE_OPERAND (size, 1), 0, 0);
9295           if (t)
9296             size = t;
9297         }
9298
9299       return build_index_type (build_min (MINUS_EXPR, sizetype,
9300                                           size, integer_one_node));
9301     }
9302
9303   /* The size might be the result of a cast. */
9304   STRIP_TYPE_NOPS (size);
9305
9306   /* It might be a const variable or enumeration constant.  */
9307   size = decl_constant_value (size);
9308
9309   /* The array bound must be an integer type.  */
9310   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9311       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9312       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9313     {
9314       if (name)
9315         cp_error ("size of array `%D' has non-integer type", name);
9316       else
9317         cp_error ("size of array has non-integer type");
9318       size = integer_one_node;
9319     }
9320
9321   /* Normally, the array-bound will be a constant.  */
9322   if (TREE_CODE (size) == INTEGER_CST)
9323     {
9324       /* Check to see if the array bound overflowed.  Make that an
9325          error, no matter how generous we're being.  */
9326       int old_flag_pedantic_errors = flag_pedantic_errors;
9327       int old_pedantic = pedantic;
9328       pedantic = flag_pedantic_errors = 1;
9329       constant_expression_warning (size);
9330       pedantic = old_pedantic;
9331       flag_pedantic_errors = old_flag_pedantic_errors;
9332
9333       /* An array must have a positive number of elements.  */
9334       if (INT_CST_LT (size, integer_zero_node))
9335         {
9336           if (name)
9337             cp_error ("size of array `%D' is negative", name);
9338           else
9339             cp_error ("size of array is negative");
9340           size = integer_one_node;
9341         }
9342       /* Except that an extension we allow zero-sized arrays.  We
9343          always allow them in system headers because glibc uses
9344          them.  */
9345       else if (integer_zerop (size) && pedantic && !in_system_header)
9346         {
9347           if (name)
9348             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9349           else
9350             cp_pedwarn ("ISO C++ forbids zero-size array");
9351         }
9352     }
9353   else if (TREE_CONSTANT (size))
9354     {
9355       /* `(int) &fn' is not a valid array bound.  */
9356       if (name)
9357         cp_error ("size of array `%D' is not an integral constant-expression",
9358                   name);
9359       else
9360         cp_error ("size of array is not an integral constant-expression");
9361     }
9362
9363   /* Compute the index of the largest element in the array.  It is
9364      one less than the number of elements in the array.  */
9365   itype
9366     = fold (cp_build_binary_op (MINUS_EXPR,
9367                                 cp_convert (ssizetype, size),
9368                                 cp_convert (ssizetype,
9369                                             integer_one_node)));
9370
9371   /* Check for variable-sized arrays.  We allow such things as an
9372      extension, even though they are not allowed in ANSI/ISO C++.  */
9373   if (!TREE_CONSTANT (itype))
9374     {
9375       if (pedantic)
9376         {
9377           if (name)
9378             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9379                         name);
9380           else
9381             cp_pedwarn ("ISO C++ forbids variable-size array");
9382         }
9383
9384       /* Create a variable-sized array index type.  */
9385       itype = variable_size (itype);
9386     }
9387   /* Make sure that there was no overflow when creating to a signed
9388      index type.  (For example, on a 32-bit machine, an array with
9389      size 2^32 - 1 is too big.)  */
9390   else if (TREE_OVERFLOW (itype))
9391     {
9392       error ("overflow in array dimension");
9393       TREE_OVERFLOW (itype) = 0;
9394     }
9395
9396   /* Create and return the appropriate index type.  */
9397   return build_index_type (itype);
9398 }
9399
9400 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9401    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9402    with this type.  */
9403
9404 static tree
9405 create_array_type_for_decl (name, type, size)
9406      tree name;
9407      tree type;
9408      tree size;
9409 {
9410   tree itype = NULL_TREE;
9411   const char* error_msg;
9412
9413   /* If things have already gone awry, bail now.  */
9414   if (type == error_mark_node || size == error_mark_node)
9415     return error_mark_node;
9416
9417   /* Assume that everything will go OK.  */
9418   error_msg = NULL;
9419
9420   /* There are some types which cannot be array elements.  */
9421   switch (TREE_CODE (type))
9422     {
9423     case VOID_TYPE:
9424       error_msg = "array of void";
9425       break;
9426
9427     case FUNCTION_TYPE:
9428       error_msg = "array of functions";
9429       break;
9430
9431     case REFERENCE_TYPE:
9432       error_msg = "array of references";
9433       break;
9434
9435     case OFFSET_TYPE:
9436       error_msg = "array of data members";
9437       break;
9438
9439     case METHOD_TYPE:
9440       error_msg = "array of function members";
9441       break;
9442
9443     default:
9444       break;
9445     }
9446
9447   /* If something went wrong, issue an error-message and return.  */
9448   if (error_msg)
9449     {
9450       if (name)
9451         cp_error ("declaration of `%D' as %s", name, error_msg);
9452       else
9453         cp_error ("creating %s", error_msg);
9454
9455       return error_mark_node;
9456     }
9457
9458   /* [dcl.array]
9459
9460      The constant expressions that specify the bounds of the arrays
9461      can be omitted only for the first member of the sequence.  */
9462   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9463     {
9464       if (name)
9465         cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9466                   name);
9467       else
9468         cp_error ("multidimensional array must have bounds for all dimensions except the first");
9469
9470       return error_mark_node;
9471     }
9472
9473   /* Figure out the index type for the array.  */
9474   if (size)
9475     itype = compute_array_index_type (name, size);
9476
9477   return build_cplus_array_type (type, itype);
9478 }
9479
9480 /* Check that it's OK to declare a function with the indicated TYPE.
9481    SFK indicates the kind of special function (if any) that this
9482    function is.  OPTYPE is the type given in a conversion operator
9483    declaration.  Returns the actual return type of the function; that
9484    may be different than TYPE if an error occurs, or for certain
9485    special functions.  */
9486
9487 static tree
9488 check_special_function_return_type (sfk, type, optype)
9489      special_function_kind sfk;
9490      tree type;
9491      tree optype;
9492 {
9493   switch (sfk)
9494     {
9495     case sfk_constructor:
9496       if (type)
9497         cp_error ("return type specification for constructor invalid");
9498
9499       type = void_type_node;
9500       break;
9501
9502     case sfk_destructor:
9503       if (type)
9504         cp_error ("return type specification for destructor invalid");
9505       type = void_type_node;
9506       break;
9507
9508     case sfk_conversion:
9509       if (type && !same_type_p (type, optype))
9510         cp_error ("operator `%T' declared to return `%T'", optype, type);
9511       else if (type)
9512         cp_pedwarn ("return type specified for `operator %T'",  optype);
9513       type = optype;
9514       break;
9515
9516     default:
9517       my_friendly_abort (20000408);
9518       break;
9519     }
9520
9521   return type;
9522 }
9523
9524 /* Given declspecs and a declarator,
9525    determine the name and type of the object declared
9526    and construct a ..._DECL node for it.
9527    (In one case we can return a ..._TYPE node instead.
9528     For invalid input we sometimes return 0.)
9529
9530    DECLSPECS is a chain of tree_list nodes whose value fields
9531     are the storage classes and type specifiers.
9532
9533    DECL_CONTEXT says which syntactic context this declaration is in:
9534      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9535      FUNCDEF for a function definition.  Like NORMAL but a few different
9536       error messages in each case.  Return value may be zero meaning
9537       this definition is too screwy to try to parse.
9538      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9539       handle member functions (which have FIELD context).
9540       Return value may be zero meaning this definition is too screwy to
9541       try to parse.
9542      PARM for a parameter declaration (either within a function prototype
9543       or before a function body).  Make a PARM_DECL, or return void_type_node.
9544      CATCHPARM for a parameter declaration before a catch clause.
9545      TYPENAME if for a typename (in a cast or sizeof).
9546       Don't make a DECL node; just return the ..._TYPE node.
9547      FIELD for a struct or union field; make a FIELD_DECL.
9548      BITFIELD for a field with specified width.
9549    INITIALIZED is 1 if the decl has an initializer.
9550
9551    ATTRLIST is a pointer to the list of attributes, which may be NULL
9552    if there are none; *ATTRLIST may be modified if attributes from inside
9553    the declarator should be applied to the declaration.
9554
9555    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9556    It may also be so in the PARM case, for a prototype where the
9557    argument type is specified but not the name.
9558
9559    This function is where the complicated C meanings of `static'
9560    and `extern' are interpreted.
9561
9562    For C++, if there is any monkey business to do, the function which
9563    calls this one must do it, i.e., prepending instance variables,
9564    renaming overloaded function names, etc.
9565
9566    Note that for this C++, it is an error to define a method within a class
9567    which does not belong to that class.
9568
9569    Except in the case where SCOPE_REFs are implicitly known (such as
9570    methods within a class being redundantly qualified),
9571    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9572    (class_name::decl_name).  The caller must also deal with this.
9573
9574    If a constructor or destructor is seen, and the context is FIELD,
9575    then the type gains the attribute TREE_HAS_x.  If such a declaration
9576    is erroneous, NULL_TREE is returned.
9577
9578    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9579    function, these are the qualifiers to give to the `this' pointer. We
9580    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9581
9582    May return void_type_node if the declarator turned out to be a friend.
9583    See grokfield for details.  */
9584
9585 tree
9586 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9587      tree declspecs;
9588      tree declarator;
9589      enum decl_context decl_context;
9590      int initialized;
9591      tree *attrlist;
9592 {
9593   RID_BIT_TYPE specbits;
9594   int nclasses = 0;
9595   tree spec;
9596   tree type = NULL_TREE;
9597   int longlong = 0;
9598   int constp;
9599   int restrictp;
9600   int volatilep;
9601   int type_quals;
9602   int virtualp, explicitp, friendp, inlinep, staticp;
9603   int explicit_int = 0;
9604   int explicit_char = 0;
9605   int defaulted_int = 0;
9606   int extern_langp = 0;
9607
9608   tree typedef_decl = NULL_TREE;
9609   const char *name;
9610   tree typedef_type = NULL_TREE;
9611   int funcdef_flag = 0;
9612   enum tree_code innermost_code = ERROR_MARK;
9613   int bitfield = 0;
9614 #if 0
9615   /* See the code below that used this.  */
9616   tree decl_attr = NULL_TREE;
9617 #endif
9618   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9619      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9620   tree init = NULL_TREE;
9621
9622   /* Keep track of what sort of function is being processed
9623      so that we can warn about default return values, or explicit
9624      return values which do not match prescribed defaults.  */
9625   special_function_kind sfk = sfk_none;
9626
9627   tree dname = NULL_TREE;
9628   tree ctype = current_class_type;
9629   tree ctor_return_type = NULL_TREE;
9630   enum overload_flags flags = NO_SPECIAL;
9631   tree quals = NULL_TREE;
9632   tree raises = NULL_TREE;
9633   int template_count = 0;
9634   tree in_namespace = NULL_TREE;
9635   tree returned_attrs = NULL_TREE;
9636
9637   RIDBIT_RESET_ALL (specbits);
9638   if (decl_context == FUNCDEF)
9639     funcdef_flag = 1, decl_context = NORMAL;
9640   else if (decl_context == MEMFUNCDEF)
9641     funcdef_flag = -1, decl_context = FIELD;
9642   else if (decl_context == BITFIELD)
9643     bitfield = 1, decl_context = FIELD;
9644
9645   /* Look inside a declarator for the name being declared
9646      and get it as a string, for an error message.  */
9647   {
9648     tree *next = &declarator;
9649     register tree decl;
9650     name = NULL;
9651
9652     while (next && *next)
9653       {
9654         decl = *next;
9655         switch (TREE_CODE (decl))
9656           {
9657           case TREE_LIST:
9658             /* For attributes.  */
9659             next = &TREE_VALUE (decl);
9660             break;
9661
9662           case COND_EXPR:
9663             ctype = NULL_TREE;
9664             next = &TREE_OPERAND (decl, 0);
9665             break;
9666
9667           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9668             {
9669               tree name = TREE_OPERAND (decl, 0);
9670               tree rename = NULL_TREE;
9671
9672               my_friendly_assert (flags == NO_SPECIAL, 152);
9673               flags = DTOR_FLAG;
9674               sfk = sfk_destructor;
9675               if (TREE_CODE (name) == TYPE_DECL)
9676                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9677               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9678               if (ctype == NULL_TREE)
9679                 {
9680                   if (current_class_type == NULL_TREE)
9681                     {
9682                       error ("destructors must be member functions");
9683                       flags = NO_SPECIAL;
9684                     }
9685                   else
9686                     {
9687                       tree t = constructor_name (current_class_name);
9688                       if (t != name)
9689                         rename = t;
9690                     }
9691                 }
9692               else
9693                 {
9694                   tree t = constructor_name (ctype);
9695                   if (t != name)
9696                     rename = t;
9697                 }
9698
9699               if (rename)
9700                 {
9701                   cp_error ("destructor `%T' must match class name `%T'",
9702                             name, rename);
9703                   TREE_OPERAND (decl, 0) = rename;
9704                 }
9705               next = &name;
9706             }
9707             break;
9708
9709           case ADDR_EXPR:       /* C++ reference declaration */
9710             /* Fall through. */
9711           case ARRAY_REF:
9712           case INDIRECT_REF:
9713             ctype = NULL_TREE;
9714             innermost_code = TREE_CODE (decl);
9715             next = &TREE_OPERAND (decl, 0);
9716             break;
9717
9718           case CALL_EXPR:
9719             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9720               {
9721                 /* This is actually a variable declaration using
9722                    constructor syntax.  We need to call start_decl and
9723                    cp_finish_decl so we can get the variable
9724                    initialized...  */
9725
9726                 tree attributes;
9727
9728                 *next = TREE_OPERAND (decl, 0);
9729                 init = CALL_DECLARATOR_PARMS (decl);
9730
9731                 if (attrlist)
9732                   {
9733                     attributes = *attrlist;
9734                   }
9735                 else
9736                   {
9737                     attributes = NULL_TREE;
9738                   }
9739
9740                 decl = start_decl (declarator, declspecs, 1,
9741                                    attributes, NULL_TREE);
9742                 decl_type_access_control (decl);
9743                 if (decl)
9744                   {
9745                     /* Look for __unused__ attribute */
9746                     if (TREE_USED (TREE_TYPE (decl)))
9747                       TREE_USED (decl) = 1;
9748                     finish_decl (decl, init, NULL_TREE);
9749                   }
9750                 else
9751                   cp_error ("invalid declarator");
9752                 return 0;
9753               }
9754             innermost_code = TREE_CODE (decl);
9755             if (decl_context == FIELD && ctype == NULL_TREE)
9756               ctype = current_class_type;
9757             if (ctype
9758                 && TREE_OPERAND (decl, 0)
9759                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9760                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9761                          == constructor_name_full (ctype))
9762                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9763                             == constructor_name (ctype)))))
9764               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9765             next = &TREE_OPERAND (decl, 0);
9766             decl = *next;
9767             if (ctype != NULL_TREE
9768                 && decl != NULL_TREE && flags != DTOR_FLAG
9769                 && decl == constructor_name (ctype))
9770               {
9771                 sfk = sfk_constructor;
9772                 ctor_return_type = ctype;
9773               }
9774             ctype = NULL_TREE;
9775             break;
9776
9777           case TEMPLATE_ID_EXPR:
9778               {
9779                 tree fns = TREE_OPERAND (decl, 0);
9780
9781                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9782                   fns = TREE_OPERAND (fns, 0);
9783
9784                 dname = fns;
9785                 if (TREE_CODE (dname) == COMPONENT_REF)
9786                   dname = TREE_OPERAND (dname, 1);
9787                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9788                   {
9789                     my_friendly_assert (is_overloaded_fn (dname),
9790                                         19990331);
9791                     dname = DECL_NAME (get_first_fn (dname));
9792                   }
9793               }
9794           /* Fall through. */
9795
9796           case IDENTIFIER_NODE:
9797             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9798               dname = decl;
9799
9800             next = 0;
9801
9802             if (C_IS_RESERVED_WORD (dname))
9803               {
9804                 cp_error ("declarator-id missing; using reserved word `%D'",
9805                           dname);
9806                 name = IDENTIFIER_POINTER (dname);
9807               }
9808             else if (!IDENTIFIER_TYPENAME_P (dname))
9809               name = IDENTIFIER_POINTER (dname);
9810             else
9811               {
9812                 my_friendly_assert (flags == NO_SPECIAL, 154);
9813                 flags = TYPENAME_FLAG;
9814                 ctor_return_type = TREE_TYPE (dname);
9815                 sfk = sfk_conversion;
9816                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9817                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9818                         == TYPE_DECL))
9819                   name = IDENTIFIER_POINTER (dname);
9820                 else
9821                   name = "<invalid operator>";
9822               }
9823             break;
9824
9825             /* C++ extension */
9826           case SCOPE_REF:
9827             {
9828               /* Perform error checking, and decide on a ctype.  */
9829               tree cname = TREE_OPERAND (decl, 0);
9830               if (cname == NULL_TREE)
9831                 ctype = NULL_TREE;
9832               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9833                 {
9834                   ctype = NULL_TREE;
9835                   in_namespace = TREE_OPERAND (decl, 0);
9836                   TREE_OPERAND (decl, 0) = NULL_TREE;
9837                 }
9838               else if (! is_aggr_type (cname, 1))
9839                 TREE_OPERAND (decl, 0) = NULL_TREE;
9840               /* Must test TREE_OPERAND (decl, 1), in case user gives
9841                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9842               else if (TREE_OPERAND (decl, 1)
9843                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9844                 ctype = cname;
9845               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9846                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9847                 {
9848                   cp_error ("`%T::%D' is not a valid declarator", cname,
9849                             TREE_OPERAND (decl, 1));
9850                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9851                             cname, TREE_OPERAND (decl, 1));
9852                   return void_type_node;
9853                 }
9854               else if (ctype == NULL_TREE)
9855                 ctype = cname;
9856               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9857                 TREE_OPERAND (decl, 0) = ctype;
9858               else
9859                 {
9860                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9861                     {
9862                       cp_error ("type `%T' is not derived from type `%T'",
9863                                 cname, ctype);
9864                       TREE_OPERAND (decl, 0) = NULL_TREE;
9865                     }
9866                   else
9867                     ctype = cname;
9868                 }
9869
9870               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9871                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9872                        == constructor_name_full (ctype))
9873                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9874                           == constructor_name (ctype))))
9875                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9876               next = &TREE_OPERAND (decl, 1);
9877               decl = *next;
9878               if (ctype)
9879                 {
9880                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9881                       && constructor_name (ctype) == decl)
9882                     {
9883                       sfk = sfk_constructor;
9884                       ctor_return_type = ctype;
9885                     }
9886                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9887                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9888                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9889                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9890                     {
9891                       sfk = sfk_destructor;
9892                       ctor_return_type = ctype;
9893                       flags = DTOR_FLAG;
9894                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9895                       next = &TREE_OPERAND (decl, 0);
9896                     }
9897                 }
9898             }
9899             break;
9900
9901           case ERROR_MARK:
9902             next = 0;
9903             break;
9904
9905           case TYPE_DECL:
9906             /* Parse error puts this typespec where
9907                a declarator should go.  */
9908             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9909             if (TREE_TYPE (decl) == current_class_type)
9910               cp_error ("  perhaps you want `%T' for a constructor",
9911                         current_class_name);
9912             dname = DECL_NAME (decl);
9913             name = IDENTIFIER_POINTER (dname);
9914
9915             /* Avoid giving two errors for this.  */
9916             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9917
9918             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9919             *next = dname;
9920             next = 0;
9921             break;
9922
9923           default:
9924             cp_compiler_error ("`%D' as declarator", decl);
9925             return 0; /* We used to do a 155 abort here.  */
9926           }
9927       }
9928   }
9929
9930   /* A function definition's declarator must have the form of
9931      a function declarator.  */
9932
9933   if (funcdef_flag && innermost_code != CALL_EXPR)
9934     return 0;
9935
9936   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9937       && innermost_code != CALL_EXPR
9938       && ! (ctype && declspecs == NULL_TREE))
9939     {
9940       cp_error ("declaration of `%D' as non-function", dname);
9941       return void_type_node;
9942     }
9943
9944   /* Anything declared one level down from the top level
9945      must be one of the parameters of a function
9946      (because the body is at least two levels down).  */
9947
9948   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9949      by not allowing C++ class definitions to specify their parameters
9950      with xdecls (must be spec.d in the parmlist).
9951
9952      Since we now wait to push a class scope until we are sure that
9953      we are in a legitimate method context, we must set oldcname
9954      explicitly (since current_class_name is not yet alive).
9955
9956      We also want to avoid calling this a PARM if it is in a namespace.  */
9957
9958   if (decl_context == NORMAL && !toplevel_bindings_p ())
9959     {
9960       struct binding_level *b = current_binding_level;
9961       current_binding_level = b->level_chain;
9962       if (current_binding_level != 0 && toplevel_bindings_p ())
9963         decl_context = PARM;
9964       current_binding_level = b;
9965     }
9966
9967   if (name == NULL)
9968     name = decl_context == PARM ? "parameter" : "type name";
9969
9970   /* Look through the decl specs and record which ones appear.
9971      Some typespecs are defined as built-in typenames.
9972      Others, the ones that are modifiers of other types,
9973      are represented by bits in SPECBITS: set the bits for
9974      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9975
9976      If there is a typedef name or a type, store the type in TYPE.
9977      This includes builtin typedefs such as `int'.
9978
9979      Set EXPLICIT_INT if the type is `int' or `char' and did not
9980      come from a user typedef.
9981
9982      Set LONGLONG if `long' is mentioned twice.
9983
9984      For C++, constructors and destructors have their own fast treatment.  */
9985
9986   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9987     {
9988       register int i;
9989       register tree id;
9990
9991       /* Certain parse errors slip through.  For example,
9992          `int class;' is not caught by the parser. Try
9993          weakly to recover here.  */
9994       if (TREE_CODE (spec) != TREE_LIST)
9995         return 0;
9996
9997       id = TREE_VALUE (spec);
9998
9999       if (TREE_CODE (id) == IDENTIFIER_NODE)
10000         {
10001           if (id == ridpointers[(int) RID_INT]
10002               || id == ridpointers[(int) RID_CHAR]
10003               || id == ridpointers[(int) RID_BOOL]
10004               || id == ridpointers[(int) RID_WCHAR])
10005             {
10006               if (type)
10007                 {
10008                   if (id == ridpointers[(int) RID_BOOL])
10009                     error ("`bool' is now a keyword");
10010                   else
10011                     cp_error ("extraneous `%T' ignored", id);
10012                 }
10013               else
10014                 {
10015                   if (id == ridpointers[(int) RID_INT])
10016                     explicit_int = 1;
10017                   else if (id == ridpointers[(int) RID_CHAR])
10018                     explicit_char = 1;
10019                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10020                 }
10021               goto found;
10022             }
10023           /* C++ aggregate types.  */
10024           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10025             {
10026               if (type)
10027                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10028               else
10029                 type = IDENTIFIER_TYPE_VALUE (id);
10030               goto found;
10031             }
10032
10033           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10034             {
10035               if (ridpointers[i] == id)
10036                 {
10037                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10038                     {
10039                       if (pedantic && ! in_system_header && warn_long_long)
10040                         pedwarn ("ISO C++ does not support `long long'");
10041                       if (longlong)
10042                         error ("`long long long' is too long for GCC");
10043                       else
10044                         longlong = 1;
10045                     }
10046                   else if (RIDBIT_SETP (i, specbits))
10047                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10048                   if (i == (int)RID_EXTERN
10049                       && TREE_PURPOSE (spec) == error_mark_node)
10050                     /* This extern was part of a language linkage.  */
10051                     extern_langp = 1;
10052                   RIDBIT_SET (i, specbits);
10053                   goto found;
10054                 }
10055             }
10056         }
10057       /* C++ aggregate types.  */
10058       else if (TREE_CODE (id) == TYPE_DECL)
10059         {
10060           if (type)
10061             cp_error ("multiple declarations `%T' and `%T'", type,
10062                       TREE_TYPE (id));
10063           else
10064             {
10065               type = TREE_TYPE (id);
10066               TREE_VALUE (spec) = type;
10067             }
10068           goto found;
10069         }
10070       if (type)
10071         error ("two or more data types in declaration of `%s'", name);
10072       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10073         {
10074           register tree t = lookup_name (id, 1);
10075           if (!t || TREE_CODE (t) != TYPE_DECL)
10076             error ("`%s' fails to be a typedef or built in type",
10077                    IDENTIFIER_POINTER (id));
10078           else
10079             {
10080               type = TREE_TYPE (t);
10081 #if 0
10082               /* See the code below that used this.  */
10083               decl_attr = DECL_ATTRIBUTES (id);
10084 #endif
10085               typedef_decl = t;
10086             }
10087         }
10088       else if (id != error_mark_node)
10089         /* Can't change CLASS nodes into RECORD nodes here!  */
10090         type = id;
10091
10092     found: ;
10093     }
10094
10095   typedef_type = type;
10096
10097   /* No type at all: default to `int', and set DEFAULTED_INT
10098      because it was not a user-defined typedef.  */
10099
10100   if (type == NULL_TREE
10101       && (RIDBIT_SETP (RID_SIGNED, specbits)
10102           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10103           || RIDBIT_SETP (RID_LONG, specbits)
10104           || RIDBIT_SETP (RID_SHORT, specbits)))
10105     {
10106       /* These imply 'int'.  */
10107       type = integer_type_node;
10108       defaulted_int = 1;
10109     }
10110
10111   if (sfk != sfk_none)
10112     type = check_special_function_return_type (sfk, type,
10113                                                ctor_return_type);
10114   else if (type == NULL_TREE)
10115     {
10116       int is_main;
10117
10118       explicit_int = -1;
10119
10120       /* We handle `main' specially here, because 'main () { }' is so
10121          common.  With no options, it is allowed.  With -Wreturn-type,
10122          it is a warning.  It is only an error with -pedantic-errors.  */
10123       is_main = (funcdef_flag
10124                  && MAIN_NAME_P (dname)
10125                  && ctype == NULL_TREE
10126                  && in_namespace == NULL_TREE
10127                  && current_namespace == global_namespace);
10128
10129       if (in_system_header || flag_ms_extensions)
10130         /* Allow it, sigh.  */;
10131       else if (pedantic || ! is_main)
10132         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10133                     name);
10134       else if (warn_return_type)
10135         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10136                     name);
10137
10138       type = integer_type_node;
10139     }
10140
10141   ctype = NULL_TREE;
10142
10143   /* Now process the modifiers that were specified
10144      and check for invalid combinations.  */
10145
10146   /* Long double is a special combination.  */
10147
10148   if (RIDBIT_SETP (RID_LONG, specbits)
10149       && TYPE_MAIN_VARIANT (type) == double_type_node)
10150     {
10151       RIDBIT_RESET (RID_LONG, specbits);
10152       type = build_qualified_type (long_double_type_node,
10153                                    cp_type_quals (type));
10154     }
10155
10156   /* Check all other uses of type modifiers.  */
10157
10158   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10159       || RIDBIT_SETP (RID_SIGNED, specbits)
10160       || RIDBIT_SETP (RID_LONG, specbits)
10161       || RIDBIT_SETP (RID_SHORT, specbits))
10162     {
10163       int ok = 0;
10164
10165       if (TREE_CODE (type) == REAL_TYPE)
10166         error ("short, signed or unsigned invalid for `%s'", name);
10167       else if (TREE_CODE (type) != INTEGER_TYPE)
10168         error ("long, short, signed or unsigned invalid for `%s'", name);
10169       else if (RIDBIT_SETP (RID_LONG, specbits)
10170                && RIDBIT_SETP (RID_SHORT, specbits))
10171         error ("long and short specified together for `%s'", name);
10172       else if ((RIDBIT_SETP (RID_LONG, specbits)
10173                 || RIDBIT_SETP (RID_SHORT, specbits))
10174                && explicit_char)
10175         error ("long or short specified with char for `%s'", name);
10176       else if ((RIDBIT_SETP (RID_LONG, specbits)
10177                 || RIDBIT_SETP (RID_SHORT, specbits))
10178                && TREE_CODE (type) == REAL_TYPE)
10179         error ("long or short specified with floating type for `%s'", name);
10180       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10181                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10182         error ("signed and unsigned given together for `%s'", name);
10183       else
10184         {
10185           ok = 1;
10186           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10187             {
10188               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10189                        name);
10190               if (flag_pedantic_errors)
10191                 ok = 0;
10192             }
10193         }
10194
10195       /* Discard the type modifiers if they are invalid.  */
10196       if (! ok)
10197         {
10198           RIDBIT_RESET (RID_UNSIGNED, specbits);
10199           RIDBIT_RESET (RID_SIGNED, specbits);
10200           RIDBIT_RESET (RID_LONG, specbits);
10201           RIDBIT_RESET (RID_SHORT, specbits);
10202           longlong = 0;
10203         }
10204     }
10205
10206   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10207       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10208     {
10209       error ("complex invalid for `%s'", name);
10210       RIDBIT_RESET (RID_COMPLEX, specbits);
10211     }
10212
10213   /* Decide whether an integer type is signed or not.
10214      Optionally treat bitfields as signed by default.  */
10215   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10216       /* [class.bit]
10217
10218          It is implementation-defined whether a plain (neither
10219          explicitly signed or unsigned) char, short, int, or long
10220          bit-field is signed or unsigned.
10221
10222          Naturally, we extend this to long long as well.  Note that
10223          this does not include wchar_t.  */
10224       || (bitfield && !flag_signed_bitfields
10225           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10226           /* A typedef for plain `int' without `signed' can be
10227              controlled just like plain `int', but a typedef for
10228              `signed int' cannot be so controlled.  */
10229           && !(typedef_decl
10230                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10231           && (TREE_CODE (type) == INTEGER_TYPE
10232               || TREE_CODE (type) == CHAR_TYPE)
10233           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10234     {
10235       if (longlong)
10236         type = long_long_unsigned_type_node;
10237       else if (RIDBIT_SETP (RID_LONG, specbits))
10238         type = long_unsigned_type_node;
10239       else if (RIDBIT_SETP (RID_SHORT, specbits))
10240         type = short_unsigned_type_node;
10241       else if (type == char_type_node)
10242         type = unsigned_char_type_node;
10243       else if (typedef_decl)
10244         type = unsigned_type (type);
10245       else
10246         type = unsigned_type_node;
10247     }
10248   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10249            && type == char_type_node)
10250     type = signed_char_type_node;
10251   else if (longlong)
10252     type = long_long_integer_type_node;
10253   else if (RIDBIT_SETP (RID_LONG, specbits))
10254     type = long_integer_type_node;
10255   else if (RIDBIT_SETP (RID_SHORT, specbits))
10256     type = short_integer_type_node;
10257
10258   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10259     {
10260       /* If we just have "complex", it is equivalent to
10261          "complex double", but if any modifiers at all are specified it is
10262          the complex form of TYPE.  E.g, "complex short" is
10263          "complex short int".  */
10264
10265       if (defaulted_int && ! longlong
10266           && ! (RIDBIT_SETP (RID_LONG, specbits)
10267                 || RIDBIT_SETP (RID_SHORT, specbits)
10268                 || RIDBIT_SETP (RID_SIGNED, specbits)
10269                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10270         type = complex_double_type_node;
10271       else if (type == integer_type_node)
10272         type = complex_integer_type_node;
10273       else if (type == float_type_node)
10274         type = complex_float_type_node;
10275       else if (type == double_type_node)
10276         type = complex_double_type_node;
10277       else if (type == long_double_type_node)
10278         type = complex_long_double_type_node;
10279       else
10280         type = build_complex_type (type);
10281     }
10282
10283   if (sfk == sfk_conversion
10284       && (RIDBIT_SETP (RID_CONST, specbits)
10285           || RIDBIT_SETP (RID_VOLATILE, specbits)
10286           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10287     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10288               ctor_return_type);
10289
10290   /* Set CONSTP if this declaration is `const', whether by
10291      explicit specification or via a typedef.
10292      Likewise for VOLATILEP.  */
10293
10294   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10295   restrictp =
10296     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10297   volatilep =
10298     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10299   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10300                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10301                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10302   type = cp_build_qualified_type (type, type_quals);
10303   staticp = 0;
10304   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10305   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10306   RIDBIT_RESET (RID_VIRTUAL, specbits);
10307   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10308   RIDBIT_RESET (RID_EXPLICIT, specbits);
10309
10310   if (RIDBIT_SETP (RID_STATIC, specbits))
10311     staticp = 1 + (decl_context == FIELD);
10312
10313   if (virtualp && staticp == 2)
10314     {
10315       cp_error ("member `%D' cannot be declared both virtual and static",
10316                 dname);
10317       staticp = 0;
10318     }
10319   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10320   RIDBIT_RESET (RID_FRIEND, specbits);
10321
10322   /* Warn if two storage classes are given. Default to `auto'.  */
10323
10324   if (RIDBIT_ANY_SET (specbits))
10325     {
10326       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10327       if (RIDBIT_SETP (RID_EXTERN, specbits) && !extern_langp) nclasses++;
10328       if (decl_context == PARM && nclasses > 0)
10329         error ("storage class specifiers invalid in parameter declarations");
10330       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10331         {
10332           if (decl_context == PARM)
10333             error ("typedef declaration invalid in parameter declaration");
10334           nclasses++;
10335         }
10336       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10337       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10338       if (!nclasses && !friendp && extern_langp)
10339         nclasses++;
10340     }
10341
10342   /* Give error if `virtual' is used outside of class declaration.  */
10343   if (virtualp
10344       && (current_class_name == NULL_TREE || decl_context != FIELD))
10345     {
10346       error ("virtual outside class declaration");
10347       virtualp = 0;
10348     }
10349
10350   /* Static anonymous unions are dealt with here.  */
10351   if (staticp && decl_context == TYPENAME
10352       && TREE_CODE (declspecs) == TREE_LIST
10353       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10354     decl_context = FIELD;
10355
10356   /* Warn about storage classes that are invalid for certain
10357      kinds of declarations (parameters, typenames, etc.).  */
10358
10359   if (nclasses > 1)
10360     error ("multiple storage classes in declaration of `%s'", name);
10361   else if (decl_context != NORMAL && nclasses > 0)
10362     {
10363       if ((decl_context == PARM || decl_context == CATCHPARM)
10364           && (RIDBIT_SETP (RID_REGISTER, specbits)
10365               || RIDBIT_SETP (RID_AUTO, specbits)))
10366         ;
10367       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10368         ;
10369       else if (decl_context == FIELD
10370                /* C++ allows static class elements  */
10371                && RIDBIT_SETP (RID_STATIC, specbits))
10372         /* C++ also allows inlines and signed and unsigned elements,
10373            but in those cases we don't come in here.  */
10374         ;
10375       else
10376         {
10377           if (decl_context == FIELD)
10378             {
10379               tree tmp = NULL_TREE;
10380               register int op = 0;
10381
10382               if (declarator)
10383                 {
10384                   /* Avoid trying to get an operand off an identifier node.  */
10385                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10386                     tmp = declarator;
10387                   else
10388                     tmp = TREE_OPERAND (declarator, 0);
10389                   op = IDENTIFIER_OPNAME_P (tmp);
10390                   if (IDENTIFIER_TYPENAME_P (tmp))
10391                     {
10392                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10393                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10394                               == TYPE_DECL))
10395                         name = IDENTIFIER_POINTER (tmp);
10396                       else
10397                         name = "<invalid operator>";
10398                     }
10399                 }
10400               error ("storage class specified for %s `%s'",
10401                      op ? "member operator" : "field",
10402                      name);
10403             }
10404           else
10405             {
10406               if (decl_context == PARM || decl_context == CATCHPARM)
10407                 error ("storage class specified for parameter `%s'", name);
10408               else
10409                 error ("storage class specified for typename");
10410             }
10411           RIDBIT_RESET (RID_REGISTER, specbits);
10412           RIDBIT_RESET (RID_AUTO, specbits);
10413           RIDBIT_RESET (RID_EXTERN, specbits);
10414         }
10415     }
10416   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10417     {
10418       if (toplevel_bindings_p ())
10419         {
10420           /* It's common practice (and completely valid) to have a const
10421              be initialized and declared extern.  */
10422           if (!(type_quals & TYPE_QUAL_CONST))
10423             warning ("`%s' initialized and declared `extern'", name);
10424         }
10425       else
10426         error ("`%s' has both `extern' and initializer", name);
10427     }
10428   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10429            && ! toplevel_bindings_p ())
10430     error ("nested function `%s' declared `extern'", name);
10431   else if (toplevel_bindings_p ())
10432     {
10433       if (RIDBIT_SETP (RID_AUTO, specbits))
10434         error ("top-level declaration of `%s' specifies `auto'", name);
10435     }
10436
10437   if (nclasses > 0 && friendp)
10438     error ("storage class specifiers invalid in friend function declarations");
10439
10440   /* Now figure out the structure of the declarator proper.
10441      Descend through it, creating more complex types, until we reach
10442      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10443
10444   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10445          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10446     {
10447       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10448          an INDIRECT_REF (for *...),
10449          a CALL_EXPR (for ...(...)),
10450          an identifier (for the name being declared)
10451          or a null pointer (for the place in an absolute declarator
10452          where the name was omitted).
10453          For the last two cases, we have just exited the loop.
10454
10455          For C++ it could also be
10456          a SCOPE_REF (for class :: ...).  In this case, we have converted
10457          sensible names to types, and those are the values we use to
10458          qualify the member name.
10459          an ADDR_EXPR (for &...),
10460          a BIT_NOT_EXPR (for destructors)
10461
10462          At this point, TYPE is the type of elements of an array,
10463          or for a function to return, or for a pointer to point to.
10464          After this sequence of ifs, TYPE is the type of the
10465          array or function or pointer, and DECLARATOR has had its
10466          outermost layer removed.  */
10467
10468       if (type == error_mark_node)
10469         {
10470           if (TREE_CODE (declarator) == SCOPE_REF)
10471             declarator = TREE_OPERAND (declarator, 1);
10472           else
10473             declarator = TREE_OPERAND (declarator, 0);
10474           continue;
10475         }
10476       if (quals != NULL_TREE
10477           && (declarator == NULL_TREE
10478               || TREE_CODE (declarator) != SCOPE_REF))
10479         {
10480           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10481             ctype = TYPE_METHOD_BASETYPE (type);
10482           if (ctype != NULL_TREE)
10483             {
10484               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10485               grok_method_quals (ctype, dummy, quals);
10486               type = TREE_TYPE (dummy);
10487               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10488               quals = NULL_TREE;
10489             }
10490         }
10491
10492       switch (TREE_CODE (declarator))
10493         {
10494         case TREE_LIST:
10495           {
10496             /* We encode a declarator with embedded attributes using
10497                a TREE_LIST.  */
10498             tree attrs = TREE_PURPOSE (declarator);
10499             tree inner_decl;
10500             int attr_flags;
10501
10502             declarator = TREE_VALUE (declarator);
10503             inner_decl = declarator;
10504             while (inner_decl != NULL_TREE
10505                    && TREE_CODE (inner_decl) == TREE_LIST)
10506               inner_decl = TREE_VALUE (inner_decl);
10507             attr_flags = 0;
10508             if (inner_decl == NULL_TREE
10509                 || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
10510               attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
10511             if (TREE_CODE (inner_decl) == CALL_EXPR)
10512               attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
10513             if (TREE_CODE (inner_decl) == ARRAY_REF)
10514               attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
10515             returned_attrs = decl_attributes (&type,
10516                                               chainon (returned_attrs, attrs),
10517                                               attr_flags);
10518           }
10519           break;
10520
10521         case ARRAY_REF:
10522           {
10523             register tree size;
10524
10525             size = TREE_OPERAND (declarator, 1);
10526
10527             /* VC++ spells a zero-sized array with [].  */
10528             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10529                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10530               size = integer_zero_node;
10531
10532             declarator = TREE_OPERAND (declarator, 0);
10533
10534             type = create_array_type_for_decl (dname, type, size);
10535
10536             /* VLAs never work as fields. */
10537             if (decl_context == FIELD && !processing_template_decl
10538                 && TREE_CODE (type) == ARRAY_TYPE
10539                 && TYPE_DOMAIN (type) != NULL_TREE
10540                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10541               {
10542                 cp_error ("size of member `%D' is not constant", dname);
10543                 /* Proceed with arbitrary constant size, so that offset
10544                    computations don't get confused. */
10545                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10546                                                    integer_one_node);
10547               }
10548
10549             ctype = NULL_TREE;
10550           }
10551           break;
10552
10553         case CALL_EXPR:
10554           {
10555             tree arg_types;
10556             int funcdecl_p;
10557             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10558             tree inner_decl = TREE_OPERAND (declarator, 0);
10559
10560             /* Declaring a function type.
10561                Make sure we have a valid type for the function to return.  */
10562
10563             /* We now know that the TYPE_QUALS don't apply to the
10564                decl, but to its return type.  */
10565             type_quals = TYPE_UNQUALIFIED;
10566
10567             /* Warn about some types functions can't return.  */
10568
10569             if (TREE_CODE (type) == FUNCTION_TYPE)
10570               {
10571                 error ("`%s' declared as function returning a function", name);
10572                 type = integer_type_node;
10573               }
10574             if (TREE_CODE (type) == ARRAY_TYPE)
10575               {
10576                 error ("`%s' declared as function returning an array", name);
10577                 type = integer_type_node;
10578               }
10579
10580             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10581               inner_decl = TREE_OPERAND (inner_decl, 1);
10582
10583             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10584               inner_decl = dname;
10585
10586             /* Pick up type qualifiers which should be applied to `this'.  */
10587             quals = CALL_DECLARATOR_QUALS (declarator);
10588
10589             /* Pick up the exception specifications.  */
10590             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10591
10592             /* Say it's a definition only for the CALL_EXPR
10593                closest to the identifier.  */
10594             funcdecl_p
10595               = inner_decl
10596               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10597                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10598                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10599
10600             if (ctype == NULL_TREE
10601                 && decl_context == FIELD
10602                 && funcdecl_p
10603                 && (friendp == 0 || dname == current_class_name))
10604               ctype = current_class_type;
10605
10606             if (ctype && sfk == sfk_conversion)
10607               TYPE_HAS_CONVERSION (ctype) = 1;
10608             if (ctype && constructor_name (ctype) == dname)
10609               {
10610                 /* We are within a class's scope. If our declarator name
10611                    is the same as the class name, and we are defining
10612                    a function, then it is a constructor/destructor, and
10613                    therefore returns a void type.  */
10614
10615                 if (flags == DTOR_FLAG)
10616                   {
10617                     /* ISO C++ 12.4/2.  A destructor may not be
10618                        declared const or volatile.  A destructor may
10619                        not be static.  */
10620                     if (staticp == 2)
10621                       error ("destructor cannot be static member function");
10622                     if (quals)
10623                       {
10624                         cp_error ("destructors may not be `%s'",
10625                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10626                         quals = NULL_TREE;
10627                       }
10628                     if (decl_context == FIELD)
10629                       {
10630                         if (! member_function_or_else (ctype,
10631                                                        current_class_type,
10632                                                        flags))
10633                           return void_type_node;
10634                       }
10635                   }
10636                 else            /* It's a constructor.  */
10637                   {
10638                     if (explicitp == 1)
10639                       explicitp = 2;
10640                     /* ISO C++ 12.1.  A constructor may not be
10641                        declared const or volatile.  A constructor may
10642                        not be virtual.  A constructor may not be
10643                        static.  */
10644                     if (staticp == 2)
10645                       error ("constructor cannot be static member function");
10646                     if (virtualp)
10647                       {
10648                         pedwarn ("constructors cannot be declared virtual");
10649                         virtualp = 0;
10650                       }
10651                     if (quals)
10652                       {
10653                         cp_error ("constructors may not be `%s'",
10654                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10655                         quals = NULL_TREE;
10656                       }
10657                     {
10658                       RID_BIT_TYPE tmp_bits;
10659                       memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
10660                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10661                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10662                       if (RIDBIT_ANY_SET (tmp_bits))
10663                         error ("return value type specifier for constructor ignored");
10664                     }
10665                     if (decl_context == FIELD)
10666                       {
10667                         if (! member_function_or_else (ctype,
10668                                                        current_class_type,
10669                                                        flags))
10670                           return void_type_node;
10671                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10672                         if (sfk != sfk_constructor)
10673                           return NULL_TREE;
10674                       }
10675                   }
10676                 if (decl_context == FIELD)
10677                   staticp = 0;
10678               }
10679             else if (friendp)
10680               {
10681                 if (initialized)
10682                   error ("can't initialize friend function `%s'", name);
10683                 if (virtualp)
10684                   {
10685                     /* Cannot be both friend and virtual.  */
10686                     error ("virtual functions cannot be friends");
10687                     RIDBIT_RESET (RID_FRIEND, specbits);
10688                     friendp = 0;
10689                   }
10690                 if (decl_context == NORMAL)
10691                   error ("friend declaration not in class definition");
10692                 if (current_function_decl && funcdef_flag)
10693                   cp_error ("can't define friend function `%s' in a local class definition",
10694                             name);
10695               }
10696
10697             /* Construct the function type and go to the next
10698                inner layer of declarator.  */
10699
10700             declarator = TREE_OPERAND (declarator, 0);
10701
10702             /* FIXME: This is where default args should be fully
10703                processed.  */
10704
10705             arg_types = grokparms (inner_parms);
10706
10707             if (declarator && flags == DTOR_FLAG)
10708               {
10709                 /* A destructor declared in the body of a class will
10710                    be represented as a BIT_NOT_EXPR.  But, we just
10711                    want the underlying IDENTIFIER.  */
10712                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10713                   declarator = TREE_OPERAND (declarator, 0);
10714
10715                 if (arg_types != void_list_node)
10716                   {
10717                     cp_error ("destructors may not have parameters");
10718                     arg_types = void_list_node;
10719                     last_function_parms = NULL_TREE;
10720                   }
10721               }
10722
10723             /* ANSI says that `const int foo ();'
10724                does not make the function foo const.  */
10725             type = build_function_type (type, arg_types);
10726
10727             {
10728               tree t;
10729               for (t = arg_types; t; t = TREE_CHAIN (t))
10730                 if (TREE_PURPOSE (t)
10731                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10732                   {
10733                     add_defarg_fn (type);
10734                     break;
10735                   }
10736             }
10737           }
10738           break;
10739
10740         case ADDR_EXPR:
10741         case INDIRECT_REF:
10742           /* Filter out pointers-to-references and references-to-references.
10743              We can get these if a TYPE_DECL is used.  */
10744
10745           if (TREE_CODE (type) == REFERENCE_TYPE)
10746             {
10747               error ("cannot declare %s to references",
10748                      TREE_CODE (declarator) == ADDR_EXPR
10749                      ? "references" : "pointers");
10750               declarator = TREE_OPERAND (declarator, 0);
10751               continue;
10752             }
10753
10754           if (TREE_CODE (type) == OFFSET_TYPE
10755               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10756                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10757             {
10758               cp_error ("cannot declare pointer to `%#T' member",
10759                         TREE_TYPE (type));
10760               type = TREE_TYPE (type);
10761             }
10762
10763           /* Merge any constancy or volatility into the target type
10764              for the pointer.  */
10765
10766           /* We now know that the TYPE_QUALS don't apply to the decl,
10767              but to the target of the pointer.  */
10768           type_quals = TYPE_UNQUALIFIED;
10769
10770           if (TREE_CODE (declarator) == ADDR_EXPR)
10771             {
10772               if (TREE_CODE (type) == VOID_TYPE)
10773                 error ("invalid type: `void &'");
10774               else
10775                 type = build_reference_type (type);
10776             }
10777           else if (TREE_CODE (type) == METHOD_TYPE)
10778             type = build_ptrmemfunc_type (build_pointer_type (type));
10779           else
10780             type = build_pointer_type (type);
10781
10782           /* Process a list of type modifier keywords (such as
10783              const or volatile) that were given inside the `*' or `&'.  */
10784
10785           if (TREE_TYPE (declarator))
10786             {
10787               register tree typemodlist;
10788               int erred = 0;
10789
10790               constp = 0;
10791               volatilep = 0;
10792               restrictp = 0;
10793               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10794                    typemodlist = TREE_CHAIN (typemodlist))
10795                 {
10796                   tree qualifier = TREE_VALUE (typemodlist);
10797
10798                   if (qualifier == ridpointers[(int) RID_CONST])
10799                     constp++;
10800                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10801                     volatilep++;
10802                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10803                     restrictp++;
10804                   else if (!erred)
10805                     {
10806                       erred = 1;
10807                       error ("invalid type modifier within pointer declarator");
10808                     }
10809                 }
10810               if (constp > 1)
10811                 pedwarn ("duplicate `const'");
10812               if (volatilep > 1)
10813                 pedwarn ("duplicate `volatile'");
10814               if (restrictp > 1)
10815                 pedwarn ("duplicate `restrict'");
10816
10817               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10818                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10819                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10820               if (TREE_CODE (declarator) == ADDR_EXPR
10821                   && (constp || volatilep))
10822                 {
10823                   if (constp)
10824                     pedwarn ("discarding `const' applied to a reference");
10825                   if (volatilep)
10826                     pedwarn ("discarding `volatile' applied to a reference");
10827                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10828                 }
10829               type = cp_build_qualified_type (type, type_quals);
10830             }
10831           declarator = TREE_OPERAND (declarator, 0);
10832           ctype = NULL_TREE;
10833           break;
10834
10835         case SCOPE_REF:
10836           {
10837             /* We have converted type names to NULL_TREE if the
10838                name was bogus, or to a _TYPE node, if not.
10839
10840                The variable CTYPE holds the type we will ultimately
10841                resolve to.  The code here just needs to build
10842                up appropriate member types.  */
10843             tree sname = TREE_OPERAND (declarator, 1);
10844             tree t;
10845
10846             /* Destructors can have their visibilities changed as well.  */
10847             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10848               sname = TREE_OPERAND (sname, 0);
10849
10850             if (TREE_COMPLEXITY (declarator) == 0)
10851               /* This needs to be here, in case we are called
10852                  multiple times.  */ ;
10853             else if (TREE_COMPLEXITY (declarator) == -1)
10854               /* Namespace member. */
10855               pop_decl_namespace ();
10856             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10857               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10858             else if (! IS_AGGR_TYPE_CODE
10859                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10860               ;
10861             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10862               {
10863                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10864                    that refer to ctype.  They couldn't be resolved earlier
10865                    because we hadn't pushed into the class yet.
10866                    Example: resolve 'B<T>::type' in
10867                    'B<typename B<T>::type> B<T>::f () { }'.  */
10868                 if (current_template_parms
10869                     && uses_template_parms (type)
10870                     && uses_template_parms (current_class_type))
10871                   {
10872                     tree args = current_template_args ();
10873                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10874                   }
10875
10876                 /* This pop_nested_class corresponds to the
10877                    push_nested_class used to push into class scope for
10878                    parsing the argument list of a function decl, in
10879                    qualified_id.  */
10880                 pop_nested_class ();
10881                 TREE_COMPLEXITY (declarator) = current_class_depth;
10882               }
10883             else
10884               my_friendly_abort (16);
10885
10886             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10887               {
10888                 /* We had a reference to a global decl, or
10889                    perhaps we were given a non-aggregate typedef,
10890                    in which case we cleared this out, and should just
10891                    keep going as though it wasn't there.  */
10892                 declarator = sname;
10893                 continue;
10894               }
10895             ctype = TREE_OPERAND (declarator, 0);
10896
10897             t = ctype;
10898             while (t != NULL_TREE && CLASS_TYPE_P (t))
10899               {
10900                 /* You're supposed to have one `template <...>'
10901                    for every template class, but you don't need one
10902                    for a full specialization.  For example:
10903
10904                      template <class T> struct S{};
10905                      template <> struct S<int> { void f(); };
10906                      void S<int>::f () {}
10907
10908                    is correct; there shouldn't be a `template <>' for
10909                    the definition of `S<int>::f'.  */
10910                 if (CLASSTYPE_TEMPLATE_INFO (t)
10911                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10912                         || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
10913                     && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
10914                   template_count += 1;
10915
10916                 t = TYPE_MAIN_DECL (t);
10917                 t = DECL_CONTEXT (t);
10918               }
10919
10920             if (sname == NULL_TREE)
10921               goto done_scoping;
10922
10923             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10924               {
10925                 /* This is the `standard' use of the scoping operator:
10926                    basetype :: member .  */
10927
10928                 if (ctype == current_class_type)
10929                   {
10930                     /* class A {
10931                          void A::f ();
10932                        };
10933
10934                        Is this ill-formed?  */
10935
10936                     if (pedantic)
10937                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10938                                   ctype, name);
10939                   }
10940                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10941                   {
10942                     if (current_class_type == NULL_TREE || friendp)
10943                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10944                                                       TYPE_ARG_TYPES (type));
10945                     else
10946                       {
10947                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10948                                   ctype, name, current_class_type);
10949                         return void_type_node;
10950                       }
10951                   }
10952                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10953                          || COMPLETE_TYPE_P (complete_type (ctype)))
10954                   {
10955                     /* Have to move this code elsewhere in this function.
10956                        this code is used for i.e., typedef int A::M; M *pm;
10957
10958                        It is?  How? jason 10/2/94 */
10959
10960                     if (current_class_type)
10961                       {
10962                         cp_error ("cannot declare member `%T::%s' within `%T'",
10963                                   ctype, name, current_class_type);
10964                         return void_type_node;
10965                       }
10966                     type = build_offset_type (ctype, type);
10967                   }
10968                 else
10969                   {
10970                     incomplete_type_error (NULL_TREE, ctype);
10971                     return error_mark_node;
10972                   }
10973
10974                 declarator = sname;
10975               }
10976             else if (TREE_CODE (sname) == SCOPE_REF)
10977               my_friendly_abort (17);
10978             else
10979               {
10980               done_scoping:
10981                 declarator = TREE_OPERAND (declarator, 1);
10982                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10983                   /* In this case, we will deal with it later.  */
10984                   ;
10985                 else
10986                   {
10987                     if (TREE_CODE (type) == FUNCTION_TYPE)
10988                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10989                                                       TYPE_ARG_TYPES (type));
10990                     else
10991                       type = build_offset_type (ctype, type);
10992                   }
10993               }
10994           }
10995           break;
10996
10997         case BIT_NOT_EXPR:
10998           declarator = TREE_OPERAND (declarator, 0);
10999           break;
11000
11001         case RECORD_TYPE:
11002         case UNION_TYPE:
11003         case ENUMERAL_TYPE:
11004           declarator = NULL_TREE;
11005           break;
11006
11007         case ERROR_MARK:
11008           declarator = NULL_TREE;
11009           break;
11010
11011         default:
11012           my_friendly_abort (158);
11013         }
11014     }
11015
11016   if (returned_attrs)
11017     {
11018       if (attrlist)
11019         *attrlist = chainon (returned_attrs, *attrlist);
11020       else
11021         attrlist = &returned_attrs;
11022     }
11023
11024   /* Now TYPE has the actual type.  */
11025
11026   /* Did array size calculations overflow?  */
11027
11028   if (TREE_CODE (type) == ARRAY_TYPE
11029       && COMPLETE_TYPE_P (type)
11030       && TREE_OVERFLOW (TYPE_SIZE (type)))
11031     {
11032       error ("size of array `%s' is too large", name);
11033       /* If we proceed with the array type as it is, we'll eventully
11034          crash in tree_low_cst().  */
11035       type = error_mark_node;
11036     }
11037
11038   if (explicitp == 1 || (explicitp && friendp))
11039     {
11040       /* [dcl.fct.spec] The explicit specifier shall only be used in
11041          declarations of constructors within a class definition.  */
11042       error ("only declarations of constructors can be `explicit'");
11043       explicitp = 0;
11044     }
11045
11046   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11047     {
11048       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11049         {
11050           error ("non-member `%s' cannot be declared `mutable'", name);
11051           RIDBIT_RESET (RID_MUTABLE, specbits);
11052         }
11053       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11054         {
11055           error ("non-object member `%s' cannot be declared `mutable'", name);
11056           RIDBIT_RESET (RID_MUTABLE, specbits);
11057         }
11058       else if (TREE_CODE (type) == FUNCTION_TYPE
11059                || TREE_CODE (type) == METHOD_TYPE)
11060         {
11061           error ("function `%s' cannot be declared `mutable'", name);
11062           RIDBIT_RESET (RID_MUTABLE, specbits);
11063         }
11064       else if (staticp)
11065         {
11066           error ("static `%s' cannot be declared `mutable'", name);
11067           RIDBIT_RESET (RID_MUTABLE, specbits);
11068         }
11069       else if (type_quals & TYPE_QUAL_CONST)
11070         {
11071           error ("const `%s' cannot be declared `mutable'", name);
11072           RIDBIT_RESET (RID_MUTABLE, specbits);
11073         }
11074     }
11075
11076   if (declarator == NULL_TREE
11077       || TREE_CODE (declarator) == IDENTIFIER_NODE
11078       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11079           && (TREE_CODE (type) == FUNCTION_TYPE
11080               || TREE_CODE (type) == METHOD_TYPE)))
11081     /* OK */;
11082   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11083     {
11084       cp_error ("template-id `%D' used as a declarator", declarator);
11085       declarator = dname;
11086     }
11087   else
11088     /* Unexpected declarator format.  */
11089     my_friendly_abort (990210);
11090
11091   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11092
11093   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11094     {
11095       tree decl;
11096
11097       /* Note that the grammar rejects storage classes
11098          in typenames, fields or parameters.  */
11099       if (current_lang_name == lang_name_java)
11100         TYPE_FOR_JAVA (type) = 1;
11101
11102       if (decl_context == FIELD)
11103         {
11104           if (declarator == constructor_name (current_class_type))
11105             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11106                         declarator);
11107           decl = build_lang_decl (TYPE_DECL, declarator, type);
11108         }
11109       else
11110         {
11111           decl = build_decl (TYPE_DECL, declarator, type);
11112           if (!current_function_decl)
11113             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11114         }
11115
11116       /* If the user declares "typedef struct {...} foo" then the
11117          struct will have an anonymous name.  Fill that name in now.
11118          Nothing can refer to it, so nothing needs know about the name
11119          change.  */
11120       if (type != error_mark_node
11121           && declarator
11122           && TYPE_NAME (type)
11123           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11124           && TYPE_ANONYMOUS_P (type)
11125           && cp_type_quals (type) == TYPE_UNQUALIFIED)
11126         {
11127           tree oldname = TYPE_NAME (type);
11128           tree t;
11129
11130           /* Replace the anonymous name with the real name everywhere.  */
11131           lookup_tag_reverse (type, declarator);
11132           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11133             if (TYPE_NAME (t) == oldname)
11134               TYPE_NAME (t) = decl;
11135
11136           if (TYPE_LANG_SPECIFIC (type))
11137             TYPE_WAS_ANONYMOUS (type) = 1;
11138
11139           /* If this is a typedef within a template class, the nested
11140              type is a (non-primary) template.  The name for the
11141              template needs updating as well.  */
11142           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11143             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11144               = TYPE_IDENTIFIER (type);
11145
11146           /* FIXME remangle member functions; member functions of a
11147              type with external linkage have external linkage.  */
11148         }
11149
11150       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11151         {
11152           cp_error_at ("typedef name may not be class-qualified", decl);
11153           return NULL_TREE;
11154         }
11155       else if (quals)
11156         {
11157           if (ctype == NULL_TREE)
11158             {
11159               if (TREE_CODE (type) != METHOD_TYPE)
11160                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11161               else
11162                 ctype = TYPE_METHOD_BASETYPE (type);
11163             }
11164           if (ctype != NULL_TREE)
11165             grok_method_quals (ctype, decl, quals);
11166         }
11167
11168       if (RIDBIT_SETP (RID_SIGNED, specbits)
11169           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11170         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11171
11172       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11173                       inlinep, friendp, raises != NULL_TREE);
11174
11175       if (initialized)
11176         error ("typedef declaration includes an initializer");
11177
11178       return decl;
11179     }
11180
11181   /* Detect the case of an array type of unspecified size
11182      which came, as such, direct from a typedef name.
11183      We must copy the type, so that each identifier gets
11184      a distinct type, so that each identifier's size can be
11185      controlled separately by its own initializer.  */
11186
11187   if (type != 0 && typedef_type != 0
11188       && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0
11189       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
11190     {
11191       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11192     }
11193
11194   /* Detect where we're using a typedef of function type to declare a
11195      function. last_function_parms will not be set, so we must create
11196      it now.  */
11197
11198   if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
11199     {
11200       tree decls = NULL_TREE;
11201       tree args;
11202
11203       for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
11204         {
11205           tree decl = build_decl (PARM_DECL, NULL_TREE, TREE_VALUE (args));
11206
11207           TREE_CHAIN (decl) = decls;
11208           decls = decl;
11209         }
11210
11211       last_function_parms = nreverse (decls);
11212     }
11213
11214   /* If this is a type name (such as, in a cast or sizeof),
11215      compute the type and return it now.  */
11216
11217   if (decl_context == TYPENAME)
11218     {
11219       /* Note that the grammar rejects storage classes
11220          in typenames, fields or parameters.  */
11221       if (type_quals != TYPE_UNQUALIFIED)
11222         type_quals = TYPE_UNQUALIFIED;
11223
11224       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11225       if (friendp)
11226         {
11227           if (type_quals != TYPE_UNQUALIFIED)
11228             {
11229               cp_error ("type qualifiers specified for friend class declaration");
11230               type_quals = TYPE_UNQUALIFIED;
11231             }
11232           if (inlinep)
11233             {
11234               cp_error ("`inline' specified for friend class declaration");
11235               inlinep = 0;
11236             }
11237
11238           /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11239              But don't allow implicit typenames except with a class-key.  */
11240           if (!current_aggr && (TREE_CODE (type) != TYPENAME_TYPE
11241                                 || IMPLICIT_TYPENAME_P (type)))
11242             {
11243               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11244                 cp_pedwarn ("template parameters cannot be friends");
11245               else if (TREE_CODE (type) == TYPENAME_TYPE)
11246                 cp_pedwarn ("\
11247 friend declaration requires class-key, i.e. `friend class %T::%T'",
11248                             constructor_name (current_class_type),
11249                             TYPE_IDENTIFIER (type));
11250               else
11251                 cp_pedwarn ("\
11252 friend declaration requires class-key, i.e. `friend %#T'",
11253                             type);
11254             }
11255
11256           /* Only try to do this stuff if we didn't already give up.  */
11257           if (type != integer_type_node)
11258             {
11259               /* DR 209. The friendly class does not need to be accessible
11260                  in the scope of the class granting friendship. */
11261               skip_type_access_control ();
11262
11263               /* A friendly class?  */
11264               if (current_class_type)
11265                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11266               else
11267                 cp_error ("trying to make class `%T' a friend of global scope",
11268                           type);
11269
11270               type = void_type_node;
11271             }
11272         }
11273       else if (quals)
11274         {
11275           if (ctype == NULL_TREE)
11276             {
11277               if (TREE_CODE (type) != METHOD_TYPE)
11278                 cp_error ("invalid qualifiers on non-member function type");
11279               else
11280                 ctype = TYPE_METHOD_BASETYPE (type);
11281             }
11282           if (ctype)
11283             {
11284               tree dummy = build_decl (TYPE_DECL, declarator, type);
11285               grok_method_quals (ctype, dummy, quals);
11286               type = TREE_TYPE (dummy);
11287             }
11288         }
11289
11290       return type;
11291     }
11292   else if (declarator == NULL_TREE && decl_context != PARM
11293            && decl_context != CATCHPARM
11294            && TREE_CODE (type) != UNION_TYPE
11295            && ! bitfield)
11296     {
11297       cp_error ("abstract declarator `%T' used as declaration", type);
11298       declarator = make_anon_name ();
11299     }
11300
11301   /* `void' at top level (not within pointer)
11302      is allowed only in typedefs or type names.
11303      We don't complain about parms either, but that is because
11304      a better error message can be made later.  */
11305
11306   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11307     {
11308       if (! declarator)
11309         error ("unnamed variable or field declared void");
11310       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11311         {
11312           if (IDENTIFIER_OPNAME_P (declarator))
11313             my_friendly_abort (356);
11314           else
11315             error ("variable or field `%s' declared void", name);
11316         }
11317       else
11318         error ("variable or field declared void");
11319       type = integer_type_node;
11320     }
11321
11322   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11323      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11324
11325   if (decl_context == PARM || decl_context == CATCHPARM)
11326     {
11327       if (ctype || in_namespace)
11328         error ("cannot use `::' in parameter declaration");
11329
11330       /* A parameter declared as an array of T is really a pointer to T.
11331          One declared as a function is really a pointer to a function.
11332          One declared as a member is really a pointer to member.  */
11333
11334       if (TREE_CODE (type) == ARRAY_TYPE)
11335         {
11336           /* Transfer const-ness of array into that of type pointed to.  */
11337           type = build_pointer_type (TREE_TYPE (type));
11338           type_quals = TYPE_UNQUALIFIED;
11339         }
11340       else if (TREE_CODE (type) == FUNCTION_TYPE)
11341         type = build_pointer_type (type);
11342       else if (TREE_CODE (type) == OFFSET_TYPE)
11343         type = build_pointer_type (type);
11344     }
11345
11346   {
11347     register tree decl;
11348
11349     if (decl_context == PARM)
11350       {
11351         decl = build_decl (PARM_DECL, declarator, type);
11352
11353         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11354                         inlinep, friendp, raises != NULL_TREE);
11355
11356         /* Compute the type actually passed in the parmlist,
11357            for the case where there is no prototype.
11358            (For example, shorts and chars are passed as ints.)
11359            When there is a prototype, this is overridden later.  */
11360
11361         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11362       }
11363     else if (decl_context == FIELD)
11364       {
11365         if (type == error_mark_node)
11366           {
11367             /* Happens when declaring arrays of sizes which
11368                are error_mark_node, for example.  */
11369             decl = NULL_TREE;
11370           }
11371         else if (in_namespace && !friendp)
11372           {
11373             /* Something like struct S { int N::j; };  */
11374             cp_error ("invalid use of `::'");
11375             decl = NULL_TREE;
11376           }
11377         else if (TREE_CODE (type) == FUNCTION_TYPE)
11378           {
11379             int publicp = 0;
11380             tree function_context;
11381
11382             /* We catch the others as conflicts with the builtin
11383                typedefs.  */
11384             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11385               {
11386                 cp_error ("function `%D' cannot be declared friend",
11387                           declarator);
11388                 friendp = 0;
11389               }
11390
11391             if (friendp == 0)
11392               {
11393                 if (ctype == NULL_TREE)
11394                   ctype = current_class_type;
11395
11396                 if (ctype == NULL_TREE)
11397                   {
11398                     cp_error ("can't make `%D' into a method -- not in a class",
11399                               declarator);
11400                     return void_type_node;
11401                   }
11402
11403                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11404                    ARM 9.5 */
11405                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11406                   {
11407                     cp_error ("function `%D' declared virtual inside a union",
11408                               declarator);
11409                     return void_type_node;
11410                   }
11411
11412                 if (declarator == ansi_opname (NEW_EXPR)
11413                     || declarator == ansi_opname (VEC_NEW_EXPR)
11414                     || declarator == ansi_opname (DELETE_EXPR)
11415                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11416                   {
11417                     if (virtualp)
11418                       {
11419                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11420                                   declarator);
11421                         virtualp = 0;
11422                       }
11423                   }
11424                 else if (staticp < 2)
11425                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11426                                                   TYPE_ARG_TYPES (type));
11427               }
11428
11429             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11430             function_context = (ctype != NULL_TREE) ?
11431               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11432             publicp = (! friendp || ! staticp)
11433               && function_context == NULL_TREE;
11434             decl = grokfndecl (ctype, type,
11435                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11436                                ? declarator : dname,
11437                                declarator,
11438                                virtualp, flags, quals, raises,
11439                                friendp ? -1 : 0, friendp, publicp, inlinep,
11440                                funcdef_flag, template_count, in_namespace);
11441             if (decl == NULL_TREE)
11442               return decl;
11443 #if 0
11444             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11445             /* The decl and setting of decl_attr is also turned off.  */
11446             decl = build_decl_attribute_variant (decl, decl_attr);
11447 #endif
11448
11449             /* [class.conv.ctor]
11450
11451                A constructor declared without the function-specifier
11452                explicit that can be called with a single parameter
11453                specifies a conversion from the type of its first
11454                parameter to the type of its class.  Such a constructor
11455                is called a converting constructor.  */
11456             if (explicitp == 2)
11457               DECL_NONCONVERTING_P (decl) = 1;
11458             else if (DECL_CONSTRUCTOR_P (decl))
11459               {
11460                 /* The constructor can be called with exactly one
11461                    parameter if there is at least one parameter, and
11462                    any subsequent parameters have default arguments.
11463                    Ignore any compiler-added parms.  */
11464                 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
11465
11466                 if (arg_types == void_list_node
11467                     || (arg_types
11468                         && TREE_CHAIN (arg_types)
11469                         && TREE_CHAIN (arg_types) != void_list_node
11470                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11471                   DECL_NONCONVERTING_P (decl) = 1;
11472               }
11473           }
11474         else if (TREE_CODE (type) == METHOD_TYPE)
11475           {
11476             /* We only get here for friend declarations of
11477                members of other classes.  */
11478             /* All method decls are public, so tell grokfndecl to set
11479                TREE_PUBLIC, also.  */
11480             decl = grokfndecl (ctype, type, declarator, declarator,
11481                                virtualp, flags, quals, raises,
11482                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11483                                template_count, in_namespace);
11484             if (decl == NULL_TREE)
11485               return NULL_TREE;
11486           }
11487         else if (!staticp && ! processing_template_decl
11488                  && !COMPLETE_TYPE_P (complete_type (type))
11489                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11490           {
11491             if (declarator)
11492               cp_error ("field `%D' has incomplete type", declarator);
11493             else
11494               cp_error ("name `%T' has incomplete type", type);
11495
11496             /* If we're instantiating a template, tell them which
11497                instantiation made the field's type be incomplete.  */
11498             if (current_class_type
11499                 && TYPE_NAME (current_class_type)
11500                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11501                 && declspecs && TREE_VALUE (declspecs)
11502                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11503               cp_error ("  in instantiation of template `%T'",
11504                         current_class_type);
11505
11506             type = error_mark_node;
11507             decl = NULL_TREE;
11508           }
11509         else
11510           {
11511             if (friendp)
11512               {
11513                 error ("`%s' is neither function nor member function; cannot be declared friend",
11514                        IDENTIFIER_POINTER (declarator));
11515                 friendp = 0;
11516               }
11517             decl = NULL_TREE;
11518           }
11519
11520         if (friendp)
11521           {
11522             /* Friends are treated specially.  */
11523             tree t = NULL_TREE;
11524
11525             /* DR 209. The friend does not need to be accessible at this
11526                point. */
11527             skip_type_access_control ();
11528
11529             if (ctype == current_class_type)
11530               warning ("member functions are implicitly friends of their class");
11531
11532             if (decl && DECL_NAME (decl))
11533               {
11534                 if (template_class_depth (current_class_type) == 0)
11535                   {
11536                     decl = check_explicit_specialization
11537                             (declarator, decl,
11538                              template_count, 2 * (funcdef_flag != 0) + 4);
11539                     if (decl == error_mark_node)
11540                       return error_mark_node;
11541                   }
11542
11543                 t = do_friend (ctype, declarator, decl,
11544                                last_function_parms, *attrlist, flags, quals,
11545                                funcdef_flag);
11546               }
11547             if (t && funcdef_flag)
11548               return t;
11549             return void_type_node;
11550           }
11551
11552         /* Structure field.  It may not be a function, except for C++ */
11553
11554         if (decl == NULL_TREE)
11555           {
11556             if (initialized)
11557               {
11558                 if (!staticp)
11559                   {
11560                     /* An attempt is being made to initialize a non-static
11561                        member.  But, from [class.mem]:
11562
11563                        4 A member-declarator can contain a
11564                        constant-initializer only if it declares a static
11565                        member (_class.static_) of integral or enumeration
11566                        type, see _class.static.data_.
11567
11568                        This used to be relatively common practice, but
11569                        the rest of the compiler does not correctly
11570                        handle the initialization unless the member is
11571                        static so we make it static below.  */
11572                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11573                                 declarator);
11574                     cp_pedwarn ("making `%D' static", declarator);
11575                     staticp = 1;
11576                   }
11577
11578                 if (uses_template_parms (type))
11579                   /* We'll check at instantiation time.  */
11580                   ;
11581                 else if (check_static_variable_definition (declarator,
11582                                                            type))
11583                   /* If we just return the declaration, crashes
11584                      will sometimes occur.  We therefore return
11585                      void_type_node, as if this was a friend
11586                      declaration, to cause callers to completely
11587                      ignore this declaration.  */
11588                   return void_type_node;
11589               }
11590
11591             /* 9.2p13 [class.mem] */
11592             if (declarator == constructor_name (current_class_type)
11593                 /* The standard does not allow non-static data members
11594                    here either, but we agreed at the 10/99 meeting
11595                    to change that in TC 1 so that they are allowed in
11596                    classes with no user-defined constructors.  */
11597                 && staticp)
11598               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11599                           declarator);
11600
11601             if (staticp)
11602               {
11603                 /* C++ allows static class members.  All other work
11604                    for this is done by grokfield.  */
11605                 decl = build_lang_decl (VAR_DECL, declarator, type);
11606                 TREE_STATIC (decl) = 1;
11607                 /* In class context, 'static' means public access.  */
11608                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11609               }
11610             else
11611               {
11612                 decl = build_decl (FIELD_DECL, declarator, type);
11613                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11614                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11615                   {
11616                     DECL_MUTABLE_P (decl) = 1;
11617                     RIDBIT_RESET (RID_MUTABLE, specbits);
11618                   }
11619               }
11620
11621             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11622                             inlinep, friendp, raises != NULL_TREE);
11623           }
11624       }
11625     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11626       {
11627         tree original_name;
11628         int publicp = 0;
11629
11630         if (! declarator)
11631           return NULL_TREE;
11632
11633         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11634           original_name = dname;
11635         else
11636           original_name = declarator;
11637
11638         if (RIDBIT_SETP (RID_AUTO, specbits))
11639           error ("storage class `auto' invalid for function `%s'", name);
11640         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11641           error ("storage class `register' invalid for function `%s'", name);
11642
11643         /* Function declaration not at top level.
11644            Storage classes other than `extern' are not allowed
11645            and `extern' makes no difference.  */
11646         if (! toplevel_bindings_p ()
11647             && (RIDBIT_SETP (RID_STATIC, specbits)
11648                 || RIDBIT_SETP (RID_INLINE, specbits))
11649             && pedantic)
11650           {
11651             if (RIDBIT_SETP (RID_STATIC, specbits))
11652               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11653             else
11654               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11655           }
11656
11657         if (ctype == NULL_TREE)
11658           {
11659             if (virtualp)
11660               {
11661                 error ("virtual non-class function `%s'", name);
11662                 virtualp = 0;
11663               }
11664           }
11665         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11666           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11667                                           TYPE_ARG_TYPES (type));
11668
11669         /* Record presence of `static'.  */
11670         publicp = (ctype != NULL_TREE
11671                    || RIDBIT_SETP (RID_EXTERN, specbits)
11672                    || !RIDBIT_SETP (RID_STATIC, specbits));
11673
11674         decl = grokfndecl (ctype, type, original_name, declarator,
11675                            virtualp, flags, quals, raises,
11676                            1, friendp,
11677                            publicp, inlinep, funcdef_flag,
11678                            template_count, in_namespace);
11679         if (decl == NULL_TREE)
11680           return NULL_TREE;
11681
11682         if (staticp == 1)
11683           {
11684             int illegal_static = 0;
11685
11686             /* Don't allow a static member function in a class, and forbid
11687                declaring main to be static.  */
11688             if (TREE_CODE (type) == METHOD_TYPE)
11689               {
11690                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11691                 illegal_static = 1;
11692               }
11693             else if (current_function_decl)
11694               {
11695                 /* FIXME need arm citation */
11696                 error ("cannot declare static function inside another function");
11697                 illegal_static = 1;
11698               }
11699
11700             if (illegal_static)
11701               {
11702                 staticp = 0;
11703                 RIDBIT_RESET (RID_STATIC, specbits);
11704               }
11705           }
11706       }
11707     else
11708       {
11709         /* It's a variable.  */
11710
11711         /* An uninitialized decl with `extern' is a reference.  */
11712         decl = grokvardecl (type, declarator, &specbits,
11713                             initialized,
11714                             (type_quals & TYPE_QUAL_CONST) != 0,
11715                             in_namespace);
11716         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11717                         inlinep, friendp, raises != NULL_TREE);
11718
11719         if (ctype)
11720           {
11721             DECL_CONTEXT (decl) = ctype;
11722             if (staticp == 1)
11723               {
11724                 cp_pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
11725                 staticp = 0;
11726                 RIDBIT_RESET (RID_STATIC, specbits);
11727               }
11728             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11729               {
11730                 cp_error ("static member `%D' declared `register'", decl);
11731                 RIDBIT_RESET (RID_REGISTER, specbits);
11732               }
11733             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11734               {
11735                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11736                             decl);
11737                 RIDBIT_RESET (RID_EXTERN, specbits);
11738               }
11739           }
11740       }
11741
11742     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11743
11744     /* Record `register' declaration for warnings on &
11745        and in case doing stupid register allocation.  */
11746
11747     if (RIDBIT_SETP (RID_REGISTER, specbits))
11748       DECL_REGISTER (decl) = 1;
11749
11750     if (RIDBIT_SETP (RID_EXTERN, specbits))
11751       DECL_THIS_EXTERN (decl) = 1;
11752
11753     if (RIDBIT_SETP (RID_STATIC, specbits))
11754       DECL_THIS_STATIC (decl) = 1;
11755
11756     /* Record constancy and volatility.  There's no need to do this
11757        when processing a template; we'll do this for the instantiated
11758        declaration based on the type of DECL.  */
11759     if (!processing_template_decl)
11760       c_apply_type_quals_to_decl (type_quals, decl);
11761
11762     return decl;
11763   }
11764 }
11765 \f
11766 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11767    An empty exprlist is a parmlist.  An exprlist which
11768    contains only identifiers at the global level
11769    is a parmlist.  Otherwise, it is an exprlist.  */
11770
11771 int
11772 parmlist_is_exprlist (exprs)
11773      tree exprs;
11774 {
11775   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11776     return 0;
11777
11778   if (toplevel_bindings_p ())
11779     {
11780       /* At the global level, if these are all identifiers,
11781          then it is a parmlist.  */
11782       while (exprs)
11783         {
11784           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11785             return 1;
11786           exprs = TREE_CHAIN (exprs);
11787         }
11788       return 0;
11789     }
11790   return 1;
11791 }
11792
11793 /* Subroutine of start_function.  Ensure that each of the parameter
11794    types (as listed in PARMS) is complete, as is required for a
11795    function definition.  */
11796
11797 static void
11798 require_complete_types_for_parms (parms)
11799      tree parms;
11800 {
11801   for (; parms; parms = TREE_CHAIN (parms))
11802     {
11803       if (VOID_TYPE_P (TREE_TYPE (parms)))
11804         /* grokparms will have already issued an error */
11805         TREE_TYPE (parms) = error_mark_node;
11806       else if (complete_type_or_else (TREE_TYPE (parms), parms))
11807         layout_decl (parms, 0);
11808       else
11809         TREE_TYPE (parms) = error_mark_node;
11810     }
11811 }
11812
11813 /* Returns non-zero if T is a local variable.  */
11814
11815 int
11816 local_variable_p (t)
11817      tree t;
11818 {
11819   if ((TREE_CODE (t) == VAR_DECL
11820        /* A VAR_DECL with a context that is a _TYPE is a static data
11821           member.  */
11822        && !TYPE_P (CP_DECL_CONTEXT (t))
11823        /* Any other non-local variable must be at namespace scope.  */
11824        && !DECL_NAMESPACE_SCOPE_P (t))
11825       || (TREE_CODE (t) == PARM_DECL))
11826     return 1;
11827
11828   return 0;
11829 }
11830
11831 /* Returns non-zero if T is an automatic local variable or a label.
11832    (These are the declarations that need to be remapped when the code
11833    containing them is duplicated.)  */
11834
11835 int
11836 nonstatic_local_decl_p (t)
11837      tree t;
11838 {
11839   return ((local_variable_p (t) && !TREE_STATIC (t))
11840           || TREE_CODE (t) == LABEL_DECL
11841           || TREE_CODE (t) == RESULT_DECL);
11842 }
11843
11844 /* Like local_variable_p, but suitable for use as a tree-walking
11845    function.  */
11846
11847 static tree
11848 local_variable_p_walkfn (tp, walk_subtrees, data)
11849      tree *tp;
11850      int *walk_subtrees ATTRIBUTE_UNUSED;
11851      void *data ATTRIBUTE_UNUSED;
11852 {
11853   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11854           ? *tp : NULL_TREE);
11855 }
11856
11857 /* Check that ARG, which is a default-argument expression for a
11858    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11859    something goes wrong.  DECL may also be a _TYPE node, rather than a
11860    DECL, if there is no DECL available.  */
11861
11862 tree
11863 check_default_argument (decl, arg)
11864      tree decl;
11865      tree arg;
11866 {
11867   tree var;
11868   tree decl_type;
11869
11870   if (TREE_CODE (arg) == DEFAULT_ARG)
11871     /* We get a DEFAULT_ARG when looking at an in-class declaration
11872        with a default argument.  Ignore the argument for now; we'll
11873        deal with it after the class is complete.  */
11874     return arg;
11875
11876   if (processing_template_decl || uses_template_parms (arg))
11877     /* We don't do anything checking until instantiation-time.  Note
11878        that there may be uninstantiated arguments even for an
11879        instantiated function, since default arguments are not
11880        instantiated until they are needed.  */
11881     return arg;
11882
11883   if (TYPE_P (decl))
11884     {
11885       decl_type = decl;
11886       decl = NULL_TREE;
11887     }
11888   else
11889     decl_type = TREE_TYPE (decl);
11890
11891   if (arg == error_mark_node
11892       || decl == error_mark_node
11893       || TREE_TYPE (arg) == error_mark_node
11894       || decl_type == error_mark_node)
11895     /* Something already went wrong.  There's no need to check
11896        further.  */
11897     return error_mark_node;
11898
11899   /* [dcl.fct.default]
11900
11901      A default argument expression is implicitly converted to the
11902      parameter type.  */
11903   if (!TREE_TYPE (arg)
11904       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11905     {
11906       if (decl)
11907         cp_error ("default argument for `%#D' has type `%T'",
11908                   decl, TREE_TYPE (arg));
11909       else
11910         cp_error ("default argument for parameter of type `%T' has type `%T'",
11911                   decl_type, TREE_TYPE (arg));
11912
11913       return error_mark_node;
11914     }
11915
11916   /* [dcl.fct.default]
11917
11918      Local variables shall not be used in default argument
11919      expressions.
11920
11921      The keyword `this' shall not be used in a default argument of a
11922      member function.  */
11923   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
11924                                       NULL);
11925   if (var)
11926     {
11927       cp_error ("default argument `%E' uses local variable `%D'",
11928                 arg, var);
11929       return error_mark_node;
11930     }
11931
11932   /* All is well.  */
11933   return arg;
11934 }
11935
11936 /* Decode the list of parameter types for a function type.
11937    Given the list of things declared inside the parens,
11938    return a list of types.
11939
11940    We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
11941    flag. If unset, we append void_list_node. A parmlist declared
11942    as `(void)' is accepted as the empty parmlist.
11943
11944    Also set last_function_parms to the chain of PARM_DECLs.  */
11945
11946 static tree
11947 grokparms (first_parm)
11948      tree first_parm;
11949 {
11950   tree result = NULL_TREE;
11951   tree decls = NULL_TREE;
11952   int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
11953   tree parm, chain;
11954   int any_error = 0;
11955
11956   my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
11957
11958   for (parm = first_parm; parm != NULL_TREE; parm = chain)
11959     {
11960       tree type = NULL_TREE;
11961       register tree decl = TREE_VALUE (parm);
11962       tree init = TREE_PURPOSE (parm);
11963
11964       chain = TREE_CHAIN (parm);
11965       /* @@ weak defense against parse errors.  */
11966       if (TREE_CODE (decl) != VOID_TYPE
11967           && TREE_CODE (decl) != TREE_LIST)
11968         {
11969           /* Give various messages as the need arises.  */
11970           if (TREE_CODE (decl) == STRING_CST)
11971             cp_error ("invalid string constant `%E'", decl);
11972           else if (TREE_CODE (decl) == INTEGER_CST)
11973             error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11974           continue;
11975         }
11976
11977       if (parm == void_list_node)
11978         break;
11979
11980       decl = grokdeclarator (TREE_VALUE (decl), TREE_PURPOSE (decl),
11981                      PARM, init != NULL_TREE, NULL);
11982       if (! decl || TREE_TYPE (decl) == error_mark_node)
11983         continue;
11984
11985       type = TREE_TYPE (decl);
11986       if (VOID_TYPE_P (type))
11987         {
11988           if (same_type_p (type, void_type_node)
11989               && !DECL_NAME (decl) && !result && !chain && !ellipsis)
11990             /* this is a parmlist of `(void)', which is ok.  */
11991             break;
11992           incomplete_type_error (decl, type);
11993           /* It's not a good idea to actually create parameters of
11994              type `void'; other parts of the compiler assume that a
11995              void type terminates the parameter list.  */
11996           type = error_mark_node;
11997           TREE_TYPE (decl) = error_mark_node;
11998         }
11999
12000       if (type != error_mark_node)
12001         {
12002           /* Top-level qualifiers on the parameters are
12003              ignored for function types.  */
12004           type = TYPE_MAIN_VARIANT (type);
12005           if (TREE_CODE (type) == METHOD_TYPE)
12006             {
12007               cp_error ("parameter `%D' invalidly declared method type", decl);
12008               type = build_pointer_type (type);
12009               TREE_TYPE (decl) = type;
12010             }
12011           else if (TREE_CODE (type) == OFFSET_TYPE)
12012             {
12013               cp_error ("parameter `%D' invalidly declared offset type", decl);
12014               type = build_pointer_type (type);
12015               TREE_TYPE (decl) = type;
12016             }
12017           else if (abstract_virtuals_error (decl, type))
12018             any_error = 1;  /* Seems like a good idea. */
12019           else if (POINTER_TYPE_P (type))
12020             {
12021               /* [dcl.fct]/6, parameter types cannot contain pointers
12022                  (references) to arrays of unknown bound.  */
12023               tree t = TREE_TYPE (type);
12024               int ptr = TYPE_PTR_P (type);
12025
12026               while (1)
12027                 {
12028                   if (TYPE_PTR_P (t))
12029                     ptr = 1;
12030                   else if (TREE_CODE (t) != ARRAY_TYPE)
12031                     break;
12032                   else if (!TYPE_DOMAIN (t))
12033                     break;
12034                   t = TREE_TYPE (t);
12035                 }
12036               if (TREE_CODE (t) == ARRAY_TYPE)
12037                 cp_error ("parameter `%D' includes %s to array of unknown bound `%T'",
12038                           decl, ptr ? "pointer" : "reference", t);
12039             }
12040
12041           DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12042           if (PROMOTE_PROTOTYPES
12043               && INTEGRAL_TYPE_P (type)
12044               && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12045             DECL_ARG_TYPE (decl) = integer_type_node;
12046           if (!any_error && init)
12047             init = check_default_argument (decl, init);
12048           else
12049             init = NULL_TREE;
12050         }
12051
12052       TREE_CHAIN (decl) = decls;
12053       decls = decl;
12054       result = tree_cons (init, type, result);
12055     }
12056   decls = nreverse (decls);
12057   result = nreverse (result);
12058   if (!ellipsis)
12059     result = chainon (result, void_list_node);
12060   last_function_parms = decls;
12061
12062   return result;
12063 }
12064
12065 \f
12066 /* D is a constructor or overloaded `operator='.
12067
12068    Let T be the class in which D is declared. Then, this function
12069    returns:
12070
12071    -1 if D's is an ill-formed constructor or copy assignment operator
12072       whose first parameter is of type `T'.
12073    0  if D is not a copy constructor or copy assignment
12074       operator.
12075    1  if D is a copy constructor or copy assignment operator whose
12076       first parameter is a reference to const qualified T.
12077    2  if D is a copy constructor or copy assignment operator whose
12078       first parameter is a reference to non-const qualified T.
12079
12080    This function can be used as a predicate. Positive values indicate
12081    a copy constructor and non-zero values indicate a copy assignment
12082    operator.  */
12083
12084 int
12085 copy_fn_p (d)
12086      tree d;
12087 {
12088   tree args;
12089   tree arg_type;
12090   int result = 1;
12091
12092   my_friendly_assert (DECL_FUNCTION_MEMBER_P (d), 20011208);
12093
12094   if (DECL_TEMPLATE_INFO (d) && is_member_template (DECL_TI_TEMPLATE (d)))
12095     /* Instantiations of template member functions are never copy
12096        functions.  Note that member functions of templated classes are
12097        represented as template functions internally, and we must
12098        accept those as copy functions.  */
12099     return 0;
12100
12101   args = FUNCTION_FIRST_USER_PARMTYPE (d);
12102   if (!args)
12103     return 0;
12104
12105   arg_type = TREE_VALUE (args);
12106
12107   if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
12108     {
12109       /* Pass by value copy assignment operator.  */
12110       result = -1;
12111     }
12112   else if (TREE_CODE (arg_type) == REFERENCE_TYPE
12113            && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
12114     {
12115       if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
12116         result = 2;
12117     }
12118   else
12119     return 0;
12120
12121   args = TREE_CHAIN (args);
12122
12123   if (args && args != void_list_node && !TREE_PURPOSE (args))
12124     /* There are more non-optional args.  */
12125     return 0;
12126
12127   return result;
12128 }
12129
12130 /* Remember any special properties of member function DECL.  */
12131
12132 void grok_special_member_properties (decl)
12133      tree decl;
12134 {
12135   if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl))
12136     ; /* Not special.  */
12137   else if (DECL_CONSTRUCTOR_P (decl))
12138     {
12139       int ctor = copy_fn_p (decl);
12140
12141       if (ctor > 0)
12142         {
12143           /* [class.copy]
12144
12145              A non-template constructor for class X is a copy
12146              constructor if its first parameter is of type X&, const
12147              X&, volatile X& or const volatile X&, and either there
12148              are no other parameters or else all other parameters have
12149              default arguments.  */
12150           TYPE_HAS_INIT_REF (DECL_CONTEXT (decl)) = 1;
12151           if (ctor > 1)
12152             TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl)) = 1;
12153         }
12154       else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
12155         TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl)) = 1;
12156     }
12157   else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
12158     {
12159       /* [class.copy]
12160
12161          A non-template assignment operator for class X is a copy
12162          assignment operator if its parameter is of type X, X&, const
12163          X&, volatile X& or const volatile X&.  */
12164
12165       int assop = copy_fn_p (decl);
12166
12167       if (assop)
12168         {
12169           TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12170           if (assop != 1)
12171             TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12172           if (DECL_PURE_VIRTUAL_P (decl))
12173             TYPE_HAS_ABSTRACT_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12174         }
12175     }
12176 }
12177
12178 /* Check a constructor DECL has the correct form.  Complains
12179    if the class has a constructor of the form X(X).  */
12180
12181 int
12182 grok_ctor_properties (ctype, decl)
12183      tree ctype, decl;
12184 {
12185   int ctor_parm = copy_fn_p (decl);
12186
12187   if (ctor_parm < 0)
12188     {
12189       /* [class.copy]
12190
12191          A declaration of a constructor for a class X is ill-formed if
12192          its first parameter is of type (optionally cv-qualified) X
12193          and either there are no other parameters or else all other
12194          parameters have default arguments.
12195
12196          We *don't* complain about member template instantiations that
12197          have this form, though; they can occur as we try to decide
12198          what constructor to use during overload resolution.  Since
12199          overload resolution will never prefer such a constructor to
12200          the non-template copy constructor (which is either explicitly
12201          or implicitly defined), there's no need to worry about their
12202          existence.  Theoretically, they should never even be
12203          instantiated, but that's hard to forestall.  */
12204       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12205                 ctype, ctype);
12206       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12207       return 0;
12208     }
12209
12210   return 1;
12211 }
12212
12213 /* An operator with this code is unary, but can also be binary.  */
12214
12215 static int
12216 ambi_op_p (code)
12217      enum tree_code code;
12218 {
12219   return (code == INDIRECT_REF
12220           || code == ADDR_EXPR
12221           || code == CONVERT_EXPR
12222           || code == NEGATE_EXPR
12223           || code == PREINCREMENT_EXPR
12224           || code == PREDECREMENT_EXPR);
12225 }
12226
12227 /* An operator with this name can only be unary.  */
12228
12229 static int
12230 unary_op_p (code)
12231      enum tree_code code;
12232 {
12233   return (code == TRUTH_NOT_EXPR
12234           || code == BIT_NOT_EXPR
12235           || code == COMPONENT_REF
12236           || code == TYPE_EXPR);
12237 }
12238
12239 /* Do a little sanity-checking on how they declared their operator.  */
12240
12241 void
12242 grok_op_properties (decl, friendp)
12243      tree decl;
12244      int friendp;
12245 {
12246   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12247   tree argtype;
12248   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12249   tree name = DECL_NAME (decl);
12250   enum tree_code operator_code;
12251   int arity;
12252
12253   /* Count the number of arguments.  */
12254   for (argtype = argtypes, arity = 0;
12255        argtype && argtype != void_list_node;
12256        argtype = TREE_CHAIN (argtype))
12257     ++arity;
12258
12259   if (current_class_type == NULL_TREE)
12260     friendp = 1;
12261
12262   if (DECL_CONV_FN_P (decl))
12263     operator_code = TYPE_EXPR;
12264   else
12265     do
12266       {
12267 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)       \
12268         if (ansi_opname (CODE) == name)                         \
12269           {                                                     \
12270             operator_code = CODE;                               \
12271             break;                                              \
12272           }                                                     \
12273         else if (ansi_assopname (CODE) == name)                 \
12274           {                                                     \
12275             operator_code = CODE;                               \
12276             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;              \
12277             break;                                              \
12278           }
12279
12280 #include "operators.def"
12281 #undef DEF_OPERATOR
12282
12283         my_friendly_abort (20000527);
12284       }
12285     while (0);
12286   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12287   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12288
12289   if (! friendp)
12290     {
12291       switch (operator_code)
12292         {
12293         case CALL_EXPR:
12294           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12295           break;
12296
12297         case ARRAY_REF:
12298           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12299           break;
12300
12301         case COMPONENT_REF:
12302         case MEMBER_REF:
12303           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12304           break;
12305
12306         case NEW_EXPR:
12307           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12308           break;
12309
12310         case DELETE_EXPR:
12311           TYPE_GETS_DELETE (current_class_type) |= 1;
12312           break;
12313
12314         case VEC_NEW_EXPR:
12315           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12316           break;
12317
12318         case VEC_DELETE_EXPR:
12319           TYPE_GETS_DELETE (current_class_type) |= 2;
12320           break;
12321
12322         default:
12323           break;
12324         }
12325     }
12326
12327   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12328     {
12329       /* When the compiler encounters the definition of A::operator new, it
12330          doesn't look at the class declaration to find out if it's static.  */
12331       if (methodp)
12332         revert_static_member_fn (decl);
12333
12334       TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12335     }
12336   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12337     {
12338       if (methodp)
12339         revert_static_member_fn (decl);
12340
12341       TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12342     }
12343   else
12344     {
12345       /* An operator function must either be a non-static member function
12346          or have at least one parameter of a class, a reference to a class,
12347          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12348       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12349         {
12350           if (operator_code == TYPE_EXPR
12351               || operator_code == CALL_EXPR
12352               || operator_code == COMPONENT_REF
12353               || operator_code == ARRAY_REF
12354               || operator_code == NOP_EXPR)
12355             cp_error ("`%D' must be a nonstatic member function", decl);
12356           else
12357             {
12358               tree p = argtypes;
12359
12360               if (DECL_STATIC_FUNCTION_P (decl))
12361                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12362
12363               if (p)
12364                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12365                   {
12366                     tree arg = TREE_VALUE (p);
12367                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12368                       arg = TREE_TYPE (arg);
12369
12370                     /* This lets bad template code slip through.  */
12371                     if (IS_AGGR_TYPE (arg)
12372                         || TREE_CODE (arg) == ENUMERAL_TYPE
12373                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12374                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12375                       goto foundaggr;
12376                   }
12377               cp_error
12378                 ("`%D' must have an argument of class or enumerated type",
12379                  decl);
12380             foundaggr:
12381               ;
12382             }
12383         }
12384
12385       if (operator_code == CALL_EXPR)
12386         return;                 /* No restrictions on args. */
12387
12388       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12389         {
12390           tree t = TREE_TYPE (name);
12391           if (! friendp)
12392             {
12393               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12394               const char *what = 0;
12395
12396               if (ref)
12397                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12398
12399               if (TREE_CODE (t) == VOID_TYPE)
12400                 what = "void";
12401               else if (t == current_class_type)
12402                 what = "the same type";
12403               /* Don't force t to be complete here.  */
12404               else if (IS_AGGR_TYPE (t)
12405                        && COMPLETE_TYPE_P (t)
12406                        && DERIVED_FROM_P (t, current_class_type))
12407                 what = "a base class";
12408
12409               if (what)
12410                 warning ("conversion to %s%s will never use a type conversion operator",
12411                          ref ? "a reference to " : "", what);
12412             }
12413         }
12414       if (operator_code == COND_EXPR)
12415         {
12416           /* 13.4.0.3 */
12417           cp_error ("ISO C++ prohibits overloading operator ?:");
12418         }
12419       else if (ambi_op_p (operator_code))
12420         {
12421           if (arity == 1)
12422             /* We pick the one-argument operator codes by default, so
12423                we don't have to change anything.  */
12424             ;
12425           else if (arity == 2)
12426             {
12427               /* If we thought this was a unary operator, we now know
12428                  it to be a binary operator.  */
12429               switch (operator_code)
12430                 {
12431                 case INDIRECT_REF:
12432                   operator_code = MULT_EXPR;
12433                   break;
12434
12435                 case ADDR_EXPR:
12436                   operator_code = BIT_AND_EXPR;
12437                   break;
12438
12439                 case CONVERT_EXPR:
12440                   operator_code = PLUS_EXPR;
12441                   break;
12442
12443                 case NEGATE_EXPR:
12444                   operator_code = MINUS_EXPR;
12445                   break;
12446
12447                 case PREINCREMENT_EXPR:
12448                   operator_code = POSTINCREMENT_EXPR;
12449                   break;
12450
12451                 case PREDECREMENT_EXPR:
12452                   operator_code = POSTDECREMENT_EXPR;
12453                   break;
12454
12455                 default:
12456                   my_friendly_abort (20000527);
12457                 }
12458
12459               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12460
12461               if ((operator_code == POSTINCREMENT_EXPR
12462                    || operator_code == POSTDECREMENT_EXPR)
12463                   && ! processing_template_decl
12464                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12465                 {
12466                   if (methodp)
12467                     cp_error ("postfix `%D' must take `int' as its argument",
12468                               decl);
12469                   else
12470                     cp_error
12471                       ("postfix `%D' must take `int' as its second argument",
12472                        decl);
12473                 }
12474             }
12475           else
12476             {
12477               if (methodp)
12478                 cp_error ("`%D' must take either zero or one argument", decl);
12479               else
12480                 cp_error ("`%D' must take either one or two arguments", decl);
12481             }
12482
12483           /* More Effective C++ rule 6.  */
12484           if (warn_ecpp
12485               && (operator_code == POSTINCREMENT_EXPR
12486                   || operator_code == POSTDECREMENT_EXPR
12487                   || operator_code == PREINCREMENT_EXPR
12488                   || operator_code == PREDECREMENT_EXPR))
12489             {
12490               tree arg = TREE_VALUE (argtypes);
12491               tree ret = TREE_TYPE (TREE_TYPE (decl));
12492               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12493                 arg = TREE_TYPE (arg);
12494               arg = TYPE_MAIN_VARIANT (arg);
12495               if (operator_code == PREINCREMENT_EXPR
12496                   || operator_code == PREDECREMENT_EXPR)
12497                 {
12498                   if (TREE_CODE (ret) != REFERENCE_TYPE
12499                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12500                                        arg))
12501                     cp_warning ("prefix `%D' should return `%T'", decl,
12502                                 build_reference_type (arg));
12503                 }
12504               else
12505                 {
12506                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12507                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12508                 }
12509             }
12510         }
12511       else if (unary_op_p (operator_code))
12512         {
12513           if (arity != 1)
12514             {
12515               if (methodp)
12516                 cp_error ("`%D' must take `void'", decl);
12517               else
12518                 cp_error ("`%D' must take exactly one argument", decl);
12519             }
12520         }
12521       else /* if (binary_op_p (operator_code)) */
12522         {
12523           if (arity != 2)
12524             {
12525               if (methodp)
12526                 cp_error ("`%D' must take exactly one argument", decl);
12527               else
12528                 cp_error ("`%D' must take exactly two arguments", decl);
12529             }
12530
12531           /* More Effective C++ rule 7.  */
12532           if (warn_ecpp
12533               && (operator_code == TRUTH_ANDIF_EXPR
12534                   || operator_code == TRUTH_ORIF_EXPR
12535                   || operator_code == COMPOUND_EXPR))
12536             cp_warning ("user-defined `%D' always evaluates both arguments",
12537                         decl);
12538         }
12539
12540       /* Effective C++ rule 23.  */
12541       if (warn_ecpp
12542           && arity == 2
12543           && (operator_code == PLUS_EXPR
12544               || operator_code == MINUS_EXPR
12545               || operator_code == TRUNC_DIV_EXPR
12546               || operator_code == MULT_EXPR)
12547           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12548         cp_warning ("`%D' should return by value", decl);
12549
12550       /* [over.oper]/8 */
12551       for (; argtypes && argtypes != void_list_node;
12552           argtypes = TREE_CHAIN (argtypes))
12553         if (TREE_PURPOSE (argtypes))
12554           {
12555             TREE_PURPOSE (argtypes) = NULL_TREE;
12556             if (operator_code == POSTINCREMENT_EXPR
12557                 || operator_code == POSTDECREMENT_EXPR)
12558               {
12559                 if (pedantic)
12560                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12561               }
12562             else
12563               cp_error ("`%D' cannot have default arguments", decl);
12564           }
12565
12566     }
12567 }
12568 \f
12569 static const char *
12570 tag_name (code)
12571      enum tag_types code;
12572 {
12573   switch (code)
12574     {
12575     case record_type:
12576       return "struct";
12577     case class_type:
12578       return "class";
12579     case union_type:
12580       return "union ";
12581     case enum_type:
12582       return "enum";
12583     default:
12584       my_friendly_abort (981122);
12585     }
12586 }
12587
12588 /* Get the struct, enum or union (CODE says which) with tag NAME.
12589    Define the tag as a forward-reference if it is not defined.
12590
12591    C++: If a class derivation is given, process it here, and report
12592    an error if multiple derivation declarations are not identical.
12593
12594    If this is a definition, come in through xref_tag and only look in
12595    the current frame for the name (since C++ allows new names in any
12596    scope.)  */
12597
12598 tree
12599 xref_tag (code_type_node, name, globalize)
12600      tree code_type_node;
12601      tree name;
12602      int globalize;
12603 {
12604   enum tag_types tag_code;
12605   enum tree_code code;
12606   register tree ref, t;
12607   struct binding_level *b = current_binding_level;
12608   int got_type = 0;
12609   tree attributes = NULL_TREE;
12610   tree context = NULL_TREE;
12611
12612   /* If we are called from the parser, code_type_node will sometimes be a
12613      TREE_LIST.  This indicates that the user wrote
12614      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12615      use them later.  */
12616   if (TREE_CODE (code_type_node) == TREE_LIST)
12617     {
12618       attributes = TREE_PURPOSE (code_type_node);
12619       code_type_node = TREE_VALUE (code_type_node);
12620     }
12621
12622   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12623   switch (tag_code)
12624     {
12625     case record_type:
12626     case class_type:
12627       code = RECORD_TYPE;
12628       break;
12629     case union_type:
12630       code = UNION_TYPE;
12631       break;
12632     case enum_type:
12633       code = ENUMERAL_TYPE;
12634       break;
12635     default:
12636       my_friendly_abort (18);
12637     }
12638
12639   /* If a cross reference is requested, look up the type
12640      already defined for this tag and return it.  */
12641   if (TYPE_P (name))
12642     {
12643       t = name;
12644       name = TYPE_IDENTIFIER (t);
12645       got_type = 1;
12646     }
12647   else
12648     t = IDENTIFIER_TYPE_VALUE (name);
12649
12650   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12651   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12652     {
12653       static int explained;
12654       tree shadowed;
12655
12656       cp_warning ("`%s %T' declares a new type at namespace scope",
12657                   tag_name (tag_code), name);
12658       if (!explained++)
12659         cp_warning ("  names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'",
12660                     tag_name (tag_code),
12661                     constructor_name (current_class_type),
12662                     TYPE_IDENTIFIER (t));
12663
12664       /* We need to remove the class scope binding for the
12665          TYPENAME_TYPE as otherwise poplevel_class gets confused. */
12666       for (shadowed = b->class_shadowed;
12667            shadowed;
12668            shadowed = TREE_CHAIN (shadowed))
12669         if (TREE_TYPE (shadowed) == TYPE_NAME (t))
12670           {
12671             TREE_PURPOSE (shadowed) = NULL_TREE;
12672             break;
12673           }
12674     }
12675
12676   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12677       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12678     t = NULL_TREE;
12679
12680   if (! globalize)
12681     {
12682       /* If we know we are defining this tag, only look it up in
12683          this scope and don't try to find it as a type.  */
12684       ref = lookup_tag (code, name, b, 1);
12685     }
12686   else
12687     {
12688       if (t)
12689         {
12690           /* [dcl.type.elab] If the identifier resolves to a
12691              typedef-name or a template type-parameter, the
12692              elaborated-type-specifier is ill-formed.  */
12693           if (t != TYPE_MAIN_VARIANT (t)
12694               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12695             cp_pedwarn ("using typedef-name `%D' after `%s'",
12696                         TYPE_NAME (t), tag_name (tag_code));
12697           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12698             cp_error ("using template type parameter `%T' after `%s'",
12699                       t, tag_name (tag_code));
12700
12701           ref = t;
12702         }
12703       else
12704         ref = lookup_tag (code, name, b, 0);
12705
12706       if (! ref)
12707         {
12708           /* Try finding it as a type declaration.  If that wins,
12709              use it.  */
12710           ref = lookup_name (name, 1);
12711
12712           if (ref != NULL_TREE
12713               && processing_template_decl
12714               && DECL_CLASS_TEMPLATE_P (ref)
12715               && template_class_depth (current_class_type) == 0)
12716             /* Since GLOBALIZE is true, we're declaring a global
12717                template, so we want this type.  */
12718             ref = DECL_TEMPLATE_RESULT (ref);
12719
12720           if (ref && TREE_CODE (ref) == TYPE_DECL
12721               && TREE_CODE (TREE_TYPE (ref)) == code)
12722             ref = TREE_TYPE (ref);
12723           else
12724             ref = NULL_TREE;
12725         }
12726
12727       if (ref && current_class_type
12728           && template_class_depth (current_class_type)
12729           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12730         {
12731           /* Since GLOBALIZE is non-zero, we are not looking at a
12732              definition of this tag.  Since, in addition, we are currently
12733              processing a (member) template declaration of a template
12734              class, we must be very careful; consider:
12735
12736                template <class X>
12737                struct S1
12738
12739                template <class U>
12740                struct S2
12741                { template <class V>
12742                friend struct S1; };
12743
12744              Here, the S2::S1 declaration should not be confused with the
12745              outer declaration.  In particular, the inner version should
12746              have a template parameter of level 2, not level 1.  This
12747              would be particularly important if the member declaration
12748              were instead:
12749
12750                template <class V = U> friend struct S1;
12751
12752              say, when we should tsubst into `U' when instantiating
12753              S2.  On the other hand, when presented with:
12754
12755                  template <class T>
12756                  struct S1 {
12757                    template <class U>
12758                    struct S2 {};
12759                    template <class U>
12760                    friend struct S2;
12761                  };
12762
12763               we must find the inner binding eventually.  We
12764               accomplish this by making sure that the new type we
12765               create to represent this declaration has the right
12766               TYPE_CONTEXT.  */
12767           context = TYPE_CONTEXT (ref);
12768           ref = NULL_TREE;
12769         }
12770     }
12771
12772   if (! ref)
12773     {
12774       /* If no such tag is yet defined, create a forward-reference node
12775          and record it as the "definition".
12776          When a real declaration of this type is found,
12777          the forward-reference will be altered into a real type.  */
12778       if (code == ENUMERAL_TYPE)
12779         {
12780           cp_error ("use of enum `%#D' without previous declaration", name);
12781
12782           ref = make_node (ENUMERAL_TYPE);
12783
12784           /* Give the type a default layout like unsigned int
12785              to avoid crashing if it does not get defined.  */
12786           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12787           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12788           TYPE_USER_ALIGN (ref) = 0;
12789           TREE_UNSIGNED (ref) = 1;
12790           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12791           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12792           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12793
12794           /* Enable us to recognize when a type is created in class context.
12795              To do nested classes correctly, this should probably be cleared
12796              out when we leave this classes scope.  Currently this in only
12797              done in `start_enum'.  */
12798
12799           pushtag (name, ref, globalize);
12800         }
12801       else
12802         {
12803           struct binding_level *old_b = class_binding_level;
12804
12805           ref = make_aggr_type (code);
12806           TYPE_CONTEXT (ref) = context;
12807
12808 #ifdef NONNESTED_CLASSES
12809           /* Class types don't nest the way enums do.  */
12810           class_binding_level = (struct binding_level *)0;
12811 #endif
12812           pushtag (name, ref, globalize);
12813           class_binding_level = old_b;
12814         }
12815     }
12816   else
12817     {
12818       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12819         redeclare_class_template (ref, current_template_parms);
12820     }
12821
12822   /* Until the type is defined, tentatively accept whatever
12823      structure tag the user hands us.  */
12824   if (!COMPLETE_TYPE_P (ref)
12825       && ref != current_class_type
12826       /* Have to check this, in case we have contradictory tag info.  */
12827       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12828     {
12829       if (tag_code == class_type)
12830         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12831       else if (tag_code == record_type)
12832         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12833     }
12834
12835   TREE_TYPE (ref) = attributes;
12836
12837   return ref;
12838 }
12839
12840 tree
12841 xref_tag_from_type (old, id, globalize)
12842      tree old, id;
12843      int globalize;
12844 {
12845   tree code_type_node;
12846
12847   if (TREE_CODE (old) == RECORD_TYPE)
12848     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12849                       ? class_type_node : record_type_node);
12850   else
12851     code_type_node = union_type_node;
12852
12853   if (id == NULL_TREE)
12854     id = TYPE_IDENTIFIER (old);
12855
12856   return xref_tag (code_type_node, id, globalize);
12857 }
12858
12859 /* REF is a type (named NAME), for which we have just seen some
12860    baseclasses.  BINFO is a list of those baseclasses; the
12861    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12862    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12863    struct, or union.  */
12864
12865 void
12866 xref_basetypes (code_type_node, name, ref, binfo)
12867      tree code_type_node;
12868      tree name, ref;
12869      tree binfo;
12870 {
12871   /* In the declaration `A : X, Y, ... Z' we mark all the types
12872      (A, X, Y, ..., Z) so we can check for duplicates.  */
12873   tree binfos;
12874   tree base;
12875
12876   int i, len;
12877   enum tag_types tag_code;
12878
12879   /* If we are called from the parser, code_type_node will sometimes be a
12880      TREE_LIST.  This indicates that the user wrote
12881      "class __attribute__ ((foo)) bar".  Extract the attributes so that
12882      tree_low_cst doesn't crash.  */
12883   if (TREE_CODE (code_type_node) == TREE_LIST)
12884     code_type_node = TREE_VALUE (code_type_node);
12885
12886   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12887
12888   if (tag_code == union_type)
12889     {
12890       cp_error ("derived union `%T' invalid", ref);
12891       return;
12892     }
12893
12894   len = list_length (binfo);
12895
12896   /* First, make sure that any templates in base-classes are
12897      instantiated.  This ensures that if we call ourselves recursively
12898      we do not get confused about which classes are marked and which
12899      are not.  */
12900   for (base = binfo; base; base = TREE_CHAIN (base))
12901     complete_type (TREE_VALUE (base));
12902
12903   SET_CLASSTYPE_MARKED (ref);
12904   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12905
12906   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12907     {
12908       /* The base of a derived struct is public by default.  */
12909       int via_public
12910         = (TREE_PURPOSE (binfo) == access_public_node
12911            || TREE_PURPOSE (binfo) == access_public_virtual_node
12912            || (tag_code != class_type
12913                && (TREE_PURPOSE (binfo) == access_default_node
12914                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12915       int via_protected
12916         = (TREE_PURPOSE (binfo) == access_protected_node
12917            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12918       int via_virtual
12919         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12920            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12921            || TREE_PURPOSE (binfo) == access_public_virtual_node
12922            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12923       tree basetype = TREE_VALUE (binfo);
12924       tree base_binfo;
12925
12926       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12927         basetype = TREE_TYPE (basetype);
12928       if (!basetype
12929           || (TREE_CODE (basetype) != RECORD_TYPE
12930               && TREE_CODE (basetype) != TYPENAME_TYPE
12931               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12932               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
12933         {
12934           cp_error ("base type `%T' fails to be a struct or class type",
12935                     TREE_VALUE (binfo));
12936           continue;
12937         }
12938
12939       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12940
12941       /* This code replaces similar code in layout_basetypes.
12942          We put the complete_type first for implicit `typename'.  */
12943       if (!COMPLETE_TYPE_P (basetype)
12944           && ! (current_template_parms && uses_template_parms (basetype)))
12945         {
12946           cp_error ("base class `%T' has incomplete type", basetype);
12947           continue;
12948         }
12949       else
12950         {
12951           if (CLASSTYPE_MARKED (basetype))
12952             {
12953               if (basetype == ref)
12954                 cp_error ("recursive type `%T' undefined", basetype);
12955               else
12956                 cp_error ("duplicate base type `%T' invalid", basetype);
12957               continue;
12958             }
12959
12960           if (TYPE_FOR_JAVA (basetype)
12961               && (current_lang_depth () == 0))
12962             TYPE_FOR_JAVA (ref) = 1;
12963
12964           /* Note that the BINFO records which describe individual
12965              inheritances are *not* shared in the lattice!  They
12966              cannot be shared because a given baseclass may be
12967              inherited with different `accessibility' by different
12968              derived classes.  (Each BINFO record describing an
12969              individual inheritance contains flags which say what
12970              the `accessibility' of that particular inheritance is.)  */
12971
12972           base_binfo
12973             = make_binfo (size_zero_node, basetype,
12974                           CLASS_TYPE_P (basetype)
12975                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12976                           CLASS_TYPE_P (basetype)
12977                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12978
12979           TREE_VEC_ELT (binfos, i) = base_binfo;
12980           TREE_VIA_PUBLIC (base_binfo) = via_public;
12981           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12982           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12983           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12984
12985           /* We need to unshare the binfos now so that lookups during class
12986              definition work.  */
12987           unshare_base_binfos (base_binfo);
12988
12989           SET_CLASSTYPE_MARKED (basetype);
12990
12991           /* We are free to modify these bits because they are meaningless
12992              at top level, and BASETYPE is a top-level type.  */
12993           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12994             {
12995               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12996               /* Converting to a virtual base class requires looking
12997                  up the offset of the virtual base.  */
12998               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12999             }
13000
13001           if (CLASS_TYPE_P (basetype))
13002             {
13003               TYPE_HAS_NEW_OPERATOR (ref)
13004                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13005               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13006                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13007               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13008               /* If the base-class uses multiple inheritance, so do we.  */
13009               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13010                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13011               /* Likewise, if converting to a base of the base may require
13012                  code, then we may need to generate code to convert to a
13013                  base as well.  */
13014               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13015                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13016             }
13017
13018           i += 1;
13019         }
13020     }
13021   if (i)
13022     TREE_VEC_LENGTH (binfos) = i;
13023   else
13024     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13025
13026   if (i > 1)
13027     {
13028       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13029       /* If there is more than one non-empty they cannot be at the same
13030          address.  */
13031       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13032     }
13033
13034   /* Unmark all the types.  */
13035   while (--i >= 0)
13036     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13037   CLEAR_CLASSTYPE_MARKED (ref);
13038
13039   /* Now that we know all the base-classes, set up the list of virtual
13040      bases.  */
13041   get_vbase_types (ref);
13042 }
13043
13044 \f
13045 /* Begin compiling the definition of an enumeration type.
13046    NAME is its name (or null if anonymous).
13047    Returns the type object, as yet incomplete.
13048    Also records info about it so that build_enumerator
13049    may be used to declare the individual values as they are read.  */
13050
13051 tree
13052 start_enum (name)
13053      tree name;
13054 {
13055   register tree enumtype = NULL_TREE;
13056   struct binding_level *b = current_binding_level;
13057
13058   /* If this is the real definition for a previous forward reference,
13059      fill in the contents in the same object that used to be the
13060      forward reference.  */
13061
13062   if (name != NULL_TREE)
13063     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13064
13065   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13066     {
13067       cp_error ("multiple definition of `%#T'", enumtype);
13068       cp_error_at ("previous definition here", enumtype);
13069       /* Clear out TYPE_VALUES, and start again.  */
13070       TYPE_VALUES (enumtype) = NULL_TREE;
13071     }
13072   else
13073     {
13074       enumtype = make_node (ENUMERAL_TYPE);
13075       pushtag (name, enumtype, 0);
13076     }
13077
13078   if (current_class_type)
13079     TREE_ADDRESSABLE (b->tags) = 1;
13080
13081   GNU_xref_decl (current_function_decl, enumtype);
13082   return enumtype;
13083 }
13084
13085 /* After processing and defining all the values of an enumeration type,
13086    install their decls in the enumeration type and finish it off.
13087    ENUMTYPE is the type object and VALUES a list of name-value pairs.  */
13088
13089 void
13090 finish_enum (enumtype)
13091      tree enumtype;
13092 {
13093   tree pair;
13094   tree minnode;
13095   tree maxnode;
13096   tree t;
13097   bool unsignedp;
13098   int lowprec;
13099   int highprec;
13100   int precision;
13101
13102   /* We built up the VALUES in reverse order.  */
13103   TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
13104
13105   /* [dcl.enum]
13106
13107      Following the closing brace of an enum-specifier, each
13108      enumerator has the type of its enumeration.  Prior to the
13109      closing brace, the type of each enumerator is the type of
13110      its initializing value.  */
13111   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13112     TREE_TYPE (TREE_VALUE (pair)) = enumtype;
13113
13114   /* For a enum defined in a template, all further processing is
13115      postponed until the template is instantiated.  */
13116   if (processing_template_decl)
13117     {
13118       tree scope = current_scope ();
13119       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13120         add_stmt (build_min (TAG_DEFN, enumtype));
13121
13122
13123       return;
13124     }
13125
13126   /* Figure out what the minimum and maximum values of the enumerators
13127      are.  */
13128   if (TYPE_VALUES (enumtype))
13129     {
13130       minnode = maxnode = NULL_TREE;
13131
13132       for (pair = TYPE_VALUES (enumtype);
13133            pair;
13134            pair = TREE_CHAIN (pair))
13135         {
13136           tree value;
13137
13138           value = DECL_INITIAL (TREE_VALUE (pair));
13139
13140           if (!minnode)
13141             minnode = maxnode = value;
13142           else if (tree_int_cst_lt (maxnode, value))
13143             maxnode = value;
13144           else if (tree_int_cst_lt (value, minnode))
13145             minnode = value;
13146         }
13147     }
13148   else
13149     minnode = maxnode = integer_zero_node;
13150
13151   /* Compute the number of bits require to represent all values of the
13152      enumeration.  We must do this before the type of MINNODE and
13153      MAXNODE are transformed, since min_precision relies on the
13154      TREE_TYPE of the value it is passed.  */
13155   unsignedp = tree_int_cst_sgn (minnode) >= 0;
13156   lowprec = min_precision (minnode, unsignedp);
13157   highprec = min_precision (maxnode, unsignedp);
13158   precision = MAX (lowprec, highprec);
13159
13160   /* Set the TREE_TYPE for the values as well.  That's so that when we
13161      call decl_constant_value we get an entity of the right type (but
13162      with the constant value).  In addition, transform the TYPE_VALUES
13163      list to contain the values, rather than the CONST_DECLs for them.  */
13164   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13165     {
13166       tree value = DECL_INITIAL (TREE_VALUE (pair));
13167
13168       TREE_TYPE (value) = enumtype;
13169       TREE_VALUE (pair) = value;
13170     }
13171
13172   /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13173   TYPE_SIZE (enumtype) = NULL_TREE;
13174   TYPE_PRECISION (enumtype) = precision;
13175   if (unsignedp)
13176     fixup_unsigned_type (enumtype);
13177   else
13178     fixup_signed_type (enumtype);
13179
13180   if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13181     /* Use the width of the narrowest normal C type which is wide
13182        enough.  */
13183     TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13184                                                 (precision, 1));
13185   else
13186     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13187
13188   TYPE_SIZE (enumtype) = NULL_TREE;
13189   layout_type (enumtype);
13190
13191   /* Fix up all variant types of this enum type.  */
13192   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13193     {
13194       TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13195       TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
13196       TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
13197       TYPE_SIZE (t) = TYPE_SIZE (enumtype);
13198       TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
13199       TYPE_MODE (t) = TYPE_MODE (enumtype);
13200       TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
13201       TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
13202       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
13203       TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype);
13204     }
13205
13206   /* Finish debugging output for this type.  */
13207   rest_of_type_compilation (enumtype, namespace_bindings_p ());
13208 }
13209
13210 /* Build and install a CONST_DECL for an enumeration constant of the
13211    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13212    Assignment of sequential values by default is handled here.  */
13213
13214 void
13215 build_enumerator (name, value, enumtype)
13216      tree name;
13217      tree value;
13218      tree enumtype;
13219 {
13220   tree decl;
13221   tree context;
13222   tree type;
13223   tree values;
13224
13225   /* Remove no-op casts from the value.  */
13226   if (value)
13227     STRIP_TYPE_NOPS (value);
13228
13229   if (! processing_template_decl)
13230     {
13231       /* Validate and default VALUE.  */
13232       if (value != NULL_TREE)
13233         {
13234           value = decl_constant_value (value);
13235
13236           if (TREE_CODE (value) == INTEGER_CST)
13237             {
13238               value = default_conversion (value);
13239               constant_expression_warning (value);
13240             }
13241           else
13242             {
13243               cp_error ("enumerator value for `%D' not integer constant", name);
13244               value = NULL_TREE;
13245             }
13246         }
13247
13248       /* Default based on previous value.  */
13249       if (value == NULL_TREE && ! processing_template_decl)
13250         {
13251           tree prev_value;
13252
13253           if (TYPE_VALUES (enumtype))
13254             {
13255               /* The next value is the previous value ... */
13256               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13257               /* ... plus one.  */
13258               value = cp_build_binary_op (PLUS_EXPR,
13259                                           prev_value,
13260                                           integer_one_node);
13261
13262               if (tree_int_cst_lt (value, prev_value))
13263                 cp_error ("overflow in enumeration values at `%D'", name);
13264             }
13265           else
13266             value = integer_zero_node;
13267         }
13268
13269       /* Remove no-op casts from the value.  */
13270       if (value)
13271         STRIP_TYPE_NOPS (value);
13272 #if 0
13273       /* To fix MAX_VAL enum consts. (bkoz)  */
13274       TREE_TYPE (value) = integer_type_node;
13275 #endif
13276     }
13277
13278   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13279      Even in other cases, we will later (in finish_enum) be setting
13280      the type of VALUE.  But, we don't need to make a copy if this
13281      VALUE is one of the enumeration constants for this same
13282      enumeration type.  */
13283   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13284     if (TREE_VALUE (values) == value)
13285       break;
13286   /* If we didn't break out of the loop, then we do need a copy.  */
13287   if (!values && value)
13288     value = copy_node (value);
13289
13290   /* C++ associates enums with global, function, or class declarations.  */
13291   context = current_scope ();
13292
13293   /* Build the actual enumeration constant.  Note that the enumeration
13294     constants have the type of their initializers until the
13295     enumeration is complete:
13296
13297       [ dcl.enum ]
13298
13299       Following the closing brace of an enum-specifier, each enumer-
13300       ator has the type of its enumeration.  Prior to the closing
13301       brace, the type of each enumerator is the type of its
13302       initializing value.
13303
13304     In finish_enum we will reset the type.  Of course, if we're
13305     processing a template, there may be no value.   */
13306   type = value ? TREE_TYPE (value) : NULL_TREE;
13307
13308   if (context && context == current_class_type)
13309     /* This enum declaration is local to the class.  We need the full
13310        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13311     decl = build_lang_decl (CONST_DECL, name, type);
13312   else
13313     /* It's a global enum, or it's local to a function.  (Note local to
13314       a function could mean local to a class method.  */
13315     decl = build_decl (CONST_DECL, name, type);
13316
13317   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13318   DECL_INITIAL (decl) = value;
13319   TREE_READONLY (decl) = 1;
13320
13321   if (context && context == current_class_type)
13322     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13323       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13324       things like `S::i' later.)  */
13325     finish_member_declaration (decl);
13326   else
13327     {
13328       pushdecl (decl);
13329       GNU_xref_decl (current_function_decl, decl);
13330     }
13331
13332   /* Add this enumeration constant to the list for this type.  */
13333   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13334 }
13335
13336 \f
13337 /* We're defining DECL.  Make sure that it's type is OK.  */
13338
13339 static void
13340 check_function_type (decl, current_function_parms)
13341      tree decl;
13342      tree current_function_parms;
13343 {
13344   tree fntype = TREE_TYPE (decl);
13345   tree return_type = complete_type (TREE_TYPE (fntype));
13346
13347   /* In a function definition, arg types must be complete.  */
13348   require_complete_types_for_parms (current_function_parms);
13349
13350   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13351     {
13352       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13353
13354       /* Make it return void instead, but don't change the
13355          type of the DECL_RESULT, in case we have a named return value.  */
13356       if (TREE_CODE (fntype) == METHOD_TYPE)
13357         {
13358           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13359           TREE_TYPE (decl)
13360             = build_cplus_method_type (ctype,
13361                                        void_type_node,
13362                                        FUNCTION_ARG_CHAIN (decl));
13363         }
13364       else
13365         TREE_TYPE (decl)
13366           = build_function_type (void_type_node,
13367                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13368       TREE_TYPE (decl)
13369         = build_exception_variant (fntype,
13370                                    TYPE_RAISES_EXCEPTIONS (fntype));
13371     }
13372   else
13373     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13374 }
13375
13376 /* Create the FUNCTION_DECL for a function definition.
13377    DECLSPECS and DECLARATOR are the parts of the declaration;
13378    they describe the function's name and the type it returns,
13379    but twisted together in a fashion that parallels the syntax of C.
13380
13381    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13382    DECLARATOR is really the DECL for the function we are about to
13383    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13384    indicating that the function is an inline defined in-class.
13385
13386    This function creates a binding context for the function body
13387    as well as setting up the FUNCTION_DECL in current_function_decl.
13388
13389    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13390    (it defines a datum instead), we return 0, which tells
13391    yyparse to report a parse error.
13392
13393    For C++, we must first check whether that datum makes any sense.
13394    For example, "class A local_a(1,2);" means that variable local_a
13395    is an aggregate of type A, which should have a constructor
13396    applied to it with the argument list [1, 2].  */
13397
13398 int
13399 start_function (declspecs, declarator, attrs, flags)
13400      tree declspecs, declarator, attrs;
13401      int flags;
13402 {
13403   tree decl1;
13404   tree ctype = NULL_TREE;
13405   tree fntype;
13406   tree restype;
13407   extern int have_extern_spec;
13408   extern int used_extern_spec;
13409   int doing_friend = 0;
13410   struct binding_level *bl;
13411   tree current_function_parms;
13412
13413   /* Sanity check.  */
13414   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13415   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13416
13417   /* This should only be done once on the top most decl.  */
13418   if (have_extern_spec && !used_extern_spec)
13419     {
13420       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13421       used_extern_spec = 1;
13422     }
13423
13424   if (flags & SF_PRE_PARSED)
13425     {
13426       decl1 = declarator;
13427
13428       fntype = TREE_TYPE (decl1);
13429       if (TREE_CODE (fntype) == METHOD_TYPE)
13430         ctype = TYPE_METHOD_BASETYPE (fntype);
13431
13432       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13433          the (lexical) scope of the class in which it is defined.  */
13434       if (!ctype && DECL_FRIEND_P (decl1))
13435         {
13436           ctype = DECL_FRIEND_CONTEXT (decl1);
13437
13438           /* CTYPE could be null here if we're dealing with a template;
13439              for example, `inline friend float foo()' inside a template
13440              will have no CTYPE set.  */
13441           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13442             ctype = NULL_TREE;
13443           else
13444             doing_friend = 1;
13445         }
13446
13447       last_function_parms = DECL_ARGUMENTS (decl1);
13448     }
13449   else
13450     {
13451       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL);
13452       /* If the declarator is not suitable for a function definition,
13453          cause a syntax error.  */
13454       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13455
13456       fntype = TREE_TYPE (decl1);
13457
13458       restype = TREE_TYPE (fntype);
13459       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13460         {
13461           cp_error ("semicolon missing after declaration of `%#T'", restype);
13462           shadow_tag (build_tree_list (NULL_TREE, restype));
13463           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13464           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13465             fntype = build_function_type (integer_type_node,
13466                                           TYPE_ARG_TYPES (fntype));
13467           else
13468             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13469                                               integer_type_node,
13470                                               TYPE_ARG_TYPES (fntype));
13471           TREE_TYPE (decl1) = fntype;
13472         }
13473
13474       if (TREE_CODE (fntype) == METHOD_TYPE)
13475         ctype = TYPE_METHOD_BASETYPE (fntype);
13476       else if (DECL_MAIN_P (decl1))
13477         {
13478           /* If this doesn't return integer_type, complain.  */
13479           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13480             {
13481               if (pedantic || warn_return_type)
13482                 pedwarn ("return type for `main' changed to `int'");
13483               TREE_TYPE (decl1) = fntype = default_function_type;
13484             }
13485         }
13486     }
13487
13488   if (DECL_DECLARED_INLINE_P (decl1)
13489       && lookup_attribute ("noinline", attrs))
13490     warning_with_decl (decl1,
13491                        "inline function `%s' given attribute noinline");
13492
13493   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13494     /* This is a constructor, we must ensure that any default args
13495        introduced by this definition are propagated to the clones
13496        now. The clones are used directly in overload resolution.  */
13497     adjust_clone_args (decl1);
13498
13499   /* Sometimes we don't notice that a function is a static member, and
13500      build a METHOD_TYPE for it.  Fix that up now.  */
13501   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13502       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13503     {
13504       revert_static_member_fn (decl1);
13505       last_function_parms = TREE_CHAIN (last_function_parms);
13506       ctype = NULL_TREE;
13507     }
13508
13509   /* Warn if function was previously implicitly declared
13510      (but not if we warned then).  */
13511   if (! warn_implicit
13512       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13513     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13514
13515   /* Set up current_class_type, and enter the scope of the class, if
13516      appropriate.  */
13517   if (ctype)
13518     push_nested_class (ctype, 1);
13519   else if (DECL_STATIC_FUNCTION_P (decl1))
13520     push_nested_class (DECL_CONTEXT (decl1), 2);
13521
13522   /* Now that we have entered the scope of the class, we must restore
13523      the bindings for any template parameters surrounding DECL1, if it
13524      is an inline member template.  (Order is important; consider the
13525      case where a template parameter has the same name as a field of
13526      the class.)  It is not until after this point that
13527      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13528   if (flags & SF_INCLASS_INLINE)
13529     maybe_begin_member_template_processing (decl1);
13530
13531   /* Effective C++ rule 15.  */
13532   if (warn_ecpp
13533       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13534       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13535     cp_warning ("`operator=' should return a reference to `*this'");
13536
13537   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13538      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13539   if (!DECL_INITIAL (decl1))
13540     DECL_INITIAL (decl1) = error_mark_node;
13541
13542   /* This function exists in static storage.
13543      (This does not mean `static' in the C sense!)  */
13544   TREE_STATIC (decl1) = 1;
13545
13546   /* We must call push_template_decl after current_class_type is set
13547      up.  (If we are processing inline definitions after exiting a
13548      class scope, current_class_type will be NULL_TREE until set above
13549      by push_nested_class.)  */
13550   if (processing_template_decl)
13551     decl1 = push_template_decl (decl1);
13552
13553   /* We are now in the scope of the function being defined.  */
13554   current_function_decl = decl1;
13555
13556   /* Save the parm names or decls from this function's declarator
13557      where store_parm_decls will find them.  */
13558   current_function_parms = last_function_parms;
13559
13560   /* Make sure the parameter and return types are reasonable.  When
13561      you declare a function, these types can be incomplete, but they
13562      must be complete when you define the function.  */
13563   if (! processing_template_decl)
13564     check_function_type (decl1, current_function_parms);
13565
13566   /* Build the return declaration for the function.  */
13567   restype = TREE_TYPE (fntype);
13568   if (!processing_template_decl)
13569     {
13570       if (!DECL_RESULT (decl1))
13571         {
13572           DECL_RESULT (decl1)
13573             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13574           c_apply_type_quals_to_decl (cp_type_quals (restype),
13575                                       DECL_RESULT (decl1));
13576         }
13577     }
13578   else
13579     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13580     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13581
13582   /* Initialize RTL machinery.  We cannot do this until
13583      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13584      even when processing a template; this is how we get
13585      CFUN set up, and our per-function variables initialized.
13586      FIXME factor out the non-RTL stuff.  */
13587   bl = current_binding_level;
13588   init_function_start (decl1, input_filename, lineno);
13589   current_binding_level = bl;
13590
13591   /* Even though we're inside a function body, we still don't want to
13592      call expand_expr to calculate the size of a variable-sized array.
13593      We haven't necessarily assigned RTL to all variables yet, so it's
13594      not safe to try to expand expressions involving them.  */
13595   immediate_size_expand = 0;
13596   cfun->x_dont_save_pending_sizes_p = 1;
13597
13598   /* Start the statement-tree, start the tree now.  */
13599   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13600
13601   /* Let the user know we're compiling this function.  */
13602   announce_function (decl1);
13603
13604   /* Record the decl so that the function name is defined.
13605      If we already have a decl for this name, and it is a FUNCTION_DECL,
13606      use the old decl.  */
13607   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13608     {
13609       /* A specialization is not used to guide overload resolution.  */
13610       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13611           && ! DECL_FUNCTION_MEMBER_P (decl1))
13612         decl1 = pushdecl (decl1);
13613       else
13614         {
13615           /* We need to set the DECL_CONTEXT. */
13616           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13617             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13618           /* And make sure we have enough default args.  */
13619           check_default_args (decl1);
13620         }
13621       fntype = TREE_TYPE (decl1);
13622     }
13623
13624   /* Reset these in case the call to pushdecl changed them.  */
13625   current_function_decl = decl1;
13626   cfun->decl = decl1;
13627
13628   /* If we are (erroneously) defining a function that we have already
13629      defined before, wipe out what we knew before.  */
13630   if (!DECL_PENDING_INLINE_P (decl1)
13631       && DECL_SAVED_FUNCTION_DATA (decl1))
13632     {
13633       free (DECL_SAVED_FUNCTION_DATA (decl1));
13634       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13635     }
13636
13637   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13638     {
13639       /* We know that this was set up by `grokclassfn'.  We do not
13640          wait until `store_parm_decls', since evil parse errors may
13641          never get us to that point.  Here we keep the consistency
13642          between `current_class_type' and `current_class_ptr'.  */
13643       tree t = DECL_ARGUMENTS (decl1);
13644
13645       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13646                           162);
13647       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13648                           19990811);
13649
13650       cp_function_chain->x_current_class_ref
13651         = build_indirect_ref (t, NULL);
13652       cp_function_chain->x_current_class_ptr = t;
13653
13654       /* Constructors and destructors need to know whether they're "in
13655          charge" of initializing virtual base classes.  */
13656       t = TREE_CHAIN (t);
13657       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13658         {
13659           current_in_charge_parm = t;
13660           t = TREE_CHAIN (t);
13661         }
13662       if (DECL_HAS_VTT_PARM_P (decl1))
13663         {
13664           if (DECL_NAME (t) != vtt_parm_identifier)
13665             abort ();
13666           current_vtt_parm = t;
13667         }
13668     }
13669
13670   if (DECL_INTERFACE_KNOWN (decl1))
13671     {
13672       tree ctx = decl_function_context (decl1);
13673
13674       if (DECL_NOT_REALLY_EXTERN (decl1))
13675         DECL_EXTERNAL (decl1) = 0;
13676
13677       if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
13678           && TREE_PUBLIC (ctx))
13679         /* This is a function in a local class in an extern inline
13680            function.  */
13681         comdat_linkage (decl1);
13682     }
13683   /* If this function belongs to an interface, it is public.
13684      If it belongs to someone else's interface, it is also external.
13685      This only affects inlines and template instantiations.  */
13686   else if (interface_unknown == 0
13687            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13688                || flag_alt_external_templates))
13689     {
13690       if (DECL_DECLARED_INLINE_P (decl1)
13691           || DECL_TEMPLATE_INSTANTIATION (decl1)
13692           || processing_template_decl)
13693         {
13694           DECL_EXTERNAL (decl1)
13695             = (interface_only
13696                || (DECL_DECLARED_INLINE_P (decl1)
13697                    && ! flag_implement_inlines
13698                    && !DECL_VINDEX (decl1)));
13699
13700           /* For WIN32 we also want to put these in linkonce sections.  */
13701           maybe_make_one_only (decl1);
13702         }
13703       else
13704         DECL_EXTERNAL (decl1) = 0;
13705       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13706       DECL_INTERFACE_KNOWN (decl1) = 1;
13707     }
13708   else if (interface_unknown && interface_only
13709            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13710                || flag_alt_external_templates))
13711     {
13712       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13713          interface, we will have interface_only set but not
13714          interface_known.  In that case, we don't want to use the normal
13715          heuristics because someone will supply a #pragma implementation
13716          elsewhere, and deducing it here would produce a conflict.  */
13717       comdat_linkage (decl1);
13718       DECL_EXTERNAL (decl1) = 0;
13719       DECL_INTERFACE_KNOWN (decl1) = 1;
13720       DECL_DEFER_OUTPUT (decl1) = 1;
13721     }
13722   else
13723     {
13724       /* This is a definition, not a reference.
13725          So clear DECL_EXTERNAL.  */
13726       DECL_EXTERNAL (decl1) = 0;
13727
13728       if ((DECL_DECLARED_INLINE_P (decl1)
13729            || DECL_TEMPLATE_INSTANTIATION (decl1))
13730           && ! DECL_INTERFACE_KNOWN (decl1)
13731           /* Don't try to defer nested functions for now.  */
13732           && ! decl_function_context (decl1))
13733         DECL_DEFER_OUTPUT (decl1) = 1;
13734       else
13735         DECL_INTERFACE_KNOWN (decl1) = 1;
13736     }
13737
13738   pushlevel (0);
13739   current_binding_level->parm_flag = 1;
13740
13741   cplus_decl_attributes (&decl1, attrs, 0);
13742
13743   /* Promote the value to int before returning it.  */
13744   if (c_promoting_integer_type_p (restype))
13745     restype = type_promotes_to (restype);
13746
13747   if (DECL_RESULT (decl1) == NULL_TREE)
13748     {
13749       DECL_RESULT (decl1)
13750         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13751       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13752       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13753     }
13754
13755   ++function_depth;
13756
13757   if (DECL_DESTRUCTOR_P (decl1))
13758     {
13759       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13760       DECL_CONTEXT (dtor_label) = current_function_decl;
13761     }
13762
13763   start_fname_decls ();
13764
13765   store_parm_decls (current_function_parms);
13766
13767   return 1;
13768 }
13769 \f
13770 /* Store the parameter declarations into the current function declaration.
13771    This is called after parsing the parameter declarations, before
13772    digesting the body of the function.
13773
13774    Also install to binding contour return value identifier, if any.  */
13775
13776 static void
13777 store_parm_decls (current_function_parms)
13778      tree current_function_parms;
13779 {
13780   register tree fndecl = current_function_decl;
13781   register tree parm;
13782   int parms_have_cleanups = 0;
13783   tree cleanups = NULL_TREE;
13784
13785   /* This is a chain of any other decls that came in among the parm
13786      declarations.  If a parm is declared with  enum {foo, bar} x;
13787      then CONST_DECLs for foo and bar are put here.  */
13788   tree nonparms = NULL_TREE;
13789
13790   if (current_function_parms)
13791     {
13792       /* This case is when the function was defined with an ANSI prototype.
13793          The parms already have decls, so we need not do anything here
13794          except record them as in effect
13795          and complain if any redundant old-style parm decls were written.  */
13796
13797       tree specparms = current_function_parms;
13798       tree next;
13799
13800       /* Must clear this because it might contain TYPE_DECLs declared
13801              at class level.  */
13802       storedecls (NULL_TREE);
13803
13804       /* If we're doing semantic analysis, then we'll call pushdecl
13805              for each of these.  We must do them in reverse order so that
13806              they end in the correct forward order.  */
13807       specparms = nreverse (specparms);
13808
13809       for (parm = specparms; parm; parm = next)
13810         {
13811           next = TREE_CHAIN (parm);
13812           if (TREE_CODE (parm) == PARM_DECL)
13813             {
13814               tree cleanup;
13815
13816               if (DECL_NAME (parm) == NULL_TREE
13817                   || TREE_CODE (parm) != VOID_TYPE)
13818                 pushdecl (parm);
13819               else
13820                 cp_error ("parameter `%D' declared void", parm);
13821
13822               cleanup = (processing_template_decl
13823                          ? NULL_TREE
13824                          : maybe_build_cleanup (parm));
13825
13826               if (cleanup)
13827                 cleanups = tree_cons (parm, cleanup, cleanups);
13828             }
13829           else
13830             {
13831               /* If we find an enum constant or a type tag,
13832                  put it aside for the moment.  */
13833               TREE_CHAIN (parm) = NULL_TREE;
13834               nonparms = chainon (nonparms, parm);
13835             }
13836         }
13837
13838       /* Get the decls in their original chain order and record in the
13839          function.  This is all and only the PARM_DECLs that were
13840          pushed into scope by the loop above.  */
13841       DECL_ARGUMENTS (fndecl) = getdecls ();
13842       storetags (gettags ());
13843     }
13844   else
13845     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13846
13847   /* Now store the final chain of decls for the arguments
13848      as the decl-chain of the current lexical scope.
13849      Put the enumerators in as well, at the front so that
13850      DECL_ARGUMENTS is not modified.  */
13851   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13852
13853   /* Now that we have initialized the parms, we can start their
13854      cleanups.  We cannot do this before, since expand_decl_cleanup
13855      should not be called before the parm can be used.  */
13856   while (cleanups)
13857     {
13858       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13859                            TREE_VALUE (cleanups));
13860       cleanups = TREE_CHAIN (cleanups);
13861     }
13862
13863   /* Create a binding contour which can be used to catch
13864      cleanup-generated temporaries.  */
13865   if (parms_have_cleanups)
13866     pushlevel (0);
13867
13868   /* Do the starting of the exception specifications, if we have any.  */
13869   if (flag_exceptions && !processing_template_decl
13870       && flag_enforce_eh_specs
13871       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13872     current_eh_spec_block = begin_eh_spec_block ();
13873 }
13874
13875 \f
13876 /* We have finished doing semantic analysis on DECL, but have not yet
13877    generated RTL for its body.  Save away our current state, so that
13878    when we want to generate RTL later we know what to do.  */
13879
13880 static void
13881 save_function_data (decl)
13882      tree decl;
13883 {
13884   struct cp_language_function *f;
13885
13886   /* Save the language-specific per-function data so that we can
13887      get it back when we really expand this function.  */
13888   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13889                       19990908);
13890
13891   /* Make a copy.  */
13892   f = ((struct cp_language_function *)
13893        xmalloc (sizeof (struct cp_language_function)));
13894   memcpy (f, cp_function_chain, sizeof (struct cp_language_function));
13895   DECL_SAVED_FUNCTION_DATA (decl) = f;
13896
13897   /* Clear out the bits we don't need.  */
13898   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
13899   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
13900   f->x_named_label_uses = NULL;
13901   f->bindings = NULL;
13902   f->x_local_names = NULL;
13903
13904   /* When we get back here again, we will be expanding.  */
13905   f->x_expanding_p = 1;
13906
13907   /* If we've already decided that we cannot inline this function, we
13908      must remember that fact when we actually go to expand the
13909      function.  */
13910   if (current_function_cannot_inline)
13911     {
13912       f->cannot_inline = current_function_cannot_inline;
13913       DECL_INLINE (decl) = 0;
13914     }
13915 }
13916
13917 /* At the end of every constructor we generate to code to return
13918    `this'.  Do that now.  */
13919
13920 static void
13921 finish_constructor_body ()
13922 {
13923   /* Any return from a constructor will end up here.  */
13924   if (ctor_label)
13925     add_stmt (build_stmt (LABEL_STMT, ctor_label));
13926
13927   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13928      generate the return, rather than a goto to CTOR_LABEL.  */
13929   ctor_label = NULL_TREE;
13930   /* In check_return_expr we translate an empty return from a
13931      constructor to a return of `this'.  */
13932   finish_return_stmt (NULL_TREE);
13933   /* Mark the end of the constructor.  */
13934   add_stmt (build_stmt (CTOR_STMT));
13935 }
13936
13937 /* At the end of every destructor we generate code to restore virtual
13938    function tables to the values desired by base classes and to call
13939    to base class destructors.  Do that now.  */
13940
13941 static void
13942 finish_destructor_body ()
13943 {
13944   tree compound_stmt;
13945   tree exprstmt;
13946
13947   /* Create a block to contain all the extra code.  */
13948   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13949
13950   /* Any return from a destructor will end up here.  */
13951   add_stmt (build_stmt (LABEL_STMT, dtor_label));
13952
13953   /* Generate the code to call destructor on base class.  If this
13954      destructor belongs to a class with virtual functions, then set
13955      the virtual function table pointer to represent the type of our
13956      base class.  */
13957
13958   /* This side-effect makes call to `build_delete' generate the code
13959      we have to have at the end of this destructor.  `build_delete'
13960      will set the flag again.  */
13961   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13962
13963   exprstmt = build_delete (current_class_type,
13964                            current_class_ref,
13965                            sfk_base_destructor,
13966                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13967                            0);
13968
13969   if (exprstmt != error_mark_node
13970       && (TREE_CODE (exprstmt) != NOP_EXPR
13971           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13972           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13973     {
13974       if (exprstmt != void_zero_node)
13975         /* Don't call `expand_expr_stmt' if we're not going to do
13976            anything, since -Wall will give a diagnostic.  */
13977         finish_expr_stmt (exprstmt);
13978
13979       /* Run destructors for all virtual baseclasses.  */
13980       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13981         {
13982           tree vbases;
13983           tree if_stmt;
13984
13985           if_stmt = begin_if_stmt ();
13986           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13987                                       current_in_charge_parm,
13988                                       integer_two_node),
13989                                if_stmt);
13990
13991           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
13992           /* The CLASSTYPE_VBASECLASSES list is in initialization
13993              order, so we have to march through it in reverse order.  */
13994           for (vbases = nreverse (copy_list (vbases));
13995                vbases;
13996                vbases = TREE_CHAIN (vbases))
13997             {
13998               tree vbase = TREE_VALUE (vbases);
13999               tree base_type = BINFO_TYPE (vbase);
14000
14001               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (base_type))
14002                 {
14003                   tree base_ptr_type = build_pointer_type (base_type);
14004                   tree expr = current_class_ptr;
14005
14006                   /* Convert to the basetype here, as we know the layout is
14007                      fixed. What is more, if we let build_method_call do it,
14008                      it will use the vtable, which may have been clobbered
14009                      by the deletion of our primary base.  */
14010
14011                   expr = build1 (NOP_EXPR, base_ptr_type, expr);
14012                   expr = build (PLUS_EXPR, base_ptr_type, expr,
14013                                 BINFO_OFFSET (vbase));
14014                   expr = build_indirect_ref (expr, NULL);
14015                   expr = build_method_call (expr, base_dtor_identifier,
14016                                             NULL_TREE, vbase,
14017                                             LOOKUP_NORMAL);
14018                   finish_expr_stmt (expr);
14019                 }
14020             }
14021
14022           finish_then_clause (if_stmt);
14023           finish_if_stmt ();
14024         }
14025     }
14026
14027   /* In a virtual destructor, we must call delete.  */
14028   if (DECL_VIRTUAL_P (current_function_decl))
14029     {
14030       tree if_stmt;
14031       tree virtual_size = c_sizeof (current_class_type);
14032
14033       /* [class.dtor]
14034
14035          At the point of definition of a virtual destructor (including
14036          an implicit definition), non-placement operator delete shall
14037          be looked up in the scope of the destructor's class and if
14038          found shall be accessible and unambiguous.  */
14039       exprstmt = build_op_delete_call
14040         (DELETE_EXPR, current_class_ptr, virtual_size,
14041          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14042
14043       if_stmt = begin_if_stmt ();
14044       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14045                                   current_in_charge_parm,
14046                                   integer_one_node),
14047                            if_stmt);
14048       finish_expr_stmt (exprstmt);
14049       finish_then_clause (if_stmt);
14050       finish_if_stmt ();
14051     }
14052
14053   /* Close the block we started above.  */
14054   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14055 }
14056
14057 /* Finish up a function declaration and compile that function
14058    all the way to assembler language output.  The free the storage
14059    for the function definition.
14060
14061    FLAGS is a bitwise or of the following values:
14062      1 - CALL_POPLEVEL
14063        An extra call to poplevel (and expand_end_bindings) must be
14064        made to take care of the binding contour for the base
14065        initializers.  This is only relevant for constructors.
14066      2 - INCLASS_INLINE
14067        We just finished processing the body of an in-class inline
14068        function definition.  (This processing will have taken place
14069        after the class definition is complete.)  */
14070
14071 tree
14072 finish_function (flags)
14073      int flags;
14074 {
14075   register tree fndecl = current_function_decl;
14076   tree fntype, ctype = NULL_TREE;
14077   int call_poplevel = (flags & 1) != 0;
14078   int inclass_inline = (flags & 2) != 0;
14079   int nested;
14080
14081   /* When we get some parse errors, we can end up without a
14082      current_function_decl, so cope.  */
14083   if (fndecl == NULL_TREE)
14084     return error_mark_node;
14085
14086   nested = function_depth > 1;
14087   fntype = TREE_TYPE (fndecl);
14088
14089   /*  TREE_READONLY (fndecl) = 1;
14090       This caused &foo to be of type ptr-to-const-function
14091       which then got a warning when stored in a ptr-to-function variable.  */
14092
14093   my_friendly_assert (building_stmt_tree (), 20000911);
14094
14095   finish_fname_decls ();
14096
14097   /* For a cloned function, we've already got all the code we need;
14098      there's no need to add any extra bits.  */
14099   if (!DECL_CLONED_FUNCTION_P (fndecl))
14100     {
14101       if (DECL_CONSTRUCTOR_P (fndecl))
14102         {
14103           finish_constructor_body ();
14104           if (call_poplevel)
14105             do_poplevel ();
14106         }
14107       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14108         finish_destructor_body ();
14109       else if (DECL_MAIN_P (fndecl))
14110         {
14111           /* Make it so that `main' always returns 0 by default.  */
14112 #ifdef VMS
14113           finish_return_stmt (integer_one_node);
14114 #else
14115           finish_return_stmt (integer_zero_node);
14116 #endif
14117         }
14118
14119       /* Finish dealing with exception specifiers.  */
14120       if (flag_exceptions && !processing_template_decl
14121           && flag_enforce_eh_specs
14122           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14123         finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14124                               (TREE_TYPE (current_function_decl)),
14125                               current_eh_spec_block);
14126     }
14127
14128   /* If we're saving up tree structure, tie off the function now.  */
14129   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14130
14131   /* This must come after expand_function_end because cleanups might
14132      have declarations (from inline functions) that need to go into
14133      this function's blocks.  */
14134   if (current_binding_level->parm_flag != 1)
14135     my_friendly_abort (122);
14136   poplevel (1, 0, 1);
14137
14138   /* Set up the named return value optimization, if we can.  Here, we
14139      eliminate the copy from the nrv into the RESULT_DECL and any cleanup
14140      for the nrv.  genrtl_start_function and declare_return_variable
14141      handle making the nrv and RESULT_DECL share space.  */
14142   if (current_function_return_value)
14143     {
14144       tree r = current_function_return_value;
14145       /* This is only worth doing for fns that return in memory--and
14146          simpler, since we don't have to worry about promoted modes.  */
14147       if (r != error_mark_node
14148           && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl))))
14149         {
14150           DECL_ALIGN (r) = DECL_ALIGN (DECL_RESULT (fndecl));
14151           walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl),
14152                                         nullify_returns_r, r);
14153         }
14154       else
14155         /* Clear it so genrtl_start_function and declare_return_variable
14156            know we're not optimizing.  */
14157         current_function_return_value = NULL_TREE;
14158     }
14159
14160   /* Remember that we were in class scope.  */
14161   if (current_class_name)
14162     ctype = current_class_type;
14163
14164   /* Must mark the RESULT_DECL as being in this function.  */
14165   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14166
14167   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14168      to the FUNCTION_DECL node itself.  */
14169   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14170
14171   /* Save away current state, if appropriate.  */
14172   if (!processing_template_decl)
14173     save_function_data (fndecl);
14174
14175   /* If this function calls `setjmp' it cannot be inlined.  When
14176      `longjmp' is called it is not guaranteed to restore the value of
14177      local variables that have been modified since the call to
14178      `setjmp'.  So, if were to inline this function into some caller
14179      `c', then when we `longjmp', we might not restore all variables
14180      in `c'.  (It might seem, at first blush, that there's no way for
14181      this function to modify local variables in `c', but their
14182      addresses may have been stored somewhere accessible to this
14183      function.)  */
14184   if (!processing_template_decl && calls_setjmp_p (fndecl))
14185     DECL_UNINLINABLE (fndecl) = 1;
14186
14187   /* Clear out memory we no longer need.  */
14188   free_after_parsing (cfun);
14189   /* Since we never call rest_of_compilation, we never clear
14190      CFUN.  Do so explicitly.  */
14191   free_after_compilation (cfun);
14192   cfun = NULL;
14193
14194   /* If this is a in-class inline definition, we may have to pop the
14195      bindings for the template parameters that we added in
14196      maybe_begin_member_template_processing when start_function was
14197      called.  */
14198   if (inclass_inline)
14199     maybe_end_member_template_processing ();
14200
14201   /* Leave the scope of the class.  */
14202   if (ctype)
14203     pop_nested_class ();
14204
14205   --function_depth;
14206
14207   /* Clean up.  */
14208   if (! nested)
14209     /* Let the error reporting routines know that we're outside a
14210        function.  For a nested function, this value is used in
14211        pop_cp_function_context and then reset via pop_function_context.  */
14212     current_function_decl = NULL_TREE;
14213
14214   return fndecl;
14215 }
14216 \f
14217 /* Create the FUNCTION_DECL for a function definition.
14218    DECLSPECS and DECLARATOR are the parts of the declaration;
14219    they describe the return type and the name of the function,
14220    but twisted together in a fashion that parallels the syntax of C.
14221
14222    This function creates a binding context for the function body
14223    as well as setting up the FUNCTION_DECL in current_function_decl.
14224
14225    Returns a FUNCTION_DECL on success.
14226
14227    If the DECLARATOR is not suitable for a function (it defines a datum
14228    instead), we return 0, which tells yyparse to report a parse error.
14229
14230    May return void_type_node indicating that this method is actually
14231    a friend.  See grokfield for more details.
14232
14233    Came here with a `.pushlevel' .
14234
14235    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14236    CHANGES TO CODE IN `grokfield'.  */
14237
14238 tree
14239 start_method (declspecs, declarator, attrlist)
14240      tree declarator, declspecs, attrlist;
14241 {
14242   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14243                                 &attrlist);
14244
14245   /* Something too ugly to handle.  */
14246   if (fndecl == NULL_TREE)
14247     return NULL_TREE;
14248
14249   /* Pass friends other than inline friend functions back.  */
14250   if (fndecl == void_type_node)
14251     return fndecl;
14252
14253   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14254     /* Not a function, tell parser to report parse error.  */
14255     return NULL_TREE;
14256
14257   if (DECL_IN_AGGR_P (fndecl))
14258     {
14259       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14260         {
14261           if (DECL_CONTEXT (fndecl)
14262               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14263             cp_error ("`%D' is already defined in class `%T'", fndecl,
14264                       DECL_CONTEXT (fndecl));
14265         }
14266       return void_type_node;
14267     }
14268
14269   check_template_shadow (fndecl);
14270
14271   DECL_DECLARED_INLINE_P (fndecl) = 1;
14272
14273   if (flag_default_inline)
14274     DECL_INLINE (fndecl) = 1;
14275
14276   /* We process method specializations in finish_struct_1.  */
14277   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14278     fndecl = push_template_decl (fndecl);
14279
14280   if (! DECL_FRIEND_P (fndecl))
14281     {
14282       if (TREE_CHAIN (fndecl))
14283         {
14284           fndecl = copy_node (fndecl);
14285           TREE_CHAIN (fndecl) = NULL_TREE;
14286         }
14287       grok_special_member_properties (fndecl);
14288     }
14289
14290   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14291
14292   /* Make a place for the parms */
14293   pushlevel (0);
14294   current_binding_level->parm_flag = 1;
14295
14296   DECL_IN_AGGR_P (fndecl) = 1;
14297   return fndecl;
14298 }
14299
14300 /* Go through the motions of finishing a function definition.
14301    We don't compile this method until after the whole class has
14302    been processed.
14303
14304    FINISH_METHOD must return something that looks as though it
14305    came from GROKFIELD (since we are defining a method, after all).
14306
14307    This is called after parsing the body of the function definition.
14308    STMTS is the chain of statements that makes up the function body.
14309
14310    DECL is the ..._DECL that `start_method' provided.  */
14311
14312 tree
14313 finish_method (decl)
14314      tree decl;
14315 {
14316   register tree fndecl = decl;
14317   tree old_initial;
14318
14319   register tree link;
14320
14321   if (decl == void_type_node)
14322     return decl;
14323
14324   old_initial = DECL_INITIAL (fndecl);
14325
14326   /* Undo the level for the parms (from start_method).
14327      This is like poplevel, but it causes nothing to be
14328      saved.  Saving information here confuses symbol-table
14329      output routines.  Besides, this information will
14330      be correctly output when this method is actually
14331      compiled.  */
14332
14333   /* Clear out the meanings of the local variables of this level;
14334      also record in each decl which block it belongs to.  */
14335
14336   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14337     {
14338       if (DECL_NAME (link) != NULL_TREE)
14339         pop_binding (DECL_NAME (link), link);
14340       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14341       DECL_CONTEXT (link) = NULL_TREE;
14342     }
14343
14344   GNU_xref_end_scope ((size_t) current_binding_level,
14345                       (size_t) current_binding_level->level_chain,
14346                       current_binding_level->parm_flag,
14347                       current_binding_level->keep);
14348
14349   poplevel (0, 0, 0);
14350
14351   DECL_INITIAL (fndecl) = old_initial;
14352
14353   /* We used to check if the context of FNDECL was different from
14354      current_class_type as another way to get inside here.  This didn't work
14355      for String.cc in libg++.  */
14356   if (DECL_FRIEND_P (fndecl))
14357     {
14358       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14359         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14360       decl = void_type_node;
14361     }
14362
14363   return decl;
14364 }
14365 \f
14366 /* Called when a new struct TYPE is defined.
14367    If this structure or union completes the type of any previous
14368    variable declaration, lay it out and output its rtl.  */
14369
14370 void
14371 hack_incomplete_structures (type)
14372      tree type;
14373 {
14374   tree *list;
14375   struct binding_level *level;
14376
14377   if (!type) /* Don't do this for class templates.  */
14378     return;
14379
14380   if (namespace_bindings_p ())
14381     {
14382       level = 0;
14383       list = &namespace_scope_incomplete;
14384     }
14385   else
14386     {
14387       level = innermost_nonclass_level ();
14388       list = &level->incomplete;
14389     }
14390
14391   while (1)
14392     {
14393       while (*list)
14394         {
14395           tree decl = TREE_VALUE (*list);
14396           if ((decl && TREE_TYPE (decl) == type)
14397               || (TREE_TYPE (decl)
14398                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14399                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14400             {
14401               int toplevel = toplevel_bindings_p ();
14402               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14403                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14404                 layout_type (TREE_TYPE (decl));
14405               layout_decl (decl, 0);
14406               rest_of_decl_compilation (decl, NULL, toplevel, 0);
14407               if (! toplevel)
14408                 {
14409                   tree cleanup;
14410                   expand_decl (decl);
14411                   cleanup = maybe_build_cleanup (decl);
14412                   expand_decl_init (decl);
14413                   if (! expand_decl_cleanup (decl, cleanup))
14414                     cp_error ("parser lost in parsing declaration of `%D'",
14415                               decl);
14416                 }
14417               *list = TREE_CHAIN (*list);
14418             }
14419           else
14420             list = &TREE_CHAIN (*list);
14421         }
14422
14423       /* Keep looking through artificial binding levels generated
14424          for local variables.  */
14425       if (level && level->keep == 2)
14426         {
14427           level = level->level_chain;
14428           list = &level->incomplete;
14429         }
14430       else
14431         break;
14432     }
14433 }
14434
14435 /* If DECL is of a type which needs a cleanup, build that cleanup
14436    here.  */
14437
14438 tree
14439 maybe_build_cleanup (decl)
14440      tree decl;
14441 {
14442   tree type = TREE_TYPE (decl);
14443
14444   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14445     {
14446       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14447       tree rval;
14448
14449       if (TREE_CODE (type) == ARRAY_TYPE)
14450         rval = decl;
14451       else
14452         {
14453           mark_addressable (decl);
14454           rval = build_unary_op (ADDR_EXPR, decl, 0);
14455         }
14456
14457       /* Optimize for space over speed here.  */
14458       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14459           || flag_expensive_optimizations)
14460         flags |= LOOKUP_NONVIRTUAL;
14461
14462       rval = build_delete (TREE_TYPE (rval), rval,
14463                            sfk_complete_destructor, flags, 0);
14464
14465       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14466           && ! TYPE_HAS_DESTRUCTOR (type))
14467         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14468                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14469
14470       return rval;
14471     }
14472   return 0;
14473 }
14474 \f
14475 /* When a stmt has been parsed, this function is called.  */
14476
14477 void
14478 finish_stmt ()
14479 {
14480   /* Always assume this statement was not an expression statement.  If
14481      it actually was an expression statement, its our callers
14482      responsibility to fix this up.  */
14483   last_expr_type = NULL_TREE;
14484 }
14485
14486 /* DECL was originally constructed as a non-static member function,
14487    but turned out to be static.  Update it accordingly.  */
14488
14489 void
14490 revert_static_member_fn (decl)
14491      tree decl;
14492 {
14493   tree tmp;
14494   tree function = TREE_TYPE (decl);
14495   tree args = TYPE_ARG_TYPES (function);
14496
14497   if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
14498       != TYPE_UNQUALIFIED)
14499     cp_error ("static member function `%#D' declared with type qualifiers",
14500               decl);
14501
14502   args = TREE_CHAIN (args);
14503   tmp = build_function_type (TREE_TYPE (function), args);
14504   tmp = build_qualified_type (tmp, cp_type_quals (function));
14505   tmp = build_exception_variant (tmp,
14506                                  TYPE_RAISES_EXCEPTIONS (function));
14507   TREE_TYPE (decl) = tmp;
14508   if (DECL_ARGUMENTS (decl))
14509     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14510   DECL_STATIC_FUNCTION_P (decl) = 1;
14511 }
14512
14513 /* Initialize the variables used during compilation of a C++
14514    function.  */
14515
14516 static void
14517 push_cp_function_context (f)
14518      struct function *f;
14519 {
14520   struct cp_language_function *p
14521     = ((struct cp_language_function *)
14522        xcalloc (1, sizeof (struct cp_language_function)));
14523   f->language = (struct language_function *) p;
14524
14525   /* It takes an explicit call to expand_body to generate RTL for a
14526      function.  */
14527   expanding_p = 0;
14528
14529   /* Whenever we start a new function, we destroy temporaries in the
14530      usual way.  */
14531   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14532 }
14533
14534 /* Free the language-specific parts of F, now that we've finished
14535    compiling the function.  */
14536
14537 static void
14538 pop_cp_function_context (f)
14539      struct function *f;
14540 {
14541   if (f->language)
14542     {
14543       struct cp_language_function *cp =
14544         (struct cp_language_function *) f->language;
14545       if (cp->x_local_names)
14546         VARRAY_FREE (cp->x_local_names);
14547       free (f->language);
14548     }
14549   f->language = 0;
14550 }
14551
14552 /* Mark P for GC.  */
14553
14554 static void
14555 mark_lang_function (p)
14556      struct cp_language_function *p;
14557 {
14558   if (!p)
14559     return;
14560
14561   mark_c_language_function (&p->base);
14562
14563   ggc_mark_tree (p->x_ctor_label);
14564   ggc_mark_tree (p->x_dtor_label);
14565   ggc_mark_tree (p->x_current_class_ptr);
14566   ggc_mark_tree (p->x_current_class_ref);
14567   ggc_mark_tree (p->x_eh_spec_block);
14568   ggc_mark_tree_varray (p->x_local_names);
14569
14570   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14571   mark_binding_level (&p->bindings);
14572 }
14573
14574 /* Mark the language-specific data in F for GC.  */
14575
14576 static void
14577 mark_cp_function_context (f)
14578      struct function *f;
14579 {
14580   mark_lang_function ((struct cp_language_function *) f->language);
14581 }
14582
14583 void
14584 lang_mark_tree (t)
14585      tree t;
14586 {
14587   enum tree_code code = TREE_CODE (t);
14588   if (code == IDENTIFIER_NODE)
14589     {
14590       struct lang_identifier *li = (struct lang_identifier *) t;
14591       struct lang_id2 *li2 = li->x;
14592       ggc_mark_tree (li->namespace_bindings);
14593       ggc_mark_tree (li->bindings);
14594       ggc_mark_tree (li->class_value);
14595       ggc_mark_tree (li->class_template_info);
14596
14597       if (li2)
14598         {
14599           ggc_mark_tree (li2->label_value);
14600           ggc_mark_tree (li2->implicit_decl);
14601           ggc_mark_tree (li2->error_locus);
14602         }
14603     }
14604   else if (code == CPLUS_BINDING)
14605     {
14606       if (BINDING_HAS_LEVEL_P (t))
14607         mark_binding_level (&BINDING_LEVEL (t));
14608       else
14609         ggc_mark_tree (BINDING_SCOPE (t));
14610       ggc_mark_tree (BINDING_VALUE (t));
14611     }
14612   else if (code == OVERLOAD)
14613     ggc_mark_tree (OVL_FUNCTION (t));
14614   else if (code == TEMPLATE_PARM_INDEX)
14615     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14616   else if (TREE_CODE_CLASS (code) == 'd')
14617     {
14618       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14619
14620       if (ld)
14621         {
14622           ggc_mark (ld);
14623           c_mark_lang_decl (&ld->decl_flags.base);
14624           if (!DECL_GLOBAL_CTOR_P (t)
14625               && !DECL_GLOBAL_DTOR_P (t)
14626               && !DECL_THUNK_P (t)
14627               && !DECL_DISCRIMINATOR_P (t))
14628             ggc_mark_tree (ld->decl_flags.u2.access);
14629           else if (DECL_THUNK_P (t))
14630             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14631           if (TREE_CODE (t) != NAMESPACE_DECL)
14632             ggc_mark_tree (ld->decl_flags.u.template_info);
14633           else
14634             mark_binding_level (&NAMESPACE_LEVEL (t));
14635           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14636             {
14637               ggc_mark_tree (ld->befriending_classes);
14638               ggc_mark_tree (ld->context);
14639               ggc_mark_tree (ld->cloned_function);
14640               if (TREE_CODE (t) == TYPE_DECL)
14641                 ggc_mark_tree (ld->u.sorted_fields);
14642               else if (TREE_CODE (t) == FUNCTION_DECL
14643                        && !DECL_PENDING_INLINE_P (t))
14644                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14645             }
14646         }
14647     }
14648   else if (TREE_CODE_CLASS (code) == 't')
14649     {
14650       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14651
14652       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14653                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14654         {
14655           ggc_mark (lt);
14656           ggc_mark_tree (lt->primary_base);
14657           ggc_mark_tree (lt->vfields);
14658           ggc_mark_tree (lt->vbases);
14659           ggc_mark_tree (lt->tags);
14660           ggc_mark_tree (lt->size);
14661           ggc_mark_tree (lt->pure_virtuals);
14662           ggc_mark_tree (lt->friend_classes);
14663           ggc_mark_tree (lt->rtti);
14664           ggc_mark_tree (lt->methods);
14665           ggc_mark_tree (lt->template_info);
14666           ggc_mark_tree (lt->befriending_classes);
14667         }
14668       else if (lt)
14669         /* In the case of pointer-to-member function types, the
14670            TYPE_LANG_SPECIFIC is really just a tree.  */
14671         ggc_mark_tree ((tree) lt);
14672     }
14673 }
14674
14675 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14676    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
14677
14678 tree
14679 identifier_global_value (t)
14680      tree t;
14681 {
14682   return IDENTIFIER_GLOBAL_VALUE (t);
14683 }
14684
14685 /* Build the void_list_node (void_type_node having been created).  */
14686 tree
14687 build_void_list_node ()
14688 {
14689   tree t = build_tree_list (NULL_TREE, void_type_node);
14690   TREE_PARMLIST (t) = 1;
14691   return t;
14692 }
14693
14694 static int
14695 cp_missing_noreturn_ok_p (decl)
14696      tree decl;
14697 {
14698   /* A missing noreturn is ok for the `main' function.  */
14699   return DECL_MAIN_P (decl);
14700 }