gcc/cp/decl.c

   1 /* Process declarations and variables for C compiler.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001  Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* Process declarations and symbol lookup for C front end.
  25    Also constructs types; the standard scalar types at initialization,
  26    and structure, union, array and enum types when they are declared.  */
  27
  28 /* ??? not all decl nodes are given the most useful possible
  29    line numbers.  For example, the CONST_DECLs for enum values.  */
  30
  31 #include "config.h"
  32 #include "system.h"
  33 #include "tree.h"
  34 #include "rtl.h"
  35 #include "expr.h"
  36 #include "flags.h"
  37 #include "cp-tree.h"
  38 #include "decl.h"
  39 #include "lex.h"
  40 #include "output.h"
  41 #include "except.h"
  42 #include "toplev.h"
  43 #include "../hash.h"
  44 #include "ggc.h"
  45 #include "tm_p.h"
  46 #include "target.h"
  47
  48 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  49
  50 #ifndef BOOL_TYPE_SIZE
  51 /* `bool' has size and alignment `1', on all platforms.  */
  52 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  53 #endif
  54
  55 static tree grokparms                           PARAMS ((tree));
  56 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  57
  58 static void push_binding_level PARAMS ((struct binding_level *, int,
  59                                       int));
  60 static void pop_binding_level PARAMS ((void));
  61 static void suspend_binding_level PARAMS ((void));
  62 static void resume_binding_level PARAMS ((struct binding_level *));
  63 static struct binding_level *make_binding_level PARAMS ((void));
  64 static void declare_namespace_level PARAMS ((void));
  65 static int decl_jump_unsafe PARAMS ((tree));
  66 static void storedecls PARAMS ((tree));
  67 static void require_complete_types_for_parms PARAMS ((tree));
  68 static int ambi_op_p PARAMS ((enum tree_code));
  69 static int unary_op_p PARAMS ((enum tree_code));
  70 static tree store_bindings PARAMS ((tree, tree));
  71 static tree lookup_tag_reverse PARAMS ((tree, tree));
  72 static tree obscure_complex_init PARAMS ((tree, tree));
  73 static tree lookup_name_real PARAMS ((tree, int, int, int));
  74 static void push_local_name PARAMS ((tree));
  75 static void warn_extern_redeclared_static PARAMS ((tree, tree));
  76 static tree grok_reference_init PARAMS ((tree, tree, tree));
  77 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
  78                               enum overload_flags, tree,
  79                               tree, int, int, int, int, int, int, tree));
  80 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
  81 static tree lookup_tag PARAMS ((enum tree_code, tree,
  82                               struct binding_level *, int));
  83 static void set_identifier_type_value_with_scope
  84         PARAMS ((tree, tree, struct binding_level *));
  85 static void record_unknown_type PARAMS ((tree, const char *));
  86 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
  87 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
  88 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
  89                                   int));
  90 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
  91 static void check_for_uninitialized_const_var PARAMS ((tree));
  92 static unsigned long typename_hash PARAMS ((hash_table_key));
  93 static bool typename_compare PARAMS ((hash_table_key, hash_table_key));
  94 static void push_binding PARAMS ((tree, tree, struct binding_level*));
  95 static int add_binding PARAMS ((tree, tree));
  96 static void pop_binding PARAMS ((tree, tree));
  97 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
  98 static tree find_binding PARAMS ((tree, tree));
  99 static tree select_decl PARAMS ((tree, int));
 100 static int lookup_flags PARAMS ((int, int));
 101 static tree qualify_lookup PARAMS ((tree, int));
 102 static tree record_builtin_java_type PARAMS ((const char *, int));
 103 static const char *tag_name PARAMS ((enum tag_types code));
 104 static void find_class_binding_level PARAMS ((void));
 105 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 106 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 107 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 108 static int walk_globals_r PARAMS ((tree, void *));
 109 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 110 static tree make_label_decl PARAMS ((tree, int));
 111 static void use_label PARAMS ((tree));
 112 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 113                                            const char *, int));
 114 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 115 static void check_switch_goto PARAMS ((struct binding_level *));
 116 static void check_previous_gotos PARAMS ((tree));
 117 static void pop_label PARAMS ((tree, tree));
 118 static void pop_labels PARAMS ((tree));
 119 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 120 static void layout_var_decl PARAMS ((tree));
 121 static void maybe_commonize_var PARAMS ((tree));
 122 static tree check_initializer PARAMS ((tree, tree));
 123 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 124 static void push_cp_function_context PARAMS ((struct function *));
 125 static void pop_cp_function_context PARAMS ((struct function *));
 126 static void mark_binding_level PARAMS ((void *));
 127 static void mark_named_label_lists PARAMS ((void *, void *));
 128 static void mark_cp_function_context PARAMS ((struct function *));
 129 static void mark_saved_scope PARAMS ((void *));
 130 static void mark_lang_function PARAMS ((struct cp_language_function *));
 131 static void save_function_data PARAMS ((tree));
 132 static void check_function_type PARAMS ((tree, tree));
 133 static void destroy_local_var PARAMS ((tree));
 134 static void finish_constructor_body PARAMS ((void));
 135 static void finish_destructor_body PARAMS ((void));
 136 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 137 static tree get_atexit_node PARAMS ((void));
 138 static tree get_dso_handle_node PARAMS ((void));
 139 static tree start_cleanup_fn PARAMS ((void));
 140 static void end_cleanup_fn PARAMS ((void));
 141 static tree cp_make_fname_decl PARAMS ((tree, int));
 142 static void initialize_predefined_identifiers PARAMS ((void));
 143 static tree check_special_function_return_type
 144   PARAMS ((special_function_kind, tree, tree));
 145 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 146 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 147 static void store_parm_decls PARAMS ((tree));
 148 static int cp_missing_noreturn_ok_p PARAMS ((tree));
 149
 150 #if defined (DEBUG_CP_BINDING_LEVELS)
 151 static void indent PARAMS ((void));
 152 #endif
 153
 154 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 155 tree error_mark_list;
 156
 157 /* The following symbols are subsumed in the cp_global_trees array, and
 158    listed here individually for documentation purposes.
 159
 160    C++ extensions
 161         tree wchar_decl_node;
 162
 163         tree vtable_entry_type;
 164         tree delta_type_node;
 165         tree __t_desc_type_node;
 166         tree ti_desc_type_node;
 167         tree bltn_desc_type_node, ptr_desc_type_node;
 168         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 169         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 170         tree ptm_desc_type_node;
 171         tree base_desc_type_node;
 172
 173         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 174         tree unknown_type_node;
 175
 176    Array type `vtable_entry_type[]'
 177
 178         tree vtbl_type_node;
 179         tree vtbl_ptr_type_node;
 180
 181    Namespaces,
 182
 183         tree std_node;
 184         tree abi_node;
 185
 186    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 187    one that the user will declare, but sufficient to be called
 188    by routines that want to abort the program.
 189
 190         tree abort_fndecl;
 191
 192    The FUNCTION_DECL for the default `::operator delete'.
 193
 194         tree global_delete_fndecl;
 195
 196    Used by RTTI
 197         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 198         tree tinfo_var_id;
 199
 200 */
 201
 202 tree cp_global_trees[CPTI_MAX];
 203
 204 /* Indicates that there is a type value in some namespace, although
 205    that is not necessarily in scope at the moment.  */
 206
 207 static tree global_type_node;
 208
 209 /* Expect only namespace names now. */
 210 static int only_namespace_names;
 211
 212 /* Used only for jumps to as-yet undefined labels, since jumps to
 213    defined labels can have their validity checked immediately.  */
 214
 215 struct named_label_use_list
 216 {
 217   struct binding_level *binding_level;
 218   tree names_in_scope;
 219   tree label_decl;
 220   const char *filename_o_goto;
 221   int lineno_o_goto;
 222   struct named_label_use_list *next;
 223 };
 224
 225 #define named_label_uses cp_function_chain->x_named_label_uses
 226
 227 #define local_names cp_function_chain->x_local_names
 228
 229 /* A list of objects which have constructors or destructors
 230    which reside in the global scope.  The decl is stored in
 231    the TREE_VALUE slot and the initializer is stored
 232    in the TREE_PURPOSE slot.  */
 233 tree static_aggregates;
 234
 235 /* -- end of C++ */
 236
 237 /* A node for the integer constants 2, and 3.  */
 238
 239 tree integer_two_node, integer_three_node;
 240
 241 /* Similar, for last_function_parm_tags.  */
 242 tree last_function_parms;
 243
 244 /* A list of all LABEL_DECLs in the function that have names.  Here so
 245    we can clear out their names' definitions at the end of the
 246    function, and so we can check the validity of jumps to these labels.  */
 247
 248 struct named_label_list
 249 {
 250   struct binding_level *binding_level;
 251   tree names_in_scope;
 252   tree old_value;
 253   tree label_decl;
 254   tree bad_decls;
 255   struct named_label_list *next;
 256   unsigned int in_try_scope : 1;
 257   unsigned int in_catch_scope : 1;
 258 };
 259
 260 #define named_labels cp_function_chain->x_named_labels
 261
 262 /* Nonzero means use the ISO C94 dialect of C.  */
 263
 264 int flag_isoc94;
 265
 266 /* Nonzero means use the ISO C99 dialect of C.  */
 267
 268 int flag_isoc99;
 269
 270 /* Nonzero means we are a hosted implementation for code shared with C.  */
 271
 272 int flag_hosted = 1;
 273
 274 /* Nonzero means add default format_arg attributes for functions not
 275    in ISO C.  */
 276
 277 int flag_noniso_default_format_attributes = 1;
 278
 279 /* Nonzero if we want to conserve space in the .o files.  We do this
 280    by putting uninitialized data and runtime initialized data into
 281    .common instead of .data at the expense of not flagging multiple
 282    definitions.  */
 283 extern int flag_conserve_space;
 284 \f
 285 /* C and C++ flags are in decl2.c.  */
 286
 287 /* Flag used when debugging spew.c */
 288
 289 extern int spew_debug;
 290
 291 /* A expression of value 0 with the same precision as a sizetype
 292    node, but signed.  */
 293 tree signed_size_zero_node;
 294
 295 /* The name of the anonymous namespace, throughout this translation
 296    unit.  */
 297 tree anonymous_namespace_name;
 298
 299 /* The number of function bodies which we are currently processing.
 300    (Zero if we are at namespace scope, one inside the body of a
 301    function, two inside the body of a function in a local class, etc.)  */
 302 int function_depth;
 303 \f
 304 /* For each binding contour we allocate a binding_level structure
 305    which records the names defined in that contour.
 306    Contours include:
 307     0) the global one
 308     1) one for each function definition,
 309        where internal declarations of the parameters appear.
 310     2) one for each compound statement,
 311        to record its declarations.
 312
 313    The current meaning of a name can be found by searching the levels
 314    from the current one out to the global one.
 315
 316    Off to the side, may be the class_binding_level.  This exists only
 317    to catch class-local declarations.  It is otherwise nonexistent.
 318
 319    Also there may be binding levels that catch cleanups that must be
 320    run when exceptions occur.  Thus, to see whether a name is bound in
 321    the current scope, it is not enough to look in the
 322    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 323    instead.  */
 324
 325 /* Note that the information in the `names' component of the global contour
 326    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 327
 328 struct binding_level
 329   {
 330     /* A chain of _DECL nodes for all variables, constants, functions,
 331        and typedef types.  These are in the reverse of the order
 332        supplied.  There may be OVERLOADs on this list, too, but they
 333        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 334     tree names;
 335
 336     /* A list of structure, union and enum definitions, for looking up
 337        tag names.
 338        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 339        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 340        or ENUMERAL_TYPE node.
 341
 342        C++: the TREE_VALUE nodes can be simple types for
 343        component_bindings.  */
 344     tree tags;
 345
 346     /* A list of USING_DECL nodes. */
 347     tree usings;
 348
 349     /* A list of used namespaces. PURPOSE is the namespace,
 350        VALUE the common ancestor with this binding_level's namespace. */
 351     tree using_directives;
 352
 353     /* If this binding level is the binding level for a class, then
 354        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 355        is the name of an entity bound in the class.  The TREE_TYPE is
 356        the DECL bound by this name in the class.  */
 357     tree class_shadowed;
 358
 359     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 360        is used for all binding levels. In addition the TREE_VALUE is the
 361        IDENTIFIER_TYPE_VALUE before we entered the class.  */
 362     tree type_shadowed;
 363
 364     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 365        label in this scope.  The TREE_PURPOSE is the previous value of
 366        the IDENTIFIER_LABEL VALUE.  */
 367     tree shadowed_labels;
 368
 369     /* For each level (except not the global one),
 370        a chain of BLOCK nodes for all the levels
 371        that were entered and exited one level down.  */
 372     tree blocks;
 373
 374     /* The _TYPE node for this level, if parm_flag == 2.  */
 375     tree this_class;
 376
 377     /* The binding level which this one is contained in (inherits from).  */
 378     struct binding_level *level_chain;
 379
 380     /* List of decls in `names' that have incomplete
 381        structure or union types.  */
 382     tree incomplete;
 383
 384     /* List of VAR_DECLS saved from a previous for statement.
 385        These would be dead in ISO-conforming code, but might
 386        be referenced in ARM-era code.  These are stored in a
 387        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 388     tree dead_vars_from_for;
 389
 390     /* 1 for the level that holds the parameters of a function.
 391        2 for the level that holds a class declaration.  */
 392     unsigned parm_flag : 2;
 393
 394     /* 1 means make a BLOCK for this level regardless of all else.
 395        2 for temporary binding contours created by the compiler.  */
 396     unsigned keep : 2;
 397
 398     /* Nonzero if this level "doesn't exist" for tags.  */
 399     unsigned tag_transparent : 1;
 400
 401     /* Nonzero if this level can safely have additional
 402        cleanup-needing variables added to it.  */
 403     unsigned more_cleanups_ok : 1;
 404     unsigned have_cleanups : 1;
 405
 406     /* Nonzero if this scope is for storing the decls for template
 407        parameters and generic decls; these decls will be discarded and
 408        replaced with a TEMPLATE_DECL.  */
 409     unsigned template_parms_p : 1;
 410
 411     /* Nonzero if this scope corresponds to the `<>' in a
 412        `template <>' clause.  Whenever this flag is set,
 413        TEMPLATE_PARMS_P will be set as well.  */
 414     unsigned template_spec_p : 1;
 415
 416     /* This is set for a namespace binding level.  */
 417     unsigned namespace_p : 1;
 418
 419     /* True if this level is that of a for-statement where we need to
 420        worry about ambiguous (ARM or ISO) scope rules.  */
 421     unsigned is_for_scope : 1;
 422
 423     /* True if this level corresponds to a TRY block.  Currently this
 424        information is only available while building the tree structure.  */
 425     unsigned is_try_scope : 1;
 426
 427     /* True if this level corresponds to a CATCH block.  Currently this
 428        information is only available while building the tree structure.  */
 429     unsigned is_catch_scope : 1;
 430
 431     /* Three bits left for this word.  */
 432
 433 #if defined(DEBUG_CP_BINDING_LEVELS)
 434     /* Binding depth at which this level began.  */
 435     unsigned binding_depth;
 436 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 437   };
 438
 439 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 440
 441 /* The binding level currently in effect.  */
 442
 443 #define current_binding_level                   \
 444   (cfun && cp_function_chain->bindings          \
 445    ? cp_function_chain->bindings                \
 446    : scope_chain->bindings)
 447
 448 /* The binding level of the current class, if any.  */
 449
 450 #define class_binding_level scope_chain->class_bindings
 451
 452 /* A chain of binding_level structures awaiting reuse.  */
 453
 454 static struct binding_level *free_binding_level;
 455
 456 /* The outermost binding level, for names of file scope.
 457    This is created when the compiler is started and exists
 458    through the entire run.  */
 459
 460 static struct binding_level *global_binding_level;
 461
 462 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 463
 464 static int keep_next_level_flag;
 465
 466 #if defined(DEBUG_CP_BINDING_LEVELS)
 467 static int binding_depth = 0;
 468 static int is_class_level = 0;
 469
 470 static void
 471 indent ()
 472 {
 473   register unsigned i;
 474
 475   for (i = 0; i < binding_depth*2; i++)
 476     putc (' ', stderr);
 477 }
 478 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 479
 480 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 481
 482 static void
 483 push_binding_level (newlevel, tag_transparent, keep)
 484      struct binding_level *newlevel;
 485      int tag_transparent, keep;
 486 {
 487   /* Add this level to the front of the chain (stack) of levels that
 488      are active.  */
 489   memset ((char*) newlevel, 0, sizeof (struct binding_level));
 490   newlevel->level_chain = current_binding_level;
 491   current_binding_level = newlevel;
 492   newlevel->tag_transparent = tag_transparent;
 493   newlevel->more_cleanups_ok = 1;
 494
 495   newlevel->keep = keep;
 496 #if defined(DEBUG_CP_BINDING_LEVELS)
 497   newlevel->binding_depth = binding_depth;
 498   indent ();
 499   fprintf (stderr, "push %s level 0x%08x line %d\n",
 500            (is_class_level) ? "class" : "block", newlevel, lineno);
 501   is_class_level = 0;
 502   binding_depth++;
 503 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 504 }
 505
 506 /* Find the innermost enclosing class scope, and reset
 507    CLASS_BINDING_LEVEL appropriately.  */
 508
 509 static void
 510 find_class_binding_level ()
 511 {
 512   struct binding_level *level = current_binding_level;
 513
 514   while (level && level->parm_flag != 2)
 515     level = level->level_chain;
 516   if (level && level->parm_flag == 2)
 517     class_binding_level = level;
 518   else
 519     class_binding_level = 0;
 520 }
 521
 522 static void
 523 pop_binding_level ()
 524 {
 525   if (global_binding_level)
 526     {
 527       /* Cannot pop a level, if there are none left to pop.  */
 528       if (current_binding_level == global_binding_level)
 529         my_friendly_abort (123);
 530     }
 531   /* Pop the current level, and free the structure for reuse.  */
 532 #if defined(DEBUG_CP_BINDING_LEVELS)
 533   binding_depth--;
 534   indent ();
 535   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 536           (is_class_level) ? "class" : "block",
 537           current_binding_level, lineno);
 538   if (is_class_level != (current_binding_level == class_binding_level))
 539     {
 540       indent ();
 541       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 542     }
 543   is_class_level = 0;
 544 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 545   {
 546     register struct binding_level *level = current_binding_level;
 547     current_binding_level = current_binding_level->level_chain;
 548     level->level_chain = free_binding_level;
 549 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 550     if (level->binding_depth != binding_depth)
 551       abort ();
 552 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 553     free_binding_level = level;
 554     find_class_binding_level ();
 555   }
 556 }
 557
 558 static void
 559 suspend_binding_level ()
 560 {
 561   if (class_binding_level)
 562     current_binding_level = class_binding_level;
 563
 564   if (global_binding_level)
 565     {
 566       /* Cannot suspend a level, if there are none left to suspend.  */
 567       if (current_binding_level == global_binding_level)
 568         my_friendly_abort (123);
 569     }
 570   /* Suspend the current level.  */
 571 #if defined(DEBUG_CP_BINDING_LEVELS)
 572   binding_depth--;
 573   indent ();
 574   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 575           (is_class_level) ? "class" : "block",
 576           current_binding_level, lineno);
 577   if (is_class_level != (current_binding_level == class_binding_level))
 578     {
 579       indent ();
 580       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 581     }
 582   is_class_level = 0;
 583 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 584   current_binding_level = current_binding_level->level_chain;
 585   find_class_binding_level ();
 586 }
 587
 588 static void
 589 resume_binding_level (b)
 590      struct binding_level *b;
 591 {
 592   /* Resuming binding levels is meant only for namespaces,
 593      and those cannot nest into classes. */
 594   my_friendly_assert(!class_binding_level, 386);
 595   /* Also, resuming a non-directly nested namespace is a no-no.  */
 596   my_friendly_assert(b->level_chain == current_binding_level, 386);
 597   current_binding_level = b;
 598 #if defined(DEBUG_CP_BINDING_LEVELS)
 599   b->binding_depth = binding_depth;
 600   indent ();
 601   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 602            (is_class_level) ? "class" : "block", b, lineno);
 603   is_class_level = 0;
 604   binding_depth++;
 605 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 606 }
 607 \f
 608 /* Create a new `struct binding_level'.  */
 609
 610 static
 611 struct binding_level *
 612 make_binding_level ()
 613 {
 614   /* NOSTRICT */
 615   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 616 }
 617
 618 /* Nonzero if we are currently in the global binding level.  */
 619
 620 int
 621 global_bindings_p ()
 622 {
 623   return current_binding_level == global_binding_level;
 624 }
 625
 626 /* Return the innermost binding level that is not for a class scope.  */
 627
 628 static struct binding_level *
 629 innermost_nonclass_level ()
 630 {
 631   struct binding_level *b;
 632
 633   b = current_binding_level;
 634   while (b->parm_flag == 2)
 635     b = b->level_chain;
 636
 637   return b;
 638 }
 639
 640 /* Nonzero if we are currently in a toplevel binding level.  This
 641    means either the global binding level or a namespace in a toplevel
 642    binding level.  Since there are no non-toplevel namespace levels,
 643    this really means any namespace or template parameter level.  We
 644    also include a class whose context is toplevel.  */
 645
 646 int
 647 toplevel_bindings_p ()
 648 {
 649   struct binding_level *b = innermost_nonclass_level ();
 650
 651   return b->namespace_p || b->template_parms_p;
 652 }
 653
 654 /* Nonzero if this is a namespace scope, or if we are defining a class
 655    which is itself at namespace scope, or whose enclosing class is
 656    such a class, etc.  */
 657
 658 int
 659 namespace_bindings_p ()
 660 {
 661   struct binding_level *b = innermost_nonclass_level ();
 662
 663   return b->namespace_p;
 664 }
 665
 666 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 667    unconditionally.  Otherwise, use the normal logic to decide whether
 668    or not to create a BLOCK.  */
 669
 670 void
 671 keep_next_level (keep)
 672      int keep;
 673 {
 674   keep_next_level_flag = keep;
 675 }
 676
 677 /* Nonzero if the current level needs to have a BLOCK made.  */
 678
 679 int
 680 kept_level_p ()
 681 {
 682   return (current_binding_level->blocks != NULL_TREE
 683           || current_binding_level->keep
 684           || current_binding_level->names != NULL_TREE
 685           || (current_binding_level->tags != NULL_TREE
 686               && !current_binding_level->tag_transparent));
 687 }
 688
 689 static void
 690 declare_namespace_level ()
 691 {
 692   current_binding_level->namespace_p = 1;
 693 }
 694
 695 /* Returns non-zero if this scope was created to store template
 696    parameters.  */
 697
 698 int
 699 template_parm_scope_p ()
 700 {
 701   return current_binding_level->template_parms_p;
 702 }
 703
 704 /* Returns the kind of template specialization we are currently
 705    processing, given that it's declaration contained N_CLASS_SCOPES
 706    explicit scope qualifications.  */
 707
 708 tmpl_spec_kind
 709 current_tmpl_spec_kind (n_class_scopes)
 710      int n_class_scopes;
 711 {
 712   int n_template_parm_scopes = 0;
 713   int seen_specialization_p = 0;
 714   int innermost_specialization_p = 0;
 715   struct binding_level *b;
 716
 717   /* Scan through the template parameter scopes.  */
 718   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 719     {
 720       /* If we see a specialization scope inside a parameter scope,
 721          then something is wrong.  That corresponds to a declaration
 722          like:
 723
 724             template <class T> template <> ...
 725
 726          which is always illegal since [temp.expl.spec] forbids the
 727          specialization of a class member template if the enclosing
 728          class templates are not explicitly specialized as well.  */
 729       if (b->template_spec_p)
 730         {
 731           if (n_template_parm_scopes == 0)
 732             innermost_specialization_p = 1;
 733           else
 734             seen_specialization_p = 1;
 735         }
 736       else if (seen_specialization_p == 1)
 737         return tsk_invalid_member_spec;
 738
 739       ++n_template_parm_scopes;
 740     }
 741
 742   /* Handle explicit instantiations.  */
 743   if (processing_explicit_instantiation)
 744     {
 745       if (n_template_parm_scopes != 0)
 746         /* We've seen a template parameter list during an explicit
 747            instantiation.  For example:
 748
 749              template <class T> template void f(int);
 750
 751            This is erroneous.  */
 752         return tsk_invalid_expl_inst;
 753       else
 754         return tsk_expl_inst;
 755     }
 756
 757   if (n_template_parm_scopes < n_class_scopes)
 758     /* We've not seen enough template headers to match all the
 759        specialized classes present.  For example:
 760
 761          template <class T> void R<T>::S<T>::f(int);
 762
 763        This is illegal; there needs to be one set of template
 764        parameters for each class.  */
 765     return tsk_insufficient_parms;
 766   else if (n_template_parm_scopes == n_class_scopes)
 767     /* We're processing a non-template declaration (even though it may
 768        be a member of a template class.)  For example:
 769
 770          template <class T> void S<T>::f(int);
 771
 772        The `class T' maches the `S<T>', leaving no template headers
 773        corresponding to the `f'.  */
 774     return tsk_none;
 775   else if (n_template_parm_scopes > n_class_scopes + 1)
 776     /* We've got too many template headers.  For example:
 777
 778          template <> template <class T> void f (T);
 779
 780        There need to be more enclosing classes.  */
 781     return tsk_excessive_parms;
 782   else
 783     /* This must be a template.  It's of the form:
 784
 785          template <class T> template <class U> void S<T>::f(U);
 786
 787        This is a specialization if the innermost level was a
 788        specialization; otherwise it's just a definition of the
 789        template.  */
 790     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 791 }
 792
 793 void
 794 set_class_shadows (shadows)
 795      tree shadows;
 796 {
 797   class_binding_level->class_shadowed = shadows;
 798 }
 799
 800 /* Enter a new binding level.
 801    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 802    not for that of tags.  */
 803
 804 void
 805 pushlevel (tag_transparent)
 806      int tag_transparent;
 807 {
 808   struct binding_level *newlevel;
 809
 810   if (cfun && !doing_semantic_analysis_p ())
 811     return;
 812
 813   /* Reuse or create a struct for this binding level.  */
 814 #if defined(DEBUG_CP_BINDING_LEVELS)
 815   if (0)
 816 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 817   if (free_binding_level)
 818 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 819     {
 820       newlevel = free_binding_level;
 821       free_binding_level = free_binding_level->level_chain;
 822     }
 823   else
 824     newlevel = make_binding_level ();
 825
 826   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 827   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 828   keep_next_level_flag = 0;
 829 }
 830
 831 /* We're defining an object of type TYPE.  If it needs a cleanup, but
 832    we're not allowed to add any more objects with cleanups to the current
 833    scope, create a new binding level.  */
 834
 835 void
 836 maybe_push_cleanup_level (type)
 837      tree type;
 838 {
 839   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
 840       && current_binding_level->more_cleanups_ok == 0)
 841     {
 842       keep_next_level (2);
 843       pushlevel (1);
 844       clear_last_expr ();
 845       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
 846     }
 847 }
 848
 849 /* Enter a new scope.  The KIND indicates what kind of scope is being
 850    created.  */
 851
 852 void
 853 begin_scope (sk)
 854      scope_kind sk;
 855 {
 856   pushlevel (0);
 857
 858   switch (sk)
 859     {
 860     case sk_template_spec:
 861       current_binding_level->template_spec_p = 1;
 862       /* Fall through.  */
 863
 864     case sk_template_parms:
 865       current_binding_level->template_parms_p = 1;
 866       break;
 867
 868     default:
 869       my_friendly_abort (20000309);
 870     }
 871 }
 872
 873 /* Exit the current scope.  */
 874
 875 void
 876 finish_scope ()
 877 {
 878   poplevel (0, 0, 0);
 879 }
 880
 881 void
 882 note_level_for_for ()
 883 {
 884   current_binding_level->is_for_scope = 1;
 885 }
 886
 887 /* Record that the current binding level represents a try block.  */
 888
 889 void
 890 note_level_for_try ()
 891 {
 892   current_binding_level->is_try_scope = 1;
 893 }
 894
 895 /* Record that the current binding level represents a catch block.  */
 896
 897 void
 898 note_level_for_catch ()
 899 {
 900   current_binding_level->is_catch_scope = 1;
 901 }
 902
 903 /* For a binding between a name and an entity at a block scope,
 904    this is the `struct binding_level' for the block.  */
 905 #define BINDING_LEVEL(NODE) \
 906    (((struct tree_binding*)NODE)->scope.level)
 907
 908 /* A free list of CPLUS_BINDING nodes, connected by their
 909    TREE_CHAINs.  */
 910
 911 static tree free_bindings;
 912
 913 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 914    level at which this declaration is being bound.  */
 915
 916 static void
 917 push_binding (id, decl, level)
 918      tree id;
 919      tree decl;
 920      struct binding_level* level;
 921 {
 922   tree binding;
 923
 924   if (free_bindings)
 925     {
 926       binding = free_bindings;
 927       free_bindings = TREE_CHAIN (binding);
 928     }
 929   else
 930     binding = make_node (CPLUS_BINDING);
 931
 932   /* Now, fill in the binding information.  */
 933   BINDING_VALUE (binding) = decl;
 934   BINDING_TYPE (binding) = NULL_TREE;
 935   BINDING_LEVEL (binding) = level;
 936   INHERITED_VALUE_BINDING_P (binding) = 0;
 937   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 938   BINDING_HAS_LEVEL_P (binding) = 1;
 939
 940   /* And put it on the front of the list of bindings for ID.  */
 941   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 942   IDENTIFIER_BINDING (id) = binding;
 943 }
 944
 945 /* ID is already bound in the current scope.  But, DECL is an
 946    additional binding for ID in the same scope.  This is the `struct
 947    stat' hack whereby a non-typedef class-name or enum-name can be
 948    bound at the same level as some other kind of entity.  It's the
 949    responsibility of the caller to check that inserting this name is
 950    legal here.  Returns nonzero if the new binding was successful.  */
 951 static int
 952 add_binding (id, decl)
 953      tree id;
 954      tree decl;
 955 {
 956   tree binding = IDENTIFIER_BINDING (id);
 957   int ok = 1;
 958
 959   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 960     /* The new name is the type name.  */
 961     BINDING_TYPE (binding) = decl;
 962   else if (!BINDING_VALUE (binding))
 963     /* This situation arises when push_class_level_binding moves an
 964        inherited type-binding out of the way to make room for a new
 965        value binding.  */
 966     BINDING_VALUE (binding) = decl;
 967   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 968            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 969     {
 970       /* The old binding was a type name.  It was placed in
 971          BINDING_VALUE because it was thought, at the point it was
 972          declared, to be the only entity with such a name.  Move the
 973          type name into the type slot; it is now hidden by the new
 974          binding.  */
 975       BINDING_TYPE (binding) = BINDING_VALUE (binding);
 976       BINDING_VALUE (binding) = decl;
 977       INHERITED_VALUE_BINDING_P (binding) = 0;
 978     }
 979   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 980            && TREE_CODE (decl) == TYPE_DECL
 981            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
 982            && same_type_p (TREE_TYPE (decl),
 983                            TREE_TYPE (BINDING_VALUE (binding))))
 984     /* We have two typedef-names, both naming the same type to have
 985        the same name.  This is OK because of:
 986
 987          [dcl.typedef]
 988
 989          In a given scope, a typedef specifier can be used to redefine
 990          the name of any type declared in that scope to refer to the
 991          type to which it already refers.  */
 992     ok = 0;
 993   /* There can be two block-scope declarations of the same variable,
 994      so long as they are `extern' declarations.  */
 995   else if (TREE_CODE (decl) == VAR_DECL
 996            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
 997            && DECL_EXTERNAL (decl)
 998            && DECL_EXTERNAL (BINDING_VALUE (binding)))
 999     {
1000       duplicate_decls (decl, BINDING_VALUE (binding));
1001       ok = 0;
1002     }
1003   else
1004     {
1005       cp_error ("declaration of `%#D'", decl);
1006       cp_error_at ("conflicts with previous declaration `%#D'",
1007                    BINDING_VALUE (binding));
1008       ok = 0;
1009     }
1010
1011   return ok;
1012 }
1013
1014 /* Add DECL to the list of things declared in B.  */
1015
1016 static void
1017 add_decl_to_level (decl, b)
1018      tree decl;
1019      struct binding_level *b;
1020 {
1021   /* We build up the list in reverse order, and reverse it later if
1022      necessary.  */
1023   TREE_CHAIN (decl) = b->names;
1024   b->names = decl;
1025 }
1026
1027 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1028    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1029    doesn't really belong to this binding level, that it got here
1030    through a using-declaration.  */
1031
1032 void
1033 push_local_binding (id, decl, flags)
1034      tree id;
1035      tree decl;
1036      int flags;
1037 {
1038   struct binding_level *b;
1039
1040   /* Skip over any local classes.  This makes sense if we call
1041      push_local_binding with a friend decl of a local class.  */
1042   b = current_binding_level;
1043   while (b->parm_flag == 2)
1044     b = b->level_chain;
1045
1046   if (lookup_name_current_level (id))
1047     {
1048       /* Supplement the existing binding.  */
1049       if (!add_binding (id, decl))
1050         /* It didn't work.  Something else must be bound at this
1051            level.  Do not add DECL to the list of things to pop
1052            later.  */
1053         return;
1054     }
1055   else
1056     /* Create a new binding.  */
1057     push_binding (id, decl, b);
1058
1059   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1060     /* We must put the OVERLOAD into a TREE_LIST since the
1061        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1062        decls that got here through a using-declaration.  */
1063     decl = build_tree_list (NULL_TREE, decl);
1064
1065   /* And put DECL on the list of things declared by the current
1066      binding level.  */
1067   add_decl_to_level (decl, b);
1068 }
1069
1070 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1071    binding was successful.  */
1072
1073 int
1074 push_class_binding (id, decl)
1075      tree id;
1076      tree decl;
1077 {
1078   int result = 1;
1079   tree binding = IDENTIFIER_BINDING (id);
1080   tree context;
1081
1082   /* Note that we declared this value so that we can issue an error if
1083      this an illegal redeclaration of a name already used for some
1084      other purpose.  */
1085   note_name_declared_in_class (id, decl);
1086
1087   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1088     /* Supplement the existing binding.  */
1089     result = add_binding (id, decl);
1090   else
1091     /* Create a new binding.  */
1092     push_binding (id, decl, class_binding_level);
1093
1094   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1095      class-level declaration.  Note that we do not use DECL here
1096      because of the possibility of the `struct stat' hack; if DECL is
1097      a class-name or enum-name we might prefer a field-name, or some
1098      such.  */
1099   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1100
1101   /* If this is a binding from a base class, mark it as such.  */
1102   binding = IDENTIFIER_BINDING (id);
1103   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1104     {
1105       /* Any implicit typename must be from a base-class.  The
1106          context for an implicit typename declaration is always
1107          the derived class in which the lookup was done, so the checks
1108          based on the context of DECL below will not trigger.  */
1109       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1110         INHERITED_VALUE_BINDING_P (binding) = 1;
1111       else
1112         {
1113           if (TREE_CODE (decl) == OVERLOAD)
1114             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1115           else
1116             {
1117               my_friendly_assert (DECL_P (decl), 0);
1118               context = context_for_name_lookup (decl);
1119             }
1120
1121           if (is_properly_derived_from (current_class_type, context))
1122             INHERITED_VALUE_BINDING_P (binding) = 1;
1123           else
1124             INHERITED_VALUE_BINDING_P (binding) = 0;
1125         }
1126     }
1127   else if (BINDING_VALUE (binding) == decl)
1128     /* We only encounter a TREE_LIST when push_class_decls detects an
1129        ambiguity.  Such an ambiguity can be overridden by a definition
1130        in this class.  */
1131     INHERITED_VALUE_BINDING_P (binding) = 1;
1132
1133   return result;
1134 }
1135
1136 /* Remove the binding for DECL which should be the innermost binding
1137    for ID.  */
1138
1139 static void
1140 pop_binding (id, decl)
1141      tree id;
1142      tree decl;
1143 {
1144   tree binding;
1145
1146   if (id == NULL_TREE)
1147     /* It's easiest to write the loops that call this function without
1148        checking whether or not the entities involved have names.  We
1149        get here for such an entity.  */
1150     return;
1151
1152   /* Get the innermost binding for ID.  */
1153   binding = IDENTIFIER_BINDING (id);
1154
1155   /* The name should be bound.  */
1156   my_friendly_assert (binding != NULL_TREE, 0);
1157
1158   /* The DECL will be either the ordinary binding or the type
1159      binding for this identifier.  Remove that binding.  */
1160   if (BINDING_VALUE (binding) == decl)
1161     BINDING_VALUE (binding) = NULL_TREE;
1162   else if (BINDING_TYPE (binding) == decl)
1163     BINDING_TYPE (binding) = NULL_TREE;
1164   else
1165     my_friendly_abort (0);
1166
1167   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1168     {
1169       /* We're completely done with the innermost binding for this
1170          identifier.  Unhook it from the list of bindings.  */
1171       IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1172
1173       /* Add it to the free list.  */
1174       TREE_CHAIN (binding) = free_bindings;
1175       free_bindings = binding;
1176
1177       /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
1178          it.  */
1179       BINDING_LEVEL (binding) = NULL;
1180     }
1181 }
1182
1183 /* When a label goes out of scope, check to see if that label was used
1184    in a valid manner, and issue any appropriate warnings or errors.  */
1185
1186 static void
1187 pop_label (label, old_value)
1188      tree label;
1189      tree old_value;
1190 {
1191   if (!processing_template_decl && doing_semantic_analysis_p ())
1192     {
1193       if (DECL_INITIAL (label) == NULL_TREE)
1194         {
1195           cp_error_at ("label `%D' used but not defined", label);
1196           /* Avoid crashing later.  */
1197           define_label (input_filename, 1, DECL_NAME (label));
1198         }
1199       else if (warn_unused_label && !TREE_USED (label))
1200         cp_warning_at ("label `%D' defined but not used", label);
1201     }
1202
1203   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1204 }
1205
1206 /* At the end of a function, all labels declared within the function
1207    go out of scope.  BLOCK is the top-level block for the
1208    function.  */
1209
1210 static void
1211 pop_labels (block)
1212      tree block;
1213 {
1214   struct named_label_list *link;
1215
1216   /* Clear out the definitions of all label names, since their scopes
1217      end here.  */
1218   for (link = named_labels; link; link = link->next)
1219     {
1220       pop_label (link->label_decl, link->old_value);
1221       /* Put the labels into the "variables" of the top-level block,
1222          so debugger can see them.  */
1223       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1224       BLOCK_VARS (block) = link->label_decl;
1225     }
1226
1227   named_labels = NULL;
1228 }
1229
1230 /* Exit a binding level.
1231    Pop the level off, and restore the state of the identifier-decl mappings
1232    that were in effect when this level was entered.
1233
1234    If KEEP == 1, this level had explicit declarations, so
1235    and create a "block" (a BLOCK node) for the level
1236    to record its declarations and subblocks for symbol table output.
1237
1238    If FUNCTIONBODY is nonzero, this level is the body of a function,
1239    so create a block as if KEEP were set and also clear out all
1240    label names.
1241
1242    If REVERSE is nonzero, reverse the order of decls before putting
1243    them into the BLOCK.  */
1244
1245 tree
1246 poplevel (keep, reverse, functionbody)
1247      int keep;
1248      int reverse;
1249      int functionbody;
1250 {
1251   register tree link;
1252   /* The chain of decls was accumulated in reverse order.
1253      Put it into forward order, just for cleanliness.  */
1254   tree decls;
1255   int tmp = functionbody;
1256   int real_functionbody;
1257   tree tags;
1258   tree subblocks;
1259   tree block = NULL_TREE;
1260   tree decl;
1261   int leaving_for_scope;
1262
1263   if (cfun && !doing_semantic_analysis_p ())
1264     return NULL_TREE;
1265
1266   my_friendly_assert (current_binding_level->parm_flag != 2,
1267                       19990916);
1268
1269   real_functionbody = (current_binding_level->keep == 2
1270                        ? ((functionbody = 0), tmp) : functionbody);
1271   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1272   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1273
1274   my_friendly_assert (!current_binding_level->class_shadowed,
1275                       19990414);
1276
1277   /* We used to use KEEP == 2 to indicate that the new block should go
1278      at the beginning of the list of blocks at this binding level,
1279      rather than the end.  This hack is no longer used.  */
1280   my_friendly_assert (keep == 0 || keep == 1, 0);
1281
1282   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1283                       (HOST_WIDE_INT) current_binding_level->level_chain,
1284                       current_binding_level->parm_flag,
1285                       current_binding_level->keep);
1286
1287   if (current_binding_level->keep == 1)
1288     keep = 1;
1289
1290   /* Any uses of undefined labels, and any defined labels, now operate
1291      under constraints of next binding contour.  */
1292   if (cfun && !functionbody)
1293     {
1294       struct binding_level *level_chain;
1295       level_chain = current_binding_level->level_chain;
1296       if (level_chain)
1297         {
1298           struct named_label_use_list *uses;
1299           struct named_label_list *labels;
1300           for (labels = named_labels; labels; labels = labels->next)
1301             if (labels->binding_level == current_binding_level)
1302               {
1303                 tree decl;
1304                 if (current_binding_level->is_try_scope)
1305                   labels->in_try_scope = 1;
1306                 if (current_binding_level->is_catch_scope)
1307                   labels->in_catch_scope = 1;
1308                 for (decl = labels->names_in_scope; decl;
1309                      decl = TREE_CHAIN (decl))
1310                   if (decl_jump_unsafe (decl))
1311                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1312                                                    labels->bad_decls);
1313                 labels->binding_level = level_chain;
1314                 labels->names_in_scope = level_chain->names;
1315               }
1316
1317           for (uses = named_label_uses; uses; uses = uses->next)
1318             if (uses->binding_level == current_binding_level)
1319               {
1320                 uses->binding_level = level_chain;
1321                 uses->names_in_scope = level_chain->names;
1322               }
1323         }
1324     }
1325
1326   /* Get the decls in the order they were written.
1327      Usually current_binding_level->names is in reverse order.
1328      But parameter decls were previously put in forward order.  */
1329
1330   if (reverse)
1331     current_binding_level->names
1332       = decls = nreverse (current_binding_level->names);
1333   else
1334     decls = current_binding_level->names;
1335
1336   /* Output any nested inline functions within this block
1337      if they weren't already output.  */
1338   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1339     if (TREE_CODE (decl) == FUNCTION_DECL
1340         && ! TREE_ASM_WRITTEN (decl)
1341         && DECL_INITIAL (decl) != NULL_TREE
1342         && TREE_ADDRESSABLE (decl)
1343         && decl_function_context (decl) == current_function_decl)
1344       {
1345         /* If this decl was copied from a file-scope decl
1346            on account of a block-scope extern decl,
1347            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1348         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1349           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1350         else
1351           {
1352             push_function_context ();
1353             output_inline_function (decl);
1354             pop_function_context ();
1355           }
1356       }
1357
1358   /* When not in function-at-a-time mode, expand_end_bindings will
1359      warn about unused variables.  But, in function-at-a-time mode
1360      expand_end_bindings is not passed the list of variables in the
1361      current scope, and therefore no warning is emitted.  So, we
1362      explicitly warn here.  */
1363   if (!processing_template_decl)
1364     warn_about_unused_variables (getdecls ());
1365
1366   /* If there were any declarations or structure tags in that level,
1367      or if this level is a function body,
1368      create a BLOCK to record them for the life of this function.  */
1369   block = NULL_TREE;
1370   if (keep == 1 || functionbody)
1371     block = make_node (BLOCK);
1372   if (block != NULL_TREE)
1373     {
1374       BLOCK_VARS (block) = decls;
1375       BLOCK_SUBBLOCKS (block) = subblocks;
1376     }
1377
1378   /* In each subblock, record that this is its superior.  */
1379   if (keep >= 0)
1380     for (link = subblocks; link; link = TREE_CHAIN (link))
1381       BLOCK_SUPERCONTEXT (link) = block;
1382
1383   /* We still support the old for-scope rules, whereby the variables
1384      in a for-init statement were in scope after the for-statement
1385      ended.  We only use the new rules in flag_new_for_scope is
1386      nonzero.  */
1387   leaving_for_scope
1388     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1389
1390   /* Remove declarations for all the DECLs in this level.  */
1391   for (link = decls; link; link = TREE_CHAIN (link))
1392     {
1393       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1394           && DECL_NAME (link))
1395         {
1396           tree outer_binding
1397             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1398           tree ns_binding;
1399
1400           if (!outer_binding)
1401             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1402           else
1403             ns_binding = NULL_TREE;
1404
1405           if (outer_binding
1406               && (BINDING_LEVEL (outer_binding)
1407                   == current_binding_level->level_chain))
1408             /* We have something like:
1409
1410                  int i;
1411                  for (int i; ;);
1412
1413                and we are leaving the `for' scope.  There's no reason to
1414                keep the binding of the inner `i' in this case.  */
1415             pop_binding (DECL_NAME (link), link);
1416           else if ((outer_binding
1417                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1418                         == TYPE_DECL))
1419                    || (ns_binding
1420                        && TREE_CODE (ns_binding) == TYPE_DECL))
1421             /* Here, we have something like:
1422
1423                  typedef int I;
1424
1425                  void f () {
1426                    for (int I; ;);
1427                  }
1428
1429                We must pop the for-scope binding so we know what's a
1430                type and what isn't.  */
1431             pop_binding (DECL_NAME (link), link);
1432           else
1433             {
1434               /* Mark this VAR_DECL as dead so that we can tell we left it
1435                  there only for backward compatibility.  */
1436               DECL_DEAD_FOR_LOCAL (link) = 1;
1437
1438               /* Keep track of what should of have happenned when we
1439                  popped the binding.  */
1440               if (outer_binding && BINDING_VALUE (outer_binding))
1441                 DECL_SHADOWED_FOR_VAR (link)
1442                   = BINDING_VALUE (outer_binding);
1443
1444               /* Add it to the list of dead variables in the next
1445                  outermost binding to that we can remove these when we
1446                  leave that binding.  */
1447               current_binding_level->level_chain->dead_vars_from_for
1448                 = tree_cons (NULL_TREE, link,
1449                              current_binding_level->level_chain->
1450                              dead_vars_from_for);
1451
1452               /* Although we don't pop the CPLUS_BINDING, we do clear
1453                  its BINDING_LEVEL since the level is going away now.  */
1454               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1455                 = 0;
1456             }
1457         }
1458       else
1459         {
1460           /* Remove the binding.  */
1461           decl = link;
1462           if (TREE_CODE (decl) == TREE_LIST)
1463             decl = TREE_VALUE (decl);
1464           if (DECL_P (decl))
1465             pop_binding (DECL_NAME (decl), decl);
1466           else if (TREE_CODE (decl) == OVERLOAD)
1467             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1468           else
1469             my_friendly_abort (0);
1470         }
1471     }
1472
1473   /* Remove declarations for any `for' variables from inner scopes
1474      that we kept around.  */
1475   for (link = current_binding_level->dead_vars_from_for;
1476        link; link = TREE_CHAIN (link))
1477     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1478
1479   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1480   for (link = current_binding_level->type_shadowed;
1481        link; link = TREE_CHAIN (link))
1482     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1483
1484   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1485   for (link = current_binding_level->shadowed_labels;
1486        link;
1487        link = TREE_CHAIN (link))
1488     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1489
1490   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1491      list if a `using' declaration put them there.  The debugging
1492      back-ends won't understand OVERLOAD, so we remove them here.
1493      Because the BLOCK_VARS are (temporarily) shared with
1494      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1495      popped all the bindings.  */
1496   if (block)
1497     {
1498       tree* d;
1499
1500       for (d = &BLOCK_VARS (block); *d; )
1501         {
1502           if (TREE_CODE (*d) == TREE_LIST)
1503             *d = TREE_CHAIN (*d);
1504           else
1505             d = &TREE_CHAIN (*d);
1506         }
1507     }
1508
1509   /* If the level being exited is the top level of a function,
1510      check over all the labels.  */
1511   if (functionbody)
1512     {
1513       /* Since this is the top level block of a function, the vars are
1514          the function's parameters.  Don't leave them in the BLOCK
1515          because they are found in the FUNCTION_DECL instead.  */
1516       BLOCK_VARS (block) = 0;
1517       pop_labels (block);
1518     }
1519
1520   tmp = current_binding_level->keep;
1521
1522   pop_binding_level ();
1523   if (functionbody)
1524     DECL_INITIAL (current_function_decl) = block;
1525   else if (block)
1526     current_binding_level->blocks
1527       = chainon (current_binding_level->blocks, block);
1528
1529   /* If we did not make a block for the level just exited,
1530      any blocks made for inner levels
1531      (since they cannot be recorded as subblocks in that level)
1532      must be carried forward so they will later become subblocks
1533      of something else.  */
1534   else if (subblocks)
1535     current_binding_level->blocks
1536       = chainon (current_binding_level->blocks, subblocks);
1537
1538   /* Each and every BLOCK node created here in `poplevel' is important
1539      (e.g. for proper debugging information) so if we created one
1540      earlier, mark it as "used".  */
1541   if (block)
1542     TREE_USED (block) = 1;
1543
1544   /* Take care of compiler's internal binding structures.  */
1545   if (tmp == 2)
1546     {
1547       tree scope_stmts;
1548
1549       scope_stmts
1550         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1551       if (block)
1552         {
1553           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1554           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1555         }
1556
1557       block = poplevel (keep, reverse, functionbody);
1558     }
1559
1560   return block;
1561 }
1562
1563 /* Delete the node BLOCK from the current binding level.
1564    This is used for the block inside a stmt expr ({...})
1565    so that the block can be reinserted where appropriate.  */
1566
1567 void
1568 delete_block (block)
1569      tree block;
1570 {
1571   tree t;
1572   if (current_binding_level->blocks == block)
1573     current_binding_level->blocks = TREE_CHAIN (block);
1574   for (t = current_binding_level->blocks; t;)
1575     {
1576       if (TREE_CHAIN (t) == block)
1577         TREE_CHAIN (t) = TREE_CHAIN (block);
1578       else
1579         t = TREE_CHAIN (t);
1580     }
1581   TREE_CHAIN (block) = NULL_TREE;
1582   /* Clear TREE_USED which is always set by poplevel.
1583      The flag is set again if insert_block is called.  */
1584   TREE_USED (block) = 0;
1585 }
1586
1587 /* Insert BLOCK at the end of the list of subblocks of the
1588    current binding level.  This is used when a BIND_EXPR is expanded,
1589    to handle the BLOCK node inside the BIND_EXPR.  */
1590
1591 void
1592 insert_block (block)
1593      tree block;
1594 {
1595   TREE_USED (block) = 1;
1596   current_binding_level->blocks
1597     = chainon (current_binding_level->blocks, block);
1598 }
1599
1600 /* Set the BLOCK node for the innermost scope
1601    (the one we are currently in).  */
1602
1603 void
1604 set_block (block)
1605     tree block ATTRIBUTE_UNUSED;
1606 {
1607   /* The RTL expansion machinery requires us to provide this callback,
1608      but it is not applicable in function-at-a-time mode.  */
1609   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1610 }
1611
1612 /* Do a pushlevel for class declarations.  */
1613
1614 void
1615 pushlevel_class ()
1616 {
1617   register struct binding_level *newlevel;
1618
1619   /* Reuse or create a struct for this binding level.  */
1620 #if defined(DEBUG_CP_BINDING_LEVELS)
1621   if (0)
1622 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1623   if (free_binding_level)
1624 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1625     {
1626       newlevel = free_binding_level;
1627       free_binding_level = free_binding_level->level_chain;
1628     }
1629   else
1630     newlevel = make_binding_level ();
1631
1632 #if defined(DEBUG_CP_BINDING_LEVELS)
1633   is_class_level = 1;
1634 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1635
1636   push_binding_level (newlevel, 0, 0);
1637
1638   class_binding_level = current_binding_level;
1639   class_binding_level->parm_flag = 2;
1640   class_binding_level->this_class = current_class_type;
1641 }
1642
1643 /* ...and a poplevel for class declarations.  */
1644
1645 void
1646 poplevel_class ()
1647 {
1648   register struct binding_level *level = class_binding_level;
1649   tree shadowed;
1650
1651   my_friendly_assert (level != 0, 354);
1652
1653   /* If we're leaving a toplevel class, don't bother to do the setting
1654      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1655      shouldn't even be used when current_class_type isn't set, and second,
1656      if we don't touch it here, we're able to use the cache effect if the
1657      next time we're entering a class scope, it is the same class.  */
1658   if (current_class_depth != 1)
1659     {
1660       struct binding_level* b;
1661
1662       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1663       for (shadowed = level->class_shadowed;
1664            shadowed;
1665            shadowed = TREE_CHAIN (shadowed))
1666         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1667
1668       /* Find the next enclosing class, and recreate
1669          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1670       b = level->level_chain;
1671       while (b && b->parm_flag != 2)
1672         b = b->level_chain;
1673
1674       if (b)
1675         for (shadowed = b->class_shadowed;
1676              shadowed;
1677              shadowed = TREE_CHAIN (shadowed))
1678           {
1679             tree t;
1680
1681             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1682             while (t && BINDING_LEVEL (t) != b)
1683               t = TREE_CHAIN (t);
1684
1685             if (t)
1686               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1687                 = BINDING_VALUE (t);
1688           }
1689     }
1690   else
1691     /* Remember to save what IDENTIFIER's were bound in this scope so we
1692        can recover from cache misses.  */
1693     {
1694       previous_class_type = current_class_type;
1695       previous_class_values = class_binding_level->class_shadowed;
1696     }
1697   for (shadowed = level->type_shadowed;
1698        shadowed;
1699        shadowed = TREE_CHAIN (shadowed))
1700     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1701
1702   /* Remove the bindings for all of the class-level declarations.  */
1703   for (shadowed = level->class_shadowed;
1704        shadowed;
1705        shadowed = TREE_CHAIN (shadowed))
1706     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1707
1708   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1709                       (HOST_WIDE_INT) class_binding_level->level_chain,
1710                       class_binding_level->parm_flag,
1711                       class_binding_level->keep);
1712
1713   /* Now, pop out of the binding level which we created up in the
1714      `pushlevel_class' routine.  */
1715 #if defined(DEBUG_CP_BINDING_LEVELS)
1716   is_class_level = 1;
1717 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1718
1719   pop_binding_level ();
1720 }
1721
1722 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1723    for any names in enclosing classes.  */
1724
1725 void
1726 clear_identifier_class_values ()
1727 {
1728   tree t;
1729
1730   if (!class_binding_level)
1731     return;
1732
1733   for (t = class_binding_level->class_shadowed;
1734        t;
1735        t = TREE_CHAIN (t))
1736     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1737 }
1738
1739 /* Returns non-zero if T is a virtual function table.  */
1740
1741 int
1742 vtable_decl_p (t, data)
1743      tree t;
1744      void *data ATTRIBUTE_UNUSED;
1745 {
1746   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1747 }
1748
1749 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1750    functions.  */
1751
1752 int
1753 vtype_decl_p (t, data)
1754      tree t;
1755      void *data ATTRIBUTE_UNUSED;
1756 {
1757   return (TREE_CODE (t) == TYPE_DECL
1758           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1759           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1760 }
1761
1762 /* Return the declarations that are members of the namespace NS.  */
1763
1764 tree
1765 cp_namespace_decls (ns)
1766      tree ns;
1767 {
1768   return NAMESPACE_LEVEL (ns)->names;
1769 }
1770
1771 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1772    itself, calling F for each.  The DATA is passed to F as well.  */
1773
1774 static int
1775 walk_namespaces_r (namespace, f, data)
1776      tree namespace;
1777      walk_namespaces_fn f;
1778      void *data;
1779 {
1780   tree current;
1781   int result = 0;
1782
1783   result |= (*f) (namespace, data);
1784
1785   for (current = cp_namespace_decls (namespace);
1786        current;
1787        current = TREE_CHAIN (current))
1788     {
1789       if (TREE_CODE (current) != NAMESPACE_DECL
1790           || DECL_NAMESPACE_ALIAS (current))
1791         continue;
1792
1793       /* We found a namespace.  */
1794       result |= walk_namespaces_r (current, f, data);
1795     }
1796
1797   return result;
1798 }
1799
1800 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1801    F as well.  */
1802
1803 int
1804 walk_namespaces (f, data)
1805      walk_namespaces_fn f;
1806      void *data;
1807 {
1808   return walk_namespaces_r (global_namespace, f, data);
1809 }
1810
1811 struct walk_globals_data {
1812   walk_globals_pred p;
1813   walk_globals_fn f;
1814   void *data;
1815 };
1816
1817 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1818    for which P returns non-zero, call F with its address.  If any call
1819    to F returns a non-zero value, return a non-zero value.  */
1820
1821 static int
1822 walk_globals_r (namespace, data)
1823      tree namespace;
1824      void *data;
1825 {
1826   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1827   walk_globals_pred p = wgd->p;
1828   walk_globals_fn f = wgd->f;
1829   void *d = wgd->data;
1830   tree *t;
1831   int result = 0;
1832
1833   t = &NAMESPACE_LEVEL (namespace)->names;
1834
1835   while (*t)
1836     {
1837       tree glbl = *t;
1838
1839       if ((*p) (glbl, d))
1840         result |= (*f) (t, d);
1841
1842       /* If F changed *T, then *T still points at the next item to
1843          examine.  */
1844       if (*t == glbl)
1845         t = &TREE_CHAIN (*t);
1846     }
1847
1848   return result;
1849 }
1850
1851 /* Walk the global declarations.  Whenever one is found for which P
1852    returns non-zero, call F with its address.  If any call to F
1853    returns a non-zero value, return a non-zero value.  */
1854
1855 int
1856 walk_globals (p, f, data)
1857      walk_globals_pred p;
1858      walk_globals_fn f;
1859      void *data;
1860 {
1861   struct walk_globals_data wgd;
1862   wgd.p = p;
1863   wgd.f = f;
1864   wgd.data = data;
1865
1866   return walk_namespaces (walk_globals_r, &wgd);
1867 }
1868
1869 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1870    DATA is non-NULL, this is the last time we will call
1871    wrapup_global_declarations for this NAMESPACE.  */
1872
1873 int
1874 wrapup_globals_for_namespace (namespace, data)
1875      tree namespace;
1876      void *data;
1877 {
1878   tree globals = cp_namespace_decls (namespace);
1879   int len = list_length (globals);
1880   tree *vec = (tree *) alloca (sizeof (tree) * len);
1881   int i;
1882   int result;
1883   tree decl;
1884   int last_time = (data != 0);
1885
1886   if (last_time && namespace == global_namespace)
1887     /* Let compile_file handle the global namespace.  */
1888     return 0;
1889
1890   /* Process the decls in reverse order--earliest first.
1891      Put them into VEC from back to front, then take out from front.  */
1892   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1893     vec[len - i - 1] = decl;
1894
1895   if (last_time)
1896     {
1897       check_global_declarations (vec, len);
1898       return 0;
1899     }
1900
1901   /* Temporarily mark vtables as external.  That prevents
1902      wrapup_global_declarations from writing them out; we must process
1903      them ourselves in finish_vtable_vardecl.  */
1904   for (i = 0; i < len; ++i)
1905     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1906       {
1907         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1908         DECL_EXTERNAL (vec[i]) = 1;
1909       }
1910
1911   /* Write out any globals that need to be output.  */
1912   result = wrapup_global_declarations (vec, len);
1913
1914   /* Undo the hack to DECL_EXTERNAL above.  */
1915   for (i = 0; i < len; ++i)
1916     if (vtable_decl_p (vec[i], /*data=*/0)
1917         && DECL_NOT_REALLY_EXTERN (vec[i]))
1918       {
1919         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1920         DECL_EXTERNAL (vec[i]) = 0;
1921       }
1922
1923   return result;
1924 }
1925
1926 \f
1927 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1928
1929 static void
1930 mark_binding_level (arg)
1931      void *arg;
1932 {
1933   struct binding_level *lvl = *(struct binding_level **)arg;
1934
1935   for (; lvl; lvl = lvl->level_chain)
1936     {
1937       ggc_mark_tree (lvl->names);
1938       ggc_mark_tree (lvl->tags);
1939       ggc_mark_tree (lvl->usings);
1940       ggc_mark_tree (lvl->using_directives);
1941       ggc_mark_tree (lvl->class_shadowed);
1942       ggc_mark_tree (lvl->type_shadowed);
1943       ggc_mark_tree (lvl->shadowed_labels);
1944       ggc_mark_tree (lvl->blocks);
1945       ggc_mark_tree (lvl->this_class);
1946       ggc_mark_tree (lvl->incomplete);
1947       ggc_mark_tree (lvl->dead_vars_from_for);
1948     }
1949 }
1950
1951 static void
1952 mark_named_label_lists (labs, uses)
1953      void *labs;
1954      void *uses;
1955 {
1956   struct named_label_list *l = *(struct named_label_list **)labs;
1957   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
1958
1959   for (; l; l = l->next)
1960     {
1961       ggc_mark (l);
1962       mark_binding_level (l->binding_level);
1963       ggc_mark_tree (l->old_value);
1964       ggc_mark_tree (l->label_decl);
1965       ggc_mark_tree (l->bad_decls);
1966     }
1967
1968   for (; u; u = u->next)
1969     ggc_mark (u);
1970 }
1971 \f
1972 /* For debugging.  */
1973 static int no_print_functions = 0;
1974 static int no_print_builtins = 0;
1975
1976 void
1977 print_binding_level (lvl)
1978      struct binding_level *lvl;
1979 {
1980   tree t;
1981   int i = 0, len;
1982   fprintf (stderr, " blocks=");
1983   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1984   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
1985            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
1986   if (lvl->tag_transparent)
1987     fprintf (stderr, " tag-transparent");
1988   if (lvl->more_cleanups_ok)
1989     fprintf (stderr, " more-cleanups-ok");
1990   if (lvl->have_cleanups)
1991     fprintf (stderr, " have-cleanups");
1992   fprintf (stderr, "\n");
1993   if (lvl->names)
1994     {
1995       fprintf (stderr, " names:\t");
1996       /* We can probably fit 3 names to a line?  */
1997       for (t = lvl->names; t; t = TREE_CHAIN (t))
1998         {
1999           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2000             continue;
2001           if (no_print_builtins
2002               && (TREE_CODE (t) == TYPE_DECL)
2003               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2004             continue;
2005
2006           /* Function decls tend to have longer names.  */
2007           if (TREE_CODE (t) == FUNCTION_DECL)
2008             len = 3;
2009           else
2010             len = 2;
2011           i += len;
2012           if (i > 6)
2013             {
2014               fprintf (stderr, "\n\t");
2015               i = len;
2016             }
2017           print_node_brief (stderr, "", t, 0);
2018           if (t == error_mark_node)
2019             break;
2020         }
2021       if (i)
2022         fprintf (stderr, "\n");
2023     }
2024   if (lvl->tags)
2025     {
2026       fprintf (stderr, " tags:\t");
2027       i = 0;
2028       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2029         {
2030           if (TREE_PURPOSE (t) == NULL_TREE)
2031             len = 3;
2032           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2033             len = 2;
2034           else
2035             len = 4;
2036           i += len;
2037           if (i > 5)
2038             {
2039               fprintf (stderr, "\n\t");
2040               i = len;
2041             }
2042           if (TREE_PURPOSE (t) == NULL_TREE)
2043             {
2044               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2045               fprintf (stderr, ">");
2046             }
2047           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2048             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2049           else
2050             {
2051               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2052               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2053               fprintf (stderr, ">");
2054             }
2055         }
2056       if (i)
2057         fprintf (stderr, "\n");
2058     }
2059   if (lvl->class_shadowed)
2060     {
2061       fprintf (stderr, " class-shadowed:");
2062       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2063         {
2064           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2065         }
2066       fprintf (stderr, "\n");
2067     }
2068   if (lvl->type_shadowed)
2069     {
2070       fprintf (stderr, " type-shadowed:");
2071       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2072         {
2073           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2074         }
2075       fprintf (stderr, "\n");
2076     }
2077 }
2078
2079 void
2080 print_other_binding_stack (stack)
2081      struct binding_level *stack;
2082 {
2083   struct binding_level *level;
2084   for (level = stack; level != global_binding_level; level = level->level_chain)
2085     {
2086       fprintf (stderr, "binding level ");
2087       fprintf (stderr, HOST_PTR_PRINTF, level);
2088       fprintf (stderr, "\n");
2089       print_binding_level (level);
2090     }
2091 }
2092
2093 void
2094 print_binding_stack ()
2095 {
2096   struct binding_level *b;
2097   fprintf (stderr, "current_binding_level=");
2098   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2099   fprintf (stderr, "\nclass_binding_level=");
2100   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2101   fprintf (stderr, "\nglobal_binding_level=");
2102   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2103   fprintf (stderr, "\n");
2104   if (class_binding_level)
2105     {
2106       for (b = class_binding_level; b; b = b->level_chain)
2107         if (b == current_binding_level)
2108           break;
2109       if (b)
2110         b = class_binding_level;
2111       else
2112         b = current_binding_level;
2113     }
2114   else
2115     b = current_binding_level;
2116   print_other_binding_stack (b);
2117   fprintf (stderr, "global:\n");
2118   print_binding_level (global_binding_level);
2119 }
2120
2121 /* Namespace binding access routines: The namespace_bindings field of
2122    the identifier is polymorphic, with three possible values:
2123    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2124    indicating the BINDING_VALUE of global_namespace. */
2125
2126 /* Check whether the a binding for the name to scope is known.
2127    Assumes that the bindings of the name are already a list
2128    of bindings. Returns the binding found, or NULL_TREE. */
2129
2130 static tree
2131 find_binding (name, scope)
2132      tree name;
2133      tree scope;
2134 {
2135   tree iter, prev = NULL_TREE;
2136
2137   scope = ORIGINAL_NAMESPACE (scope);
2138
2139   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2140        iter = TREE_CHAIN (iter))
2141     {
2142       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2143       if (BINDING_SCOPE (iter) == scope)
2144         {
2145           /* Move binding found to the front of the list, so
2146              subsequent lookups will find it faster. */
2147           if (prev)
2148             {
2149               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2150               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2151               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2152             }
2153           return iter;
2154         }
2155       prev = iter;
2156     }
2157   return NULL_TREE;
2158 }
2159
2160 /* Always returns a binding for name in scope. If the
2161    namespace_bindings is not a list, convert it to one first.
2162    If no binding is found, make a new one. */
2163
2164 tree
2165 binding_for_name (name, scope)
2166      tree name;
2167      tree scope;
2168 {
2169   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2170   tree result;
2171
2172   scope = ORIGINAL_NAMESPACE (scope);
2173
2174   if (b && TREE_CODE (b) != CPLUS_BINDING)
2175     {
2176       /* Get rid of optimization for global scope. */
2177       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2178       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2179       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2180     }
2181   if (b && (result = find_binding (name, scope)))
2182     return result;
2183   /* Not found, make a new one. */
2184   result = make_node (CPLUS_BINDING);
2185   TREE_CHAIN (result) = b;
2186   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2187   BINDING_SCOPE (result) = scope;
2188   BINDING_TYPE (result) = NULL_TREE;
2189   BINDING_VALUE (result) = NULL_TREE;
2190   return result;
2191 }
2192
2193 /* Return the binding value for name in scope, considering that
2194    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2195
2196 tree
2197 namespace_binding (name, scope)
2198      tree name;
2199      tree scope;
2200 {
2201   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2202   if (b == NULL_TREE)
2203     return NULL_TREE;
2204   if (scope == NULL_TREE)
2205     scope = global_namespace;
2206   if (TREE_CODE (b) != CPLUS_BINDING)
2207     return (scope == global_namespace) ? b : NULL_TREE;
2208   name = find_binding (name,scope);
2209   if (name == NULL_TREE)
2210     return name;
2211   return BINDING_VALUE (name);
2212 }
2213
2214 /* Set the binding value for name in scope. If modifying the binding
2215    of global_namespace is attempted, try to optimize it. */
2216
2217 void
2218 set_namespace_binding (name, scope, val)
2219      tree name;
2220      tree scope;
2221      tree val;
2222 {
2223   tree b;
2224
2225   if (scope == NULL_TREE)
2226     scope = global_namespace;
2227
2228   if (scope == global_namespace)
2229     {
2230       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2231       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2232         {
2233           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2234           return;
2235         }
2236     }
2237   b = binding_for_name (name, scope);
2238   BINDING_VALUE (b) = val;
2239 }
2240
2241 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2242    select a name that is unique to this compilation unit.  */
2243
2244 void
2245 push_namespace (name)
2246      tree name;
2247 {
2248   tree d = NULL_TREE;
2249   int need_new = 1;
2250   int implicit_use = 0;
2251   int global = 0;
2252   if (!global_namespace)
2253     {
2254       /* This must be ::. */
2255       my_friendly_assert (name == get_identifier ("::"), 377);
2256       global = 1;
2257     }
2258   else if (!name)
2259     {
2260       /* The name of anonymous namespace is unique for the translation
2261          unit.  */
2262       if (!anonymous_namespace_name)
2263         anonymous_namespace_name = get_file_function_name ('N');
2264       name = anonymous_namespace_name;
2265       d = IDENTIFIER_NAMESPACE_VALUE (name);
2266       if (d)
2267         /* Reopening anonymous namespace.  */
2268         need_new = 0;
2269       implicit_use = 1;
2270     }
2271   else
2272     {
2273       /* Check whether this is an extended namespace definition. */
2274       d = IDENTIFIER_NAMESPACE_VALUE (name);
2275       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2276         {
2277           need_new = 0;
2278           if (DECL_NAMESPACE_ALIAS (d))
2279             {
2280               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2281                         d, DECL_NAMESPACE_ALIAS (d));
2282               d = DECL_NAMESPACE_ALIAS (d);
2283             }
2284         }
2285     }
2286
2287   if (need_new)
2288     {
2289       /* Make a new namespace, binding the name to it. */
2290       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2291       /* The global namespace is not pushed, and the global binding
2292          level is set elsewhere.  */
2293       if (!global)
2294         {
2295           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2296           d = pushdecl (d);
2297           pushlevel (0);
2298           declare_namespace_level ();
2299           NAMESPACE_LEVEL (d) = current_binding_level;
2300         }
2301     }
2302   else
2303     resume_binding_level (NAMESPACE_LEVEL (d));
2304
2305   if (implicit_use)
2306     do_using_directive (d);
2307   /* Enter the name space. */
2308   current_namespace = d;
2309 }
2310
2311 /* Pop from the scope of the current namespace.  */
2312
2313 void
2314 pop_namespace ()
2315 {
2316   my_friendly_assert (current_namespace != global_namespace, 20010801);
2317   current_namespace = CP_DECL_CONTEXT (current_namespace);
2318   /* The binding level is not popped, as it might be re-opened later.  */
2319   suspend_binding_level ();
2320 }
2321
2322 /* Push into the scope of the namespace NS, even if it is deeply
2323    nested within another namespace.  */
2324
2325 void
2326 push_nested_namespace (ns)
2327      tree ns;
2328 {
2329   if (ns == global_namespace)
2330     push_to_top_level ();
2331   else
2332     {
2333       push_nested_namespace (CP_DECL_CONTEXT (ns));
2334       push_namespace (DECL_NAME (ns));
2335     }
2336 }
2337
2338 /* Pop back from the scope of the namespace NS, which was previously
2339    entered with push_nested_namespace.  */
2340
2341 void
2342 pop_nested_namespace (ns)
2343      tree ns;
2344 {
2345   while (ns != global_namespace)
2346     {
2347       pop_namespace ();
2348       ns = CP_DECL_CONTEXT (ns);
2349     }
2350
2351   pop_from_top_level ();
2352 }
2353
2354 \f
2355 /* Subroutines for reverting temporarily to top-level for instantiation
2356    of templates and such.  We actually need to clear out the class- and
2357    local-value slots of all identifiers, so that only the global values
2358    are at all visible.  Simply setting current_binding_level to the global
2359    scope isn't enough, because more binding levels may be pushed.  */
2360 struct saved_scope *scope_chain;
2361
2362 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2363
2364 static void
2365 mark_saved_scope (arg)
2366      void *arg;
2367 {
2368   struct saved_scope *t = *(struct saved_scope **)arg;
2369   while (t)
2370     {
2371       mark_binding_level (&t->class_bindings);
2372       ggc_mark_tree (t->old_bindings);
2373       ggc_mark_tree (t->old_namespace);
2374       ggc_mark_tree (t->decl_ns_list);
2375       ggc_mark_tree (t->class_name);
2376       ggc_mark_tree (t->class_type);
2377       ggc_mark_tree (t->access_specifier);
2378       ggc_mark_tree (t->function_decl);
2379       if (t->lang_base)
2380         ggc_mark_tree_varray (t->lang_base);
2381       ggc_mark_tree (t->lang_name);
2382       ggc_mark_tree (t->template_parms);
2383       ggc_mark_tree (t->x_previous_class_type);
2384       ggc_mark_tree (t->x_previous_class_values);
2385       ggc_mark_tree (t->x_saved_tree);
2386       ggc_mark_tree (t->incomplete);
2387       ggc_mark_tree (t->lookups);
2388
2389       mark_stmt_tree (&t->x_stmt_tree);
2390       mark_binding_level (&t->bindings);
2391       t = t->prev;
2392     }
2393 }
2394
2395 static tree
2396 store_bindings (names, old_bindings)
2397      tree names, old_bindings;
2398 {
2399   tree t;
2400   tree search_bindings = old_bindings;
2401
2402   for (t = names; t; t = TREE_CHAIN (t))
2403     {
2404       tree binding, t1, id;
2405
2406       if (TREE_CODE (t) == TREE_LIST)
2407         id = TREE_PURPOSE (t);
2408       else
2409         id = DECL_NAME (t);
2410
2411       if (!id
2412           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2413              we have no IDENTIFIER_BINDING if we have left the class
2414              scope, but cached the class-level declarations.  */
2415           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2416         continue;
2417
2418       for (t1 = search_bindings; t1; t1 = TREE_CHAIN (t1))
2419         if (TREE_VEC_ELT (t1, 0) == id)
2420           goto skip_it;
2421
2422       my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2423       binding = make_tree_vec (4);
2424       TREE_VEC_ELT (binding, 0) = id;
2425       TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2426       TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2427       TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2428       IDENTIFIER_BINDING (id) = NULL_TREE;
2429       IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2430       TREE_CHAIN (binding) = old_bindings;
2431       old_bindings = binding;
2432     skip_it:
2433       ;
2434     }
2435   return old_bindings;
2436 }
2437
2438 void
2439 maybe_push_to_top_level (pseudo)
2440      int pseudo;
2441 {
2442   struct saved_scope *s;
2443   struct binding_level *b;
2444   tree old_bindings;
2445   int need_pop;
2446
2447   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2448
2449   b = scope_chain ? current_binding_level : 0;
2450
2451   /* If we're in the middle of some function, save our state.  */
2452   if (cfun)
2453     {
2454       need_pop = 1;
2455       push_function_context_to (NULL_TREE);
2456     }
2457   else
2458     need_pop = 0;
2459
2460   old_bindings = NULL_TREE;
2461   if (scope_chain && previous_class_type)
2462     old_bindings = store_bindings (previous_class_values, old_bindings);
2463
2464   /* Have to include global_binding_level, because class-level decls
2465      aren't listed anywhere useful.  */
2466   for (; b; b = b->level_chain)
2467     {
2468       tree t;
2469
2470       /* Template IDs are inserted into the global level. If they were
2471          inserted into namespace level, finish_file wouldn't find them
2472          when doing pending instantiations. Therefore, don't stop at
2473          namespace level, but continue until :: .  */
2474       if (b == global_binding_level || (pseudo && b->template_parms_p))
2475         break;
2476
2477       old_bindings = store_bindings (b->names, old_bindings);
2478       /* We also need to check class_shadowed to save class-level type
2479          bindings, since pushclass doesn't fill in b->names.  */
2480       if (b->parm_flag == 2)
2481         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2482
2483       /* Unwind type-value slots back to top level.  */
2484       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2485         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2486     }
2487   s->prev = scope_chain;
2488   s->old_bindings = old_bindings;
2489   s->bindings = b;
2490   s->need_pop_function_context = need_pop;
2491   s->function_decl = current_function_decl;
2492
2493   scope_chain = s;
2494   current_function_decl = NULL_TREE;
2495   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2496   current_lang_name = lang_name_cplusplus;
2497   current_namespace = global_namespace;
2498 }
2499
2500 void
2501 push_to_top_level ()
2502 {
2503   maybe_push_to_top_level (0);
2504 }
2505
2506 void
2507 pop_from_top_level ()
2508 {
2509   struct saved_scope *s = scope_chain;
2510   tree t;
2511
2512   /* Clear out class-level bindings cache.  */
2513   if (previous_class_type)
2514     invalidate_class_lookup_cache ();
2515
2516   VARRAY_FREE (current_lang_base);
2517
2518   scope_chain = s->prev;
2519   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2520     {
2521       tree id = TREE_VEC_ELT (t, 0);
2522
2523       SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2524       IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2525       IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2526     }
2527
2528   /* If we were in the middle of compiling a function, restore our
2529      state.  */
2530   if (s->need_pop_function_context)
2531     pop_function_context_from (NULL_TREE);
2532   current_function_decl = s->function_decl;
2533
2534   free (s);
2535 }
2536 \f
2537 /* Push a definition of struct, union or enum tag "name".
2538    into binding_level "b".   "type" should be the type node,
2539    We assume that the tag "name" is not already defined.
2540
2541    Note that the definition may really be just a forward reference.
2542    In that case, the TYPE_SIZE will be a NULL_TREE.
2543
2544    C++ gratuitously puts all these tags in the name space.  */
2545
2546 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2547    record the shadowed value for this binding contour.  TYPE is
2548    the type that ID maps to.  */
2549
2550 static void
2551 set_identifier_type_value_with_scope (id, type, b)
2552      tree id;
2553      tree type;
2554      struct binding_level *b;
2555 {
2556   if (!b->namespace_p)
2557     {
2558       /* Shadow the marker, not the real thing, so that the marker
2559          gets restored later. */
2560       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2561       b->type_shadowed
2562         = tree_cons (id, old_type_value, b->type_shadowed);
2563     }
2564   else
2565     {
2566       tree binding = binding_for_name (id, current_namespace);
2567       BINDING_TYPE (binding) = type;
2568       /* Store marker instead of real type. */
2569       type = global_type_node;
2570     }
2571   SET_IDENTIFIER_TYPE_VALUE (id, type);
2572 }
2573
2574 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2575
2576 void
2577 set_identifier_type_value (id, type)
2578      tree id;
2579      tree type;
2580 {
2581   set_identifier_type_value_with_scope (id, type, current_binding_level);
2582 }
2583
2584 /* Return the type associated with id. */
2585
2586 tree
2587 identifier_type_value (id)
2588      tree id;
2589 {
2590   /* There is no type with that name, anywhere. */
2591   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2592     return NULL_TREE;
2593   /* This is not the type marker, but the real thing. */
2594   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2595     return REAL_IDENTIFIER_TYPE_VALUE (id);
2596   /* Have to search for it. It must be on the global level, now.
2597      Ask lookup_name not to return non-types. */
2598   id = lookup_name_real (id, 2, 1, 0);
2599   if (id)
2600     return TREE_TYPE (id);
2601   return NULL_TREE;
2602 }
2603
2604 /* Pop off extraneous binding levels left over due to syntax errors.
2605
2606    We don't pop past namespaces, as they might be valid.  */
2607
2608 void
2609 pop_everything ()
2610 {
2611 #ifdef DEBUG_CP_BINDING_LEVELS
2612   fprintf (stderr, "XXX entering pop_everything ()\n");
2613 #endif
2614   while (!toplevel_bindings_p ())
2615     {
2616       if (current_binding_level->parm_flag == 2)
2617         pop_nested_class ();
2618       else
2619         poplevel (0, 0, 0);
2620     }
2621 #ifdef DEBUG_CP_BINDING_LEVELS
2622   fprintf (stderr, "XXX leaving pop_everything ()\n");
2623 #endif
2624 }
2625
2626 /* The type TYPE is being declared.  If it is a class template, or a
2627    specialization of a class template, do any processing required and
2628    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2629    being declared a friend.  B is the binding level at which this TYPE
2630    should be bound.
2631
2632    Returns the TYPE_DECL for TYPE, which may have been altered by this
2633    processing.  */
2634
2635 static tree
2636 maybe_process_template_type_declaration (type, globalize, b)
2637      tree type;
2638      int globalize;
2639      struct binding_level* b;
2640 {
2641   tree decl = TYPE_NAME (type);
2642
2643   if (processing_template_parmlist)
2644     /* You can't declare a new template type in a template parameter
2645        list.  But, you can declare a non-template type:
2646
2647          template <class A*> struct S;
2648
2649        is a forward-declaration of `A'.  */
2650     ;
2651   else
2652     {
2653       maybe_check_template_type (type);
2654
2655       my_friendly_assert (IS_AGGR_TYPE (type)
2656                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2657
2658
2659       if (processing_template_decl)
2660         {
2661           /* This may change after the call to
2662              push_template_decl_real, but we want the original value.  */
2663           tree name = DECL_NAME (decl);
2664
2665           decl = push_template_decl_real (decl, globalize);
2666           /* If the current binding level is the binding level for the
2667              template parameters (see the comment in
2668              begin_template_parm_list) and the enclosing level is a class
2669              scope, and we're not looking at a friend, push the
2670              declaration of the member class into the class scope.  In the
2671              friend case, push_template_decl will already have put the
2672              friend into global scope, if appropriate.  */
2673           if (TREE_CODE (type) != ENUMERAL_TYPE
2674               && !globalize && b->template_parms_p
2675               && b->level_chain->parm_flag == 2)
2676             {
2677               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2678               /* Put this tag on the list of tags for the class, since
2679                  that won't happen below because B is not the class
2680                  binding level, but is instead the pseudo-global level.  */
2681               b->level_chain->tags =
2682                 tree_cons (name, type, b->level_chain->tags);
2683               if (!COMPLETE_TYPE_P (current_class_type))
2684                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2685             }
2686         }
2687     }
2688
2689   return decl;
2690 }
2691
2692 /* In C++, you don't have to write `struct S' to refer to `S'; you
2693    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2694    if the user had written `typedef struct S S'.  Create and return
2695    the TYPE_DECL for TYPE.  */
2696
2697 tree
2698 create_implicit_typedef (name, type)
2699      tree name;
2700      tree type;
2701 {
2702   tree decl;
2703
2704   decl = build_decl (TYPE_DECL, name, type);
2705   DECL_ARTIFICIAL (decl) = 1;
2706   /* There are other implicit type declarations, like the one *within*
2707      a class that allows you to write `S::S'.  We must distinguish
2708      amongst these.  */
2709   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2710   TYPE_NAME (type) = decl;
2711
2712   return decl;
2713 }
2714
2715 /* Remember a local name for name-mangling purposes.  */
2716
2717 static void
2718 push_local_name (decl)
2719      tree decl;
2720 {
2721   size_t i, nelts;
2722   tree t, name;
2723
2724   if (!local_names)
2725     VARRAY_TREE_INIT (local_names, 8, "local_names");
2726
2727   name = DECL_NAME (decl);
2728
2729   nelts = VARRAY_ACTIVE_SIZE (local_names);
2730   for (i = 0; i < nelts; i++)
2731     {
2732       t = VARRAY_TREE (local_names, i);
2733       if (DECL_NAME (t) == name)
2734         {
2735           if (!DECL_LANG_SPECIFIC (decl))
2736             retrofit_lang_decl (decl);
2737           if (DECL_LANG_SPECIFIC (t))
2738             DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
2739           else
2740             DECL_DISCRIMINATOR (decl) = 1;
2741
2742           VARRAY_TREE (local_names, i) = decl;
2743           return;
2744         }
2745     }
2746
2747   VARRAY_PUSH_TREE (local_names, decl);
2748 }
2749
2750 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2751    Normally put it into the inner-most non-tag-transparent scope,
2752    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2753    The latter is needed for implicit declarations.  */
2754
2755 void
2756 pushtag (name, type, globalize)
2757      tree name, type;
2758      int globalize;
2759 {
2760   register struct binding_level *b;
2761
2762   b = current_binding_level;
2763   while (b->tag_transparent
2764          || (b->parm_flag == 2
2765              && (globalize
2766                  /* We may be defining a new type in the initializer
2767                     of a static member variable. We allow this when
2768                     not pedantic, and it is particularly useful for
2769                     type punning via an anonymous union. */
2770                  || COMPLETE_TYPE_P (b->this_class))))
2771     b = b->level_chain;
2772
2773   b->tags = tree_cons (name, type, b->tags);
2774
2775   if (name)
2776     {
2777       /* Do C++ gratuitous typedefing.  */
2778       if (IDENTIFIER_TYPE_VALUE (name) != type)
2779         {
2780           register tree d = NULL_TREE;
2781           int in_class = 0;
2782           tree context = TYPE_CONTEXT (type);
2783
2784           if (! context)
2785             {
2786               tree cs = current_scope ();
2787
2788               if (! globalize)
2789                 context = cs;
2790               else if (cs != NULL_TREE && TYPE_P (cs))
2791                 /* When declaring a friend class of a local class, we want
2792                    to inject the newly named class into the scope
2793                    containing the local class, not the namespace scope.  */
2794                 context = decl_function_context (get_type_decl (cs));
2795             }
2796           if (!context)
2797             context = current_namespace;
2798
2799           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2800               || b->parm_flag == 2)
2801             in_class = 1;
2802
2803           if (current_lang_name == lang_name_java)
2804             TYPE_FOR_JAVA (type) = 1;
2805
2806           d = create_implicit_typedef (name, type);
2807           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2808           if (! in_class)
2809             set_identifier_type_value_with_scope (name, type, b);
2810
2811           d = maybe_process_template_type_declaration (type,
2812                                                        globalize, b);
2813
2814           if (b->parm_flag == 2)
2815             {
2816               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2817                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2818                    class.  But if it's a member template class, we
2819                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2820                    is done later.  */
2821                 finish_member_declaration (d);
2822               else
2823                 pushdecl_class_level (d);
2824             }
2825           else
2826             d = pushdecl_with_scope (d, b);
2827
2828           /* FIXME what if it gets a name from typedef?  */
2829           if (ANON_AGGRNAME_P (name))
2830             DECL_IGNORED_P (d) = 1;
2831
2832           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2833
2834           /* If this is a local class, keep track of it.  We need this
2835              information for name-mangling, and so that it is possible to find
2836              all function definitions in a translation unit in a convenient
2837              way.  (It's otherwise tricky to find a member function definition
2838              it's only pointed to from within a local class.)  */
2839           if (TYPE_CONTEXT (type)
2840               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2841               && !processing_template_decl)
2842             VARRAY_PUSH_TREE (local_classes, type);
2843         }
2844       if (b->parm_flag == 2)
2845         {
2846           if (!COMPLETE_TYPE_P (current_class_type))
2847             CLASSTYPE_TAGS (current_class_type) = b->tags;
2848         }
2849     }
2850
2851   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2852     /* Use the canonical TYPE_DECL for this node.  */
2853     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2854   else
2855     {
2856       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2857          will be the tagged type we just added to the current
2858          binding level.  This fake NULL-named TYPE_DECL node helps
2859          dwarfout.c to know when it needs to output a
2860          representation of a tagged type, and it also gives us a
2861          convenient place to record the "scope start" address for
2862          the tagged type.  */
2863
2864       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2865       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2866     }
2867 }
2868
2869 /* Counter used to create anonymous type names.  */
2870
2871 static int anon_cnt = 0;
2872
2873 /* Return an IDENTIFIER which can be used as a name for
2874    anonymous structs and unions.  */
2875
2876 tree
2877 make_anon_name ()
2878 {
2879   char buf[32];
2880
2881   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2882   return get_identifier (buf);
2883 }
2884
2885 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2886    This keeps dbxout from getting confused.  */
2887
2888 void
2889 clear_anon_tags ()
2890 {
2891   register struct binding_level *b;
2892   register tree tags;
2893   static int last_cnt = 0;
2894
2895   /* Fast out if no new anon names were declared.  */
2896   if (last_cnt == anon_cnt)
2897     return;
2898
2899   b = current_binding_level;
2900   while (b->tag_transparent)
2901     b = b->level_chain;
2902   tags = b->tags;
2903   while (tags)
2904     {
2905       /* A NULL purpose means we have already processed all tags
2906          from here to the end of the list.  */
2907       if (TREE_PURPOSE (tags) == NULL_TREE)
2908         break;
2909       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2910         TREE_PURPOSE (tags) = NULL_TREE;
2911       tags = TREE_CHAIN (tags);
2912     }
2913   last_cnt = anon_cnt;
2914 }
2915 \f
2916 /* Subroutine of duplicate_decls: return truthvalue of whether
2917    or not types of these decls match.
2918
2919    For C++, we must compare the parameter list so that `int' can match
2920    `int&' in a parameter position, but `int&' is not confused with
2921    `const int&'.  */
2922
2923 int
2924 decls_match (newdecl, olddecl)
2925      tree newdecl, olddecl;
2926 {
2927   int types_match;
2928
2929   if (newdecl == olddecl)
2930     return 1;
2931
2932   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2933     /* If the two DECLs are not even the same kind of thing, we're not
2934        interested in their types.  */
2935     return 0;
2936
2937   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2938     {
2939       tree f1 = TREE_TYPE (newdecl);
2940       tree f2 = TREE_TYPE (olddecl);
2941       tree p1 = TYPE_ARG_TYPES (f1);
2942       tree p2 = TYPE_ARG_TYPES (f2);
2943
2944       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2945           && ! (DECL_EXTERN_C_P (newdecl)
2946                 && DECL_EXTERN_C_P (olddecl)))
2947         return 0;
2948
2949       if (TREE_CODE (f1) != TREE_CODE (f2))
2950         return 0;
2951
2952       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2953         {
2954           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
2955               && (DECL_BUILT_IN (olddecl)
2956 #ifndef NO_IMPLICIT_EXTERN_C
2957                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
2958                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
2959 #endif
2960               ))
2961             {
2962               types_match = self_promoting_args_p (p1);
2963               if (p1 == void_list_node)
2964                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2965             }
2966 #ifndef NO_IMPLICIT_EXTERN_C
2967           else if (p1 == NULL_TREE
2968                    && (DECL_EXTERN_C_P (olddecl)
2969                        && DECL_IN_SYSTEM_HEADER (olddecl)
2970                        && !DECL_CLASS_SCOPE_P (olddecl))
2971                    && (DECL_EXTERN_C_P (newdecl)
2972                        && DECL_IN_SYSTEM_HEADER (newdecl)
2973                        && !DECL_CLASS_SCOPE_P (newdecl)))
2974             {
2975               types_match = self_promoting_args_p (p2);
2976               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2977             }
2978 #endif
2979           else
2980             types_match = compparms (p1, p2);
2981         }
2982       else
2983         types_match = 0;
2984     }
2985   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2986     {
2987       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2988                                 DECL_TEMPLATE_PARMS (olddecl)))
2989         return 0;
2990
2991       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
2992           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
2993         return 0;
2994
2995       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2996         types_match = 1;
2997       else
2998         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2999                                    DECL_TEMPLATE_RESULT (newdecl));
3000     }
3001   else
3002     {
3003       if (TREE_TYPE (newdecl) == error_mark_node)
3004         types_match = TREE_TYPE (olddecl) == error_mark_node;
3005       else if (TREE_TYPE (olddecl) == NULL_TREE)
3006         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3007       else if (TREE_TYPE (newdecl) == NULL_TREE)
3008         types_match = 0;
3009       else
3010         types_match = comptypes (TREE_TYPE (newdecl),
3011                                  TREE_TYPE (olddecl),
3012                                  COMPARE_REDECLARATION);
3013     }
3014
3015   return types_match;
3016 }
3017
3018 /* If NEWDECL is `static' and an `extern' was seen previously,
3019    warn about it.  OLDDECL is the previous declaration.
3020
3021    Note that this does not apply to the C++ case of declaring
3022    a variable `extern const' and then later `const'.
3023
3024    Don't complain about built-in functions, since they are beyond
3025    the user's control.  */
3026
3027 static void
3028 warn_extern_redeclared_static (newdecl, olddecl)
3029      tree newdecl, olddecl;
3030 {
3031   static const char *explicit_extern_static_warning
3032     = "`%D' was declared `extern' and later `static'";
3033   static const char *implicit_extern_static_warning
3034     = "`%D' was declared implicitly `extern' and later `static'";
3035
3036   tree name;
3037
3038   if (TREE_CODE (newdecl) == TYPE_DECL
3039       || TREE_CODE (newdecl) == TEMPLATE_DECL
3040       || TREE_CODE (newdecl) == CONST_DECL)
3041     return;
3042
3043   /* Don't get confused by static member functions; that's a different
3044      use of `static'.  */
3045   if (TREE_CODE (newdecl) == FUNCTION_DECL
3046       && DECL_STATIC_FUNCTION_P (newdecl))
3047     return;
3048
3049   /* If the old declaration was `static', or the new one isn't, then
3050      then everything is OK.  */
3051   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3052     return;
3053
3054   /* It's OK to declare a builtin function as `static'.  */
3055   if (TREE_CODE (olddecl) == FUNCTION_DECL
3056       && DECL_ARTIFICIAL (olddecl))
3057     return;
3058
3059   name = DECL_ASSEMBLER_NAME (newdecl);
3060   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3061               ? implicit_extern_static_warning
3062               : explicit_extern_static_warning, newdecl);
3063   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3064 }
3065
3066 /* Handle when a new declaration NEWDECL has the same name as an old
3067    one OLDDECL in the same binding contour.  Prints an error message
3068    if appropriate.
3069
3070    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3071    Otherwise, return 0.  */
3072
3073 int
3074 duplicate_decls (newdecl, olddecl)
3075      tree newdecl, olddecl;
3076 {
3077   unsigned olddecl_uid = DECL_UID (olddecl);
3078   int olddecl_friend = 0, types_match = 0;
3079   int new_defines_function = 0;
3080
3081   if (newdecl == olddecl)
3082     return 1;
3083
3084   types_match = decls_match (newdecl, olddecl);
3085
3086   /* If either the type of the new decl or the type of the old decl is an
3087      error_mark_node, then that implies that we have already issued an
3088      error (earlier) for some bogus type specification, and in that case,
3089      it is rather pointless to harass the user with yet more error message
3090      about the same declaration, so just pretend the types match here.  */
3091   if (TREE_TYPE (newdecl) == error_mark_node
3092       || TREE_TYPE (olddecl) == error_mark_node)
3093     types_match = 1;
3094
3095   /* Check for redeclaration and other discrepancies. */
3096   if (TREE_CODE (olddecl) == FUNCTION_DECL
3097       && DECL_ARTIFICIAL (olddecl))
3098     {
3099       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3100         {
3101           /* If you declare a built-in or predefined function name as static,
3102              the old definition is overridden, but optionally warn this was a
3103              bad choice of name.  */
3104           if (! TREE_PUBLIC (newdecl))
3105             {
3106               if (warn_shadow)
3107                 cp_warning ("shadowing %s function `%#D'",
3108                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3109                             olddecl);
3110               /* Discard the old built-in function.  */
3111               return 0;
3112             }
3113           /* If the built-in is not ansi, then programs can override
3114              it even globally without an error.  */
3115           else if (! DECL_BUILT_IN (olddecl))
3116             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3117                         olddecl, newdecl);
3118           else
3119             {
3120               cp_error ("declaration of `%#D'", newdecl);
3121               cp_error ("conflicts with built-in declaration `%#D'",
3122                         olddecl);
3123             }
3124           return 0;
3125         }
3126       else if (!types_match)
3127         {
3128           if ((DECL_EXTERN_C_P (newdecl)
3129                && DECL_EXTERN_C_P (olddecl))
3130               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3131                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3132             {
3133               /* A near match; override the builtin.  */
3134
3135               if (TREE_PUBLIC (newdecl))
3136                 {
3137                   cp_warning ("new declaration `%#D'", newdecl);
3138                   cp_warning ("ambiguates built-in declaration `%#D'",
3139                               olddecl);
3140                 }
3141               else if (warn_shadow)
3142                 cp_warning ("shadowing %s function `%#D'",
3143                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3144                             olddecl);
3145             }
3146           else
3147             /* Discard the old built-in function.  */
3148             return 0;
3149         }
3150
3151       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3152         {
3153           /* If a builtin function is redeclared as `static', merge
3154              the declarations, but make the original one static.  */
3155           DECL_THIS_STATIC (olddecl) = 1;
3156           TREE_PUBLIC (olddecl) = 0;
3157
3158           /* Make the old declaration consistent with the new one so
3159              that all remnants of the builtin-ness of this function
3160              will be banished.  */
3161           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3162           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3163           COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3164           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3165                                        newdecl);
3166         }
3167     }
3168   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3169     {
3170       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3171            && TREE_CODE (newdecl) != TYPE_DECL
3172            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3173                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3174           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3175               && TREE_CODE (olddecl) != TYPE_DECL
3176               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3177                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3178                         == TYPE_DECL))))
3179         {
3180           /* We do nothing special here, because C++ does such nasty
3181              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3182              get shadowed, and know that if we need to find a TYPE_DECL
3183              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3184              slot of the identifier.  */
3185           return 0;
3186         }
3187
3188       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3189            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3190           || (TREE_CODE (olddecl) == FUNCTION_DECL
3191               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3192         return 0;
3193
3194       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3195       if (TREE_CODE (olddecl) == TREE_LIST)
3196         olddecl = TREE_VALUE (olddecl);
3197       cp_error_at ("previous declaration of `%#D'", olddecl);
3198
3199       /* New decl is completely inconsistent with the old one =>
3200          tell caller to replace the old one.  */
3201
3202       return 0;
3203     }
3204   else if (!types_match)
3205     {
3206       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3207         /* These are certainly not duplicate declarations; they're
3208            from different scopes.  */
3209         return 0;
3210
3211       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3212         {
3213           /* The name of a class template may not be declared to refer to
3214              any other template, class, function, object, namespace, value,
3215              or type in the same scope.  */
3216           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3217               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3218             {
3219               cp_error ("declaration of template `%#D'", newdecl);
3220               cp_error_at ("conflicts with previous declaration `%#D'",
3221                            olddecl);
3222             }
3223           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3224                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3225                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3226                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3227                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3228                                            DECL_TEMPLATE_PARMS (olddecl)))
3229             {
3230               cp_error ("new declaration `%#D'", newdecl);
3231               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3232             }
3233           return 0;
3234         }
3235       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3236         {
3237           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3238             {
3239               cp_error ("declaration of C function `%#D' conflicts with",
3240                         newdecl);
3241               cp_error_at ("previous declaration `%#D' here", olddecl);
3242             }
3243           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3244                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3245             {
3246               cp_error ("new declaration `%#D'", newdecl);
3247               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3248             }
3249           else
3250             return 0;
3251         }
3252
3253       /* Already complained about this, so don't do so again.  */
3254       else if (current_class_type == NULL_TREE
3255           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3256         {
3257           cp_error ("conflicting types for `%#D'", newdecl);
3258           cp_error_at ("previous declaration as `%#D'", olddecl);
3259         }
3260     }
3261   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3262             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3263                  && (!DECL_TEMPLATE_INFO (newdecl)
3264                      || (DECL_TI_TEMPLATE (newdecl)
3265                          != DECL_TI_TEMPLATE (olddecl))))
3266                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3267                     && (!DECL_TEMPLATE_INFO (olddecl)
3268                         || (DECL_TI_TEMPLATE (olddecl)
3269                             != DECL_TI_TEMPLATE (newdecl))))))
3270     /* It's OK to have a template specialization and a non-template
3271        with the same type, or to have specializations of two
3272        different templates with the same type.  Note that if one is a
3273        specialization, and the other is an instantiation of the same
3274        template, that we do not exit at this point.  That situation
3275        can occur if we instantiate a template class, and then
3276        specialize one of its methods.  This situation is legal, but
3277        the declarations must be merged in the usual way.  */
3278     return 0;
3279   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3280            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3281                 && !DECL_USE_TEMPLATE (newdecl))
3282                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3283                    && !DECL_USE_TEMPLATE (olddecl))))
3284     /* One of the declarations is a template instantiation, and the
3285        other is not a template at all.  That's OK.  */
3286     return 0;
3287   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3288            && DECL_NAMESPACE_ALIAS (newdecl)
3289            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3290     /* Redeclaration of namespace alias, ignore it. */
3291     return 1;
3292   else
3293     {
3294       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3295       if (errmsg)
3296         {
3297           cp_error (errmsg, newdecl);
3298           if (DECL_NAME (olddecl) != NULL_TREE)
3299             cp_error_at ((DECL_INITIAL (olddecl)
3300                           && namespace_bindings_p ())
3301                          ? "`%#D' previously defined here"
3302                          : "`%#D' previously declared here", olddecl);
3303         }
3304       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3305                && DECL_INITIAL (olddecl) != NULL_TREE
3306                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3307                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3308         {
3309           /* Prototype decl follows defn w/o prototype.  */
3310           cp_warning_at ("prototype for `%#D'", newdecl);
3311           cp_warning_at ("follows non-prototype definition here", olddecl);
3312         }
3313       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3314                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3315         {
3316           /* extern "C" int foo ();
3317              int foo () { bar (); }
3318              is OK.  */
3319           if (current_lang_depth () == 0)
3320             SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3321           else
3322             {
3323               cp_error_at ("previous declaration of `%#D' with %L linkage",
3324                            olddecl, DECL_LANGUAGE (olddecl));
3325               cp_error ("conflicts with new declaration with %L linkage",
3326                         DECL_LANGUAGE (newdecl));
3327             }
3328         }
3329
3330       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3331         ;
3332       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3333         {
3334           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3335           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3336           int i = 1;
3337
3338           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3339             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3340
3341           for (; t1 && t1 != void_list_node;
3342                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3343             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3344               {
3345                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3346                                            TREE_PURPOSE (t2)))
3347                   {
3348                     if (pedantic)
3349                       {
3350                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3351                                     i, newdecl);
3352                         cp_pedwarn_at ("after previous specification in `%#D'",
3353                                        olddecl);
3354                       }
3355                   }
3356                 else
3357                   {
3358                     cp_error ("default argument given for parameter %d of `%#D'",
3359                               i, newdecl);
3360                     cp_error_at ("after previous specification in `%#D'",
3361                                  olddecl);
3362                   }
3363               }
3364
3365           if (DECL_DECLARED_INLINE_P (newdecl)
3366               && ! DECL_DECLARED_INLINE_P (olddecl)
3367               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3368             {
3369               cp_warning ("`%#D' was used before it was declared inline",
3370                           newdecl);
3371               cp_warning_at ("previous non-inline declaration here",
3372                              olddecl);
3373             }
3374         }
3375     }
3376
3377   /* If new decl is `static' and an `extern' was seen previously,
3378      warn about it.  */
3379   warn_extern_redeclared_static (newdecl, olddecl);
3380
3381   /* We have committed to returning 1 at this point.  */
3382   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3383     {
3384       /* Now that functions must hold information normally held
3385          by field decls, there is extra work to do so that
3386          declaration information does not get destroyed during
3387          definition.  */
3388       if (DECL_VINDEX (olddecl))
3389         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3390       if (DECL_VIRTUAL_CONTEXT (olddecl))
3391         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3392       if (DECL_CONTEXT (olddecl))
3393         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3394       if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3395         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3396       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3397       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3398       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3399       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3400       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3401       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3402       if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
3403         SET_OVERLOADED_OPERATOR_CODE
3404           (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
3405       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3406
3407       /* Optionally warn about more than one declaration for the same
3408          name, but don't warn about a function declaration followed by a
3409          definition.  */
3410       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3411           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3412           /* Don't warn about extern decl followed by definition. */
3413           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3414           /* Don't warn about friends, let add_friend take care of it. */
3415           && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
3416         {
3417           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3418           cp_warning_at ("previous declaration of `%D'", olddecl);
3419         }
3420     }
3421
3422   /* Deal with C++: must preserve virtual function table size.  */
3423   if (TREE_CODE (olddecl) == TYPE_DECL)
3424     {
3425       register tree newtype = TREE_TYPE (newdecl);
3426       register tree oldtype = TREE_TYPE (olddecl);
3427
3428       if (newtype != error_mark_node && oldtype != error_mark_node
3429           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3430         {
3431           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3432           CLASSTYPE_FRIEND_CLASSES (newtype)
3433             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3434         }
3435
3436       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3437     }
3438
3439   /* Copy all the DECL_... slots specified in the new decl
3440      except for any that we copy here from the old type.  */
3441   DECL_MACHINE_ATTRIBUTES (newdecl)
3442     = (*targetm.merge_decl_attributes) (olddecl, newdecl);
3443
3444   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3445     {
3446       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3447       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3448         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3449                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3450
3451       /* If the new declaration is a definition, update the file and
3452          line information on the declaration.  */
3453       if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
3454           && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
3455         {
3456           DECL_SOURCE_LINE (olddecl)
3457             = DECL_SOURCE_LINE (DECL_TEMPLATE_RESULT (olddecl))
3458             = DECL_SOURCE_LINE (newdecl);
3459           DECL_SOURCE_FILE (olddecl)
3460             = DECL_SOURCE_FILE (DECL_TEMPLATE_RESULT (olddecl))
3461             = DECL_SOURCE_FILE (newdecl);
3462         }
3463
3464       return 1;
3465     }
3466
3467   if (types_match)
3468     {
3469       /* Automatically handles default parameters.  */
3470       tree oldtype = TREE_TYPE (olddecl);
3471       tree newtype;
3472
3473       /* Merge the data types specified in the two decls.  */
3474       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3475
3476       /* If common_type produces a non-typedef type, just use the old type.  */
3477       if (TREE_CODE (newdecl) == TYPE_DECL
3478           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3479         newtype = oldtype;
3480
3481       if (TREE_CODE (newdecl) == VAR_DECL)
3482         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3483       /* Do this after calling `common_type' so that default
3484          parameters don't confuse us.  */
3485       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3486           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3487               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3488         {
3489           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3490                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3491           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3492                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3493
3494           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3495               && DECL_SOURCE_LINE (olddecl) != 0
3496               && flag_exceptions
3497               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3498                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3499             {
3500               cp_error ("declaration of `%F' throws different exceptions",
3501                         newdecl);
3502               cp_error_at ("than previous declaration `%F'", olddecl);
3503             }
3504         }
3505       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3506
3507       /* Lay the type out, unless already done.  */
3508       if (! same_type_p (newtype, oldtype)
3509           && TREE_TYPE (newdecl) != error_mark_node
3510           && !(processing_template_decl && uses_template_parms (newdecl)))
3511         layout_type (TREE_TYPE (newdecl));
3512
3513       if ((TREE_CODE (newdecl) == VAR_DECL
3514            || TREE_CODE (newdecl) == PARM_DECL
3515            || TREE_CODE (newdecl) == RESULT_DECL
3516            || TREE_CODE (newdecl) == FIELD_DECL
3517            || TREE_CODE (newdecl) == TYPE_DECL)
3518           && !(processing_template_decl && uses_template_parms (newdecl)))
3519         layout_decl (newdecl, 0);
3520
3521       /* Merge the type qualifiers.  */
3522       if (TREE_READONLY (newdecl))
3523         TREE_READONLY (olddecl) = 1;
3524       if (TREE_THIS_VOLATILE (newdecl))
3525         TREE_THIS_VOLATILE (olddecl) = 1;
3526
3527       /* Merge the initialization information.  */
3528       if (DECL_INITIAL (newdecl) == NULL_TREE
3529           && DECL_INITIAL (olddecl) != NULL_TREE)
3530         {
3531           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3532           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3533           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3534           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3535               && DECL_LANG_SPECIFIC (newdecl)
3536               && DECL_LANG_SPECIFIC (olddecl))
3537             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3538         }
3539
3540       /* Merge the section attribute.
3541          We want to issue an error if the sections conflict but that must be
3542          done later in decl_attributes since we are called before attributes
3543          are assigned.  */
3544       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3545         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3546
3547       /* Keep the old rtl since we can safely use it.  */
3548       COPY_DECL_RTL (olddecl, newdecl);
3549
3550       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3551         {
3552           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3553             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3554           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3555             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3556           DECL_NO_LIMIT_STACK (newdecl)
3557             |= DECL_NO_LIMIT_STACK (olddecl);
3558         }
3559     }
3560   /* If cannot merge, then use the new type and qualifiers,
3561      and don't preserve the old rtl.  */
3562   else
3563     {
3564       /* Clean out any memory we had of the old declaration.  */
3565       tree oldstatic = value_member (olddecl, static_aggregates);
3566       if (oldstatic)
3567         TREE_VALUE (oldstatic) = error_mark_node;
3568
3569       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3570       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3571       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3572       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3573     }
3574
3575   /* Merge the storage class information.  */
3576   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3577   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3578   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3579   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3580   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3581   if (! DECL_EXTERNAL (olddecl))
3582     DECL_EXTERNAL (newdecl) = 0;
3583
3584   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3585     {
3586       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3587       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3588       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3589       DECL_TEMPLATE_INSTANTIATED (newdecl)
3590         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3591       /* Don't really know how much of the language-specific
3592          values we should copy from old to new.  */
3593       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3594       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3595       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3596       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3597       DECL_INITIALIZED_IN_CLASS_P (newdecl)
3598         |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
3599       olddecl_friend = DECL_FRIEND_P (olddecl);
3600
3601       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3602       if (TREE_CODE (newdecl) == FUNCTION_DECL
3603           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3604         DECL_BEFRIENDING_CLASSES (newdecl)
3605           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3606                      DECL_BEFRIENDING_CLASSES (olddecl));
3607     }
3608
3609   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3610     {
3611       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3612           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3613         {
3614           /* If newdecl is not a specialization, then it is not a
3615              template-related function at all.  And that means that we
3616              shoud have exited above, returning 0.  */
3617           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3618                               0);
3619
3620           if (TREE_USED (olddecl))
3621             /* From [temp.expl.spec]:
3622
3623                If a template, a member template or the member of a class
3624                template is explicitly specialized then that
3625                specialization shall be declared before the first use of
3626                that specialization that would cause an implicit
3627                instantiation to take place, in every translation unit in
3628                which such a use occurs.  */
3629             cp_error ("explicit specialization of %D after first use",
3630                       olddecl);
3631
3632           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3633         }
3634       DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
3635
3636       /* If either decl says `inline', this fn is inline, unless its
3637          definition was passed already.  */
3638       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3639         DECL_INLINE (olddecl) = 1;
3640       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3641
3642       /* Preserve abstractness on cloned [cd]tors.  */
3643       DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
3644
3645       if (! types_match)
3646         {
3647           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3648           COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
3649           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3650         }
3651       if (! types_match || new_defines_function)
3652         {
3653           /* These need to be copied so that the names are available.
3654              Note that if the types do match, we'll preserve inline
3655              info and other bits, but if not, we won't.  */
3656           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3657           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3658         }
3659       if (new_defines_function)
3660         /* If defining a function declared with other language
3661            linkage, use the previously declared language linkage.  */
3662         SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3663       else if (types_match)
3664         {
3665           /* If redeclaring a builtin function, and not a definition,
3666              it stays built in.  */
3667           if (DECL_BUILT_IN (olddecl))
3668             {
3669               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3670               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3671               /* If we're keeping the built-in definition, keep the rtl,
3672                  regardless of declaration matches.  */
3673               SET_DECL_RTL (newdecl, DECL_RTL (olddecl));
3674             }
3675           else
3676             DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
3677
3678           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3679           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3680             /* Previously saved insns go together with
3681                the function's previous definition.  */
3682             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3683           /* Don't clear out the arguments if we're redefining a function.  */
3684           if (DECL_ARGUMENTS (olddecl))
3685             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3686         }
3687     }
3688   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3689     NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3690
3691   /* Now preserve various other info from the definition.  */
3692   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3693   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3694   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3695   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3696
3697   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3698     {
3699       int function_size;
3700
3701       function_size = sizeof (struct tree_decl);
3702
3703       memcpy ((char *) olddecl + sizeof (struct tree_common),
3704               (char *) newdecl + sizeof (struct tree_common),
3705               function_size - sizeof (struct tree_common));
3706
3707       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3708         {
3709           /* If newdecl is a template instantiation, it is possible that
3710              the following sequence of events has occurred:
3711
3712              o A friend function was declared in a class template.  The
3713              class template was instantiated.
3714
3715              o The instantiation of the friend declaration was
3716              recorded on the instantiation list, and is newdecl.
3717
3718              o Later, however, instantiate_class_template called pushdecl
3719              on the newdecl to perform name injection.  But, pushdecl in
3720              turn called duplicate_decls when it discovered that another
3721              declaration of a global function with the same name already
3722              existed.
3723
3724              o Here, in duplicate_decls, we decided to clobber newdecl.
3725
3726              If we're going to do that, we'd better make sure that
3727              olddecl, and not newdecl, is on the list of
3728              instantiations so that if we try to do the instantiation
3729              again we won't get the clobbered declaration.  */
3730
3731           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3732           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3733
3734           for (; decls; decls = TREE_CHAIN (decls))
3735             if (TREE_VALUE (decls) == newdecl)
3736               TREE_VALUE (decls) = olddecl;
3737         }
3738     }
3739   else
3740     {
3741       memcpy ((char *) olddecl + sizeof (struct tree_common),
3742               (char *) newdecl + sizeof (struct tree_common),
3743               sizeof (struct tree_decl) - sizeof (struct tree_common)
3744               + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3745     }
3746
3747   DECL_UID (olddecl) = olddecl_uid;
3748   if (olddecl_friend)
3749     DECL_FRIEND_P (olddecl) = 1;
3750
3751   /* NEWDECL contains the merged attribute lists.
3752      Update OLDDECL to be the same.  */
3753   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3754
3755   return 1;
3756 }
3757
3758 /* Record a decl-node X as belonging to the current lexical scope.
3759    Check for errors (such as an incompatible declaration for the same
3760    name already seen in the same scope).
3761
3762    Returns either X or an old decl for the same name.
3763    If an old decl is returned, it may have been smashed
3764    to agree with what X says.  */
3765
3766 tree
3767 pushdecl (x)
3768      tree x;
3769 {
3770   register tree t;
3771   register tree name;
3772   int need_new_binding;
3773
3774   /* We shouldn't be calling pushdecl when we're generating RTL for a
3775      function that we already did semantic analysis on previously.  */
3776   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3777                       19990913);
3778
3779   need_new_binding = 1;
3780
3781   if (DECL_TEMPLATE_PARM_P (x))
3782     /* Template parameters have no context; they are not X::T even
3783        when declared within a class or namespace.  */
3784     ;
3785   else
3786     {
3787       if (current_function_decl && x != current_function_decl
3788           /* A local declaration for a function doesn't constitute
3789              nesting.  */
3790           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3791           /* A local declaration for an `extern' variable is in the
3792              scope of the current namespace, not the current
3793              function.  */
3794           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3795           && !DECL_CONTEXT (x))
3796         DECL_CONTEXT (x) = current_function_decl;
3797
3798       /* If this is the declaration for a namespace-scope function,
3799          but the declaration itself is in a local scope, mark the
3800          declaration.  */
3801       if (TREE_CODE (x) == FUNCTION_DECL
3802           && DECL_NAMESPACE_SCOPE_P (x)
3803           && current_function_decl
3804           && x != current_function_decl)
3805         DECL_LOCAL_FUNCTION_P (x) = 1;
3806     }
3807
3808   name = DECL_NAME (x);
3809   if (name)
3810     {
3811       int different_binding_level = 0;
3812
3813       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3814         name = TREE_OPERAND (name, 0);
3815
3816       /* In case this decl was explicitly namespace-qualified, look it
3817          up in its namespace context.  */
3818       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3819           && namespace_bindings_p ())
3820         t = namespace_binding (name, DECL_CONTEXT (x));
3821       else
3822         t = lookup_name_current_level (name);
3823
3824       /* [basic.link] If there is a visible declaration of an entity
3825          with linkage having the same name and type, ignoring entities
3826          declared outside the innermost enclosing namespace scope, the
3827          block scope declaration declares that same entity and
3828          receives the linkage of the previous declaration.  */
3829       if (! t && current_function_decl && x != current_function_decl
3830           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3831           && DECL_EXTERNAL (x))
3832         {
3833           /* Look in block scope.  */
3834           t = IDENTIFIER_VALUE (name);
3835           /* Or in the innermost namespace.  */
3836           if (! t)
3837             t = namespace_binding (name, DECL_CONTEXT (x));
3838           /* Does it have linkage?  Note that if this isn't a DECL, it's an
3839              OVERLOAD, which is OK.  */
3840           if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3841             t = NULL_TREE;
3842           if (t)
3843             different_binding_level = 1;
3844         }
3845
3846       /* If we are declaring a function, and the result of name-lookup
3847          was an OVERLOAD, look for an overloaded instance that is
3848          actually the same as the function we are declaring.  (If
3849          there is one, we have to merge our declaration with the
3850          previous declaration.)  */
3851       if (t && TREE_CODE (t) == OVERLOAD)
3852         {
3853           tree match;
3854
3855           if (TREE_CODE (x) == FUNCTION_DECL)
3856             for (match = t; match; match = OVL_NEXT (match))
3857               {
3858                 if (decls_match (OVL_CURRENT (match), x))
3859                   break;
3860               }
3861           else
3862             /* Just choose one.  */
3863             match = t;
3864
3865           if (match)
3866             t = OVL_CURRENT (match);
3867           else
3868             t = NULL_TREE;
3869         }
3870
3871       if (t == error_mark_node)
3872         {
3873           /* error_mark_node is 0 for a while during initialization!  */
3874           t = NULL_TREE;
3875           cp_error_at ("`%#D' used prior to declaration", x);
3876         }
3877       else if (t != NULL_TREE)
3878         {
3879           if (different_binding_level)
3880             {
3881               if (decls_match (x, t))
3882                 /* The standard only says that the local extern
3883                    inherits linkage from the previous decl; in
3884                    particular, default args are not shared.  It would
3885                    be nice to propagate inlining info, though.  FIXME.  */
3886                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3887             }
3888           else if (TREE_CODE (t) == PARM_DECL)
3889             {
3890               if (DECL_CONTEXT (t) == NULL_TREE)
3891                 /* This is probaby caused by too many errors, but calling
3892                    abort will say that if errors have occurred.  */
3893                 abort ();
3894
3895               /* Check for duplicate params.  */
3896               if (duplicate_decls (x, t))
3897                 return t;
3898             }
3899           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3900                     || DECL_FUNCTION_TEMPLATE_P (x))
3901                    && is_overloaded_fn (t))
3902             /* Don't do anything just yet. */;
3903           else if (t == wchar_decl_node)
3904             {
3905               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3906                 cp_pedwarn ("redeclaration of `wchar_t' as `%T'",
3907                             TREE_TYPE (x));
3908
3909               /* Throw away the redeclaration.  */
3910               return t;
3911             }
3912           else if (TREE_CODE (t) != TREE_CODE (x))
3913             {
3914               if (duplicate_decls (x, t))
3915                 return t;
3916             }
3917           else if (duplicate_decls (x, t))
3918             {
3919               if (TREE_CODE (t) == TYPE_DECL)
3920                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3921               else if (TREE_CODE (t) == FUNCTION_DECL)
3922                 check_default_args (t);
3923
3924               return t;
3925             }
3926           else if (DECL_MAIN_P (x))
3927             {
3928               /* A redeclaration of main, but not a duplicate of the
3929                  previous one.
3930
3931                  [basic.start.main]
3932
3933                  This function shall not be overloaded.  */
3934               cp_error_at ("invalid redeclaration of `%D'", t);
3935               cp_error ("as `%D'", x);
3936               /* We don't try to push this declaration since that
3937                  causes a crash.  */
3938               return x;
3939             }
3940         }
3941
3942       check_template_shadow (x);
3943
3944       /* If this is a function conjured up by the backend, massage it
3945          so it looks friendly.  */
3946       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3947         {
3948           retrofit_lang_decl (x);
3949           SET_DECL_LANGUAGE (x, lang_c);
3950         }
3951
3952       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3953         {
3954           t = push_overloaded_decl (x, PUSH_LOCAL);
3955           if (t != x)
3956             return t;
3957           if (!namespace_bindings_p ())
3958             /* We do not need to create a binding for this name;
3959                push_overloaded_decl will have already done so if
3960                necessary.  */
3961             need_new_binding = 0;
3962         }
3963       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3964         {
3965           t = push_overloaded_decl (x, PUSH_GLOBAL);
3966           if (t == x)
3967             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3968           return t;
3969         }
3970
3971       /* If declaring a type as a typedef, copy the type (unless we're
3972          at line 0), and install this TYPE_DECL as the new type's typedef
3973          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3974       if (TREE_CODE (x) == TYPE_DECL)
3975         {
3976           tree type = TREE_TYPE (x);
3977           if (DECL_SOURCE_LINE (x) == 0)
3978             {
3979               if (TYPE_NAME (type) == 0)
3980                 TYPE_NAME (type) = x;
3981             }
3982           else if (type != error_mark_node && TYPE_NAME (type) != x
3983                    /* We don't want to copy the type when all we're
3984                       doing is making a TYPE_DECL for the purposes of
3985                       inlining.  */
3986                    && (!TYPE_NAME (type)
3987                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3988             {
3989               DECL_ORIGINAL_TYPE (x) = type;
3990               type = build_type_copy (type);
3991               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3992               TYPE_NAME (type) = x;
3993               TREE_TYPE (x) = type;
3994             }
3995
3996           if (type != error_mark_node
3997               && TYPE_NAME (type)
3998               && TYPE_IDENTIFIER (type))
3999             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4000                                                   current_binding_level);
4001
4002         }
4003
4004       /* Multiple external decls of the same identifier ought to match.
4005
4006          We get warnings about inline functions where they are defined.
4007          We get warnings about other functions from push_overloaded_decl.
4008
4009          Avoid duplicate warnings where they are used.  */
4010       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4011         {
4012           tree decl;
4013
4014           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4015           if (decl && TREE_CODE (decl) == OVERLOAD)
4016             decl = OVL_FUNCTION (decl);
4017
4018           if (decl && decl != error_mark_node
4019               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4020               /* If different sort of thing, we already gave an error.  */
4021               && TREE_CODE (decl) == TREE_CODE (x)
4022               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4023             {
4024               cp_pedwarn ("type mismatch with previous external decl", x);
4025               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4026             }
4027         }
4028
4029       /* This name is new in its binding level.
4030          Install the new declaration and return it.  */
4031       if (namespace_bindings_p ())
4032         {
4033           /* Install a global value.  */
4034
4035           /* If the first global decl has external linkage,
4036              warn if we later see static one.  */
4037           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4038             TREE_PUBLIC (name) = 1;
4039
4040           /* Bind the name for the entity.  */
4041           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4042                 && t != NULL_TREE)
4043               && (TREE_CODE (x) == TYPE_DECL
4044                   || TREE_CODE (x) == VAR_DECL
4045                   || TREE_CODE (x) == NAMESPACE_DECL
4046                   || TREE_CODE (x) == CONST_DECL
4047                   || TREE_CODE (x) == TEMPLATE_DECL))
4048             SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
4049
4050           /* Don't forget if the function was used via an implicit decl.  */
4051           if (IDENTIFIER_IMPLICIT_DECL (name)
4052               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4053             TREE_USED (x) = 1;
4054
4055           /* Don't forget if its address was taken in that way.  */
4056           if (IDENTIFIER_IMPLICIT_DECL (name)
4057               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4058             TREE_ADDRESSABLE (x) = 1;
4059
4060           /* Warn about mismatches against previous implicit decl.  */
4061           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4062               /* If this real decl matches the implicit, don't complain.  */
4063               && ! (TREE_CODE (x) == FUNCTION_DECL
4064                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4065             cp_warning
4066               ("`%D' was previously implicitly declared to return `int'", x);
4067
4068           /* If new decl is `static' and an `extern' was seen previously,
4069              warn about it.  */
4070           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4071             warn_extern_redeclared_static (x, t);
4072         }
4073       else
4074         {
4075           /* Here to install a non-global value.  */
4076           tree oldlocal = IDENTIFIER_VALUE (name);
4077           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4078
4079           if (need_new_binding)
4080             {
4081               push_local_binding (name, x, 0);
4082               /* Because push_local_binding will hook X on to the
4083                  current_binding_level's name list, we don't want to
4084                  do that again below.  */
4085               need_new_binding = 0;
4086             }
4087
4088           /* If this is a TYPE_DECL, push it into the type value slot.  */
4089           if (TREE_CODE (x) == TYPE_DECL)
4090             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4091                                                   current_binding_level);
4092
4093           /* Clear out any TYPE_DECL shadowed by a namespace so that
4094              we won't think this is a type.  The C struct hack doesn't
4095              go through namespaces.  */
4096           if (TREE_CODE (x) == NAMESPACE_DECL)
4097             set_identifier_type_value_with_scope (name, NULL_TREE,
4098                                                   current_binding_level);
4099
4100           if (oldlocal)
4101             {
4102               tree d = oldlocal;
4103
4104               while (oldlocal
4105                      && TREE_CODE (oldlocal) == VAR_DECL
4106                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4107                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4108
4109               if (oldlocal == NULL_TREE)
4110                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4111             }
4112
4113           /* If this is an extern function declaration, see if we
4114              have a global definition or declaration for the function.  */
4115           if (oldlocal == NULL_TREE
4116               && DECL_EXTERNAL (x)
4117               && oldglobal != NULL_TREE
4118               && TREE_CODE (x) == FUNCTION_DECL
4119               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4120             {
4121               /* We have one.  Their types must agree.  */
4122               if (decls_match (x, oldglobal))
4123                 /* OK */;
4124               else
4125                 {
4126                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4127                   cp_warning_at ("global declaration `%#D'", oldglobal);
4128                 }
4129             }
4130           /* If we have a local external declaration,
4131              and no file-scope declaration has yet been seen,
4132              then if we later have a file-scope decl it must not be static.  */
4133           if (oldlocal == NULL_TREE
4134               && oldglobal == NULL_TREE
4135               && DECL_EXTERNAL (x)
4136               && TREE_PUBLIC (x))
4137             TREE_PUBLIC (name) = 1;
4138
4139           /* Warn if shadowing an argument at the top level of the body.  */
4140           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4141               /* Inline decls shadow nothing.  */
4142               && !DECL_FROM_INLINE (x)
4143               && TREE_CODE (oldlocal) == PARM_DECL
4144               /* Don't complain if it's from an enclosing function.  */
4145               && DECL_CONTEXT (oldlocal) == current_function_decl
4146               && TREE_CODE (x) != PARM_DECL)
4147             {
4148               /* Go to where the parms should be and see if we
4149                  find them there.  */
4150               struct binding_level *b = current_binding_level->level_chain;
4151
4152               if (cleanup_label)
4153                 b = b->level_chain;
4154
4155               /* ARM $8.3 */
4156               if (b->parm_flag == 1)
4157                 cp_error ("declaration of `%#D' shadows a parameter", name);
4158             }
4159
4160           /* Maybe warn if shadowing something else.  */
4161           if (warn_shadow && !DECL_EXTERNAL (x)
4162               /* Inline decls shadow nothing.  */
4163               && !DECL_FROM_INLINE (x)
4164               /* No shadow warnings for internally generated vars.  */
4165               && ! DECL_ARTIFICIAL (x)
4166               /* No shadow warnings for vars made for inlining.  */
4167               && ! DECL_FROM_INLINE (x))
4168             {
4169               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4170                 warning ("declaration of `%s' shadows a parameter",
4171                         IDENTIFIER_POINTER (name));
4172               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4173                        && current_class_ptr
4174                        && !TREE_STATIC (name))
4175                 warning ("declaration of `%s' shadows a member of `this'",
4176                         IDENTIFIER_POINTER (name));
4177               else if (oldlocal != NULL_TREE)
4178                 warning ("declaration of `%s' shadows previous local",
4179                         IDENTIFIER_POINTER (name));
4180               else if (oldglobal != NULL_TREE)
4181                 /* XXX shadow warnings in outer-more namespaces */
4182                 warning ("declaration of `%s' shadows global declaration",
4183                         IDENTIFIER_POINTER (name));
4184             }
4185         }
4186
4187       if (TREE_CODE (x) == FUNCTION_DECL)
4188         check_default_args (x);
4189
4190       /* Keep count of variables in this level with incomplete type.  */
4191       if (TREE_CODE (x) == VAR_DECL
4192           && TREE_TYPE (x) != error_mark_node
4193           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4194                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4195               /* RTTI TD entries are created while defining the type_info.  */
4196               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4197                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4198         {
4199           if (namespace_bindings_p ())
4200             namespace_scope_incomplete
4201               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4202           else
4203             current_binding_level->incomplete
4204               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4205         }
4206     }
4207
4208   if (need_new_binding)
4209     add_decl_to_level (x,
4210                        DECL_NAMESPACE_SCOPE_P (x)
4211                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4212                        : current_binding_level);
4213
4214   return x;
4215 }
4216
4217 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4218    caller to set DECL_CONTEXT properly.  */
4219
4220 static tree
4221 pushdecl_with_scope (x, level)
4222      tree x;
4223      struct binding_level *level;
4224 {
4225   register struct binding_level *b;
4226   tree function_decl = current_function_decl;
4227
4228   current_function_decl = NULL_TREE;
4229   if (level->parm_flag == 2)
4230     {
4231       b = class_binding_level;
4232       class_binding_level = level;
4233       pushdecl_class_level (x);
4234       class_binding_level = b;
4235     }
4236   else
4237     {
4238       b = current_binding_level;
4239       current_binding_level = level;
4240       x = pushdecl (x);
4241       current_binding_level = b;
4242     }
4243   current_function_decl = function_decl;
4244   return x;
4245 }
4246
4247 /* Like pushdecl, only it places X in the current namespace,
4248    if appropriate.  */
4249
4250 tree
4251 pushdecl_namespace_level (x)
4252      tree x;
4253 {
4254   register struct binding_level *b = current_binding_level;
4255   register tree t;
4256
4257   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4258
4259   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4260      what we want.  */
4261   if (TREE_CODE (x) == TYPE_DECL)
4262     {
4263       tree name = DECL_NAME (x);
4264       tree newval;
4265       tree *ptr = (tree *)0;
4266       for (; b != global_binding_level; b = b->level_chain)
4267         {
4268           tree shadowed = b->type_shadowed;
4269           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4270             if (TREE_PURPOSE (shadowed) == name)
4271               {
4272                 ptr = &TREE_VALUE (shadowed);
4273                 /* Can't break out of the loop here because sometimes
4274                    a binding level will have duplicate bindings for
4275                    PT names.  It's gross, but I haven't time to fix it.  */
4276               }
4277         }
4278       newval = TREE_TYPE (x);
4279       if (ptr == (tree *)0)
4280         {
4281           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4282              up here if this is changed to an assertion.  --KR  */
4283           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4284         }
4285       else
4286         {
4287           *ptr = newval;
4288         }
4289     }
4290   return t;
4291 }
4292
4293 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4294    if appropriate.  */
4295
4296 tree
4297 pushdecl_top_level (x)
4298      tree x;
4299 {
4300   push_to_top_level ();
4301   x = pushdecl_namespace_level (x);
4302   pop_from_top_level ();
4303   return x;
4304 }
4305
4306 /* Make the declaration of X appear in CLASS scope.  */
4307
4308 void
4309 pushdecl_class_level (x)
4310      tree x;
4311 {
4312   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4313      scope looks for the pre-mangled name.  */
4314   register tree name;
4315
4316   if (TREE_CODE (x) == OVERLOAD)
4317     x = OVL_CURRENT (x);
4318   name = DECL_NAME (x);
4319
4320   if (name)
4321     {
4322       push_class_level_binding (name, x);
4323       if (TREE_CODE (x) == TYPE_DECL)
4324         set_identifier_type_value (name, TREE_TYPE (x));
4325     }
4326   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4327     {
4328       tree f;
4329
4330       for (f = TYPE_FIELDS (TREE_TYPE (x));
4331            f;
4332            f = TREE_CHAIN (f))
4333         pushdecl_class_level (f);
4334     }
4335 }
4336
4337 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4338    DECL, or a modified version thereof.  */
4339
4340 tree
4341 maybe_push_decl (decl)
4342      tree decl;
4343 {
4344   tree type = TREE_TYPE (decl);
4345
4346   /* Add this decl to the current binding level, but not if it comes
4347      from another scope, e.g. a static member variable.  TEM may equal
4348      DECL or it may be a previous decl of the same name.  */
4349   if (decl == error_mark_node
4350       || (TREE_CODE (decl) != PARM_DECL
4351           && DECL_CONTEXT (decl) != NULL_TREE
4352           /* Definitions of namespace members outside their namespace are
4353              possible. */
4354           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4355       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4356       || TREE_CODE (type) == UNKNOWN_TYPE
4357       /* The declaration of a template specialization does not affect
4358          the functions available for overload resolution, so we do not
4359          call pushdecl.  */
4360       || (TREE_CODE (decl) == FUNCTION_DECL
4361           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4362     return decl;
4363   else
4364     return pushdecl (decl);
4365 }
4366
4367 /* Make the declaration(s) of X appear in CLASS scope
4368    under the name NAME.  */
4369
4370 void
4371 push_class_level_binding (name, x)
4372      tree name;
4373      tree x;
4374 {
4375   tree binding;
4376   /* The class_binding_level will be NULL if x is a template
4377      parameter name in a member template.  */
4378   if (!class_binding_level)
4379     return;
4380
4381   /* Make sure that this new member does not have the same name
4382      as a template parameter.  */
4383   if (TYPE_BEING_DEFINED (current_class_type))
4384     check_template_shadow (x);
4385
4386   /* If this declaration shadows a declaration from an enclosing
4387      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4388      we leave this class.  Record the shadowed declaration here.  */
4389   binding = IDENTIFIER_BINDING (name);
4390   if (binding
4391       && ((TREE_CODE (x) == OVERLOAD
4392            && BINDING_VALUE (binding)
4393            && is_overloaded_fn (BINDING_VALUE (binding)))
4394           || INHERITED_VALUE_BINDING_P (binding)))
4395     {
4396       tree shadow;
4397       tree old_decl;
4398
4399       /* If the old binding was from a base class, and was for a tag
4400          name, slide it over to make room for the new binding.  The
4401          old binding is still visible if explicitly qualified with a
4402          class-key.  */
4403       if (INHERITED_VALUE_BINDING_P (binding)
4404           && BINDING_VALUE (binding)
4405           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4406           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4407           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4408         {
4409           old_decl = BINDING_TYPE (binding);
4410           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4411           BINDING_VALUE (binding) = NULL_TREE;
4412           INHERITED_VALUE_BINDING_P (binding) = 0;
4413         }
4414       else
4415         old_decl = BINDING_VALUE (binding);
4416
4417       /* Find the previous binding of name on the class-shadowed
4418          list, and update it.  */
4419       for (shadow = class_binding_level->class_shadowed;
4420            shadow;
4421            shadow = TREE_CHAIN (shadow))
4422         if (TREE_PURPOSE (shadow) == name
4423             && TREE_TYPE (shadow) == old_decl)
4424           {
4425             BINDING_VALUE (binding) = x;
4426             INHERITED_VALUE_BINDING_P (binding) = 0;
4427             TREE_TYPE (shadow) = x;
4428             IDENTIFIER_CLASS_VALUE (name) = x;
4429             return;
4430           }
4431     }
4432
4433   /* If we didn't replace an existing binding, put the binding on the
4434      stack of bindings for the identifier, and update the shadowed list.  */
4435   if (push_class_binding (name, x))
4436     {
4437       class_binding_level->class_shadowed
4438         = tree_cons (name, NULL,
4439                      class_binding_level->class_shadowed);
4440       /* Record the value we are binding NAME to so that we can know
4441          what to pop later.  */
4442       TREE_TYPE (class_binding_level->class_shadowed) = x;
4443     }
4444 }
4445
4446 /* Insert another USING_DECL into the current binding level, returning
4447    this declaration. If this is a redeclaration, do nothing, and
4448    return NULL_TREE if this not in namespace scope (in namespace
4449    scope, a using decl might extend any previous bindings).  */
4450
4451 tree
4452 push_using_decl (scope, name)
4453      tree scope;
4454      tree name;
4455 {
4456   tree decl;
4457
4458   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4459   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4460   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4461     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4462       break;
4463   if (decl)
4464     return namespace_bindings_p () ? decl : NULL_TREE;
4465   decl = build_lang_decl (USING_DECL, name, void_type_node);
4466   DECL_INITIAL (decl) = scope;
4467   TREE_CHAIN (decl) = current_binding_level->usings;
4468   current_binding_level->usings = decl;
4469   return decl;
4470 }
4471
4472 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4473    changed (i.e. there was already a directive), or the fresh
4474    TREE_LIST otherwise.  */
4475
4476 tree
4477 push_using_directive (used)
4478      tree used;
4479 {
4480   tree ud = current_binding_level->using_directives;
4481   tree iter, ancestor;
4482
4483   /* Check if we already have this. */
4484   if (purpose_member (used, ud) != NULL_TREE)
4485     return NULL_TREE;
4486
4487   /* Recursively add all namespaces used. */
4488   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4489     push_using_directive (TREE_PURPOSE (iter));
4490
4491   ancestor = namespace_ancestor (current_decl_namespace (), used);
4492   ud = current_binding_level->using_directives;
4493   ud = tree_cons (used, ancestor, ud);
4494   current_binding_level->using_directives = ud;
4495   return ud;
4496 }
4497
4498 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4499    other definitions already in place.  We get around this by making
4500    the value of the identifier point to a list of all the things that
4501    want to be referenced by that name.  It is then up to the users of
4502    that name to decide what to do with that list.
4503
4504    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4505    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4506
4507    FLAGS is a bitwise-or of the following values:
4508      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4509                  namespace scope.
4510      PUSH_USING: DECL is being pushed as the result of a using
4511                  declaration.
4512
4513    The value returned may be a previous declaration if we guessed wrong
4514    about what language DECL should belong to (C or C++).  Otherwise,
4515    it's always DECL (and never something that's not a _DECL).  */
4516
4517 tree
4518 push_overloaded_decl (decl, flags)
4519      tree decl;
4520      int flags;
4521 {
4522   tree name = DECL_NAME (decl);
4523   tree old;
4524   tree new_binding;
4525   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4526
4527   if (doing_global)
4528     old = namespace_binding (name, DECL_CONTEXT (decl));
4529   else
4530     old = lookup_name_current_level (name);
4531
4532   if (old)
4533     {
4534       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4535         {
4536           tree t = TREE_TYPE (old);
4537           if (IS_AGGR_TYPE (t) && warn_shadow
4538               && (! DECL_IN_SYSTEM_HEADER (decl)
4539                   || ! DECL_IN_SYSTEM_HEADER (old)))
4540             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4541           old = NULL_TREE;
4542         }
4543       else if (is_overloaded_fn (old))
4544         {
4545           tree tmp;
4546
4547           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4548             {
4549               tree fn = OVL_CURRENT (tmp);
4550
4551               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4552                   && !(flags & PUSH_USING)
4553                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4554                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4555                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4556                           decl, fn);
4557
4558               if (duplicate_decls (decl, fn))
4559                 return fn;
4560             }
4561         }
4562       else if (old == error_mark_node)
4563         /* Ignore the undefined symbol marker.  */
4564         old = NULL_TREE;
4565       else
4566         {
4567           cp_error_at ("previous non-function declaration `%#D'", old);
4568           cp_error ("conflicts with function declaration `%#D'", decl);
4569           return decl;
4570         }
4571     }
4572
4573   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4574     {
4575       if (old && TREE_CODE (old) != OVERLOAD)
4576         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4577       else
4578         new_binding = ovl_cons (decl, old);
4579       if (flags & PUSH_USING)
4580         OVL_USED (new_binding) = 1;
4581     }
4582   else
4583     /* NAME is not ambiguous.  */
4584     new_binding = decl;
4585
4586   if (doing_global)
4587     set_namespace_binding (name, current_namespace, new_binding);
4588   else
4589     {
4590       /* We only create an OVERLOAD if there was a previous binding at
4591          this level, or if decl is a template. In the former case, we
4592          need to remove the old binding and replace it with the new
4593          binding.  We must also run through the NAMES on the binding
4594          level where the name was bound to update the chain.  */
4595
4596       if (TREE_CODE (new_binding) == OVERLOAD && old)
4597         {
4598           tree *d;
4599
4600           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4601                *d;
4602                d = &TREE_CHAIN (*d))
4603             if (*d == old
4604                 || (TREE_CODE (*d) == TREE_LIST
4605                     && TREE_VALUE (*d) == old))
4606               {
4607                 if (TREE_CODE (*d) == TREE_LIST)
4608                   /* Just replace the old binding with the new.  */
4609                   TREE_VALUE (*d) = new_binding;
4610                 else
4611                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4612                   *d = tree_cons (NULL_TREE, new_binding,
4613                                   TREE_CHAIN (*d));
4614
4615                 /* And update the CPLUS_BINDING node.  */
4616                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4617                   = new_binding;
4618                 return decl;
4619               }
4620
4621           /* We should always find a previous binding in this case.  */
4622           my_friendly_abort (0);
4623         }
4624
4625       /* Install the new binding.  */
4626       push_local_binding (name, new_binding, flags);
4627     }
4628
4629   return decl;
4630 }
4631 \f
4632 /* Generate an implicit declaration for identifier FUNCTIONID
4633    as a function of type int ().  Print a warning if appropriate.  */
4634
4635 tree
4636 implicitly_declare (functionid)
4637      tree functionid;
4638 {
4639   register tree decl;
4640
4641   /* We used to reuse an old implicit decl here,
4642      but this loses with inline functions because it can clobber
4643      the saved decl chains.  */
4644   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4645
4646   DECL_EXTERNAL (decl) = 1;
4647   TREE_PUBLIC (decl) = 1;
4648
4649   /* ISO standard says implicit declarations are in the innermost block.
4650      So we record the decl in the standard fashion.  */
4651   pushdecl (decl);
4652   rest_of_decl_compilation (decl, NULL, 0, 0);
4653
4654   if (warn_implicit
4655       /* Only one warning per identifier.  */
4656       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4657     {
4658       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4659     }
4660
4661   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4662
4663   return decl;
4664 }
4665
4666 /* Return zero if the declaration NEWDECL is valid
4667    when the declaration OLDDECL (assumed to be for the same name)
4668    has already been seen.
4669    Otherwise return an error message format string with a %s
4670    where the identifier should go.  */
4671
4672 static const char *
4673 redeclaration_error_message (newdecl, olddecl)
4674      tree newdecl, olddecl;
4675 {
4676   if (TREE_CODE (newdecl) == TYPE_DECL)
4677     {
4678       /* Because C++ can put things into name space for free,
4679          constructs like "typedef struct foo { ... } foo"
4680          would look like an erroneous redeclaration.  */
4681       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4682         return 0;
4683       else
4684         return "redefinition of `%#D'";
4685     }
4686   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4687     {
4688       /* If this is a pure function, its olddecl will actually be
4689          the original initialization to `0' (which we force to call
4690          abort()).  Don't complain about redefinition in this case.  */
4691       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4692         return 0;
4693
4694       /* If both functions come from different namespaces, this is not
4695          a redeclaration - this is a conflict with a used function. */
4696       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4697           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4698         return "`%D' conflicts with used function";
4699
4700       /* We'll complain about linkage mismatches in
4701          warn_extern_redeclared_static.  */
4702
4703       /* Defining the same name twice is no good.  */
4704       if (DECL_INITIAL (olddecl) != NULL_TREE
4705           && DECL_INITIAL (newdecl) != NULL_TREE)
4706         {
4707           if (DECL_NAME (olddecl) == NULL_TREE)
4708             return "`%#D' not declared in class";
4709           else
4710             return "redefinition of `%#D'";
4711         }
4712       return 0;
4713     }
4714   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4715     {
4716       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4717            && (DECL_TEMPLATE_RESULT (newdecl)
4718                != DECL_TEMPLATE_RESULT (olddecl))
4719            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4720            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4721           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4722               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4723               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4724         return "redefinition of `%#D'";
4725       return 0;
4726     }
4727   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4728     {
4729       /* Objects declared at top level:  */
4730       /* If at least one is a reference, it's ok.  */
4731       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4732         return 0;
4733       /* Reject two definitions.  */
4734       return "redefinition of `%#D'";
4735     }
4736   else
4737     {
4738       /* Objects declared with block scope:  */
4739       /* Reject two definitions, and reject a definition
4740          together with an external reference.  */
4741       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4742         return "redeclaration of `%#D'";
4743       return 0;
4744     }
4745 }
4746 \f
4747 /* Create a new label, named ID.  */
4748
4749 static tree
4750 make_label_decl (id, local_p)
4751      tree id;
4752      int local_p;
4753 {
4754   tree decl;
4755
4756   decl = build_decl (LABEL_DECL, id, void_type_node);
4757   if (expanding_p)
4758     /* Make sure every label has an rtx.  */
4759     label_rtx (decl);
4760
4761   DECL_CONTEXT (decl) = current_function_decl;
4762   DECL_MODE (decl) = VOIDmode;
4763   C_DECLARED_LABEL_FLAG (decl) = local_p;
4764
4765   /* Say where one reference is to the label, for the sake of the
4766      error if it is not defined.  */
4767   DECL_SOURCE_LINE (decl) = lineno;
4768   DECL_SOURCE_FILE (decl) = input_filename;
4769
4770   /* Record the fact that this identifier is bound to this label.  */
4771   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4772
4773   return decl;
4774 }
4775
4776 /* Record this label on the list of used labels so that we can check
4777    at the end of the function to see whether or not the label was
4778    actually defined, and so we can check when the label is defined whether
4779    this use is valid.  */
4780
4781 static void
4782 use_label (decl)
4783      tree decl;
4784 {
4785   if (named_label_uses == NULL
4786       || named_label_uses->names_in_scope != current_binding_level->names
4787       || named_label_uses->label_decl != decl)
4788     {
4789       struct named_label_use_list *new_ent;
4790       new_ent = ((struct named_label_use_list *)
4791                  ggc_alloc (sizeof (struct named_label_use_list)));
4792       new_ent->label_decl = decl;
4793       new_ent->names_in_scope = current_binding_level->names;
4794       new_ent->binding_level = current_binding_level;
4795       new_ent->lineno_o_goto = lineno;
4796       new_ent->filename_o_goto = input_filename;
4797       new_ent->next = named_label_uses;
4798       named_label_uses = new_ent;
4799     }
4800 }
4801
4802 /* Look for a label named ID in the current function.  If one cannot
4803    be found, create one.  (We keep track of used, but undefined,
4804    labels, and complain about them at the end of a function.)  */
4805
4806 tree
4807 lookup_label (id)
4808      tree id;
4809 {
4810   tree decl;
4811   struct named_label_list *ent;
4812
4813   /* You can't use labels at global scope.  */
4814   if (current_function_decl == NULL_TREE)
4815     {
4816       error ("label `%s' referenced outside of any function",
4817              IDENTIFIER_POINTER (id));
4818       return NULL_TREE;
4819     }
4820
4821   /* See if we've already got this label.  */
4822   decl = IDENTIFIER_LABEL_VALUE (id);
4823   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4824     return decl;
4825
4826   /* Record this label on the list of labels used in this function.
4827      We do this before calling make_label_decl so that we get the
4828      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4829   ent = ((struct named_label_list *)
4830          ggc_alloc_cleared (sizeof (struct named_label_list)));
4831   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4832   ent->next = named_labels;
4833   named_labels = ent;
4834
4835   /* We need a new label.  */
4836   decl = make_label_decl (id, /*local_p=*/0);
4837
4838   /* Now fill in the information we didn't have before.  */
4839   ent->label_decl = decl;
4840
4841   return decl;
4842 }
4843
4844 /* Declare a local label named ID.  */
4845
4846 tree
4847 declare_local_label (id)
4848      tree id;
4849 {
4850   tree decl;
4851
4852   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4853      this scope we can restore the old value of
4854      IDENTIFIER_TYPE_VALUE.  */
4855   current_binding_level->shadowed_labels
4856     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4857                  current_binding_level->shadowed_labels);
4858   /* Look for the label.  */
4859   decl = make_label_decl (id, /*local_p=*/1);
4860   /* Now fill in the information we didn't have before.  */
4861   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4862
4863   return decl;
4864 }
4865
4866 /* Returns nonzero if it is ill-formed to jump past the declaration of
4867    DECL.  Returns 2 if it's also a real problem.  */
4868
4869 static int
4870 decl_jump_unsafe (decl)
4871      tree decl;
4872 {
4873   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4874     return 0;
4875
4876   if (DECL_INITIAL (decl) == NULL_TREE
4877       && pod_type_p (TREE_TYPE (decl)))
4878     return 0;
4879
4880   /* This is really only important if we're crossing an initialization.
4881      The POD stuff is just pedantry; why should it matter if the class
4882      contains a field of pointer to member type?  */
4883   if (DECL_INITIAL (decl)
4884       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4885     return 2;
4886   return 1;
4887 }
4888
4889 /* Check that a single previously seen jump to a newly defined label
4890    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4891    the jump context; NAMES are the names in scope in LEVEL at the jump
4892    context; FILE and LINE are the source position of the jump or 0.  */
4893
4894 static void
4895 check_previous_goto_1 (decl, level, names, file, line)
4896      tree decl;
4897      struct binding_level *level;
4898      tree names;
4899      const char *file;
4900      int line;
4901 {
4902   int identified = 0;
4903   int saw_eh = 0;
4904   struct binding_level *b = current_binding_level;
4905   for (; b; b = b->level_chain)
4906     {
4907       tree new_decls = b->names;
4908       tree old_decls = (b == level ? names : NULL_TREE);
4909       for (; new_decls != old_decls;
4910            new_decls = TREE_CHAIN (new_decls))
4911         {
4912           int problem = decl_jump_unsafe (new_decls);
4913           if (! problem)
4914             continue;
4915
4916           if (! identified)
4917             {
4918               if (decl)
4919                 cp_pedwarn ("jump to label `%D'", decl);
4920               else
4921                 pedwarn ("jump to case label");
4922
4923               if (file)
4924                 pedwarn_with_file_and_line (file, line, "  from here");
4925               identified = 1;
4926             }
4927
4928           if (problem > 1)
4929             cp_error_at ("  crosses initialization of `%#D'",
4930                          new_decls);
4931           else
4932             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4933                            new_decls);
4934         }
4935
4936       if (b == level)
4937         break;
4938       if ((b->is_try_scope || b->is_catch_scope) && ! saw_eh)
4939         {
4940           if (! identified)
4941             {
4942               if (decl)
4943                 cp_pedwarn ("jump to label `%D'", decl);
4944               else
4945                 pedwarn ("jump to case label");
4946
4947               if (file)
4948                 pedwarn_with_file_and_line (file, line, "  from here");
4949               identified = 1;
4950             }
4951           if (b->is_try_scope)
4952             error ("  enters try block");
4953           else
4954             error ("  enters catch block");
4955           saw_eh = 1;
4956         }
4957     }
4958 }
4959
4960 static void
4961 check_previous_goto (use)
4962      struct named_label_use_list *use;
4963 {
4964   check_previous_goto_1 (use->label_decl, use->binding_level,
4965                          use->names_in_scope, use->filename_o_goto,
4966                          use->lineno_o_goto);
4967 }
4968
4969 static void
4970 check_switch_goto (level)
4971      struct binding_level *level;
4972 {
4973   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
4974 }
4975
4976 /* Check that any previously seen jumps to a newly defined label DECL
4977    are OK.  Called by define_label.  */
4978
4979 static void
4980 check_previous_gotos (decl)
4981      tree decl;
4982 {
4983   struct named_label_use_list **usep;
4984
4985   if (! TREE_USED (decl))
4986     return;
4987
4988   for (usep = &named_label_uses; *usep; )
4989     {
4990       struct named_label_use_list *use = *usep;
4991       if (use->label_decl == decl)
4992         {
4993           check_previous_goto (use);
4994           *usep = use->next;
4995         }
4996       else
4997         usep = &(use->next);
4998     }
4999 }
5000
5001 /* Check that a new jump to a label DECL is OK.  Called by
5002    finish_goto_stmt.  */
5003
5004 void
5005 check_goto (decl)
5006      tree decl;
5007 {
5008   int identified = 0;
5009   tree bad;
5010   struct named_label_list *lab;
5011
5012   /* We can't know where a computed goto is jumping.  So we assume
5013      that it's OK.  */
5014   if (! DECL_P (decl))
5015     return;
5016
5017   /* If the label hasn't been defined yet, defer checking.  */
5018   if (! DECL_INITIAL (decl))
5019     {
5020       use_label (decl);
5021       return;
5022     }
5023
5024   for (lab = named_labels; lab; lab = lab->next)
5025     if (decl == lab->label_decl)
5026       break;
5027
5028   /* If the label is not on named_labels it's a gcc local label, so
5029      it must be in an outer scope, so jumping to it is always OK.  */
5030   if (lab == 0)
5031     return;
5032
5033   if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
5034       && !identified)
5035     {
5036       cp_pedwarn_at ("jump to label `%D'", decl);
5037       pedwarn ("  from here");
5038       identified = 1;
5039     }
5040
5041   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5042     {
5043       tree b = TREE_VALUE (bad);
5044       int u = decl_jump_unsafe (b);
5045
5046       if (u > 1 && DECL_ARTIFICIAL (b))
5047         /* Can't skip init of __exception_info.  */
5048         cp_error_at ("  enters catch block", b);
5049       else if (u > 1)
5050         cp_error_at ("  skips initialization of `%#D'", b);
5051       else
5052         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5053     }
5054
5055   if (lab->in_try_scope)
5056     error ("  enters try block");
5057   else if (lab->in_catch_scope)
5058     error ("  enters catch block");
5059 }
5060
5061 /* Define a label, specifying the location in the source file.
5062    Return the LABEL_DECL node for the label, if the definition is valid.
5063    Otherwise return 0.  */
5064
5065 tree
5066 define_label (filename, line, name)
5067      const char *filename;
5068      int line;
5069      tree name;
5070 {
5071   tree decl = lookup_label (name);
5072   struct named_label_list *ent;
5073   register struct binding_level *p;
5074
5075   for (ent = named_labels; ent; ent = ent->next)
5076     if (ent->label_decl == decl)
5077       break;
5078
5079   /* After labels, make any new cleanups in the function go into their
5080      own new (temporary) binding contour.  */
5081   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5082     p->more_cleanups_ok = 0;
5083
5084   if (name == get_identifier ("wchar_t"))
5085     cp_pedwarn ("label named wchar_t");
5086
5087   if (DECL_INITIAL (decl) != NULL_TREE)
5088     {
5089       cp_error ("duplicate label `%D'", decl);
5090       return 0;
5091     }
5092   else
5093     {
5094       /* Mark label as having been defined.  */
5095       DECL_INITIAL (decl) = error_mark_node;
5096       /* Say where in the source.  */
5097       DECL_SOURCE_FILE (decl) = filename;
5098       DECL_SOURCE_LINE (decl) = line;
5099       if (ent)
5100         {
5101           ent->names_in_scope = current_binding_level->names;
5102           ent->binding_level = current_binding_level;
5103         }
5104       check_previous_gotos (decl);
5105       return decl;
5106     }
5107 }
5108
5109 struct cp_switch
5110 {
5111   struct binding_level *level;
5112   struct cp_switch *next;
5113   /* The SWITCH_STMT being built.  */
5114   tree switch_stmt;
5115   /* A splay-tree mapping the low element of a case range to the high
5116      element, or NULL_TREE if there is no high element.  Used to
5117      determine whether or not a new case label duplicates an old case
5118      label.  We need a tree, rather than simply a hash table, because
5119      of the GNU case range extension.  */
5120   splay_tree cases;
5121 };
5122
5123 /* A stack of the currently active switch statements.  The innermost
5124    switch statement is on the top of the stack.  There is no need to
5125    mark the stack for garbage collection because it is only active
5126    during the processing of the body of a function, and we never
5127    collect at that point.  */
5128
5129 static struct cp_switch *switch_stack;
5130
5131 /* Called right after a switch-statement condition is parsed.
5132    SWITCH_STMT is the switch statement being parsed.  */
5133
5134 void
5135 push_switch (switch_stmt)
5136      tree switch_stmt;
5137 {
5138   struct cp_switch *p
5139     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5140   p->level = current_binding_level;
5141   p->next = switch_stack;
5142   p->switch_stmt = switch_stmt;
5143   p->cases = splay_tree_new (case_compare, NULL, NULL);
5144   switch_stack = p;
5145 }
5146
5147 void
5148 pop_switch ()
5149 {
5150   struct cp_switch *cs;
5151
5152   cs = switch_stack;
5153   splay_tree_delete (cs->cases);
5154   switch_stack = switch_stack->next;
5155   free (cs);
5156 }
5157
5158 /* Note that we've seen a definition of a case label, and complain if this
5159    is a bad place for one.  */
5160
5161 tree
5162 finish_case_label (low_value, high_value)
5163      tree low_value;
5164      tree high_value;
5165 {
5166   tree cond, r;
5167   register struct binding_level *p;
5168
5169   if (! switch_stack)
5170     {
5171       if (high_value)
5172         error ("case label not within a switch statement");
5173       else if (low_value)
5174         cp_error ("case label `%E' not within a switch statement",
5175                   low_value);
5176       else
5177         error ("`default' label not within a switch statement");
5178       return NULL_TREE;
5179     }
5180
5181   if (processing_template_decl)
5182     {
5183       tree label;
5184
5185       /* For templates, just add the case label; we'll do semantic
5186          analysis at instantiation-time.  */
5187       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5188       return add_stmt (build_case_label (low_value, high_value, label));
5189     }
5190
5191   /* Find the condition on which this switch statement depends.  */
5192   cond = SWITCH_COND (switch_stack->switch_stmt);
5193   if (cond && TREE_CODE (cond) == TREE_LIST)
5194     cond = TREE_VALUE (cond);
5195
5196   r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5197   if (r == error_mark_node)
5198     r = NULL_TREE;
5199
5200   check_switch_goto (switch_stack->level);
5201
5202   /* After labels, make any new cleanups in the function go into their
5203      own new (temporary) binding contour.  */
5204   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5205     p->more_cleanups_ok = 0;
5206
5207   return r;
5208 }
5209 \f
5210 /* Return the list of declarations of the current level.
5211    Note that this list is in reverse order unless/until
5212    you nreverse it; and when you do nreverse it, you must
5213    store the result back using `storedecls' or you will lose.  */
5214
5215 tree
5216 getdecls ()
5217 {
5218   return current_binding_level->names;
5219 }
5220
5221 /* Return the list of type-tags (for structs, etc) of the current level.  */
5222
5223 tree
5224 gettags ()
5225 {
5226   return current_binding_level->tags;
5227 }
5228
5229 /* Store the list of declarations of the current level.
5230    This is done for the parameter declarations of a function being defined,
5231    after they are modified in the light of any missing parameters.  */
5232
5233 static void
5234 storedecls (decls)
5235      tree decls;
5236 {
5237   current_binding_level->names = decls;
5238 }
5239
5240 /* Similarly, store the list of tags of the current level.  */
5241
5242 void
5243 storetags (tags)
5244      tree tags;
5245 {
5246   current_binding_level->tags = tags;
5247 }
5248 \f
5249 /* Given NAME, an IDENTIFIER_NODE,
5250    return the structure (or union or enum) definition for that name.
5251    Searches binding levels from BINDING_LEVEL up to the global level.
5252    If THISLEVEL_ONLY is nonzero, searches only the specified context
5253    (but skips any tag-transparent contexts to find one that is
5254    meaningful for tags).
5255    FORM says which kind of type the caller wants;
5256    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5257    If the wrong kind of type is found, and it's not a template, an error is
5258    reported.  */
5259
5260 static tree
5261 lookup_tag (form, name, binding_level, thislevel_only)
5262      enum tree_code form;
5263      tree name;
5264      struct binding_level *binding_level;
5265      int thislevel_only;
5266 {
5267   register struct binding_level *level;
5268   /* Non-zero if, we should look past a template parameter level, even
5269      if THISLEVEL_ONLY.  */
5270   int allow_template_parms_p = 1;
5271
5272   for (level = binding_level; level; level = level->level_chain)
5273     {
5274       register tree tail;
5275       if (ANON_AGGRNAME_P (name))
5276         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5277           {
5278             /* There's no need for error checking here, because
5279                anon names are unique throughout the compilation.  */
5280             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5281               return TREE_VALUE (tail);
5282           }
5283       else if (level->namespace_p)
5284         /* Do namespace lookup. */
5285         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5286           {
5287             tree old = binding_for_name (name, tail);
5288
5289             /* If we just skipped past a template parameter level,
5290                even though THISLEVEL_ONLY, and we find a template
5291                class declaration, then we use the _TYPE node for the
5292                template.  See the example below.  */
5293             if (thislevel_only && !allow_template_parms_p
5294                 && old && BINDING_VALUE (old)
5295                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5296               old = TREE_TYPE (BINDING_VALUE (old));
5297             else
5298               old = BINDING_TYPE (old);
5299
5300             /* If it has an original type, it is a typedef, and we
5301                should not return it.  */
5302             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5303               old = NULL_TREE;
5304             if (old && TREE_CODE (old) != form
5305                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5306               {
5307                 cp_error ("`%#D' redeclared as %C", old, form);
5308                 return NULL_TREE;
5309               }
5310             if (old)
5311               return old;
5312             if (thislevel_only || tail == global_namespace)
5313               return NULL_TREE;
5314           }
5315       else
5316         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5317           {
5318             if (TREE_PURPOSE (tail) == name)
5319               {
5320                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5321                 /* Should tighten this up; it'll probably permit
5322                    UNION_TYPE and a struct template, for example.  */
5323                 if (code != form
5324                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5325                   {
5326                     /* Definition isn't the kind we were looking for.  */
5327                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5328                               form);
5329                     return NULL_TREE;
5330                   }
5331                 return TREE_VALUE (tail);
5332               }
5333           }
5334       if (thislevel_only && ! level->tag_transparent)
5335         {
5336           if (level->template_parms_p && allow_template_parms_p)
5337             {
5338               /* We must deal with cases like this:
5339
5340                    template <class T> struct S;
5341                    template <class T> struct S {};
5342
5343                  When looking up `S', for the second declaration, we
5344                  would like to find the first declaration.  But, we
5345                  are in the pseudo-global level created for the
5346                  template parameters, rather than the (surrounding)
5347                  namespace level.  Thus, we keep going one more level,
5348                  even though THISLEVEL_ONLY is non-zero.  */
5349               allow_template_parms_p = 0;
5350               continue;
5351             }
5352           else
5353             return NULL_TREE;
5354         }
5355     }
5356   return NULL_TREE;
5357 }
5358
5359 #if 0
5360 void
5361 set_current_level_tags_transparency (tags_transparent)
5362      int tags_transparent;
5363 {
5364   current_binding_level->tag_transparent = tags_transparent;
5365 }
5366 #endif
5367
5368 /* Given a type, find the tag that was defined for it and return the tag name.
5369    Otherwise return 0.  However, the value can never be 0
5370    in the cases in which this is used.
5371
5372    C++: If NAME is non-zero, this is the new name to install.  This is
5373    done when replacing anonymous tags with real tag names.  */
5374
5375 static tree
5376 lookup_tag_reverse (type, name)
5377      tree type;
5378      tree name;
5379 {
5380   register struct binding_level *level;
5381
5382   for (level = current_binding_level; level; level = level->level_chain)
5383     {
5384       register tree tail;
5385       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5386         {
5387           if (TREE_VALUE (tail) == type)
5388             {
5389               if (name)
5390                 TREE_PURPOSE (tail) = name;
5391               return TREE_PURPOSE (tail);
5392             }
5393         }
5394     }
5395   return NULL_TREE;
5396 }
5397 \f
5398 /* Look up NAME in the NAMESPACE.  */
5399
5400 tree
5401 lookup_namespace_name (namespace, name)
5402      tree namespace, name;
5403 {
5404   tree val;
5405   tree template_id = NULL_TREE;
5406
5407   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5408
5409   if (TREE_CODE (name) == NAMESPACE_DECL)
5410     /* This happens for A::B<int> when B is a namespace. */
5411     return name;
5412   else if (TREE_CODE (name) == TEMPLATE_DECL)
5413     {
5414       /* This happens for A::B where B is a template, and there are no
5415          template arguments.  */
5416       cp_error ("invalid use of `%D'", name);
5417       return error_mark_node;
5418     }
5419
5420   namespace = ORIGINAL_NAMESPACE (namespace);
5421
5422   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5423     {
5424       template_id = name;
5425       name = TREE_OPERAND (name, 0);
5426       if (TREE_CODE (name) == OVERLOAD)
5427         name = DECL_NAME (OVL_CURRENT (name));
5428       else if (DECL_P (name))
5429         name = DECL_NAME (name);
5430     }
5431
5432   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5433
5434   val = make_node (CPLUS_BINDING);
5435   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5436     return error_mark_node;
5437
5438   if (BINDING_VALUE (val))
5439     {
5440       val = BINDING_VALUE (val);
5441
5442       if (template_id)
5443         {
5444           if (DECL_CLASS_TEMPLATE_P (val))
5445             val = lookup_template_class (val,
5446                                          TREE_OPERAND (template_id, 1),
5447                                          /*in_decl=*/NULL_TREE,
5448                                          /*context=*/NULL_TREE,
5449                                          /*entering_scope=*/0,
5450                                          /*complain=*/1);
5451           else if (DECL_FUNCTION_TEMPLATE_P (val)
5452                    || TREE_CODE (val) == OVERLOAD)
5453             val = lookup_template_function (val,
5454                                             TREE_OPERAND (template_id, 1));
5455           else
5456             {
5457               cp_error ("`%D::%D' is not a template",
5458                         namespace, name);
5459               return error_mark_node;
5460             }
5461         }
5462
5463       /* If we have a single function from a using decl, pull it out.  */
5464       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5465         val = OVL_FUNCTION (val);
5466       return val;
5467     }
5468
5469   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5470   return error_mark_node;
5471 }
5472
5473 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5474
5475 static unsigned long
5476 typename_hash (k)
5477      hash_table_key k;
5478 {
5479   unsigned long hash;
5480   tree t;
5481
5482   t = (tree) k;
5483   hash = (((unsigned long) TYPE_CONTEXT (t))
5484           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5485
5486   return hash;
5487 }
5488
5489 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5490
5491 static bool
5492 typename_compare (k1, k2)
5493      hash_table_key k1;
5494      hash_table_key k2;
5495 {
5496   tree t1;
5497   tree t2;
5498   tree d1;
5499   tree d2;
5500
5501   t1 = (tree) k1;
5502   t2 = (tree) k2;
5503   d1 = TYPE_NAME (t1);
5504   d2 = TYPE_NAME (t2);
5505
5506   return (DECL_NAME (d1) == DECL_NAME (d2)
5507           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5508           && ((TREE_TYPE (t1) != NULL_TREE)
5509               == (TREE_TYPE (t2) != NULL_TREE))
5510           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5511           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5512 }
5513
5514 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5515    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5516    is non-NULL, this type is being created by the implicit typename
5517    extension, and BASE_TYPE is a type named `t' in some base class of
5518    `T' which depends on template parameters.
5519
5520    Returns the new TYPENAME_TYPE.  */
5521
5522 tree
5523 build_typename_type (context, name, fullname, base_type)
5524      tree context;
5525      tree name;
5526      tree fullname;
5527      tree base_type;
5528 {
5529   tree t;
5530   tree d;
5531   struct hash_entry *e;
5532
5533   static struct hash_table ht;
5534
5535   if (!ht.table)
5536     {
5537       static struct hash_table *h = &ht;
5538
5539       hash_table_init (&ht, &hash_newfunc, &typename_hash, &typename_compare);
5540       ggc_add_tree_hash_table_root (&h, 1);
5541     }
5542
5543   /* Build the TYPENAME_TYPE.  */
5544   t = make_aggr_type (TYPENAME_TYPE);
5545   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5546   TYPENAME_TYPE_FULLNAME (t) = fullname;
5547   TREE_TYPE (t) = base_type;
5548
5549   /* Build the corresponding TYPE_DECL.  */
5550   d = build_decl (TYPE_DECL, name, t);
5551   TYPE_NAME (TREE_TYPE (d)) = d;
5552   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5553   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5554   DECL_ARTIFICIAL (d) = 1;
5555
5556   /* See if we already have this type.  */
5557   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5558   if (e)
5559     t = (tree) e->key;
5560   else
5561     /* Insert the type into the table.  */
5562     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5563
5564   return t;
5565 }
5566
5567 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5568    unless an error occurs, in which case error_mark_node is returned.
5569    If COMPLAIN zero, don't complain about any errors that occur.  */
5570
5571 tree
5572 make_typename_type (context, name, complain)
5573      tree context, name;
5574      int complain;
5575 {
5576   tree fullname;
5577
5578   if (TYPE_P (name))
5579     {
5580       if (!(TYPE_LANG_SPECIFIC (name)
5581             && (CLASSTYPE_IS_TEMPLATE (name)
5582                 || CLASSTYPE_USE_TEMPLATE (name))))
5583         name = TYPE_IDENTIFIER (name);
5584       else
5585         /* Create a TEMPLATE_ID_EXPR for the type.  */
5586         name = build_nt (TEMPLATE_ID_EXPR,
5587                          CLASSTYPE_TI_TEMPLATE (name),
5588                          CLASSTYPE_TI_ARGS (name));
5589     }
5590   else if (TREE_CODE (name) == TYPE_DECL)
5591     name = DECL_NAME (name);
5592
5593   fullname = name;
5594
5595   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5596     {
5597       name = TREE_OPERAND (name, 0);
5598       if (TREE_CODE (name) == TEMPLATE_DECL)
5599         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5600     }
5601   if (TREE_CODE (name) != IDENTIFIER_NODE)
5602     my_friendly_abort (2000);
5603
5604   if (TREE_CODE (context) == NAMESPACE_DECL)
5605     {
5606       /* We can get here from typename_sub0 in the explicit_template_type
5607          expansion.  Just fail.  */
5608       if (complain)
5609         cp_error ("no class template named `%#T' in `%#T'",
5610                   name, context);
5611       return error_mark_node;
5612     }
5613
5614   if (! uses_template_parms (context)
5615       || currently_open_class (context))
5616     {
5617       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5618         {
5619           tree tmpl = NULL_TREE;
5620           if (IS_AGGR_TYPE (context))
5621             tmpl = lookup_field (context, name, 0, 0);
5622           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5623             {
5624               if (complain)
5625                 cp_error ("no class template named `%#T' in `%#T'",
5626                           name, context);
5627               return error_mark_node;
5628             }
5629
5630           return lookup_template_class (tmpl,
5631                                         TREE_OPERAND (fullname, 1),
5632                                         NULL_TREE, context,
5633                                         /*entering_scope=*/0,
5634                                         /*complain=*/1);
5635         }
5636       else
5637         {
5638           tree t;
5639
5640           if (!IS_AGGR_TYPE (context))
5641             {
5642               if (complain)
5643                 cp_error ("no type named `%#T' in `%#T'", name, context);
5644               return error_mark_node;
5645             }
5646
5647           t = lookup_field (context, name, 0, 1);
5648           if (t)
5649             return TREE_TYPE (t);
5650         }
5651     }
5652
5653   /* If the CONTEXT is not a template type, then either the field is
5654      there now or its never going to be.  */
5655   if (!uses_template_parms (context))
5656     {
5657       if (complain)
5658         cp_error ("no type named `%#T' in `%#T'", name, context);
5659       return error_mark_node;
5660     }
5661
5662
5663   return build_typename_type (context, name, fullname,  NULL_TREE);
5664 }
5665
5666 /* Select the right _DECL from multiple choices. */
5667
5668 static tree
5669 select_decl (binding, flags)
5670      tree binding;
5671      int flags;
5672 {
5673   tree val;
5674   val = BINDING_VALUE (binding);
5675
5676   /* When we implicitly declare some builtin entity, we mark it
5677      DECL_ANTICIPATED, so that we know to ignore it until it is
5678      really declared.  */
5679   if (val && DECL_P (val)
5680       && DECL_LANG_SPECIFIC (val)
5681       && DECL_ANTICIPATED (val))
5682     return NULL_TREE;
5683
5684   if (LOOKUP_NAMESPACES_ONLY (flags))
5685     {
5686       /* We are not interested in types. */
5687       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5688         return val;
5689       return NULL_TREE;
5690     }
5691
5692   /* If we could have a type and
5693      we have nothing or we need a type and have none.  */
5694   if (BINDING_TYPE (binding)
5695       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5696                    && TREE_CODE (val) != TYPE_DECL)))
5697     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5698   /* Don't return non-types if we really prefer types. */
5699   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5700            && (TREE_CODE (val) != TEMPLATE_DECL
5701                || !DECL_CLASS_TEMPLATE_P (val)))
5702     val = NULL_TREE;
5703
5704   return val;
5705 }
5706
5707 /* Unscoped lookup of a global: iterate over current namespaces,
5708    considering using-directives.  If SPACESP is non-NULL, store a list
5709    of the namespaces we've considered in it.  */
5710
5711 tree
5712 unqualified_namespace_lookup (name, flags, spacesp)
5713      tree name;
5714      int flags;
5715      tree *spacesp;
5716 {
5717   tree b = make_node (CPLUS_BINDING);
5718   tree initial = current_decl_namespace ();
5719   tree scope = initial;
5720   tree siter;
5721   struct binding_level *level;
5722   tree val = NULL_TREE;
5723
5724   if (spacesp)
5725     *spacesp = NULL_TREE;
5726
5727   for (; !val; scope = CP_DECL_CONTEXT (scope))
5728     {
5729       if (spacesp)
5730         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5731       val = binding_for_name (name, scope);
5732
5733       /* Initialize binding for this context. */
5734       BINDING_VALUE (b) = BINDING_VALUE (val);
5735       BINDING_TYPE (b) = BINDING_TYPE (val);
5736
5737       /* Add all _DECLs seen through local using-directives. */
5738       for (level = current_binding_level;
5739            !level->namespace_p;
5740            level = level->level_chain)
5741         if (!lookup_using_namespace (name, b, level->using_directives,
5742                                      scope, flags, spacesp))
5743           /* Give up because of error. */
5744           return error_mark_node;
5745
5746       /* Add all _DECLs seen through global using-directives. */
5747       /* XXX local and global using lists should work equally. */
5748       siter = initial;
5749       while (1)
5750         {
5751           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5752                                        scope, flags, spacesp))
5753             /* Give up because of error. */
5754             return error_mark_node;
5755           if (siter == scope) break;
5756           siter = CP_DECL_CONTEXT (siter);
5757         }
5758
5759       val = select_decl (b, flags);
5760       if (scope == global_namespace)
5761         break;
5762     }
5763   return val;
5764 }
5765
5766 /* Combine prefer_type and namespaces_only into flags.  */
5767
5768 static int
5769 lookup_flags (prefer_type, namespaces_only)
5770   int prefer_type, namespaces_only;
5771 {
5772   if (namespaces_only)
5773     return LOOKUP_PREFER_NAMESPACES;
5774   if (prefer_type > 1)
5775     return LOOKUP_PREFER_TYPES;
5776   if (prefer_type > 0)
5777     return LOOKUP_PREFER_BOTH;
5778   return 0;
5779 }
5780
5781 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5782    ignore it or not.  Subroutine of lookup_name_real.  */
5783
5784 static tree
5785 qualify_lookup (val, flags)
5786      tree val;
5787      int flags;
5788 {
5789   if (val == NULL_TREE)
5790     return val;
5791   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5792     return val;
5793   if ((flags & LOOKUP_PREFER_TYPES)
5794       && (TREE_CODE (val) == TYPE_DECL
5795           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5796               && DECL_CLASS_TEMPLATE_P (val))))
5797     return val;
5798   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5799     return NULL_TREE;
5800   return val;
5801 }
5802
5803 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5804    that.  */
5805
5806 static void
5807 warn_about_implicit_typename_lookup (typename, binding)
5808      tree typename;
5809      tree binding;
5810 {
5811   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5812   tree name = DECL_NAME (typename);
5813
5814   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5815          && CLASSTYPE_TEMPLATE_INFO (subtype)
5816          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5817       && ! (TREE_CODE (binding) == TYPE_DECL
5818             && same_type_p (TREE_TYPE (binding), subtype)))
5819     {
5820       cp_warning ("lookup of `%D' finds `%#D'",
5821                   name, binding);
5822       cp_warning ("  instead of `%D' from dependent base class",
5823                   typename);
5824       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5825                   constructor_name (current_class_type), name);
5826     }
5827 }
5828
5829 /* Look up NAME in the current binding level and its superiors in the
5830    namespace of variables, functions and typedefs.  Return a ..._DECL
5831    node of some kind representing its definition if there is only one
5832    such declaration, or return a TREE_LIST with all the overloaded
5833    definitions if there are many, or return 0 if it is undefined.
5834
5835    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5836    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5837    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5838    Otherwise we prefer non-TYPE_DECLs.
5839
5840    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5841    using IDENTIFIER_CLASS_VALUE.  */
5842
5843 static tree
5844 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5845      tree name;
5846      int prefer_type, nonclass, namespaces_only;
5847 {
5848   tree t;
5849   tree val = NULL_TREE;
5850   int yylex = 0;
5851   tree from_obj = NULL_TREE;
5852   int flags;
5853   int val_is_implicit_typename = 0;
5854
5855   /* Hack: copy flag set by parser, if set. */
5856   if (only_namespace_names)
5857     namespaces_only = 1;
5858
5859   if (prefer_type == -2)
5860     {
5861       extern int looking_for_typename;
5862       tree type = NULL_TREE;
5863
5864       yylex = 1;
5865       prefer_type = looking_for_typename;
5866
5867       flags = lookup_flags (prefer_type, namespaces_only);
5868       /* If the next thing is '<', class templates are types. */
5869       if (looking_for_template)
5870         flags |= LOOKUP_TEMPLATES_EXPECTED;
5871
5872       if (got_scope)
5873         type = got_scope;
5874       else if (got_object != error_mark_node)
5875         type = got_object;
5876
5877       if (type)
5878         {
5879           if (type == error_mark_node)
5880             return error_mark_node;
5881           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5882             type = TREE_TYPE (type);
5883
5884           if (TYPE_P (type))
5885             type = complete_type (type);
5886
5887           if (TREE_CODE (type) == VOID_TYPE)
5888             type = global_namespace;
5889           if (TREE_CODE (type) == NAMESPACE_DECL)
5890             {
5891               val = make_node (CPLUS_BINDING);
5892               flags |= LOOKUP_COMPLAIN;
5893               if (!qualified_lookup_using_namespace (name, type, val, flags))
5894                 return NULL_TREE;
5895               val = select_decl (val, flags);
5896             }
5897           else if (! IS_AGGR_TYPE (type)
5898                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5899                    || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
5900                    || TREE_CODE (type) == TYPENAME_TYPE)
5901             /* Someone else will give an error about this if needed.  */
5902             val = NULL_TREE;
5903           else if (type == current_class_type)
5904             val = IDENTIFIER_CLASS_VALUE (name);
5905           else
5906             {
5907               val = lookup_member (type, name, 0, prefer_type);
5908               type_access_control (type, val);
5909
5910               /* Restore the containing TYPENAME_TYPE if we looked
5911                  through it before.  */
5912               if (got_scope && got_scope != type
5913                   && val && TREE_CODE (val) == TYPE_DECL
5914                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
5915                 TYPE_CONTEXT (TREE_TYPE (val)) = got_scope;
5916             }
5917         }
5918       else
5919         val = NULL_TREE;
5920
5921       if (got_scope)
5922         goto done;
5923       else if (got_object && val)
5924         {
5925           from_obj = val;
5926           val = NULL_TREE;
5927         }
5928     }
5929   else
5930     {
5931       flags = lookup_flags (prefer_type, namespaces_only);
5932       /* If we're not parsing, we need to complain. */
5933       flags |= LOOKUP_COMPLAIN;
5934     }
5935
5936   /* First, look in non-namespace scopes.  */
5937
5938   if (current_class_type == NULL_TREE)
5939     nonclass = 1;
5940
5941   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5942     {
5943       tree binding;
5944
5945       if (!LOCAL_BINDING_P (t) && nonclass)
5946         /* We're not looking for class-scoped bindings, so keep going.  */
5947         continue;
5948
5949       /* If this is the kind of thing we're looking for, we're done.  */
5950       if (qualify_lookup (BINDING_VALUE (t), flags))
5951         binding = BINDING_VALUE (t);
5952       else if ((flags & LOOKUP_PREFER_TYPES)
5953                && qualify_lookup (BINDING_TYPE (t), flags))
5954         binding = BINDING_TYPE (t);
5955       else
5956         binding = NULL_TREE;
5957
5958       /* Handle access control on types from enclosing or base classes.  */
5959       if (binding && ! yylex
5960           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5961         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5962
5963       if (binding
5964           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5965         {
5966           if (val_is_implicit_typename && !yylex)
5967             warn_about_implicit_typename_lookup (val, binding);
5968           val = binding;
5969           val_is_implicit_typename
5970             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5971           if (!val_is_implicit_typename)
5972             break;
5973         }
5974     }
5975
5976   /* Now lookup in namespace scopes.  */
5977   if (!val || val_is_implicit_typename)
5978     {
5979       t = unqualified_namespace_lookup (name, flags, 0);
5980       if (t)
5981         {
5982           if (val_is_implicit_typename && !yylex)
5983             warn_about_implicit_typename_lookup (val, t);
5984           val = t;
5985         }
5986     }
5987
5988  done:
5989   if (val)
5990     {
5991       /* This should only warn about types used in qualified-ids.  */
5992       if (from_obj && from_obj != val)
5993         {
5994           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5995               && TREE_CODE (val) == TYPE_DECL
5996               && ! same_type_p (TREE_TYPE (from_obj), TREE_TYPE (val)))
5997             cp_pedwarn ("\
5998 lookup of `%D' in the scope of `%#T' (`%#D') \
5999 does not match lookup in the current scope (`%#D')",
6000                         name, got_object, from_obj, val);
6001
6002           /* We don't change val to from_obj if got_object depends on
6003              template parms because that breaks implicit typename for
6004              destructor calls.  */
6005           if (! uses_template_parms (got_object))
6006             val = from_obj;
6007         }
6008
6009       /* If we have a single function from a using decl, pull it out.  */
6010       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6011         val = OVL_FUNCTION (val);
6012     }
6013   else if (from_obj)
6014     val = from_obj;
6015
6016   return val;
6017 }
6018
6019 tree
6020 lookup_name_nonclass (name)
6021      tree name;
6022 {
6023   return lookup_name_real (name, 0, 1, 0);
6024 }
6025
6026 tree
6027 lookup_function_nonclass (name, args)
6028      tree name;
6029      tree args;
6030 {
6031   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6032 }
6033
6034 tree
6035 lookup_name_namespace_only (name)
6036      tree name;
6037 {
6038   /* type-or-namespace, nonclass, namespace_only */
6039   return lookup_name_real (name, 1, 1, 1);
6040 }
6041
6042 tree
6043 lookup_name (name, prefer_type)
6044      tree name;
6045      int prefer_type;
6046 {
6047   return lookup_name_real (name, prefer_type, 0, 0);
6048 }
6049
6050 /* Similar to `lookup_name' but look only in the innermost non-class
6051    binding level.  */
6052
6053 tree
6054 lookup_name_current_level (name)
6055      tree name;
6056 {
6057   struct binding_level *b;
6058   tree t = NULL_TREE;
6059
6060   b = current_binding_level;
6061   while (b->parm_flag == 2)
6062     b = b->level_chain;
6063
6064   if (b->namespace_p)
6065     {
6066       t = IDENTIFIER_NAMESPACE_VALUE (name);
6067
6068       /* extern "C" function() */
6069       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6070         t = TREE_VALUE (t);
6071     }
6072   else if (IDENTIFIER_BINDING (name)
6073            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6074     {
6075       while (1)
6076         {
6077           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6078             return IDENTIFIER_VALUE (name);
6079
6080           if (b->keep == 2)
6081             b = b->level_chain;
6082           else
6083             break;
6084         }
6085     }
6086
6087   return t;
6088 }
6089
6090 /* Like lookup_name_current_level, but for types.  */
6091
6092 tree
6093 lookup_type_current_level (name)
6094      tree name;
6095 {
6096   register tree t = NULL_TREE;
6097
6098   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6099
6100   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6101       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6102     {
6103       struct binding_level *b = current_binding_level;
6104       while (1)
6105         {
6106           if (purpose_member (name, b->type_shadowed))
6107             return REAL_IDENTIFIER_TYPE_VALUE (name);
6108           if (b->keep == 2)
6109             b = b->level_chain;
6110           else
6111             break;
6112         }
6113     }
6114
6115   return t;
6116 }
6117
6118 void
6119 begin_only_namespace_names ()
6120 {
6121   only_namespace_names = 1;
6122 }
6123
6124 void
6125 end_only_namespace_names ()
6126 {
6127   only_namespace_names = 0;
6128 }
6129 \f
6130 /* Push the declarations of builtin types into the namespace.
6131    RID_INDEX is the index of the builtin type
6132    in the array RID_POINTERS.  NAME is the name used when looking
6133    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6134
6135 void
6136 record_builtin_type (rid_index, name, type)
6137      enum rid rid_index;
6138      const char *name;
6139      tree type;
6140 {
6141   tree rname = NULL_TREE, tname = NULL_TREE;
6142   tree tdecl = NULL_TREE;
6143
6144   if ((int) rid_index < (int) RID_MAX)
6145     rname = ridpointers[(int) rid_index];
6146   if (name)
6147     tname = get_identifier (name);
6148
6149   TYPE_BUILT_IN (type) = 1;
6150
6151   if (tname)
6152     {
6153       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6154       set_identifier_type_value (tname, NULL_TREE);
6155       if ((int) rid_index < (int) RID_MAX)
6156         /* Built-in types live in the global namespace. */
6157         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6158     }
6159   if (rname != NULL_TREE)
6160     {
6161       if (tname != NULL_TREE)
6162         {
6163           set_identifier_type_value (rname, NULL_TREE);
6164           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6165         }
6166       else
6167         {
6168           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6169           set_identifier_type_value (rname, NULL_TREE);
6170         }
6171     }
6172 }
6173
6174 /* Record one of the standard Java types.
6175  * Declare it as having the given NAME.
6176  * If SIZE > 0, it is the size of one of the integral types;
6177  * otherwise it is the negative of the size of one of the other types.  */
6178
6179 static tree
6180 record_builtin_java_type (name, size)
6181      const char *name;
6182      int size;
6183 {
6184   tree type, decl;
6185   if (size > 0)
6186     type = make_signed_type (size);
6187   else if (size > -32)
6188     { /* "__java_char" or ""__java_boolean". */
6189       type = make_unsigned_type (-size);
6190       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6191     }
6192   else
6193     { /* "__java_float" or ""__java_double". */
6194       type = make_node (REAL_TYPE);
6195       TYPE_PRECISION (type) = - size;
6196       layout_type (type);
6197     }
6198   record_builtin_type (RID_MAX, name, type);
6199   decl = TYPE_NAME (type);
6200
6201   /* Suppress generate debug symbol entries for these types,
6202      since for normal C++ they are just clutter.
6203      However, push_lang_context undoes this if extern "Java" is seen. */
6204   DECL_IGNORED_P (decl) = 1;
6205
6206   TYPE_FOR_JAVA (type) = 1;
6207   return type;
6208 }
6209
6210 /* Push a type into the namespace so that the back-ends ignore it. */
6211
6212 static void
6213 record_unknown_type (type, name)
6214      tree type;
6215      const char *name;
6216 {
6217   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6218   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6219   DECL_IGNORED_P (decl) = 1;
6220   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6221   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6222   TYPE_ALIGN (type) = 1;
6223   TYPE_USER_ALIGN (type) = 0;
6224   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6225 }
6226
6227 /* An string for which we should create an IDENTIFIER_NODE at
6228    startup.  */
6229
6230 typedef struct predefined_identifier
6231 {
6232   /* The name of the identifier.  */
6233   const char *name;
6234   /* The place where the IDENTIFIER_NODE should be stored.  */
6235   tree *node;
6236   /* Non-zero if this is the name of a constructor or destructor.  */
6237   int ctor_or_dtor_p;
6238 } predefined_identifier;
6239
6240 /* Create all the predefined identifiers.  */
6241
6242 static void
6243 initialize_predefined_identifiers ()
6244 {
6245   struct predefined_identifier *pid;
6246
6247   /* A table of identifiers to create at startup.  */
6248   static predefined_identifier predefined_identifiers[] = {
6249     { "C++", &lang_name_cplusplus, 0 },
6250     { "C", &lang_name_c, 0 },
6251     { "Java", &lang_name_java, 0 },
6252     { CTOR_NAME, &ctor_identifier, 1 },
6253     { "__base_ctor", &base_ctor_identifier, 1 },
6254     { "__comp_ctor", &complete_ctor_identifier, 1 },
6255     { DTOR_NAME, &dtor_identifier, 1 },
6256     { "__comp_dtor", &complete_dtor_identifier, 1 },
6257     { "__base_dtor", &base_dtor_identifier, 1 },
6258     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6259     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6260     { "nelts", &nelts_identifier, 0 },
6261     { THIS_NAME, &this_identifier, 0 },
6262     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6263     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6264     { "_vptr", &vptr_identifier, 0 },
6265     { "__vtt_parm", &vtt_parm_identifier, 0 },
6266     { "std", &std_identifier, 0 },
6267     { NULL, NULL, 0 }
6268   };
6269
6270   for (pid = predefined_identifiers; pid->name; ++pid)
6271     {
6272       *pid->node = get_identifier (pid->name);
6273       if (pid->ctor_or_dtor_p)
6274         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6275     }
6276 }
6277
6278 /* Create the predefined scalar types of C,
6279    and some nodes representing standard constants (0, 1, (void *)0).
6280    Initialize the global binding level.
6281    Make definitions for built-in primitive functions.  */
6282
6283 void
6284 init_decl_processing ()
6285 {
6286   tree void_ftype;
6287   tree void_ftype_ptr;
6288
6289   /* Create all the identifiers we need.  */
6290   initialize_predefined_identifiers ();
6291
6292   /* Fill in back-end hooks.  */
6293   init_lang_status = &push_cp_function_context;
6294   free_lang_status = &pop_cp_function_context;
6295   mark_lang_status = &mark_cp_function_context;
6296   lang_safe_from_p = &c_safe_from_p;
6297   lang_dump_tree = &cp_dump_tree;
6298   lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
6299
6300   cp_parse_init ();
6301   init_decl2 ();
6302   init_pt ();
6303
6304   /* Create the global variables.  */
6305   push_to_top_level ();
6306
6307   /* Enter the global namespace. */
6308   my_friendly_assert (global_namespace == NULL_TREE, 375);
6309   push_namespace (get_identifier ("::"));
6310   global_namespace = current_namespace;
6311   current_lang_name = NULL_TREE;
6312
6313   /* Adjust various flags based on command-line settings.  */
6314   if (! flag_permissive && ! pedantic)
6315     flag_pedantic_errors = 1;
6316   if (!flag_no_inline)
6317     {
6318       flag_inline_trees = 1;
6319       flag_no_inline = 1;
6320     }
6321   if (flag_inline_functions)
6322     {
6323       flag_inline_trees = 2;
6324       flag_inline_functions = 0;
6325     }
6326
6327   /* In C++, we never create builtin functions whose name does not
6328      begin with `__'.  Users should be using headers to get prototypes
6329      in C++.  It would be nice if we could warn when `-fbuiltin' is
6330      used explicitly, but we do not have that information.  */
6331   flag_no_builtin = 1;
6332
6333   /* Initially, C.  */
6334   current_lang_name = lang_name_c;
6335
6336   current_function_decl = NULL_TREE;
6337   current_binding_level = NULL_BINDING_LEVEL;
6338   free_binding_level = NULL_BINDING_LEVEL;
6339
6340   build_common_tree_nodes (flag_signed_char);
6341
6342   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6343   TREE_TYPE (error_mark_list) = error_mark_node;
6344
6345   /* Make the binding_level structure for global names.  */
6346   pushlevel (0);
6347   global_binding_level = current_binding_level;
6348   /* The global level is the namespace level of ::.  */
6349   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6350   declare_namespace_level ();
6351
6352   /* Create the `std' namespace.  */
6353   push_namespace (std_identifier);
6354   std_node = current_namespace;
6355   pop_namespace ();
6356
6357   c_common_nodes_and_builtins ();
6358
6359   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6360   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6361   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6362   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6363   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6364   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6365   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6366   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6367
6368   integer_two_node = build_int_2 (2, 0);
6369   TREE_TYPE (integer_two_node) = integer_type_node;
6370   integer_three_node = build_int_2 (3, 0);
6371   TREE_TYPE (integer_three_node) = integer_type_node;
6372
6373   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6374   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6375   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6376   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6377   TYPE_PRECISION (boolean_type_node) = 1;
6378   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6379   boolean_false_node = build_int_2 (0, 0);
6380   TREE_TYPE (boolean_false_node) = boolean_type_node;
6381   boolean_true_node = build_int_2 (1, 0);
6382   TREE_TYPE (boolean_true_node) = boolean_type_node;
6383
6384   signed_size_zero_node = build_int_2 (0, 0);
6385   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6386
6387   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6388
6389 #if 0
6390   record_builtin_type (RID_MAX, NULL, string_type_node);
6391 #endif
6392
6393   delta_type_node = ptrdiff_type_node;
6394   vtable_index_type = ptrdiff_type_node;
6395
6396   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6397   lang_type_promotes_to = convert_type_from_ellipsis;
6398
6399   void_ftype = build_function_type (void_type_node, void_list_node);
6400   void_ftype_ptr = build_function_type (void_type_node,
6401                                         tree_cons (NULL_TREE,
6402                                                    ptr_type_node,
6403                                                    void_list_node));
6404   void_ftype_ptr
6405     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6406
6407   /* C++ extensions */
6408
6409   unknown_type_node = make_node (UNKNOWN_TYPE);
6410   record_unknown_type (unknown_type_node, "unknown type");
6411
6412   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6413   TREE_TYPE (unknown_type_node) = unknown_type_node;
6414
6415   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6416
6417   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6418      result.  */
6419   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6420   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6421
6422   {
6423     /* Make sure we get a unique function type, so we can give
6424        its pointer type a name.  (This wins for gdb.) */
6425     tree vfunc_type = make_node (FUNCTION_TYPE);
6426     TREE_TYPE (vfunc_type) = integer_type_node;
6427     TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6428     layout_type (vfunc_type);
6429
6430     vtable_entry_type = build_pointer_type (vfunc_type);
6431   }
6432   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6433
6434   vtbl_type_node
6435     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6436   layout_type (vtbl_type_node);
6437   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6438   record_builtin_type (RID_MAX, NULL, vtbl_type_node);
6439   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6440   layout_type (vtbl_ptr_type_node);
6441   record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
6442
6443   push_namespace (get_identifier ("__cxxabiv1"));
6444   abi_node = current_namespace;
6445   pop_namespace ();
6446
6447   global_type_node = make_node (LANG_TYPE);
6448   record_unknown_type (global_type_node, "global type");
6449
6450   /* Now, C++.  */
6451   current_lang_name = lang_name_cplusplus;
6452
6453   {
6454     tree bad_alloc_type_node, newtype, deltype;
6455     tree ptr_ftype_sizetype;
6456
6457     push_namespace (std_identifier);
6458     bad_alloc_type_node = xref_tag
6459       (class_type_node, get_identifier ("bad_alloc"), 1);
6460     pop_namespace ();
6461     ptr_ftype_sizetype
6462       = build_function_type (ptr_type_node,
6463                              tree_cons (NULL_TREE,
6464                                         c_size_type_node,
6465                                         void_list_node));
6466     newtype = build_exception_variant
6467       (ptr_ftype_sizetype, add_exception_specifier
6468        (NULL_TREE, bad_alloc_type_node, -1));
6469     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6470     push_cp_library_fn (NEW_EXPR, newtype);
6471     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6472     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6473     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6474   }
6475
6476   abort_fndecl
6477     = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
6478
6479   /* Perform other language dependent initializations.  */
6480   init_class_processing ();
6481   init_init_processing ();
6482   init_search_processing ();
6483   init_rtti_processing ();
6484
6485   if (flag_exceptions)
6486     init_exception_processing ();
6487
6488   if (! supports_one_only ())
6489     flag_weak = 0;
6490
6491   make_fname_decl = cp_make_fname_decl;
6492   start_fname_decls ();
6493
6494   /* Prepare to check format strings against argument lists.  */
6495   init_function_format_info ();
6496
6497   /* Show we use EH for cleanups.  */
6498   using_eh_for_cleanups ();
6499
6500   valid_lang_attribute = cp_valid_lang_attribute;
6501
6502   /* Maintain consistency.  Perhaps we should just complain if they
6503      say -fwritable-strings?  */
6504   if (flag_writable_strings)
6505     flag_const_strings = 0;
6506
6507   /* Add GC roots for all of our global variables.  */
6508   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6509   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6510   ggc_add_tree_root (&integer_three_node, 1);
6511   ggc_add_tree_root (&integer_two_node, 1);
6512   ggc_add_tree_root (&signed_size_zero_node, 1);
6513   ggc_add_tree_root (&size_one_node, 1);
6514   ggc_add_tree_root (&size_zero_node, 1);
6515   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6516                 mark_binding_level);
6517   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6518   ggc_add_tree_root (&static_ctors, 1);
6519   ggc_add_tree_root (&static_dtors, 1);
6520   ggc_add_tree_root (&lastiddecl, 1);
6521
6522   ggc_add_tree_root (&last_function_parms, 1);
6523   ggc_add_tree_root (&error_mark_list, 1);
6524
6525   ggc_add_tree_root (&global_namespace, 1);
6526   ggc_add_tree_root (&global_type_node, 1);
6527   ggc_add_tree_root (&anonymous_namespace_name, 1);
6528
6529   ggc_add_tree_root (&got_object, 1);
6530   ggc_add_tree_root (&got_scope, 1);
6531
6532   ggc_add_tree_root (&current_lang_name, 1);
6533   ggc_add_tree_root (&static_aggregates, 1);
6534   ggc_add_tree_root (&free_bindings, 1);
6535 }
6536
6537 /* Generate an initializer for a function naming variable from
6538    NAME. NAME may be NULL, in which case we generate a special
6539    ERROR_MARK node which should be replaced later. */
6540
6541 tree
6542 cp_fname_init (name)
6543      const char *name;
6544 {
6545   tree domain = NULL_TREE;
6546   tree type;
6547   tree init = NULL_TREE;
6548   size_t length = 0;
6549
6550   if (name)
6551     {
6552       length = strlen (name);
6553       domain = build_index_type (size_int (length));
6554       init = build_string (length + 1, name);
6555     }
6556
6557   type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
6558   type = build_cplus_array_type (type, domain);
6559
6560   if (init)
6561     TREE_TYPE (init) = type;
6562   else
6563     /* We don't know the value until instantiation time. Make
6564        something which will be digested now, but replaced later. */
6565     init = build (ERROR_MARK, type);
6566
6567   return init;
6568 }
6569
6570 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6571    decl, NAME is the initialization string and TYPE_DEP indicates whether
6572    NAME depended on the type of the function. We make use of that to detect
6573    __PRETTY_FUNCTION__ inside a template fn. This is being done
6574    lazily at the point of first use, so we musn't push the decl now.  */
6575
6576 static tree
6577 cp_make_fname_decl (id, type_dep)
6578      tree id;
6579      int type_dep;
6580 {
6581   const char *name = (type_dep && processing_template_decl
6582                       ? NULL : fname_as_string (type_dep));
6583   tree init = cp_fname_init (name);
6584   tree decl = build_decl (VAR_DECL, id, TREE_TYPE (init));
6585
6586   /* As we don't push the decl here, we must set the context. */
6587   DECL_CONTEXT (decl) = current_function_decl;
6588   DECL_PRETTY_FUNCTION_P (decl) = type_dep;
6589
6590   TREE_STATIC (decl) = 1;
6591   TREE_READONLY (decl) = 1;
6592   DECL_ARTIFICIAL (decl) = 1;
6593   DECL_INITIAL (decl) = init;
6594
6595   TREE_USED (decl) = 1;
6596
6597   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6598
6599   return decl;
6600 }
6601
6602 /* Entry point for the benefit of c_common_nodes_and_builtins.
6603
6604    Make a definition for a builtin function named NAME and whose data type
6605    is TYPE.  TYPE should be a function type with argument types.
6606
6607    CLASS and CODE tell later passes how to compile calls to this function.
6608    See tree.h for possible values.
6609
6610    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6611    the name to be called if we can't opencode the function.  */
6612
6613 tree
6614 builtin_function (name, type, code, class, libname)
6615      const char *name;
6616      tree type;
6617      int code;
6618      enum built_in_class class;
6619      const char *libname;
6620 {
6621   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6622   DECL_BUILT_IN_CLASS (decl) = class;
6623   DECL_FUNCTION_CODE (decl) = code;
6624
6625   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6626
6627   /* All builtins that don't begin with an `_' should go in the `std'
6628      namespace.  */
6629   if (name[0] != '_')
6630     {
6631       push_namespace (std_identifier);
6632       DECL_CONTEXT (decl) = std_node;
6633     }
6634   pushdecl (decl);
6635   if (name[0] != '_')
6636     pop_namespace ();
6637
6638   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6639      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6640      function in the namespace.  */
6641   if (libname)
6642     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
6643   make_decl_rtl (decl, NULL);
6644
6645   /* Warn if a function in the namespace for users
6646      is used without an occasion to consider it declared.  */
6647   if (name[0] != '_' || name[1] != '_')
6648     DECL_ANTICIPATED (decl) = 1;
6649
6650   return decl;
6651 }
6652
6653 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6654    function.  Not called directly.  */
6655
6656 static tree
6657 build_library_fn_1 (name, operator_code, type)
6658      tree name;
6659      enum tree_code operator_code;
6660      tree type;
6661 {
6662   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6663   DECL_EXTERNAL (fn) = 1;
6664   TREE_PUBLIC (fn) = 1;
6665   DECL_ARTIFICIAL (fn) = 1;
6666   TREE_NOTHROW (fn) = 1;
6667   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6668   SET_DECL_LANGUAGE (fn, lang_c);
6669   return fn;
6670 }
6671
6672 /* Returns the _DECL for a library function with C linkage.
6673    We assume that such functions never throw; if this is incorrect,
6674    callers should unset TREE_NOTHROW.  */
6675
6676 tree
6677 build_library_fn (name, type)
6678      tree name;
6679      tree type;
6680 {
6681   return build_library_fn_1 (name, ERROR_MARK, type);
6682 }
6683
6684 /* Returns the _DECL for a library function with C++ linkage.  */
6685
6686 static tree
6687 build_cp_library_fn (name, operator_code, type)
6688      tree name;
6689      enum tree_code operator_code;
6690      tree type;
6691 {
6692   tree fn = build_library_fn_1 (name, operator_code, type);
6693   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6694   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6695   SET_DECL_LANGUAGE (fn, lang_cplusplus);
6696   set_mangled_name_for_decl (fn);
6697   return fn;
6698 }
6699
6700 /* Like build_library_fn, but takes a C string instead of an
6701    IDENTIFIER_NODE.  */
6702
6703 tree
6704 build_library_fn_ptr (name, type)
6705      const char *name;
6706      tree type;
6707 {
6708   return build_library_fn (get_identifier (name), type);
6709 }
6710
6711 /* Like build_cp_library_fn, but takes a C string instead of an
6712    IDENTIFIER_NODE.  */
6713
6714 tree
6715 build_cp_library_fn_ptr (name, type)
6716      const char *name;
6717      tree type;
6718 {
6719   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6720 }
6721
6722 /* Like build_library_fn, but also pushes the function so that we will
6723    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6724
6725 tree
6726 push_library_fn (name, type)
6727      tree name, type;
6728 {
6729   tree fn = build_library_fn (name, type);
6730   pushdecl_top_level (fn);
6731   return fn;
6732 }
6733
6734 /* Like build_cp_library_fn, but also pushes the function so that it
6735    will be found by normal lookup.  */
6736
6737 static tree
6738 push_cp_library_fn (operator_code, type)
6739      enum tree_code operator_code;
6740      tree type;
6741 {
6742   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6743                                  operator_code,
6744                                  type);
6745   pushdecl (fn);
6746   return fn;
6747 }
6748
6749 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6750    a FUNCTION_TYPE.  */
6751
6752 tree
6753 push_void_library_fn (name, parmtypes)
6754      tree name, parmtypes;
6755 {
6756   tree type = build_function_type (void_type_node, parmtypes);
6757   return push_library_fn (name, type);
6758 }
6759
6760 /* Like push_library_fn, but also note that this function throws
6761    and does not return.  Used for __throw_foo and the like.  */
6762
6763 tree
6764 push_throw_library_fn (name, type)
6765      tree name, type;
6766 {
6767   tree fn = push_library_fn (name, type);
6768   TREE_THIS_VOLATILE (fn) = 1;
6769   TREE_NOTHROW (fn) = 0;
6770   return fn;
6771 }
6772 \f
6773 /* When we call finish_struct for an anonymous union, we create
6774    default copy constructors and such.  But, an anonymous union
6775    shouldn't have such things; this function undoes the damage to the
6776    anonymous union type T.
6777
6778    (The reason that we create the synthesized methods is that we don't
6779    distinguish `union { int i; }' from `typedef union { int i; } U'.
6780    The first is an anonymous union; the second is just an ordinary
6781    union type.)  */
6782
6783 void
6784 fixup_anonymous_aggr (t)
6785      tree t;
6786 {
6787   tree *q;
6788
6789   /* Wipe out memory of synthesized methods */
6790   TYPE_HAS_CONSTRUCTOR (t) = 0;
6791   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6792   TYPE_HAS_INIT_REF (t) = 0;
6793   TYPE_HAS_CONST_INIT_REF (t) = 0;
6794   TYPE_HAS_ASSIGN_REF (t) = 0;
6795   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6796
6797   /* Splice the implicitly generated functions out of the TYPE_METHODS
6798      list.  */
6799   q = &TYPE_METHODS (t);
6800   while (*q)
6801     {
6802       if (DECL_ARTIFICIAL (*q))
6803         *q = TREE_CHAIN (*q);
6804       else
6805         q = &TREE_CHAIN (*q);
6806     }
6807
6808   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6809   if (TYPE_METHODS (t))
6810     cp_error_at ("an anonymous union cannot have function members", t);
6811
6812   /* Anonymous aggregates cannot have fields with ctors, dtors or complex
6813      assignment operators (because they cannot have these methods themselves).
6814      For anonymous unions this is already checked because they are not allowed
6815      in any union, otherwise we have to check it.  */
6816   if (TREE_CODE (t) != UNION_TYPE)
6817     {
6818       tree field, type;
6819
6820       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
6821         if (TREE_CODE (field) == FIELD_DECL)
6822           {
6823             type = TREE_TYPE (field);
6824             if (CLASS_TYPE_P (type))
6825               {
6826                 if (TYPE_NEEDS_CONSTRUCTING (type))
6827                   cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
6828                                field);
6829                 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6830                   cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
6831                                field);
6832                 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
6833                   cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
6834                                field);
6835               }
6836           }
6837     }
6838 }
6839
6840 /* Make sure that a declaration with no declarator is well-formed, i.e.
6841    just defines a tagged type or anonymous union.
6842
6843    Returns the type defined, if any.  */
6844
6845 tree
6846 check_tag_decl (declspecs)
6847      tree declspecs;
6848 {
6849   int found_type = 0;
6850   int saw_friend = 0;
6851   int saw_typedef = 0;
6852   tree ob_modifier = NULL_TREE;
6853   register tree link;
6854   register tree t = NULL_TREE;
6855
6856   for (link = declspecs; link; link = TREE_CHAIN (link))
6857     {
6858       register tree value = TREE_VALUE (link);
6859
6860       if (TYPE_P (value)
6861           || TREE_CODE (value) == TYPE_DECL
6862           || (TREE_CODE (value) == IDENTIFIER_NODE
6863               && IDENTIFIER_GLOBAL_VALUE (value)
6864               && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value)) == TYPE_DECL))
6865         {
6866           ++found_type;
6867
6868           if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
6869             {
6870               if (! in_system_header)
6871                 cp_pedwarn ("redeclaration of C++ built-in type `%T'", value);
6872               return NULL_TREE;
6873             }
6874
6875           if (TYPE_P (value)
6876               && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
6877                   || TREE_CODE (value) == ENUMERAL_TYPE))
6878             {
6879               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6880               t = value;
6881             }
6882         }
6883       else if (value == ridpointers[(int) RID_TYPEDEF])
6884         saw_typedef = 1;
6885       else if (value == ridpointers[(int) RID_FRIEND])
6886         {
6887           if (current_class_type == NULL_TREE
6888               || current_scope () != current_class_type)
6889             ob_modifier = value;
6890           else
6891             saw_friend = 1;
6892         }
6893       else if (value == ridpointers[(int) RID_STATIC]
6894                || value == ridpointers[(int) RID_EXTERN]
6895                || value == ridpointers[(int) RID_AUTO]
6896                || value == ridpointers[(int) RID_REGISTER]
6897                || value == ridpointers[(int) RID_INLINE]
6898                || value == ridpointers[(int) RID_VIRTUAL]
6899                || value == ridpointers[(int) RID_CONST]
6900                || value == ridpointers[(int) RID_VOLATILE]
6901                || value == ridpointers[(int) RID_EXPLICIT])
6902         ob_modifier = value;
6903     }
6904
6905   if (found_type > 1)
6906     error ("multiple types in one declaration");
6907
6908   if (t == NULL_TREE && ! saw_friend)
6909     pedwarn ("declaration does not declare anything");
6910
6911   /* Check for an anonymous union.  */
6912   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
6913            && TYPE_ANONYMOUS_P (t))
6914     {
6915       /* 7/3 In a simple-declaration, the optional init-declarator-list
6916          can be omitted only when declaring a class (clause 9) or
6917          enumeration (7.2), that is, when the decl-specifier-seq contains
6918          either a class-specifier, an elaborated-type-specifier with
6919          a class-key (9.1), or an enum-specifier.  In these cases and
6920          whenever a class-specifier or enum-specifier is present in the
6921          decl-specifier-seq, the identifiers in these specifiers are among
6922          the names being declared by the declaration (as class-name,
6923          enum-names, or enumerators, depending on the syntax).  In such
6924          cases, and except for the declaration of an unnamed bit-field (9.6),
6925          the decl-specifier-seq shall introduce one or more names into the
6926          program, or shall redeclare a name introduced by a previous
6927          declaration.  [Example:
6928              enum { };            // ill-formed
6929              typedef class { };   // ill-formed
6930          --end example]  */
6931       if (saw_typedef)
6932         {
6933           error ("Missing type-name in typedef-declaration.");
6934           return NULL_TREE;
6935         }
6936       /* Anonymous unions are objects, so they can have specifiers.  */;
6937       SET_ANON_AGGR_TYPE_P (t);
6938
6939       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
6940         pedwarn ("ISO C++ prohibits anonymous structs");
6941     }
6942
6943   else if (ob_modifier)
6944     {
6945       if (ob_modifier == ridpointers[(int) RID_INLINE]
6946           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6947         cp_error ("`%D' can only be specified for functions", ob_modifier);
6948       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
6949         cp_error ("`%D' can only be specified inside a class", ob_modifier);
6950       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6951         cp_error ("`%D' can only be specified for constructors",
6952                   ob_modifier);
6953       else
6954         cp_error ("`%D' can only be specified for objects and functions",
6955                   ob_modifier);
6956     }
6957
6958   return t;
6959 }
6960
6961 /* Called when a declaration is seen that contains no names to declare.
6962    If its type is a reference to a structure, union or enum inherited
6963    from a containing scope, shadow that tag name for the current scope
6964    with a forward reference.
6965    If its type defines a new named structure or union
6966    or defines an enum, it is valid but we need not do anything here.
6967    Otherwise, it is an error.
6968
6969    C++: may have to grok the declspecs to learn about static,
6970    complain for anonymous unions.  */
6971
6972 void
6973 shadow_tag (declspecs)
6974      tree declspecs;
6975 {
6976   tree t = check_tag_decl (declspecs);
6977
6978   if (t)
6979     maybe_process_partial_specialization (t);
6980
6981   /* This is where the variables in an anonymous union are
6982      declared.  An anonymous union declaration looks like:
6983      union { ... } ;
6984      because there is no declarator after the union, the parser
6985      sends that declaration here.  */
6986   if (t && ANON_AGGR_TYPE_P (t))
6987     {
6988       fixup_anonymous_aggr (t);
6989
6990       if (TYPE_FIELDS (t))
6991         {
6992           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
6993                                       NULL_TREE);
6994           finish_anon_union (decl);
6995         }
6996     }
6997 }
6998 \f
6999 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7000
7001 tree
7002 groktypename (typename)
7003      tree typename;
7004 {
7005   if (TREE_CODE (typename) != TREE_LIST)
7006     return typename;
7007   return grokdeclarator (TREE_VALUE (typename),
7008                          TREE_PURPOSE (typename),
7009                          TYPENAME, 0, NULL_TREE);
7010 }
7011
7012 /* Decode a declarator in an ordinary declaration or data definition.
7013    This is called as soon as the type information and variable name
7014    have been parsed, before parsing the initializer if any.
7015    Here we create the ..._DECL node, fill in its type,
7016    and put it on the list of decls for the current context.
7017    The ..._DECL node is returned as the value.
7018
7019    Exception: for arrays where the length is not specified,
7020    the type is left null, to be filled in by `cp_finish_decl'.
7021
7022    Function definitions do not come here; they go to start_function
7023    instead.  However, external and forward declarations of functions
7024    do go through here.  Structure field declarations are done by
7025    grokfield and not through here.  */
7026
7027 tree
7028 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7029      tree declarator, declspecs;
7030      int initialized;
7031      tree attributes, prefix_attributes;
7032 {
7033   tree decl;
7034   register tree type, tem;
7035   tree context;
7036   extern int have_extern_spec;
7037   extern int used_extern_spec;
7038   tree attrlist;
7039
7040 #if 0
7041   /* See code below that used this.  */
7042   int init_written = initialized;
7043 #endif
7044
7045   /* This should only be done once on the top most decl.  */
7046   if (have_extern_spec && !used_extern_spec)
7047     {
7048       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7049                              declspecs);
7050       used_extern_spec = 1;
7051     }
7052
7053   if (attributes || prefix_attributes)
7054     attrlist = build_tree_list (attributes, prefix_attributes);
7055   else
7056     attrlist = NULL_TREE;
7057
7058   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7059                          attrlist);
7060
7061   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7062     return NULL_TREE;
7063
7064   type = TREE_TYPE (decl);
7065
7066   if (type == error_mark_node)
7067     return NULL_TREE;
7068
7069   context = DECL_CONTEXT (decl);
7070
7071   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7072       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7073     {
7074       /* When parsing the initializer, lookup should use the object's
7075          namespace. */
7076       push_decl_namespace (context);
7077     }
7078
7079   /* We are only interested in class contexts, later. */
7080   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7081     context = NULL_TREE;
7082
7083   if (initialized)
7084     /* Is it valid for this decl to have an initializer at all?
7085        If not, set INITIALIZED to zero, which will indirectly
7086        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7087     switch (TREE_CODE (decl))
7088       {
7089       case TYPE_DECL:
7090         /* typedef foo = bar  means give foo the same type as bar.
7091            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7092            Any other case of an initialization in a TYPE_DECL is an error.  */
7093         if (pedantic || list_length (declspecs) > 1)
7094           {
7095             cp_error ("typedef `%D' is initialized", decl);
7096             initialized = 0;
7097           }
7098         break;
7099
7100       case FUNCTION_DECL:
7101         cp_error ("function `%#D' is initialized like a variable", decl);
7102         initialized = 0;
7103         break;
7104
7105       default:
7106         break;
7107       }
7108
7109   if (initialized)
7110     {
7111       if (! toplevel_bindings_p ()
7112           && DECL_EXTERNAL (decl))
7113         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7114                     decl);
7115       DECL_EXTERNAL (decl) = 0;
7116       if (toplevel_bindings_p ())
7117         TREE_STATIC (decl) = 1;
7118
7119       /* Tell `pushdecl' this is an initialized decl
7120          even though we don't yet have the initializer expression.
7121          Also tell `cp_finish_decl' it may store the real initializer.  */
7122       DECL_INITIAL (decl) = error_mark_node;
7123     }
7124
7125   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7126   cplus_decl_attributes (&decl, attributes, prefix_attributes, 0);
7127
7128   if (context && COMPLETE_TYPE_P (complete_type (context)))
7129     {
7130       push_nested_class (context, 2);
7131
7132       if (TREE_CODE (decl) == VAR_DECL)
7133         {
7134           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7135           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7136             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7137           else
7138             {
7139               if (DECL_CONTEXT (field) != context)
7140                 {
7141                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7142                               DECL_CONTEXT (field), DECL_NAME (decl),
7143                               context, DECL_NAME (decl));
7144                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7145                 }
7146               /* Static data member are tricky; an in-class initialization
7147                  still doesn't provide a definition, so the in-class
7148                  declaration will have DECL_EXTERNAL set, but will have an
7149                  initialization.  Thus, duplicate_decls won't warn
7150                  about this situation, and so we check here.  */
7151               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7152                 cp_error ("duplicate initialization of %D", decl);
7153               if (duplicate_decls (decl, field))
7154                 decl = field;
7155             }
7156         }
7157       else
7158         {
7159           tree field = check_classfn (context, decl);
7160           if (field && duplicate_decls (decl, field))
7161             decl = field;
7162         }
7163
7164       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7165       DECL_IN_AGGR_P (decl) = 0;
7166       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7167           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7168         {
7169           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7170           /* [temp.expl.spec] An explicit specialization of a static data
7171              member of a template is a definition if the declaration
7172              includes an initializer; otherwise, it is a declaration.
7173
7174              We check for processing_specialization so this only applies
7175              to the new specialization syntax.  */
7176           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7177             DECL_EXTERNAL (decl) = 1;
7178         }
7179
7180       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7181         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7182                     decl);
7183     }
7184
7185   /* Enter this declaration into the symbol table.  */
7186   tem = maybe_push_decl (decl);
7187
7188   if (processing_template_decl)
7189     tem = push_template_decl (tem);
7190
7191 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7192   /* Tell the back-end to use or not use .common as appropriate.  If we say
7193      -fconserve-space, we want this to save .data space, at the expense of
7194      wrong semantics.  If we say -fno-conserve-space, we want this to
7195      produce errors about redefs; to do this we force variables into the
7196      data segment.  */
7197   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7198 #endif
7199
7200   if (! processing_template_decl)
7201     start_decl_1 (tem);
7202
7203   return tem;
7204 }
7205
7206 void
7207 start_decl_1 (decl)
7208      tree decl;
7209 {
7210   tree type = TREE_TYPE (decl);
7211   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7212
7213   if (type == error_mark_node)
7214     return;
7215
7216   maybe_push_cleanup_level (type);
7217
7218   if (initialized)
7219     /* Is it valid for this decl to have an initializer at all?
7220        If not, set INITIALIZED to zero, which will indirectly
7221        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7222     {
7223       /* Don't allow initializations for incomplete types except for
7224          arrays which might be completed by the initialization.  */
7225       if (COMPLETE_TYPE_P (complete_type (type)))
7226         ;                       /* A complete type is ok.  */
7227       else if (TREE_CODE (type) != ARRAY_TYPE)
7228         {
7229           cp_error ("variable `%#D' has initializer but incomplete type",
7230                     decl);
7231           initialized = 0;
7232           type = TREE_TYPE (decl) = error_mark_node;
7233         }
7234       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7235         {
7236           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7237             cp_error ("elements of array `%#D' have incomplete type", decl);
7238           /* else we already gave an error in start_decl.  */
7239           initialized = 0;
7240         }
7241     }
7242
7243   if (!initialized
7244       && TREE_CODE (decl) != TYPE_DECL
7245       && TREE_CODE (decl) != TEMPLATE_DECL
7246       && type != error_mark_node
7247       && IS_AGGR_TYPE (type)
7248       && ! DECL_EXTERNAL (decl))
7249     {
7250       if ((! processing_template_decl || ! uses_template_parms (type))
7251           && !COMPLETE_TYPE_P (complete_type (type)))
7252         {
7253           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7254                  decl);
7255           /* Change the type so that assemble_variable will give
7256              DECL an rtl we can live with: (mem (const_int 0)).  */
7257           type = TREE_TYPE (decl) = error_mark_node;
7258         }
7259       else
7260         {
7261           /* If any base type in the hierarchy of TYPE needs a constructor,
7262              then we set initialized to 1.  This way any nodes which are
7263              created for the purposes of initializing this aggregate
7264              will live as long as it does.  This is necessary for global
7265              aggregates which do not have their initializers processed until
7266              the end of the file.  */
7267           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7268         }
7269     }
7270
7271   if (! initialized)
7272     DECL_INITIAL (decl) = NULL_TREE;
7273 }
7274
7275 /* Handle initialization of references.
7276    These three arguments are from `cp_finish_decl', and have the
7277    same meaning here that they do there.
7278
7279    Quotes on semantics can be found in ARM 8.4.3.  */
7280
7281 static tree
7282 grok_reference_init (decl, type, init)
7283      tree decl, type, init;
7284 {
7285   tree tmp;
7286
7287   if (init == NULL_TREE)
7288     {
7289       if ((DECL_LANG_SPECIFIC (decl) == 0
7290            || DECL_IN_AGGR_P (decl) == 0)
7291           && ! DECL_THIS_EXTERN (decl))
7292         cp_error ("`%D' declared as reference but not initialized", decl);
7293       return NULL_TREE;
7294     }
7295
7296   if (init == error_mark_node)
7297     return NULL_TREE;
7298
7299   if (TREE_CODE (init) == CONSTRUCTOR)
7300     {
7301       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7302       return NULL_TREE;
7303     }
7304
7305   if (TREE_CODE (init) == TREE_LIST)
7306     init = build_compound_expr (init);
7307
7308   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7309     init = convert_from_reference (init);
7310
7311   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7312       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7313     {
7314       /* Note: default conversion is only called in very special cases.  */
7315       init = default_conversion (init);
7316     }
7317
7318   /* Convert INIT to the reference type TYPE.  This may involve the
7319      creation of a temporary, whose lifetime must be the same as that
7320      of the reference.  If so, a DECL_STMT for the temporary will be
7321      added just after the DECL_STMT for DECL.  That's why we don't set
7322      DECL_INITIAL for local references (instead assigning to them
7323      explicitly); we need to allow the temporary to be initialized
7324      first.  */
7325   tmp = convert_to_reference
7326     (type, init, CONV_IMPLICIT,
7327      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7328      decl);
7329
7330   if (tmp == error_mark_node)
7331     return NULL_TREE;
7332   else if (tmp == NULL_TREE)
7333     {
7334       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7335       return NULL_TREE;
7336     }
7337
7338   if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
7339     return tmp;
7340
7341   DECL_INITIAL (decl) = tmp;
7342
7343   return NULL_TREE;
7344 }
7345
7346 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7347    mucking with forces it does not comprehend (i.e. initialization with a
7348    constructor).  If we are at global scope and won't go into COMMON, fill
7349    it in with a dummy CONSTRUCTOR to force the variable into .data;
7350    otherwise we can use error_mark_node.  */
7351
7352 static tree
7353 obscure_complex_init (decl, init)
7354      tree decl, init;
7355 {
7356   if (! flag_no_inline && TREE_STATIC (decl))
7357     {
7358       if (extract_init (decl, init))
7359         return NULL_TREE;
7360     }
7361
7362 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7363   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7364     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7365                                  NULL_TREE);
7366   else
7367 #endif
7368     DECL_INITIAL (decl) = error_mark_node;
7369
7370   return init;
7371 }
7372
7373 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7374    array until we finish parsing the initializer.  If that's the
7375    situation we're in, update DECL accordingly.  */
7376
7377 static void
7378 maybe_deduce_size_from_array_init (decl, init)
7379      tree decl;
7380      tree init;
7381 {
7382   tree type = TREE_TYPE (decl);
7383
7384   if (TREE_CODE (type) == ARRAY_TYPE
7385       && TYPE_DOMAIN (type) == NULL_TREE
7386       && TREE_CODE (decl) != TYPE_DECL)
7387     {
7388       /* do_default is really a C-ism to deal with tentative definitions.
7389          But let's leave it here to ease the eventual merge.  */
7390       int do_default = !DECL_EXTERNAL (decl);
7391       tree initializer = init ? init : DECL_INITIAL (decl);
7392       int failure = complete_array_type (type, initializer, do_default);
7393
7394       if (failure == 1)
7395         cp_error ("initializer fails to determine size of `%D'", decl);
7396
7397       if (failure == 2)
7398         {
7399           if (do_default)
7400             cp_error ("array size missing in `%D'", decl);
7401           /* If a `static' var's size isn't known, make it extern as
7402              well as static, so it does not get allocated.  If it's not
7403              `static', then don't mark it extern; finish_incomplete_decl
7404              will give it a default size and it will get allocated.  */
7405           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7406             DECL_EXTERNAL (decl) = 1;
7407         }
7408
7409       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7410           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7411                               integer_zero_node))
7412         cp_error ("zero-size array `%D'", decl);
7413
7414       layout_decl (decl, 0);
7415     }
7416 }
7417
7418 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7419    any appropriate error messages regarding the layout.  */
7420
7421 static void
7422 layout_var_decl (decl)
7423      tree decl;
7424 {
7425   tree type = TREE_TYPE (decl);
7426 #if 0
7427   tree ttype = target_type (type);
7428 #endif
7429
7430   /* If we haven't already layed out this declaration, do so now.
7431      Note that we must not call complete type for an external object
7432      because it's type might involve templates that we are not
7433      supposed to isntantiate yet.  (And it's perfectly legal to say
7434      `extern X x' for some incomplete type `X'.)  */
7435   if (!DECL_EXTERNAL (decl))
7436     complete_type (type);
7437   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7438     layout_decl (decl, 0);
7439
7440   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7441     {
7442       /* An automatic variable with an incomplete type: that is an error.
7443          Don't talk about array types here, since we took care of that
7444          message in grokdeclarator.  */
7445       cp_error ("storage size of `%D' isn't known", decl);
7446       TREE_TYPE (decl) = error_mark_node;
7447     }
7448 #if 0
7449   /* Keep this code around in case we later want to control debug info
7450      based on whether a type is "used".  (jason 1999-11-11) */
7451
7452   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7453     /* Let debugger know it should output info for this type.  */
7454     note_debug_info_needed (ttype);
7455
7456   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7457     note_debug_info_needed (DECL_CONTEXT (decl));
7458 #endif
7459
7460   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7461       && DECL_SIZE (decl) != NULL_TREE
7462       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7463     {
7464       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7465         constant_expression_warning (DECL_SIZE (decl));
7466       else
7467         cp_error ("storage size of `%D' isn't constant", decl);
7468     }
7469
7470   if (TREE_STATIC (decl)
7471       && !DECL_ARTIFICIAL (decl)
7472       && current_function_decl
7473       && DECL_CONTEXT (decl) == current_function_decl)
7474     push_local_name (decl);
7475 }
7476
7477 /* If a local static variable is declared in an inline function, or if
7478    we have a weak definition, we must endeavor to create only one
7479    instance of the variable at link-time.  */
7480
7481 static void
7482 maybe_commonize_var (decl)
7483      tree decl;
7484 {
7485   /* Static data in a function with comdat linkage also has comdat
7486      linkage.  */
7487   if (TREE_STATIC (decl)
7488       /* Don't mess with __FUNCTION__.  */
7489       && ! DECL_ARTIFICIAL (decl)
7490       && current_function_decl
7491       && DECL_CONTEXT (decl) == current_function_decl
7492       && (DECL_DECLARED_INLINE_P (current_function_decl)
7493           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7494       && TREE_PUBLIC (current_function_decl))
7495     {
7496       /* If flag_weak, we don't need to mess with this, as we can just
7497          make the function weak, and let it refer to its unique local
7498          copy.  This works because we don't allow the function to be
7499          inlined.  */
7500       if (! flag_weak)
7501         {
7502           if (DECL_INTERFACE_KNOWN (current_function_decl))
7503             {
7504               TREE_PUBLIC (decl) = 1;
7505               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7506             }
7507           else if (DECL_INITIAL (decl) == NULL_TREE
7508                    || DECL_INITIAL (decl) == error_mark_node)
7509             {
7510               TREE_PUBLIC (decl) = 1;
7511               DECL_COMMON (decl) = 1;
7512             }
7513           /* else we lose. We can only do this if we can use common,
7514              which we can't if it has been initialized.  */
7515
7516           if (!TREE_PUBLIC (decl))
7517             {
7518               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7519               cp_warning_at ("  you can work around this by removing the initializer", decl);
7520             }
7521         }
7522       else
7523         comdat_linkage (decl);
7524     }
7525   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7526     /* Set it up again; we might have set DECL_INITIAL since the last
7527        time.  */
7528     comdat_linkage (decl);
7529 }
7530
7531 /* Issue an error message if DECL is an uninitialized const variable.  */
7532
7533 static void
7534 check_for_uninitialized_const_var (decl)
7535      tree decl;
7536 {
7537   tree type = TREE_TYPE (decl);
7538
7539   /* ``Unless explicitly declared extern, a const object does not have
7540      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7541      7.1.6 */
7542   if (TREE_CODE (decl) == VAR_DECL
7543       && TREE_CODE (type) != REFERENCE_TYPE
7544       && CP_TYPE_CONST_P (type)
7545       && !TYPE_NEEDS_CONSTRUCTING (type)
7546       && !DECL_INITIAL (decl))
7547     cp_error ("uninitialized const `%D'", decl);
7548 }
7549
7550 /* Verify INIT (the initializer for DECL), and record the
7551    initialization in DECL_INITIAL, if appropriate.  Returns a new
7552    value for INIT.  */
7553
7554 static tree
7555 check_initializer (decl, init)
7556      tree decl;
7557      tree init;
7558 {
7559   tree type;
7560
7561   if (TREE_CODE (decl) == FIELD_DECL)
7562     return init;
7563
7564   type = TREE_TYPE (decl);
7565
7566   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7567   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7568     init = NULL_TREE;
7569
7570   /* Check the initializer.  */
7571   if (init)
7572     {
7573       /* Things that are going to be initialized need to have complete
7574          type.  */
7575       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7576
7577       if (type == error_mark_node)
7578         /* We will have already complained.  */
7579         init = NULL_TREE;
7580       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7581         {
7582           cp_error ("variable-sized object `%D' may not be initialized", decl);
7583           init = NULL_TREE;
7584         }
7585       else if (TREE_CODE (type) == ARRAY_TYPE
7586                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7587         {
7588           cp_error ("elements of array `%#D' have incomplete type", decl);
7589           init = NULL_TREE;
7590         }
7591       else if (!COMPLETE_TYPE_P (type))
7592         {
7593           cp_error ("`%D' has incomplete type", decl);
7594           TREE_TYPE (decl) = error_mark_node;
7595           init = NULL_TREE;
7596         }
7597     }
7598
7599   if (TREE_CODE (decl) == CONST_DECL)
7600     {
7601       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7602
7603       DECL_INITIAL (decl) = init;
7604
7605       my_friendly_assert (init != NULL_TREE, 149);
7606       init = NULL_TREE;
7607     }
7608   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7609     {
7610       init = grok_reference_init (decl, type, init);
7611       if (init)
7612         init = obscure_complex_init (decl, init);
7613     }
7614   else if (init)
7615     {
7616       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7617         {
7618           if (TREE_CODE (type) == ARRAY_TYPE)
7619             init = digest_init (type, init, (tree *) 0);
7620           else if (TREE_CODE (init) == CONSTRUCTOR
7621                    && TREE_HAS_CONSTRUCTOR (init))
7622             {
7623               if (TYPE_NON_AGGREGATE_CLASS (type))
7624                 {
7625                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7626                             decl);
7627                   init = error_mark_node;
7628                 }
7629               else
7630                 goto dont_use_constructor;
7631             }
7632         }
7633       else
7634         {
7635         dont_use_constructor:
7636           if (TREE_CODE (init) != TREE_VEC)
7637             init = store_init_value (decl, init);
7638         }
7639
7640       if (init)
7641         /* We must hide the initializer so that expand_decl
7642            won't try to do something it does not understand.  */
7643         init = obscure_complex_init (decl, init);
7644     }
7645   else if (DECL_EXTERNAL (decl))
7646     ;
7647   else if (TYPE_P (type)
7648            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7649     {
7650       tree core_type = strip_array_types (type);
7651
7652       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7653         {
7654           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7655             cp_error ("structure `%D' with uninitialized const members", decl);
7656           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7657             cp_error ("structure `%D' with uninitialized reference members",
7658                       decl);
7659         }
7660
7661       check_for_uninitialized_const_var (decl);
7662
7663       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7664         init = obscure_complex_init (decl, NULL_TREE);
7665
7666     }
7667   else
7668     check_for_uninitialized_const_var (decl);
7669
7670   return init;
7671 }
7672
7673 /* If DECL is not a local variable, give it RTL.  */
7674
7675 static void
7676 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7677      tree decl;
7678      tree init;
7679      const char *asmspec;
7680 {
7681   int toplev = toplevel_bindings_p ();
7682   int defer_p;
7683
7684   /* Handle non-variables up front.  */
7685   if (TREE_CODE (decl) != VAR_DECL)
7686     {
7687       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7688       return;
7689     }
7690
7691   /* If we see a class member here, it should be a static data
7692      member.  */
7693   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7694     {
7695       my_friendly_assert (TREE_STATIC (decl), 19990828);
7696       /* An in-class declaration of a static data member should be
7697          external; it is only a declaration, and not a definition.  */
7698       if (init == NULL_TREE)
7699         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7700     }
7701
7702   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7703   if (asmspec)
7704     {
7705       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
7706       /* The `register' keyword, when used together with an
7707          asm-specification, indicates that the variable should be
7708          placed in a particular register.  */
7709       if (DECL_REGISTER (decl))
7710         DECL_C_HARD_REGISTER (decl) = 1;
7711     }
7712
7713   /* We don't create any RTL for local variables.  */
7714   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7715     return;
7716
7717   /* We defer emission of local statics until the corresponding
7718      DECL_STMT is expanded.  */
7719   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7720
7721   /* We try to defer namespace-scope static constants so that they are
7722      not emitted into the object file unncessarily.  */
7723   if (!DECL_VIRTUAL_P (decl)
7724       && TREE_READONLY (decl)
7725       && DECL_INITIAL (decl) != NULL_TREE
7726       && DECL_INITIAL (decl) != error_mark_node
7727       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7728       && toplev
7729       && !TREE_PUBLIC (decl))
7730     {
7731       /* Fool with the linkage according to #pragma interface.  */
7732       if (!interface_unknown)
7733         {
7734           TREE_PUBLIC (decl) = 1;
7735           DECL_EXTERNAL (decl) = interface_only;
7736         }
7737
7738       defer_p = 1;
7739     }
7740
7741   /* If we're deferring the variable, we only need to make RTL if
7742      there's an ASMSPEC.  Otherwise, we'll lazily create it later when
7743      we need it.  (There's no way to lazily create RTL for things that
7744      have assembly specs because the information about the specifier
7745      isn't stored in the tree, yet)  */
7746   if (defer_p && asmspec)
7747     make_decl_rtl (decl, asmspec);
7748   /* If we're not deferring, go ahead and assemble the variable.  */
7749   else if (!defer_p)
7750     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7751 }
7752
7753 /* The old ARM scoping rules injected variables declared in the
7754    initialization statement of a for-statement into the surrounding
7755    scope.  We support this usage, in order to be backward-compatible.
7756    DECL is a just-declared VAR_DECL; if necessary inject its
7757    declaration into the surrounding scope.  */
7758
7759 void
7760 maybe_inject_for_scope_var (decl)
7761      tree decl;
7762 {
7763   if (!DECL_NAME (decl))
7764     return;
7765
7766   if (current_binding_level->is_for_scope)
7767     {
7768       struct binding_level *outer
7769         = current_binding_level->level_chain;
7770
7771       /* Check to see if the same name is already bound at the outer
7772          level, either because it was directly declared, or because a
7773          dead for-decl got preserved.  In either case, the code would
7774          not have been valid under the ARM scope rules, so clear
7775          is_for_scope for the current_binding_level.
7776
7777          Otherwise, we need to preserve the temp slot for decl to last
7778          into the outer binding level.  */
7779
7780       tree outer_binding
7781         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7782
7783       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7784           && (TREE_CODE (BINDING_VALUE (outer_binding))
7785               == VAR_DECL)
7786           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7787         {
7788           BINDING_VALUE (outer_binding)
7789             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7790           current_binding_level->is_for_scope = 0;
7791         }
7792       else if (DECL_IN_MEMORY_P (decl))
7793         preserve_temp_slots (DECL_RTL (decl));
7794     }
7795 }
7796
7797 /* Generate code to initialize DECL (a local variable).  */
7798
7799 void
7800 initialize_local_var (decl, init, flags)
7801      tree decl;
7802      tree init;
7803      int flags;
7804 {
7805   tree type = TREE_TYPE (decl);
7806
7807   /* If the type is bogus, don't bother initializing the variable.  */
7808   if (type == error_mark_node)
7809     return;
7810
7811   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7812     {
7813       /* If we used it already as memory, it must stay in memory.  */
7814       DECL_INITIAL (decl) = NULL_TREE;
7815       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7816     }
7817
7818   /* Local statics are handled differently from ordinary automatic
7819      variables.  */
7820   if (TREE_STATIC (decl))
7821     {
7822       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7823           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7824         expand_static_init (decl, init);
7825       return;
7826     }
7827
7828   if (DECL_SIZE (decl) && type != error_mark_node)
7829     {
7830       int already_used;
7831
7832       /* Compute and store the initial value.  */
7833       already_used = TREE_USED (decl) || TREE_USED (type);
7834
7835       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7836         {
7837           int saved_stmts_are_full_exprs_p;
7838
7839           my_friendly_assert (building_stmt_tree (), 20000906);
7840           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7841           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
7842           finish_expr_stmt (build_aggr_init (decl, init, flags));
7843           current_stmt_tree ()->stmts_are_full_exprs_p =
7844             saved_stmts_are_full_exprs_p;
7845         }
7846
7847       /* Set this to 0 so we can tell whether an aggregate which was
7848          initialized was ever used.  Don't do this if it has a
7849          destructor, so we don't complain about the 'resource
7850          allocation is initialization' idiom.  Now set
7851          attribute((unused)) on types so decls of that type will be
7852          marked used. (see TREE_USED, above.)  */
7853       if (TYPE_NEEDS_CONSTRUCTING (type)
7854           && ! already_used
7855           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7856           && DECL_NAME (decl))
7857         TREE_USED (decl) = 0;
7858       else if (already_used)
7859         TREE_USED (decl) = 1;
7860     }
7861 }
7862
7863 /* Generate code to destroy DECL (a local variable).  */
7864
7865 static void
7866 destroy_local_var (decl)
7867      tree decl;
7868 {
7869   tree type = TREE_TYPE (decl);
7870   tree cleanup;
7871
7872   /* Only variables get cleaned up.  */
7873   if (TREE_CODE (decl) != VAR_DECL)
7874     return;
7875
7876   /* And only things with destructors need cleaning up.  */
7877   if (type == error_mark_node
7878       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7879     return;
7880
7881   if (TREE_CODE (decl) == VAR_DECL &&
7882       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7883     /* We don't clean up things that aren't defined in this
7884        translation unit, or that need a static cleanup.  The latter
7885        are handled by finish_file.  */
7886     return;
7887
7888   /* Compute the cleanup.  */
7889   cleanup = maybe_build_cleanup (decl);
7890
7891   /* Record the cleanup required for this declaration.  */
7892   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7893       && cleanup)
7894     finish_decl_cleanup (decl, cleanup);
7895 }
7896
7897 /* Finish processing of a declaration;
7898    install its line number and initial value.
7899    If the length of an array type is not known before,
7900    it must be determined now, from the initial value, or it is an error.
7901
7902    INIT holds the value of an initializer that should be allowed to escape
7903    the normal rules.
7904
7905    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
7906    if the (init) syntax was used.  */
7907
7908 void
7909 cp_finish_decl (decl, init, asmspec_tree, flags)
7910      tree decl, init;
7911      tree asmspec_tree;
7912      int flags;
7913 {
7914   register tree type;
7915   tree ttype = NULL_TREE;
7916   const char *asmspec = NULL;
7917   int was_readonly = 0;
7918
7919   if (! decl)
7920     {
7921       if (init)
7922         error ("assignment (not initialization) in declaration");
7923       return;
7924     }
7925
7926   /* If a name was specified, get the string.  */
7927   if (asmspec_tree)
7928       asmspec = TREE_STRING_POINTER (asmspec_tree);
7929
7930   if (init && TREE_CODE (init) == NAMESPACE_DECL)
7931     {
7932       cp_error ("cannot initialize `%D' to namespace `%D'",
7933                 decl, init);
7934       init = NULL_TREE;
7935     }
7936
7937   if (current_class_type
7938       && CP_DECL_CONTEXT (decl) == current_class_type
7939       && TYPE_BEING_DEFINED (current_class_type)
7940       && (DECL_INITIAL (decl) || init))
7941     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
7942
7943   if (TREE_CODE (decl) == VAR_DECL
7944       && DECL_CONTEXT (decl)
7945       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
7946       && DECL_CONTEXT (decl) != current_namespace
7947       && init)
7948     {
7949       /* Leave the namespace of the object. */
7950       pop_decl_namespace ();
7951     }
7952
7953   type = TREE_TYPE (decl);
7954
7955   if (type == error_mark_node)
7956     return;
7957
7958   if (TYPE_HAS_MUTABLE_P (type))
7959     TREE_READONLY (decl) = 0;
7960
7961   if (processing_template_decl)
7962     {
7963       /* Add this declaration to the statement-tree.  */
7964       if (at_function_scope_p ()
7965           && TREE_CODE (decl) != RESULT_DECL)
7966         add_decl_stmt (decl);
7967
7968       if (init && DECL_INITIAL (decl))
7969         DECL_INITIAL (decl) = init;
7970       goto finish_end0;
7971     }
7972
7973   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
7974   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
7975
7976   /* Take care of TYPE_DECLs up front.  */
7977   if (TREE_CODE (decl) == TYPE_DECL)
7978     {
7979       if (init && DECL_INITIAL (decl))
7980         {
7981           /* typedef foo = bar; store the type of bar as the type of foo.  */
7982           TREE_TYPE (decl) = type = TREE_TYPE (init);
7983           DECL_INITIAL (decl) = init = NULL_TREE;
7984         }
7985       if (type != error_mark_node
7986           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
7987         {
7988           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
7989             cp_warning ("shadowing previous type declaration of `%#D'", decl);
7990           set_identifier_type_value (DECL_NAME (decl), type);
7991           CLASSTYPE_GOT_SEMICOLON (type) = 1;
7992         }
7993       GNU_xref_decl (current_function_decl, decl);
7994
7995       /* If we have installed this as the canonical typedef for this
7996          type, and that type has not been defined yet, delay emitting
7997          the debug information for it, as we will emit it later.  */
7998       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
7999           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8000         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8001
8002       rest_of_decl_compilation (decl, NULL,
8003                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8004       goto finish_end;
8005     }
8006
8007   if (TREE_CODE (decl) != FUNCTION_DECL)
8008     ttype = target_type (type);
8009
8010   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8011       && TYPE_NEEDS_CONSTRUCTING (type))
8012     {
8013       /* Currently, GNU C++ puts constants in text space, making them
8014          impossible to initialize.  In the future, one would hope for
8015          an operating system which understood the difference between
8016          initialization and the running of a program.  */
8017       was_readonly = 1;
8018       TREE_READONLY (decl) = 0;
8019     }
8020
8021   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8022     {
8023       /* This must override the asm specifier which was placed by
8024          grokclassfn.  Lay this out fresh.  */
8025       SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
8026       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8027       make_decl_rtl (decl, asmspec);
8028     }
8029
8030   /* Deduce size of array from initialization, if not already known.  */
8031   maybe_deduce_size_from_array_init (decl, init);
8032   init = check_initializer (decl, init);
8033
8034   GNU_xref_decl (current_function_decl, decl);
8035
8036   /* Add this declaration to the statement-tree.  */
8037   if (building_stmt_tree ()
8038       && at_function_scope_p ()
8039       && TREE_CODE (decl) != RESULT_DECL)
8040     add_decl_stmt (decl);
8041
8042   if (TREE_CODE (decl) == VAR_DECL)
8043     layout_var_decl (decl);
8044
8045   /* Output the assembler code and/or RTL code for variables and functions,
8046      unless the type is an undefined structure or union.
8047      If not, it will get done when the type is completed.  */
8048   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8049       || TREE_CODE (decl) == RESULT_DECL)
8050     {
8051       if (TREE_CODE (decl) == VAR_DECL)
8052         maybe_commonize_var (decl);
8053
8054       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8055
8056       if (TREE_CODE (type) == FUNCTION_TYPE
8057           || TREE_CODE (type) == METHOD_TYPE)
8058         abstract_virtuals_error (decl,
8059                                  strip_array_types (TREE_TYPE (type)));
8060       else
8061         abstract_virtuals_error (decl, strip_array_types (type));
8062
8063       if (TREE_CODE (decl) == FUNCTION_DECL)
8064         ;
8065       else if (DECL_EXTERNAL (decl)
8066                && ! (DECL_LANG_SPECIFIC (decl)
8067                      && DECL_NOT_REALLY_EXTERN (decl)))
8068         {
8069           if (init)
8070             DECL_INITIAL (decl) = init;
8071         }
8072       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8073         {
8074           /* This is a local declaration.  */
8075           if (doing_semantic_analysis_p ())
8076             maybe_inject_for_scope_var (decl);
8077           /* Initialize the local variable.  But, if we're building a
8078              statement-tree, we'll do the initialization when we
8079              expand the tree.  */
8080           if (processing_template_decl)
8081             {
8082               if (init || DECL_INITIAL (decl) == error_mark_node)
8083                 DECL_INITIAL (decl) = init;
8084             }
8085           else
8086             {
8087               /* If we're not building RTL, then we need to do so
8088                  now.  */
8089               my_friendly_assert (building_stmt_tree (), 20000906);
8090               /* Initialize the variable.  */
8091               initialize_local_var (decl, init, flags);
8092               /* Clean up the variable.  */
8093               destroy_local_var (decl);
8094             }
8095         }
8096       else if (TREE_STATIC (decl) && type != error_mark_node)
8097         {
8098           /* Cleanups for static variables are handled by `finish_file'.  */
8099           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8100               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8101             expand_static_init (decl, init);
8102         }
8103     finish_end0:
8104
8105       /* Undo call to `pushclass' that was done in `start_decl'
8106          due to initialization of qualified member variable.
8107          I.e., Foo::x = 10;  */
8108       {
8109         tree context = CP_DECL_CONTEXT (decl);
8110         if (context
8111             && TYPE_P (context)
8112             && (TREE_CODE (decl) == VAR_DECL
8113                 /* We also have a pushclass done that we need to undo here
8114                    if we're at top level and declare a method.  */
8115                 || TREE_CODE (decl) == FUNCTION_DECL)
8116             /* If size hasn't been set, we're still defining it,
8117                and therefore inside the class body; don't pop
8118                the binding level..  */
8119             && COMPLETE_TYPE_P (context)
8120             && context == current_class_type)
8121           pop_nested_class ();
8122       }
8123     }
8124
8125  finish_end:
8126
8127   if (was_readonly)
8128     TREE_READONLY (decl) = 1;
8129 }
8130
8131 /* This is here for a midend callback from c-common.c */
8132
8133 void
8134 finish_decl (decl, init, asmspec_tree)
8135      tree decl, init;
8136      tree asmspec_tree;
8137 {
8138   cp_finish_decl (decl, init, asmspec_tree, 0);
8139 }
8140
8141 /* Returns a declaration for a VAR_DECL as if:
8142
8143      extern "C" TYPE NAME;
8144
8145    had been seen.  Used to create compiler-generated global
8146    variables.  */
8147
8148 tree
8149 declare_global_var (name, type)
8150      tree name;
8151      tree type;
8152 {
8153   tree decl;
8154
8155   push_to_top_level ();
8156   decl = build_decl (VAR_DECL, name, type);
8157   TREE_PUBLIC (decl) = 1;
8158   DECL_EXTERNAL (decl) = 1;
8159   DECL_ARTIFICIAL (decl) = 1;
8160   pushdecl (decl);
8161   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8162   pop_from_top_level ();
8163
8164   return decl;
8165 }
8166
8167 /* Returns a pointer to the `atexit' function.  Note that if
8168    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8169    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8170
8171 static tree
8172 get_atexit_node ()
8173 {
8174   tree atexit_fndecl;
8175   tree arg_types;
8176   tree fn_type;
8177   tree fn_ptr_type;
8178   const char *name;
8179
8180   if (atexit_node)
8181     return atexit_node;
8182
8183   if (flag_use_cxa_atexit)
8184     {
8185       /* The declaration for `__cxa_atexit' is:
8186
8187            int __cxa_atexit (void (*)(void *), void *, void *)
8188
8189          We build up the argument types and then then function type
8190          itself.  */
8191
8192       /* First, build the pointer-to-function type for the first
8193          argument.  */
8194       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8195       fn_type = build_function_type (void_type_node, arg_types);
8196       fn_ptr_type = build_pointer_type (fn_type);
8197       /* Then, build the rest of the argument types.  */
8198       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8199       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8200       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8201       /* And the final __cxa_atexit type.  */
8202       fn_type = build_function_type (integer_type_node, arg_types);
8203       fn_ptr_type = build_pointer_type (fn_type);
8204       name = "__cxa_atexit";
8205     }
8206   else
8207     {
8208       /* The declaration for `atexit' is:
8209
8210            int atexit (void (*)());
8211
8212          We build up the argument types and then then function type
8213          itself.  */
8214       fn_type = build_function_type (void_type_node, void_list_node);
8215       fn_ptr_type = build_pointer_type (fn_type);
8216       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8217       /* Build the final atexit type.  */
8218       fn_type = build_function_type (integer_type_node, arg_types);
8219       name = "atexit";
8220     }
8221
8222   /* Now, build the function declaration.  */
8223   push_lang_context (lang_name_c);
8224   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8225   mark_used (atexit_fndecl);
8226   pop_lang_context ();
8227   atexit_node = default_conversion (atexit_fndecl);
8228
8229   return atexit_node;
8230 }
8231
8232 /* Returns the __dso_handle VAR_DECL.  */
8233
8234 static tree
8235 get_dso_handle_node ()
8236 {
8237   if (dso_handle_node)
8238     return dso_handle_node;
8239
8240   /* Declare the variable.  */
8241   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8242                                         ptr_type_node);
8243
8244   return dso_handle_node;
8245 }
8246
8247 /* Begin a new function with internal linkage whose job will be simply
8248    to destroy some particular variable.  */
8249
8250 static tree
8251 start_cleanup_fn ()
8252 {
8253   static int counter = 0;
8254   int old_interface_unknown = interface_unknown;
8255   char name[32];
8256   tree parmtypes;
8257   tree fntype;
8258   tree fndecl;
8259
8260   push_to_top_level ();
8261
8262   /* No need to mangle this.  */
8263   push_lang_context (lang_name_c);
8264
8265   interface_unknown = 1;
8266
8267   /* Build the parameter-types.  */
8268   parmtypes = void_list_node;
8269   /* Functions passed to __cxa_atexit take an additional parameter.
8270      We'll just ignore it.  After we implement the new calling
8271      convention for destructors, we can eliminate the use of
8272      additional cleanup functions entirely in the -fnew-abi case.  */
8273   if (flag_use_cxa_atexit)
8274     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8275   /* Build the function type itself.  */
8276   fntype = build_function_type (void_type_node, parmtypes);
8277   /* Build the name of the function.  */
8278   sprintf (name, "__tcf_%d", counter++);
8279   /* Build the function declaration.  */
8280   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8281   /* It's a function with internal linkage, generated by the
8282      compiler.  */
8283   TREE_PUBLIC (fndecl) = 0;
8284   DECL_ARTIFICIAL (fndecl) = 1;
8285   /* Make the function `inline' so that it is only emitted if it is
8286      actually needed.  It is unlikely that it will be inlined, since
8287      it is only called via a function pointer, but we avoid unncessary
8288      emissions this way.  */
8289   DECL_INLINE (fndecl) = 1;
8290   /* Build the parameter.  */
8291   if (flag_use_cxa_atexit)
8292     {
8293       tree parmdecl;
8294
8295       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8296       DECL_CONTEXT (parmdecl) = fndecl;
8297       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8298       TREE_USED (parmdecl) = 1;
8299       DECL_ARGUMENTS (fndecl) = parmdecl;
8300     }
8301
8302   pushdecl (fndecl);
8303   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8304   do_pushlevel ();
8305
8306   interface_unknown = old_interface_unknown;
8307
8308   pop_lang_context ();
8309
8310   return current_function_decl;
8311 }
8312
8313 /* Finish the cleanup function begun by start_cleanup_fn.  */
8314
8315 static void
8316 end_cleanup_fn ()
8317 {
8318   do_poplevel ();
8319
8320   expand_body (finish_function (0));
8321
8322   pop_from_top_level ();
8323 }
8324
8325 /* Generate code to handle the destruction of DECL, an object with
8326    static storage duration.  */
8327
8328 void
8329 register_dtor_fn (decl)
8330      tree decl;
8331 {
8332   tree cleanup;
8333   tree compound_stmt;
8334   tree args;
8335   tree fcall;
8336
8337   int saved_flag_access_control;
8338
8339   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8340     return;
8341
8342   /* Call build_cleanup before we enter the anonymous function so that
8343      any access checks will be done relative to the current scope,
8344      rather than the scope of the anonymous function.  */
8345   build_cleanup (decl);
8346
8347   /* Now start the function.  */
8348   cleanup = start_cleanup_fn ();
8349
8350   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8351      to the original function, rather than the anonymous one.  That
8352      will make the back-end think that nested functions are in use,
8353      which causes confusion.  */
8354   saved_flag_access_control = flag_access_control;
8355   flag_access_control = 0;
8356   fcall = build_cleanup (decl);
8357   flag_access_control = saved_flag_access_control;
8358
8359   /* Create the body of the anonymous function.  */
8360   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8361   finish_expr_stmt (fcall);
8362   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8363   end_cleanup_fn ();
8364
8365   /* Call atexit with the cleanup function.  */
8366   mark_addressable (cleanup);
8367   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8368   if (flag_use_cxa_atexit)
8369     {
8370       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8371       args = tree_cons (NULL_TREE, null_pointer_node, args);
8372       args = tree_cons (NULL_TREE, cleanup, args);
8373     }
8374   else
8375     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8376   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8377 }
8378
8379 void
8380 expand_static_init (decl, init)
8381      tree decl;
8382      tree init;
8383 {
8384   tree oldstatic = value_member (decl, static_aggregates);
8385
8386   if (oldstatic)
8387     {
8388       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8389         cp_error ("multiple initializations given for `%D'", decl);
8390     }
8391   else if (! toplevel_bindings_p ())
8392     {
8393       /* Emit code to perform this initialization but once.  */
8394       tree if_stmt;
8395       tree then_clause;
8396       tree assignment;
8397       tree guard;
8398       tree guard_init;
8399
8400       /* Emit code to perform this initialization but once.  This code
8401          looks like:
8402
8403            static int guard = 0;
8404            if (!guard) {
8405              // Do initialization.
8406              guard = 1;
8407              // Register variable for destruction at end of program.
8408            }
8409
8410          Note that the `temp' variable is only set to 1 *after* the
8411          initialization is complete.  This ensures that an exception,
8412          thrown during the construction, will cause the variable to
8413          reinitialized when we pass through this code again, as per:
8414
8415            [stmt.dcl]
8416
8417            If the initialization exits by throwing an exception, the
8418            initialization is not complete, so it will be tried again
8419            the next time control enters the declaration.
8420
8421          In theory, this process should be thread-safe, too; multiple
8422          threads should not be able to initialize the variable more
8423          than once.  We don't yet attempt to ensure thread-safety.  */
8424
8425       /* Create the guard variable.  */
8426       guard = get_guard (decl);
8427
8428       /* Begin the conditional initialization.  */
8429       if_stmt = begin_if_stmt ();
8430       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8431       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8432
8433       /* Do the initialization itself.  */
8434       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8435           || (init && TREE_CODE (init) == TREE_LIST))
8436         assignment = build_aggr_init (decl, init, 0);
8437       else if (init)
8438         /* The initialization we're doing here is just a bitwise
8439            copy.  */
8440         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8441       else
8442         assignment = NULL_TREE;
8443
8444       /* Once the assignment is complete, set TEMP to 1.  Since the
8445          construction of the static object is complete at this point,
8446          we want to make sure TEMP is set to 1 even if a temporary
8447          constructed during the initialization throws an exception
8448          when it is destroyed.  So, we combine the initialization and
8449          the assignment to TEMP into a single expression, ensuring
8450          that when we call finish_expr_stmt the cleanups will not be
8451          run until after TEMP is set to 1.  */
8452       guard_init = set_guard (guard);
8453       if (assignment)
8454         {
8455           assignment = tree_cons (NULL_TREE, assignment,
8456                                   build_tree_list (NULL_TREE,
8457                                                    guard_init));
8458           assignment = build_compound_expr (assignment);
8459         }
8460       else
8461         assignment = guard_init;
8462       finish_expr_stmt (assignment);
8463
8464       /* Use atexit to register a function for destroying this static
8465          variable.  */
8466       register_dtor_fn (decl);
8467
8468       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8469       finish_then_clause (if_stmt);
8470       finish_if_stmt ();
8471     }
8472   else
8473     static_aggregates = tree_cons (init, decl, static_aggregates);
8474 }
8475
8476 /* Finish the declaration of a catch-parameter.  */
8477
8478 tree
8479 start_handler_parms (declspecs, declarator)
8480      tree declspecs;
8481      tree declarator;
8482 {
8483   tree decl;
8484   if (declspecs)
8485     {
8486       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8487                              1, NULL_TREE);
8488       if (decl == NULL_TREE)
8489         error ("invalid catch parameter");
8490     }
8491   else
8492     decl = NULL_TREE;
8493
8494   return decl;
8495 }
8496
8497 \f
8498 /* Make TYPE a complete type based on INITIAL_VALUE.
8499    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8500    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8501
8502 int
8503 complete_array_type (type, initial_value, do_default)
8504      tree type, initial_value;
8505      int do_default;
8506 {
8507   register tree maxindex = NULL_TREE;
8508   int value = 0;
8509
8510   if (initial_value)
8511     {
8512       /* An array of character type can be initialized from a
8513          brace-enclosed string constant.  */
8514       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8515           && TREE_CODE (initial_value) == CONSTRUCTOR
8516           && CONSTRUCTOR_ELTS (initial_value)
8517           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8518               == STRING_CST)
8519           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8520         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8521
8522       /* Note MAXINDEX is really the maximum index, one less than the
8523          size.  */
8524       if (TREE_CODE (initial_value) == STRING_CST)
8525         {
8526           int eltsize
8527             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8528           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8529                                    / eltsize) - 1, 0);
8530         }
8531       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8532         {
8533           tree elts = CONSTRUCTOR_ELTS (initial_value);
8534
8535           maxindex = ssize_int (-1);
8536           for (; elts; elts = TREE_CHAIN (elts))
8537             {
8538               if (TREE_PURPOSE (elts))
8539                 maxindex = TREE_PURPOSE (elts);
8540               else
8541                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8542             }
8543           maxindex = copy_node (maxindex);
8544         }
8545       else
8546         {
8547           /* Make an error message unless that happened already.  */
8548           if (initial_value != error_mark_node)
8549             value = 1;
8550           else
8551             initial_value = NULL_TREE;
8552
8553           /* Prevent further error messages.  */
8554           maxindex = build_int_2 (0, 0);
8555         }
8556     }
8557
8558   if (!maxindex)
8559     {
8560       if (do_default)
8561         maxindex = build_int_2 (0, 0);
8562       value = 2;
8563     }
8564
8565   if (maxindex)
8566     {
8567       tree itype;
8568       tree domain;
8569
8570       domain = build_index_type (maxindex);
8571       TYPE_DOMAIN (type) = domain;
8572
8573       if (! TREE_TYPE (maxindex))
8574         TREE_TYPE (maxindex) = domain;
8575       if (initial_value)
8576         itype = TREE_TYPE (initial_value);
8577       else
8578         itype = NULL;
8579       if (itype && !TYPE_DOMAIN (itype))
8580         TYPE_DOMAIN (itype) = domain;
8581       /* The type of the main variant should never be used for arrays
8582          of different sizes.  It should only ever be completed with the
8583          size of the array.  */
8584       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8585         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8586     }
8587
8588   /* Lay out the type now that we can get the real answer.  */
8589
8590   layout_type (type);
8591
8592   return value;
8593 }
8594 \f
8595 /* Return zero if something is declared to be a member of type
8596    CTYPE when in the context of CUR_TYPE.  STRING is the error
8597    message to print in that case.  Otherwise, quietly return 1.  */
8598
8599 static int
8600 member_function_or_else (ctype, cur_type, flags)
8601      tree ctype, cur_type;
8602      enum overload_flags flags;
8603 {
8604   if (ctype && ctype != cur_type)
8605     {
8606       if (flags == DTOR_FLAG)
8607         cp_error ("destructor for alien class `%T' cannot be a member",
8608                   ctype);
8609       else
8610         cp_error ("constructor for alien class `%T' cannot be a member",
8611                   ctype);
8612       return 0;
8613     }
8614   return 1;
8615 }
8616 \f
8617 /* Subroutine of `grokdeclarator'.  */
8618
8619 /* Generate errors possibly applicable for a given set of specifiers.
8620    This is for ARM $7.1.2.  */
8621
8622 static void
8623 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8624      tree object;
8625      const char *type;
8626      int virtualp, quals, friendp, raises, inlinep;
8627 {
8628   if (virtualp)
8629     cp_error ("`%D' declared as a `virtual' %s", object, type);
8630   if (inlinep)
8631     cp_error ("`%D' declared as an `inline' %s", object, type);
8632   if (quals)
8633     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8634               object, type);
8635   if (friendp)
8636     cp_error_at ("`%D' declared as a friend", object);
8637   if (raises && !TYPE_PTRFN_P (TREE_TYPE (object))
8638       && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))
8639     cp_error_at ("`%D' declared with an exception specification", object);
8640 }
8641
8642 /* CTYPE is class type, or null if non-class.
8643    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8644    or METHOD_TYPE.
8645    DECLARATOR is the function's name.
8646    VIRTUALP is truthvalue of whether the function is virtual or not.
8647    FLAGS are to be passed through to `grokclassfn'.
8648    QUALS are qualifiers indicating whether the function is `const'
8649    or `volatile'.
8650    RAISES is a list of exceptions that this function can raise.
8651    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8652    not look, and -1 if we should not call `grokclassfn' at all.
8653
8654    Returns `NULL_TREE' if something goes wrong, after issuing
8655    applicable error messages.  */
8656
8657 static tree
8658 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8659             raises, check, friendp, publicp, inlinep, funcdef_flag,
8660             template_count, in_namespace)
8661      tree ctype, type;
8662      tree declarator;
8663      tree orig_declarator;
8664      int virtualp;
8665      enum overload_flags flags;
8666      tree quals, raises;
8667      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8668      tree in_namespace;
8669 {
8670   tree decl;
8671   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8672   int has_default_arg = 0;
8673   tree t;
8674
8675   if (raises)
8676     {
8677       type = build_exception_variant (type, raises);
8678     }
8679
8680   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8681   /* Propagate volatile out from type to decl. */
8682   if (TYPE_VOLATILE (type))
8683     TREE_THIS_VOLATILE (decl) = 1;
8684
8685   /* If this decl has namespace scope, set that up.  */
8686   if (in_namespace)
8687     set_decl_namespace (decl, in_namespace, friendp);
8688   else if (!ctype)
8689     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8690
8691   /* `main' and builtins have implicit 'C' linkage.  */
8692   if ((MAIN_NAME_P (declarator)
8693        || (IDENTIFIER_LENGTH (declarator) > 10
8694            && IDENTIFIER_POINTER (declarator)[0] == '_'
8695            && IDENTIFIER_POINTER (declarator)[1] == '_'
8696            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8697       && current_lang_name == lang_name_cplusplus
8698       && ctype == NULL_TREE
8699       /* NULL_TREE means global namespace.  */
8700       && DECL_CONTEXT (decl) == NULL_TREE)
8701     SET_DECL_LANGUAGE (decl, lang_c);
8702
8703   /* Should probably propagate const out from type to decl I bet (mrs).  */
8704   if (staticp)
8705     {
8706       DECL_STATIC_FUNCTION_P (decl) = 1;
8707       DECL_CONTEXT (decl) = ctype;
8708     }
8709
8710   if (ctype)
8711     DECL_CONTEXT (decl) = ctype;
8712
8713   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8714     {
8715       if (processing_template_decl)
8716         error ("cannot declare `::main' to be a template");
8717       if (inlinep)
8718         error ("cannot declare `::main' to be inline");
8719       if (!publicp)
8720         error ("cannot declare `::main' to be static");
8721       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8722                         integer_type_node))
8723         error ("`main' must return `int'");
8724       inlinep = 0;
8725       publicp = 1;
8726     }
8727
8728   /* Members of anonymous types and local classes have no linkage; make
8729      them internal.  */
8730   /* FIXME what if it gets a name from typedef?  */
8731   if (ctype && (TYPE_ANONYMOUS_P (ctype)
8732                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8733     publicp = 0;
8734
8735   if (publicp)
8736     {
8737       /* [basic.link]: A name with no linkage (notably, the name of a class
8738          or enumeration declared in a local scope) shall not be used to
8739          declare an entity with linkage.
8740
8741          Only check this for public decls for now.  */
8742       t = no_linkage_check (TREE_TYPE (decl));
8743       if (t)
8744         {
8745           if (TYPE_ANONYMOUS_P (t))
8746             {
8747               if (DECL_EXTERN_C_P (decl))
8748                 /* Allow this; it's pretty common in C.  */;
8749               else
8750                 {
8751                   cp_pedwarn ("non-local function `%#D' uses anonymous type",
8752                               decl);
8753                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
8754                     cp_pedwarn_at ("\
8755 `%#D' does not refer to the unqualified type, so it is not used for linkage",
8756                                 TYPE_NAME (t));
8757                 }
8758             }
8759           else
8760             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8761                         decl, t);
8762         }
8763     }
8764
8765   TREE_PUBLIC (decl) = publicp;
8766   if (! publicp)
8767     {
8768       DECL_INTERFACE_KNOWN (decl) = 1;
8769       DECL_NOT_REALLY_EXTERN (decl) = 1;
8770     }
8771
8772   /* If the declaration was declared inline, mark it as such.  */
8773   if (inlinep)
8774     DECL_DECLARED_INLINE_P (decl) = 1;
8775   /* We inline functions that are explicitly declared inline, or, when
8776      the user explicitly asks us to, all functions.  */
8777   if (DECL_DECLARED_INLINE_P (decl) || flag_inline_trees == 2)
8778     DECL_INLINE (decl) = 1;
8779
8780   DECL_EXTERNAL (decl) = 1;
8781   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8782     {
8783       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8784                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8785       quals = NULL_TREE;
8786     }
8787
8788   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8789     grok_op_properties (decl, virtualp, check < 0);
8790
8791   if (ctype && decl_function_context (decl))
8792     DECL_NO_STATIC_CHAIN (decl) = 1;
8793
8794   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8795     if (TREE_PURPOSE (t)
8796         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8797       {
8798         has_default_arg = 1;
8799         break;
8800       }
8801
8802   if (friendp
8803       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8804     {
8805       if (funcdef_flag)
8806         cp_error
8807           ("defining explicit specialization `%D' in friend declaration",
8808            orig_declarator);
8809       else
8810         {
8811           tree fns = TREE_OPERAND (orig_declarator, 0);
8812           tree args = TREE_OPERAND (orig_declarator, 1);
8813
8814           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8815             {
8816               /* Something like `template <class T> friend void f<T>()'.  */
8817               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8818                         orig_declarator);
8819               return NULL_TREE;
8820             }
8821
8822
8823           /* A friend declaration of the form friend void f<>().  Record
8824              the information in the TEMPLATE_ID_EXPR.  */
8825           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8826
8827           if (TREE_CODE (fns) == COMPONENT_REF)
8828             {
8829               /* Due to bison parser ickiness, we will have already looked
8830                  up an operator_name or PFUNCNAME within the current class
8831                  (see template_id in parse.y). If the current class contains
8832                  such a name, we'll get a COMPONENT_REF here. Undo that. */
8833
8834               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
8835                                   == current_class_type, 20001120);
8836               fns = TREE_OPERAND (fns, 1);
8837             }
8838           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
8839                               || TREE_CODE (fns) == LOOKUP_EXPR
8840                               || TREE_CODE (fns) == OVERLOAD, 20001120);
8841           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
8842
8843           if (has_default_arg)
8844             {
8845               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8846                         decl);
8847               return NULL_TREE;
8848             }
8849
8850           if (inlinep)
8851             {
8852               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8853                         decl);
8854               return NULL_TREE;
8855             }
8856         }
8857     }
8858
8859   if (has_default_arg)
8860     add_defarg_fn (decl);
8861
8862   if (funcdef_flag)
8863     /* Make the init_value nonzero so pushdecl knows this is not
8864        tentative.  error_mark_node is replaced later with the BLOCK.  */
8865     DECL_INITIAL (decl) = error_mark_node;
8866
8867   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8868     TREE_NOTHROW (decl) = 1;
8869
8870   /* Caller will do the rest of this.  */
8871   if (check < 0)
8872     return decl;
8873
8874   if (flags == NO_SPECIAL && ctype && constructor_name (ctype) == declarator)
8875     DECL_CONSTRUCTOR_P (decl) = 1;
8876
8877   /* Function gets the ugly name, field gets the nice one.  This call
8878      may change the type of the function (because of default
8879      parameters)!  */
8880   if (ctype != NULL_TREE)
8881     grokclassfn (ctype, decl, flags, quals);
8882
8883   decl = check_explicit_specialization (orig_declarator, decl,
8884                                         template_count,
8885                                         2 * (funcdef_flag != 0) +
8886                                         4 * (friendp != 0));
8887   if (decl == error_mark_node)
8888     return NULL_TREE;
8889
8890   if (ctype != NULL_TREE
8891       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8892       && check)
8893     {
8894       tree old_decl;
8895
8896       old_decl = check_classfn (ctype, decl);
8897
8898       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
8899         /* Because grokfndecl is always supposed to return a
8900            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8901            here.  We depend on our callers to figure out that its
8902            really a template that's being returned.  */
8903         old_decl = DECL_TEMPLATE_RESULT (old_decl);
8904
8905       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
8906           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8907         {
8908           /* Remove the `this' parm added by grokclassfn.
8909              XXX Isn't this done in start_function, too?  */
8910           revert_static_member_fn (decl);
8911           last_function_parms = TREE_CHAIN (last_function_parms);
8912         }
8913       if (old_decl && DECL_ARTIFICIAL (old_decl))
8914         cp_error ("definition of implicitly-declared `%D'", old_decl);
8915
8916       if (old_decl)
8917         {
8918           /* Since we've smashed OLD_DECL to its
8919              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
8920           if (TREE_CODE (decl) == TEMPLATE_DECL)
8921             decl = DECL_TEMPLATE_RESULT (decl);
8922
8923           /* Attempt to merge the declarations.  This can fail, in
8924              the case of some illegal specialization declarations.  */
8925           if (!duplicate_decls (decl, old_decl))
8926             cp_error ("no `%#D' member function declared in class `%T'",
8927                       decl, ctype);
8928           return old_decl;
8929         }
8930     }
8931
8932   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
8933     return NULL_TREE;
8934
8935   if (ctype == NULL_TREE || check)
8936     return decl;
8937
8938   if (virtualp)
8939     DECL_VIRTUAL_P (decl) = 1;
8940
8941   return decl;
8942 }
8943
8944 static tree
8945 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
8946      tree type;
8947      tree declarator;
8948      RID_BIT_TYPE *specbits_in;
8949      int initialized;
8950      int constp;
8951      tree in_namespace;
8952 {
8953   tree decl;
8954   RID_BIT_TYPE specbits;
8955
8956   specbits = *specbits_in;
8957
8958   if (TREE_CODE (type) == OFFSET_TYPE)
8959     {
8960       /* If you declare a static member so that it
8961          can be initialized, the code will reach here.  */
8962       tree basetype = TYPE_OFFSET_BASETYPE (type);
8963       type = TREE_TYPE (type);
8964       decl = build_lang_decl (VAR_DECL, declarator, type);
8965       DECL_CONTEXT (decl) = basetype;
8966     }
8967   else
8968     {
8969       tree context;
8970
8971       if (in_namespace)
8972         context = in_namespace;
8973       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
8974         context = current_namespace;
8975       else
8976         context = NULL_TREE;
8977
8978       /* For namespace-scope variables, declared in a template, we
8979          need the full lang_decl.  The same is true for
8980          namespace-scope variables that do not have C++ language
8981          linkage.  */
8982       if (context
8983           && (processing_template_decl
8984               || current_lang_name != lang_name_cplusplus))
8985         decl = build_lang_decl (VAR_DECL, declarator, type);
8986       else
8987         decl = build_decl (VAR_DECL, declarator, type);
8988
8989       if (context)
8990         set_decl_namespace (decl, context, 0);
8991
8992       context = DECL_CONTEXT (decl);
8993       if (declarator && context && current_lang_name != lang_name_c)
8994         /* We can't mangle lazily here because we don't have any
8995            way to recover whether or not a variable was `extern
8996            "C"' later.  */
8997         mangle_decl (decl);
8998     }
8999
9000   if (in_namespace)
9001     set_decl_namespace (decl, in_namespace, 0);
9002
9003   if (RIDBIT_SETP (RID_EXTERN, specbits))
9004     {
9005       DECL_THIS_EXTERN (decl) = 1;
9006       DECL_EXTERNAL (decl) = !initialized;
9007     }
9008
9009   /* In class context, static means one per class,
9010      public access, and static storage.  */
9011   if (DECL_CLASS_SCOPE_P (decl))
9012     {
9013       TREE_PUBLIC (decl) = 1;
9014       TREE_STATIC (decl) = 1;
9015       DECL_EXTERNAL (decl) = 0;
9016     }
9017   /* At top level, either `static' or no s.c. makes a definition
9018      (perhaps tentative), and absence of `static' makes it public.  */
9019   else if (toplevel_bindings_p ())
9020     {
9021       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9022                             && (DECL_THIS_EXTERN (decl) || ! constp));
9023       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9024     }
9025   /* Not at top level, only `static' makes a static definition.  */
9026   else
9027     {
9028       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9029       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9030     }
9031
9032   if (TREE_PUBLIC (decl))
9033     {
9034       /* [basic.link]: A name with no linkage (notably, the name of a class
9035          or enumeration declared in a local scope) shall not be used to
9036          declare an entity with linkage.
9037
9038          Only check this for public decls for now.  */
9039       tree t = no_linkage_check (TREE_TYPE (decl));
9040       if (t)
9041         {
9042           if (TYPE_ANONYMOUS_P (t))
9043             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9044           else
9045             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9046                         decl, t);
9047         }
9048     }
9049
9050   return decl;
9051 }
9052
9053 /* Create and return a canonical pointer to member function type, for
9054    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9055
9056 tree
9057 build_ptrmemfunc_type (type)
9058      tree type;
9059 {
9060   tree fields[4];
9061   tree t;
9062   tree unqualified_variant = NULL_TREE;
9063
9064   if (type == error_mark_node)
9065     return type;
9066
9067   /* If a canonical type already exists for this type, use it.  We use
9068      this method instead of type_hash_canon, because it only does a
9069      simple equality check on the list of field members.  */
9070
9071   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9072     return t;
9073
9074   /* Make sure that we always have the unqualified pointer-to-member
9075      type first.  */
9076   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9077     unqualified_variant
9078       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9079
9080   t = make_aggr_type (RECORD_TYPE);
9081   /* Let the front-end know this is a pointer to member function...  */
9082   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9083   /* ... and not really an aggregate.  */
9084   SET_IS_AGGR_TYPE (t, 0);
9085
9086   fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9087   fields[1] = build_decl (FIELD_DECL, delta_identifier,
9088                           delta_type_node);
9089   finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9090
9091   /* Zap out the name so that the back-end will give us the debugging
9092      information for this anonymous RECORD_TYPE.  */
9093   TYPE_NAME (t) = NULL_TREE;
9094
9095   /* If this is not the unqualified form of this pointer-to-member
9096      type, set the TYPE_MAIN_VARIANT for this type to be the
9097      unqualified type.  Since they are actually RECORD_TYPEs that are
9098      not variants of each other, we must do this manually.  */
9099   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9100     {
9101       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9102       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9103       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9104       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9105     }
9106
9107   /* Cache this pointer-to-member type so that we can find it again
9108      later.  */
9109   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9110
9111   /* Seems to be wanted.  */
9112   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9113
9114   return t;
9115 }
9116
9117 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9118    Check to see that the definition is valid.  Issue appropriate error
9119    messages.  Return 1 if the definition is particularly bad, or 0
9120    otherwise.  */
9121
9122 int
9123 check_static_variable_definition (decl, type)
9124      tree decl;
9125      tree type;
9126 {
9127   /* Motion 10 at San Diego: If a static const integral data member is
9128      initialized with an integral constant expression, the initializer
9129      may appear either in the declaration (within the class), or in
9130      the definition, but not both.  If it appears in the class, the
9131      member is a member constant.  The file-scope definition is always
9132      required.  */
9133   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9134     {
9135       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9136                 type);
9137       /* If we just return the declaration, crashes will sometimes
9138          occur.  We therefore return void_type_node, as if this was a
9139          friend declaration, to cause callers to completely ignore
9140          this declaration.  */
9141       return 1;
9142     }
9143   else if (!CP_TYPE_CONST_P (type))
9144     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9145               decl);
9146   else if (pedantic && !INTEGRAL_TYPE_P (type))
9147     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9148
9149   return 0;
9150 }
9151
9152 /* Given the SIZE (i.e., number of elements) in an array, compute an
9153    appropriate index type for the array.  If non-NULL, NAME is the
9154    name of the thing being declared.  */
9155
9156 tree
9157 compute_array_index_type (name, size)
9158      tree name;
9159      tree size;
9160 {
9161   tree itype;
9162
9163   /* If this involves a template parameter, it will be a constant at
9164      instantiation time, but we don't know what the value is yet.
9165      Even if no template parameters are involved, we may an expression
9166      that is not a constant; we don't even simplify `1 + 2' when
9167      processing a template.  */
9168   if (processing_template_decl)
9169     {
9170       /* Resolve a qualified reference to an enumerator or static
9171          const data member of ours.  */
9172       if (TREE_CODE (size) == SCOPE_REF
9173           && TREE_OPERAND (size, 0) == current_class_type)
9174         {
9175           tree t = lookup_field (current_class_type,
9176                                  TREE_OPERAND (size, 1), 0, 0);
9177           if (t)
9178             size = t;
9179         }
9180
9181       return build_index_type (build_min (MINUS_EXPR, sizetype,
9182                                           size, integer_one_node));
9183     }
9184
9185   /* The size might be the result of a cast. */
9186   STRIP_TYPE_NOPS (size);
9187
9188   /* It might be a const variable or enumeration constant.  */
9189   size = decl_constant_value (size);
9190
9191   /* The array bound must be an integer type.  */
9192   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9193       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9194       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9195     {
9196       if (name)
9197         cp_error ("size of array `%D' has non-integer type", name);
9198       else
9199         cp_error ("size of array has non-integer type");
9200       size = integer_one_node;
9201     }
9202
9203   /* Normally, the array-bound will be a constant.  */
9204   if (TREE_CODE (size) == INTEGER_CST)
9205     {
9206       /* Check to see if the array bound overflowed.  Make that an
9207          error, no matter how generous we're being.  */
9208       int old_flag_pedantic_errors = flag_pedantic_errors;
9209       int old_pedantic = pedantic;
9210       pedantic = flag_pedantic_errors = 1;
9211       constant_expression_warning (size);
9212       pedantic = old_pedantic;
9213       flag_pedantic_errors = old_flag_pedantic_errors;
9214
9215       /* An array must have a positive number of elements.  */
9216       if (INT_CST_LT (size, integer_zero_node))
9217         {
9218           if (name)
9219             cp_error ("size of array `%D' is negative", name);
9220           else
9221             cp_error ("size of array is negative");
9222           size = integer_one_node;
9223         }
9224       /* Except that an extension we allow zero-sized arrays.  We
9225          always allow them in system headers because glibc uses
9226          them.  */
9227       else if (integer_zerop (size) && pedantic && !in_system_header)
9228         {
9229           if (name)
9230             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9231           else
9232             cp_pedwarn ("ISO C++ forbids zero-size array");
9233         }
9234     }
9235   else if (TREE_CONSTANT (size))
9236     {
9237       /* `(int) &fn' is not a valid array bound.  */
9238       if (name)
9239         cp_error ("size of array `%D' is not an integral constant-expression",
9240                   name);
9241       else
9242         cp_error ("size of array is not an integral constant-expression");
9243     }
9244
9245   /* Compute the index of the largest element in the array.  It is
9246      one less than the number of elements in the array.  */
9247   itype
9248     = fold (cp_build_binary_op (MINUS_EXPR,
9249                                 cp_convert (ssizetype, size),
9250                                 cp_convert (ssizetype,
9251                                             integer_one_node)));
9252
9253   /* Check for variable-sized arrays.  We allow such things as an
9254      extension, even though they are not allowed in ANSI/ISO C++.  */
9255   if (!TREE_CONSTANT (itype))
9256     {
9257       if (pedantic)
9258         {
9259           if (name)
9260             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9261                         name);
9262           else
9263             cp_pedwarn ("ISO C++ forbids variable-size array");
9264         }
9265
9266       /* Create a variable-sized array index type.  */
9267       itype = variable_size (itype);
9268     }
9269   /* Make sure that there was no overflow when creating to a signed
9270      index type.  (For example, on a 32-bit machine, an array with
9271      size 2^32 - 1 is too big.)  */
9272   else if (TREE_OVERFLOW (itype))
9273     {
9274       error ("overflow in array dimension");
9275       TREE_OVERFLOW (itype) = 0;
9276     }
9277
9278   /* Create and return the appropriate index type.  */
9279   return build_index_type (itype);
9280 }
9281
9282 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9283    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9284    with this type.  */
9285
9286 static tree
9287 create_array_type_for_decl (name, type, size)
9288      tree name;
9289      tree type;
9290      tree size;
9291 {
9292   tree itype = NULL_TREE;
9293   const char* error_msg;
9294
9295   /* If things have already gone awry, bail now.  */
9296   if (type == error_mark_node || size == error_mark_node)
9297     return error_mark_node;
9298
9299   /* Assume that everything will go OK.  */
9300   error_msg = NULL;
9301
9302   /* There are some types which cannot be array elements.  */
9303   switch (TREE_CODE (type))
9304     {
9305     case VOID_TYPE:
9306       error_msg = "array of void";
9307       break;
9308
9309     case FUNCTION_TYPE:
9310       error_msg = "array of functions";
9311       break;
9312
9313     case REFERENCE_TYPE:
9314       error_msg = "array of references";
9315       break;
9316
9317     case OFFSET_TYPE:
9318       error_msg = "array of data members";
9319       break;
9320
9321     case METHOD_TYPE:
9322       error_msg = "array of function members";
9323       break;
9324
9325     default:
9326       break;
9327     }
9328
9329   /* If something went wrong, issue an error-message and return.  */
9330   if (error_msg)
9331     {
9332       if (name)
9333         cp_error ("declaration of `%D' as %s", name, error_msg);
9334       else
9335         cp_error ("creating %s", error_msg);
9336
9337       return error_mark_node;
9338     }
9339
9340   /* [dcl.array]
9341
9342      The constant expressions that specify the bounds of the arrays
9343      can be omitted only for the first member of the sequence.  */
9344   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9345     {
9346       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9347                 name);
9348
9349       return error_mark_node;
9350     }
9351
9352   /* Figure out the index type for the array.  */
9353   if (size)
9354     itype = compute_array_index_type (name, size);
9355
9356   return build_cplus_array_type (type, itype);
9357 }
9358
9359 /* Check that it's OK to declare a function with the indicated TYPE.
9360    SFK indicates the kind of special function (if any) that this
9361    function is.  OPTYPE is the type given in a conversion operator
9362    declaration.  Returns the actual return type of the function; that
9363    may be different than TYPE if an error occurs, or for certain
9364    special functions.  */
9365
9366 static tree
9367 check_special_function_return_type (sfk, type, optype)
9368      special_function_kind sfk;
9369      tree type;
9370      tree optype;
9371 {
9372   switch (sfk)
9373     {
9374     case sfk_constructor:
9375       if (type)
9376         cp_error ("return type specification for constructor invalid");
9377
9378       type = void_type_node;
9379       break;
9380
9381     case sfk_destructor:
9382       if (type)
9383         cp_error ("return type specification for destructor invalid");
9384       type = void_type_node;
9385       break;
9386
9387     case sfk_conversion:
9388       if (type && !same_type_p (type, optype))
9389         cp_error ("operator `%T' declared to return `%T'", optype, type);
9390       else if (type)
9391         cp_pedwarn ("return type specified for `operator %T'",  optype);
9392       type = optype;
9393       break;
9394
9395     default:
9396       my_friendly_abort (20000408);
9397       break;
9398     }
9399
9400   return type;
9401 }
9402
9403 /* Given declspecs and a declarator,
9404    determine the name and type of the object declared
9405    and construct a ..._DECL node for it.
9406    (In one case we can return a ..._TYPE node instead.
9407     For invalid input we sometimes return 0.)
9408
9409    DECLSPECS is a chain of tree_list nodes whose value fields
9410     are the storage classes and type specifiers.
9411
9412    DECL_CONTEXT says which syntactic context this declaration is in:
9413      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9414      FUNCDEF for a function definition.  Like NORMAL but a few different
9415       error messages in each case.  Return value may be zero meaning
9416       this definition is too screwy to try to parse.
9417      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9418       handle member functions (which have FIELD context).
9419       Return value may be zero meaning this definition is too screwy to
9420       try to parse.
9421      PARM for a parameter declaration (either within a function prototype
9422       or before a function body).  Make a PARM_DECL, or return void_type_node.
9423      CATCHPARM for a parameter declaration before a catch clause.
9424      TYPENAME if for a typename (in a cast or sizeof).
9425       Don't make a DECL node; just return the ..._TYPE node.
9426      FIELD for a struct or union field; make a FIELD_DECL.
9427      BITFIELD for a field with specified width.
9428    INITIALIZED is 1 if the decl has an initializer.
9429
9430    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9431    normal attributes in TREE_PURPOSE, or NULL_TREE.
9432
9433    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9434    It may also be so in the PARM case, for a prototype where the
9435    argument type is specified but not the name.
9436
9437    This function is where the complicated C meanings of `static'
9438    and `extern' are interpreted.
9439
9440    For C++, if there is any monkey business to do, the function which
9441    calls this one must do it, i.e., prepending instance variables,
9442    renaming overloaded function names, etc.
9443
9444    Note that for this C++, it is an error to define a method within a class
9445    which does not belong to that class.
9446
9447    Except in the case where SCOPE_REFs are implicitly known (such as
9448    methods within a class being redundantly qualified),
9449    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9450    (class_name::decl_name).  The caller must also deal with this.
9451
9452    If a constructor or destructor is seen, and the context is FIELD,
9453    then the type gains the attribute TREE_HAS_x.  If such a declaration
9454    is erroneous, NULL_TREE is returned.
9455
9456    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9457    function, these are the qualifiers to give to the `this' pointer. We
9458    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9459
9460    May return void_type_node if the declarator turned out to be a friend.
9461    See grokfield for details.  */
9462
9463 tree
9464 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9465      tree declspecs;
9466      tree declarator;
9467      enum decl_context decl_context;
9468      int initialized;
9469      tree attrlist;
9470 {
9471   RID_BIT_TYPE specbits;
9472   int nclasses = 0;
9473   tree spec;
9474   tree type = NULL_TREE;
9475   int longlong = 0;
9476   int constp;
9477   int restrictp;
9478   int volatilep;
9479   int type_quals;
9480   int virtualp, explicitp, friendp, inlinep, staticp;
9481   int explicit_int = 0;
9482   int explicit_char = 0;
9483   int defaulted_int = 0;
9484   tree typedef_decl = NULL_TREE;
9485   const char *name;
9486   tree typedef_type = NULL_TREE;
9487   int funcdef_flag = 0;
9488   enum tree_code innermost_code = ERROR_MARK;
9489   int bitfield = 0;
9490 #if 0
9491   /* See the code below that used this.  */
9492   tree decl_machine_attr = NULL_TREE;
9493 #endif
9494   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9495      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9496   tree init = NULL_TREE;
9497
9498   /* Keep track of what sort of function is being processed
9499      so that we can warn about default return values, or explicit
9500      return values which do not match prescribed defaults.  */
9501   special_function_kind sfk = sfk_none;
9502
9503   tree dname = NULL_TREE;
9504   tree ctype = current_class_type;
9505   tree ctor_return_type = NULL_TREE;
9506   enum overload_flags flags = NO_SPECIAL;
9507   tree quals = NULL_TREE;
9508   tree raises = NULL_TREE;
9509   int template_count = 0;
9510   tree in_namespace = NULL_TREE;
9511   tree inner_attrs;
9512   int ignore_attrs;
9513
9514   RIDBIT_RESET_ALL (specbits);
9515   if (decl_context == FUNCDEF)
9516     funcdef_flag = 1, decl_context = NORMAL;
9517   else if (decl_context == MEMFUNCDEF)
9518     funcdef_flag = -1, decl_context = FIELD;
9519   else if (decl_context == BITFIELD)
9520     bitfield = 1, decl_context = FIELD;
9521
9522   /* Look inside a declarator for the name being declared
9523      and get it as a string, for an error message.  */
9524   {
9525     tree *next = &declarator;
9526     register tree decl;
9527     name = NULL;
9528
9529     while (next && *next)
9530       {
9531         decl = *next;
9532         switch (TREE_CODE (decl))
9533           {
9534           case TREE_LIST:
9535             /* For attributes.  */
9536             next = &TREE_VALUE (decl);
9537             break;
9538
9539           case COND_EXPR:
9540             ctype = NULL_TREE;
9541             next = &TREE_OPERAND (decl, 0);
9542             break;
9543
9544           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9545             {
9546               tree name = TREE_OPERAND (decl, 0);
9547               tree rename = NULL_TREE;
9548
9549               my_friendly_assert (flags == NO_SPECIAL, 152);
9550               flags = DTOR_FLAG;
9551               sfk = sfk_destructor;
9552               if (TREE_CODE (name) == TYPE_DECL)
9553                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9554               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9555               if (ctype == NULL_TREE)
9556                 {
9557                   if (current_class_type == NULL_TREE)
9558                     {
9559                       error ("destructors must be member functions");
9560                       flags = NO_SPECIAL;
9561                     }
9562                   else
9563                     {
9564                       tree t = constructor_name (current_class_name);
9565                       if (t != name)
9566                         rename = t;
9567                     }
9568                 }
9569               else
9570                 {
9571                   tree t = constructor_name (ctype);
9572                   if (t != name)
9573                     rename = t;
9574                 }
9575
9576               if (rename)
9577                 {
9578                   cp_error ("destructor `%T' must match class name `%T'",
9579                             name, rename);
9580                   TREE_OPERAND (decl, 0) = rename;
9581                 }
9582               next = &name;
9583             }
9584             break;
9585
9586           case ADDR_EXPR:       /* C++ reference declaration */
9587             /* Fall through. */
9588           case ARRAY_REF:
9589           case INDIRECT_REF:
9590             ctype = NULL_TREE;
9591             innermost_code = TREE_CODE (decl);
9592             next = &TREE_OPERAND (decl, 0);
9593             break;
9594
9595           case CALL_EXPR:
9596             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9597               {
9598                 /* This is actually a variable declaration using
9599                    constructor syntax.  We need to call start_decl and
9600                    cp_finish_decl so we can get the variable
9601                    initialized...  */
9602
9603                 tree attributes, prefix_attributes;
9604
9605                 *next = TREE_OPERAND (decl, 0);
9606                 init = CALL_DECLARATOR_PARMS (decl);
9607
9608                 if (attrlist)
9609                   {
9610                     attributes = TREE_PURPOSE (attrlist);
9611                     prefix_attributes = TREE_VALUE (attrlist);
9612                   }
9613                 else
9614                   {
9615                     attributes = NULL_TREE;
9616                     prefix_attributes = NULL_TREE;
9617                   }
9618
9619                 decl = start_decl (declarator, declspecs, 1,
9620                                    attributes, prefix_attributes);
9621                 decl_type_access_control (decl);
9622                 if (decl)
9623                   {
9624                     /* Look for __unused__ attribute */
9625                     if (TREE_USED (TREE_TYPE (decl)))
9626                       TREE_USED (decl) = 1;
9627                     finish_decl (decl, init, NULL_TREE);
9628                   }
9629                 else
9630                   cp_error ("invalid declarator");
9631                 return 0;
9632               }
9633             innermost_code = TREE_CODE (decl);
9634             if (decl_context == FIELD && ctype == NULL_TREE)
9635               ctype = current_class_type;
9636             if (ctype
9637                 && TREE_OPERAND (decl, 0)
9638                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9639                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9640                          == constructor_name_full (ctype))
9641                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9642                             == constructor_name (ctype)))))
9643               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9644             next = &TREE_OPERAND (decl, 0);
9645             decl = *next;
9646             if (ctype != NULL_TREE
9647                 && decl != NULL_TREE && flags != DTOR_FLAG
9648                 && decl == constructor_name (ctype))
9649               {
9650                 sfk = sfk_constructor;
9651                 ctor_return_type = ctype;
9652               }
9653             ctype = NULL_TREE;
9654             break;
9655
9656           case TEMPLATE_ID_EXPR:
9657               {
9658                 tree fns = TREE_OPERAND (decl, 0);
9659
9660                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9661                   fns = TREE_OPERAND (fns, 0);
9662
9663                 dname = fns;
9664                 if (TREE_CODE (dname) == COMPONENT_REF)
9665                   dname = TREE_OPERAND (dname, 1);
9666                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9667                   {
9668                     my_friendly_assert (is_overloaded_fn (dname),
9669                                         19990331);
9670                     dname = DECL_NAME (get_first_fn (dname));
9671                   }
9672               }
9673           /* Fall through. */
9674
9675           case IDENTIFIER_NODE:
9676             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9677               dname = decl;
9678
9679             next = 0;
9680
9681             if (C_IS_RESERVED_WORD (dname))
9682               {
9683                 cp_error ("declarator-id missing; using reserved word `%D'",
9684                           dname);
9685                 name = IDENTIFIER_POINTER (dname);
9686               }
9687             else if (!IDENTIFIER_TYPENAME_P (dname))
9688               name = IDENTIFIER_POINTER (dname);
9689             else
9690               {
9691                 my_friendly_assert (flags == NO_SPECIAL, 154);
9692                 flags = TYPENAME_FLAG;
9693                 ctor_return_type = TREE_TYPE (dname);
9694                 sfk = sfk_conversion;
9695                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9696                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9697                         == TYPE_DECL))
9698                   name = IDENTIFIER_POINTER (dname);
9699                 else
9700                   name = "<invalid operator>";
9701               }
9702             break;
9703
9704             /* C++ extension */
9705           case SCOPE_REF:
9706             {
9707               /* Perform error checking, and decide on a ctype.  */
9708               tree cname = TREE_OPERAND (decl, 0);
9709               if (cname == NULL_TREE)
9710                 ctype = NULL_TREE;
9711               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9712                 {
9713                   ctype = NULL_TREE;
9714                   in_namespace = TREE_OPERAND (decl, 0);
9715                   TREE_OPERAND (decl, 0) = NULL_TREE;
9716                 }
9717               else if (! is_aggr_type (cname, 1))
9718                 TREE_OPERAND (decl, 0) = NULL_TREE;
9719               /* Must test TREE_OPERAND (decl, 1), in case user gives
9720                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9721               else if (TREE_OPERAND (decl, 1)
9722                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9723                 ctype = cname;
9724               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9725                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9726                 {
9727                   cp_error ("`%T::%D' is not a valid declarator", cname,
9728                             TREE_OPERAND (decl, 1));
9729                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9730                             cname, TREE_OPERAND (decl, 1));
9731                   return void_type_node;
9732                 }
9733               else if (ctype == NULL_TREE)
9734                 ctype = cname;
9735               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9736                 TREE_OPERAND (decl, 0) = ctype;
9737               else
9738                 {
9739                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9740                     {
9741                       cp_error ("type `%T' is not derived from type `%T'",
9742                                 cname, ctype);
9743                       TREE_OPERAND (decl, 0) = NULL_TREE;
9744                     }
9745                   else
9746                     ctype = cname;
9747                 }
9748
9749               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9750                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9751                        == constructor_name_full (ctype))
9752                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9753                           == constructor_name (ctype))))
9754                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9755               next = &TREE_OPERAND (decl, 1);
9756               decl = *next;
9757               if (ctype)
9758                 {
9759                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9760                       && constructor_name (ctype) == decl)
9761                     {
9762                       sfk = sfk_constructor;
9763                       ctor_return_type = ctype;
9764                     }
9765                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9766                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9767                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9768                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9769                     {
9770                       sfk = sfk_destructor;
9771                       ctor_return_type = ctype;
9772                       flags = DTOR_FLAG;
9773                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9774                       next = &TREE_OPERAND (decl, 0);
9775                     }
9776                 }
9777             }
9778             break;
9779
9780           case ERROR_MARK:
9781             next = 0;
9782             break;
9783
9784           case TYPE_DECL:
9785             /* Parse error puts this typespec where
9786                a declarator should go.  */
9787             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9788             if (TREE_TYPE (decl) == current_class_type)
9789               cp_error ("  perhaps you want `%T' for a constructor",
9790                         current_class_name);
9791             dname = DECL_NAME (decl);
9792             name = IDENTIFIER_POINTER (dname);
9793
9794             /* Avoid giving two errors for this.  */
9795             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9796
9797             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9798             *next = dname;
9799             next = 0;
9800             break;
9801
9802           default:
9803             cp_compiler_error ("`%D' as declarator", decl);
9804             return 0; /* We used to do a 155 abort here.  */
9805           }
9806       }
9807   }
9808
9809   /* A function definition's declarator must have the form of
9810      a function declarator.  */
9811
9812   if (funcdef_flag && innermost_code != CALL_EXPR)
9813     return 0;
9814
9815   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9816       && innermost_code != CALL_EXPR
9817       && ! (ctype && declspecs == NULL_TREE))
9818     {
9819       cp_error ("declaration of `%D' as non-function", dname);
9820       return void_type_node;
9821     }
9822
9823   /* Anything declared one level down from the top level
9824      must be one of the parameters of a function
9825      (because the body is at least two levels down).  */
9826
9827   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9828      by not allowing C++ class definitions to specify their parameters
9829      with xdecls (must be spec.d in the parmlist).
9830
9831      Since we now wait to push a class scope until we are sure that
9832      we are in a legitimate method context, we must set oldcname
9833      explicitly (since current_class_name is not yet alive).
9834
9835      We also want to avoid calling this a PARM if it is in a namespace.  */
9836
9837   if (decl_context == NORMAL && !toplevel_bindings_p ())
9838     {
9839       struct binding_level *b = current_binding_level;
9840       current_binding_level = b->level_chain;
9841       if (current_binding_level != 0 && toplevel_bindings_p ())
9842         decl_context = PARM;
9843       current_binding_level = b;
9844     }
9845
9846   if (name == NULL)
9847     name = decl_context == PARM ? "parameter" : "type name";
9848
9849   /* Look through the decl specs and record which ones appear.
9850      Some typespecs are defined as built-in typenames.
9851      Others, the ones that are modifiers of other types,
9852      are represented by bits in SPECBITS: set the bits for
9853      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9854
9855      If there is a typedef name or a type, store the type in TYPE.
9856      This includes builtin typedefs such as `int'.
9857
9858      Set EXPLICIT_INT if the type is `int' or `char' and did not
9859      come from a user typedef.
9860
9861      Set LONGLONG if `long' is mentioned twice.
9862
9863      For C++, constructors and destructors have their own fast treatment.  */
9864
9865   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9866     {
9867       register int i;
9868       register tree id;
9869
9870       /* Certain parse errors slip through.  For example,
9871          `int class;' is not caught by the parser. Try
9872          weakly to recover here.  */
9873       if (TREE_CODE (spec) != TREE_LIST)
9874         return 0;
9875
9876       id = TREE_VALUE (spec);
9877
9878       if (TREE_CODE (id) == IDENTIFIER_NODE)
9879         {
9880           if (id == ridpointers[(int) RID_INT]
9881               || id == ridpointers[(int) RID_CHAR]
9882               || id == ridpointers[(int) RID_BOOL]
9883               || id == ridpointers[(int) RID_WCHAR])
9884             {
9885               if (type)
9886                 {
9887                   if (id == ridpointers[(int) RID_BOOL])
9888                     error ("`bool' is now a keyword");
9889                   else
9890                     cp_error ("extraneous `%T' ignored", id);
9891                 }
9892               else
9893                 {
9894                   if (id == ridpointers[(int) RID_INT])
9895                     explicit_int = 1;
9896                   else if (id == ridpointers[(int) RID_CHAR])
9897                     explicit_char = 1;
9898                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9899                 }
9900               goto found;
9901             }
9902           /* C++ aggregate types.  */
9903           if (IDENTIFIER_HAS_TYPE_VALUE (id))
9904             {
9905               if (type)
9906                 cp_error ("multiple declarations `%T' and `%T'", type, id);
9907               else
9908                 type = IDENTIFIER_TYPE_VALUE (id);
9909               goto found;
9910             }
9911
9912           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
9913             {
9914               if (ridpointers[i] == id)
9915                 {
9916                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
9917                     {
9918                       if (pedantic && ! in_system_header && warn_long_long)
9919                         pedwarn ("ISO C++ does not support `long long'");
9920                       if (longlong)
9921                         error ("`long long long' is too long for GCC");
9922                       else
9923                         longlong = 1;
9924                     }
9925                   else if (RIDBIT_SETP (i, specbits))
9926                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
9927                   RIDBIT_SET (i, specbits);
9928                   goto found;
9929                 }
9930             }
9931         }
9932       /* C++ aggregate types.  */
9933       else if (TREE_CODE (id) == TYPE_DECL)
9934         {
9935           if (type)
9936             cp_error ("multiple declarations `%T' and `%T'", type,
9937                       TREE_TYPE (id));
9938           else
9939             {
9940               type = TREE_TYPE (id);
9941               TREE_VALUE (spec) = type;
9942             }
9943           goto found;
9944         }
9945       if (type)
9946         error ("two or more data types in declaration of `%s'", name);
9947       else if (TREE_CODE (id) == IDENTIFIER_NODE)
9948         {
9949           register tree t = lookup_name (id, 1);
9950           if (!t || TREE_CODE (t) != TYPE_DECL)
9951             error ("`%s' fails to be a typedef or built in type",
9952                    IDENTIFIER_POINTER (id));
9953           else
9954             {
9955               type = TREE_TYPE (t);
9956 #if 0
9957               /* See the code below that used this.  */
9958               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
9959 #endif
9960               typedef_decl = t;
9961             }
9962         }
9963       else if (id != error_mark_node)
9964         /* Can't change CLASS nodes into RECORD nodes here!  */
9965         type = id;
9966
9967     found: ;
9968     }
9969
9970   typedef_type = type;
9971
9972   /* No type at all: default to `int', and set DEFAULTED_INT
9973      because it was not a user-defined typedef.  */
9974
9975   if (type == NULL_TREE
9976       && (RIDBIT_SETP (RID_SIGNED, specbits)
9977           || RIDBIT_SETP (RID_UNSIGNED, specbits)
9978           || RIDBIT_SETP (RID_LONG, specbits)
9979           || RIDBIT_SETP (RID_SHORT, specbits)))
9980     {
9981       /* These imply 'int'.  */
9982       type = integer_type_node;
9983       defaulted_int = 1;
9984     }
9985
9986   if (sfk != sfk_none)
9987     type = check_special_function_return_type (sfk, type,
9988                                                ctor_return_type);
9989   else if (type == NULL_TREE)
9990     {
9991       int is_main;
9992
9993       explicit_int = -1;
9994
9995       /* We handle `main' specially here, because 'main () { }' is so
9996          common.  With no options, it is allowed.  With -Wreturn-type,
9997          it is a warning.  It is only an error with -pedantic-errors.  */
9998       is_main = (funcdef_flag
9999                  && MAIN_NAME_P (dname)
10000                  && ctype == NULL_TREE
10001                  && in_namespace == NULL_TREE
10002                  && current_namespace == global_namespace);
10003
10004       if (in_system_header || flag_ms_extensions)
10005         /* Allow it, sigh.  */;
10006       else if (pedantic || ! is_main)
10007         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10008                     name);
10009       else if (warn_return_type)
10010         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10011                     name);
10012
10013       type = integer_type_node;
10014     }
10015
10016   ctype = NULL_TREE;
10017
10018   /* Now process the modifiers that were specified
10019      and check for invalid combinations.  */
10020
10021   /* Long double is a special combination.  */
10022
10023   if (RIDBIT_SETP (RID_LONG, specbits)
10024       && TYPE_MAIN_VARIANT (type) == double_type_node)
10025     {
10026       RIDBIT_RESET (RID_LONG, specbits);
10027       type = build_qualified_type (long_double_type_node,
10028                                    CP_TYPE_QUALS (type));
10029     }
10030
10031   /* Check all other uses of type modifiers.  */
10032
10033   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10034       || RIDBIT_SETP (RID_SIGNED, specbits)
10035       || RIDBIT_SETP (RID_LONG, specbits)
10036       || RIDBIT_SETP (RID_SHORT, specbits))
10037     {
10038       int ok = 0;
10039
10040       if (TREE_CODE (type) == REAL_TYPE)
10041         error ("short, signed or unsigned invalid for `%s'", name);
10042       else if (TREE_CODE (type) != INTEGER_TYPE)
10043         error ("long, short, signed or unsigned invalid for `%s'", name);
10044       else if (RIDBIT_SETP (RID_LONG, specbits)
10045                && RIDBIT_SETP (RID_SHORT, specbits))
10046         error ("long and short specified together for `%s'", name);
10047       else if ((RIDBIT_SETP (RID_LONG, specbits)
10048                 || RIDBIT_SETP (RID_SHORT, specbits))
10049                && explicit_char)
10050         error ("long or short specified with char for `%s'", name);
10051       else if ((RIDBIT_SETP (RID_LONG, specbits)
10052                 || RIDBIT_SETP (RID_SHORT, specbits))
10053                && TREE_CODE (type) == REAL_TYPE)
10054         error ("long or short specified with floating type for `%s'", name);
10055       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10056                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10057         error ("signed and unsigned given together for `%s'", name);
10058       else
10059         {
10060           ok = 1;
10061           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10062             {
10063               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10064                        name);
10065               if (flag_pedantic_errors)
10066                 ok = 0;
10067             }
10068         }
10069
10070       /* Discard the type modifiers if they are invalid.  */
10071       if (! ok)
10072         {
10073           RIDBIT_RESET (RID_UNSIGNED, specbits);
10074           RIDBIT_RESET (RID_SIGNED, specbits);
10075           RIDBIT_RESET (RID_LONG, specbits);
10076           RIDBIT_RESET (RID_SHORT, specbits);
10077           longlong = 0;
10078         }
10079     }
10080
10081   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10082       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10083     {
10084       error ("complex invalid for `%s'", name);
10085       RIDBIT_RESET (RID_COMPLEX, specbits);
10086     }
10087
10088   /* Decide whether an integer type is signed or not.
10089      Optionally treat bitfields as signed by default.  */
10090   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10091       /* [class.bit]
10092
10093          It is implementation-defined whether a plain (neither
10094          explicitly signed or unsigned) char, short, int, or long
10095          bit-field is signed or unsigned.
10096
10097          Naturally, we extend this to long long as well.  Note that
10098          this does not include wchar_t.  */
10099       || (bitfield && !flag_signed_bitfields
10100           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10101           /* A typedef for plain `int' without `signed' can be
10102              controlled just like plain `int', but a typedef for
10103              `signed int' cannot be so controlled.  */
10104           && !(typedef_decl
10105                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10106           && (TREE_CODE (type) == INTEGER_TYPE
10107               || TREE_CODE (type) == CHAR_TYPE)
10108           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10109     {
10110       if (longlong)
10111         type = long_long_unsigned_type_node;
10112       else if (RIDBIT_SETP (RID_LONG, specbits))
10113         type = long_unsigned_type_node;
10114       else if (RIDBIT_SETP (RID_SHORT, specbits))
10115         type = short_unsigned_type_node;
10116       else if (type == char_type_node)
10117         type = unsigned_char_type_node;
10118       else if (typedef_decl)
10119         type = unsigned_type (type);
10120       else
10121         type = unsigned_type_node;
10122     }
10123   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10124            && type == char_type_node)
10125     type = signed_char_type_node;
10126   else if (longlong)
10127     type = long_long_integer_type_node;
10128   else if (RIDBIT_SETP (RID_LONG, specbits))
10129     type = long_integer_type_node;
10130   else if (RIDBIT_SETP (RID_SHORT, specbits))
10131     type = short_integer_type_node;
10132
10133   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10134     {
10135       /* If we just have "complex", it is equivalent to
10136          "complex double", but if any modifiers at all are specified it is
10137          the complex form of TYPE.  E.g, "complex short" is
10138          "complex short int".  */
10139
10140       if (defaulted_int && ! longlong
10141           && ! (RIDBIT_SETP (RID_LONG, specbits)
10142                 || RIDBIT_SETP (RID_SHORT, specbits)
10143                 || RIDBIT_SETP (RID_SIGNED, specbits)
10144                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10145         type = complex_double_type_node;
10146       else if (type == integer_type_node)
10147         type = complex_integer_type_node;
10148       else if (type == float_type_node)
10149         type = complex_float_type_node;
10150       else if (type == double_type_node)
10151         type = complex_double_type_node;
10152       else if (type == long_double_type_node)
10153         type = complex_long_double_type_node;
10154       else
10155         type = build_complex_type (type);
10156     }
10157
10158   if (sfk == sfk_conversion
10159       && (RIDBIT_SETP (RID_CONST, specbits)
10160           || RIDBIT_SETP (RID_VOLATILE, specbits)
10161           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10162     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10163               ctor_return_type);
10164
10165   /* Set CONSTP if this declaration is `const', whether by
10166      explicit specification or via a typedef.
10167      Likewise for VOLATILEP.  */
10168
10169   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10170   restrictp =
10171     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10172   volatilep =
10173     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10174   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10175                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10176                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10177   type = cp_build_qualified_type (type, type_quals);
10178   staticp = 0;
10179   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10180   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10181   RIDBIT_RESET (RID_VIRTUAL, specbits);
10182   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10183   RIDBIT_RESET (RID_EXPLICIT, specbits);
10184
10185   if (RIDBIT_SETP (RID_STATIC, specbits))
10186     staticp = 1 + (decl_context == FIELD);
10187
10188   if (virtualp && staticp == 2)
10189     {
10190       cp_error ("member `%D' cannot be declared both virtual and static",
10191                 dname);
10192       staticp = 0;
10193     }
10194   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10195   RIDBIT_RESET (RID_FRIEND, specbits);
10196
10197   /* Warn if two storage classes are given. Default to `auto'.  */
10198
10199   if (RIDBIT_ANY_SET (specbits))
10200     {
10201       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10202       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10203       if (decl_context == PARM && nclasses > 0)
10204         error ("storage class specifiers invalid in parameter declarations");
10205       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10206         {
10207           if (decl_context == PARM)
10208             error ("typedef declaration invalid in parameter declaration");
10209           nclasses++;
10210         }
10211       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10212       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10213     }
10214
10215   /* Give error if `virtual' is used outside of class declaration.  */
10216   if (virtualp
10217       && (current_class_name == NULL_TREE || decl_context != FIELD))
10218     {
10219       error ("virtual outside class declaration");
10220       virtualp = 0;
10221     }
10222
10223   /* Static anonymous unions are dealt with here.  */
10224   if (staticp && decl_context == TYPENAME
10225       && TREE_CODE (declspecs) == TREE_LIST
10226       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10227     decl_context = FIELD;
10228
10229   /* Warn about storage classes that are invalid for certain
10230      kinds of declarations (parameters, typenames, etc.).  */
10231
10232   if (nclasses > 1)
10233     error ("multiple storage classes in declaration of `%s'", name);
10234   else if (decl_context != NORMAL && nclasses > 0)
10235     {
10236       if ((decl_context == PARM || decl_context == CATCHPARM)
10237           && (RIDBIT_SETP (RID_REGISTER, specbits)
10238               || RIDBIT_SETP (RID_AUTO, specbits)))
10239         ;
10240       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10241         ;
10242       else if (decl_context == FIELD
10243                /* C++ allows static class elements  */
10244                && RIDBIT_SETP (RID_STATIC, specbits))
10245         /* C++ also allows inlines and signed and unsigned elements,
10246            but in those cases we don't come in here.  */
10247         ;
10248       else
10249         {
10250           if (decl_context == FIELD)
10251             {
10252               tree tmp = NULL_TREE;
10253               register int op = 0;
10254
10255               if (declarator)
10256                 {
10257                   /* Avoid trying to get an operand off an identifier node.  */
10258                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10259                     tmp = declarator;
10260                   else
10261                     tmp = TREE_OPERAND (declarator, 0);
10262                   op = IDENTIFIER_OPNAME_P (tmp);
10263                   if (IDENTIFIER_TYPENAME_P (tmp))
10264                     {
10265                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10266                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10267                               == TYPE_DECL))
10268                         name = IDENTIFIER_POINTER (tmp);
10269                       else
10270                         name = "<invalid operator>";
10271                     }
10272                 }
10273               error ("storage class specified for %s `%s'",
10274                      op ? "member operator" : "field",
10275                      name);
10276             }
10277           else
10278             {
10279               if (decl_context == PARM || decl_context == CATCHPARM)
10280                 error ("storage class specified for parameter `%s'", name);
10281               else
10282                 error ("storage class specified for typename");
10283             }
10284           RIDBIT_RESET (RID_REGISTER, specbits);
10285           RIDBIT_RESET (RID_AUTO, specbits);
10286           RIDBIT_RESET (RID_EXTERN, specbits);
10287         }
10288     }
10289   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10290     {
10291       if (toplevel_bindings_p ())
10292         {
10293           /* It's common practice (and completely valid) to have a const
10294              be initialized and declared extern.  */
10295           if (!(type_quals & TYPE_QUAL_CONST))
10296             warning ("`%s' initialized and declared `extern'", name);
10297         }
10298       else
10299         error ("`%s' has both `extern' and initializer", name);
10300     }
10301   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10302            && ! toplevel_bindings_p ())
10303     error ("nested function `%s' declared `extern'", name);
10304   else if (toplevel_bindings_p ())
10305     {
10306       if (RIDBIT_SETP (RID_AUTO, specbits))
10307         error ("top-level declaration of `%s' specifies `auto'", name);
10308     }
10309
10310   if (nclasses > 0 && friendp)
10311     error ("storage class specifiers invalid in friend function declarations");
10312
10313   /* Now figure out the structure of the declarator proper.
10314      Descend through it, creating more complex types, until we reach
10315      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10316
10317   inner_attrs = NULL_TREE;
10318   ignore_attrs = 0;
10319
10320   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10321          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10322     {
10323       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10324          an INDIRECT_REF (for *...),
10325          a CALL_EXPR (for ...(...)),
10326          an identifier (for the name being declared)
10327          or a null pointer (for the place in an absolute declarator
10328          where the name was omitted).
10329          For the last two cases, we have just exited the loop.
10330
10331          For C++ it could also be
10332          a SCOPE_REF (for class :: ...).  In this case, we have converted
10333          sensible names to types, and those are the values we use to
10334          qualify the member name.
10335          an ADDR_EXPR (for &...),
10336          a BIT_NOT_EXPR (for destructors)
10337
10338          At this point, TYPE is the type of elements of an array,
10339          or for a function to return, or for a pointer to point to.
10340          After this sequence of ifs, TYPE is the type of the
10341          array or function or pointer, and DECLARATOR has had its
10342          outermost layer removed.  */
10343
10344       if (type == error_mark_node)
10345         {
10346           if (TREE_CODE (declarator) == SCOPE_REF)
10347             declarator = TREE_OPERAND (declarator, 1);
10348           else
10349             declarator = TREE_OPERAND (declarator, 0);
10350           continue;
10351         }
10352       if (quals != NULL_TREE
10353           && (declarator == NULL_TREE
10354               || TREE_CODE (declarator) != SCOPE_REF))
10355         {
10356           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10357             ctype = TYPE_METHOD_BASETYPE (type);
10358           if (ctype != NULL_TREE)
10359             {
10360               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10361               grok_method_quals (ctype, dummy, quals);
10362               type = TREE_TYPE (dummy);
10363               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10364               quals = NULL_TREE;
10365             }
10366         }
10367
10368       /* See the comment for the TREE_LIST case, below.  */
10369       if (ignore_attrs)
10370         ignore_attrs = 0;
10371       else if (inner_attrs)
10372         {
10373           decl_attributes (&type, inner_attrs, 0);
10374           inner_attrs = NULL_TREE;
10375         }
10376
10377       switch (TREE_CODE (declarator))
10378         {
10379         case TREE_LIST:
10380           {
10381             /* We encode a declarator with embedded attributes using
10382                a TREE_LIST.  The attributes apply to the declarator
10383                directly inside them, so we have to skip an iteration
10384                before applying them to the type.  If the declarator just
10385                inside is the declarator-id, we apply the attrs to the
10386                decl itself.  */
10387             inner_attrs = TREE_PURPOSE (declarator);
10388             ignore_attrs = 1;
10389             declarator = TREE_VALUE (declarator);
10390           }
10391           break;
10392
10393         case ARRAY_REF:
10394           {
10395             register tree size;
10396
10397             size = TREE_OPERAND (declarator, 1);
10398
10399             /* VC++ spells a zero-sized array with [].  */
10400             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10401                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10402               size = integer_zero_node;
10403
10404             declarator = TREE_OPERAND (declarator, 0);
10405
10406             type = create_array_type_for_decl (dname, type, size);
10407
10408             /* VLAs never work as fields. */
10409             if (decl_context == FIELD && !processing_template_decl
10410                 && TREE_CODE (type) == ARRAY_TYPE
10411                 && TYPE_DOMAIN (type) != NULL_TREE
10412                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10413               {
10414                 cp_error ("size of member `%D' is not constant", dname);
10415                 /* Proceed with arbitrary constant size, so that offset
10416                    computations don't get confused. */
10417                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10418                                                    integer_one_node);
10419               }
10420
10421             ctype = NULL_TREE;
10422           }
10423           break;
10424
10425         case CALL_EXPR:
10426           {
10427             tree arg_types;
10428             int funcdecl_p;
10429             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10430             tree inner_decl = TREE_OPERAND (declarator, 0);
10431
10432             /* Declaring a function type.
10433                Make sure we have a valid type for the function to return.  */
10434
10435             /* We now know that the TYPE_QUALS don't apply to the
10436                decl, but to its return type.  */
10437             type_quals = TYPE_UNQUALIFIED;
10438
10439             /* Warn about some types functions can't return.  */
10440
10441             if (TREE_CODE (type) == FUNCTION_TYPE)
10442               {
10443                 error ("`%s' declared as function returning a function", name);
10444                 type = integer_type_node;
10445               }
10446             if (TREE_CODE (type) == ARRAY_TYPE)
10447               {
10448                 error ("`%s' declared as function returning an array", name);
10449                 type = integer_type_node;
10450               }
10451
10452             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10453               inner_decl = TREE_OPERAND (inner_decl, 1);
10454
10455             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10456               inner_decl = dname;
10457
10458             /* Pick up type qualifiers which should be applied to `this'.  */
10459             quals = CALL_DECLARATOR_QUALS (declarator);
10460
10461             /* Pick up the exception specifications.  */
10462             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10463
10464             /* Say it's a definition only for the CALL_EXPR
10465                closest to the identifier.  */
10466             funcdecl_p
10467               = inner_decl
10468               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10469                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10470                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10471
10472             if (ctype == NULL_TREE
10473                 && decl_context == FIELD
10474                 && funcdecl_p
10475                 && (friendp == 0 || dname == current_class_name))
10476               ctype = current_class_type;
10477
10478             if (ctype && sfk == sfk_conversion)
10479               TYPE_HAS_CONVERSION (ctype) = 1;
10480             if (ctype && constructor_name (ctype) == dname)
10481               {
10482                 /* We are within a class's scope. If our declarator name
10483                    is the same as the class name, and we are defining
10484                    a function, then it is a constructor/destructor, and
10485                    therefore returns a void type.  */
10486
10487                 if (flags == DTOR_FLAG)
10488                   {
10489                     /* ISO C++ 12.4/2.  A destructor may not be
10490                        declared const or volatile.  A destructor may
10491                        not be static.  */
10492                     if (staticp == 2)
10493                       error ("destructor cannot be static member function");
10494                     if (quals)
10495                       {
10496                         cp_error ("destructors may not be `%s'",
10497                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10498                         quals = NULL_TREE;
10499                       }
10500                     if (decl_context == FIELD)
10501                       {
10502                         if (! member_function_or_else (ctype,
10503                                                        current_class_type,
10504                                                        flags))
10505                           return void_type_node;
10506                       }
10507                   }
10508                 else            /* It's a constructor.  */
10509                   {
10510                     if (explicitp == 1)
10511                       explicitp = 2;
10512                     /* ISO C++ 12.1.  A constructor may not be
10513                        declared const or volatile.  A constructor may
10514                        not be virtual.  A constructor may not be
10515                        static.  */
10516                     if (staticp == 2)
10517                       error ("constructor cannot be static member function");
10518                     if (virtualp)
10519                       {
10520                         pedwarn ("constructors cannot be declared virtual");
10521                         virtualp = 0;
10522                       }
10523                     if (quals)
10524                       {
10525                         cp_error ("constructors may not be `%s'",
10526                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10527                         quals = NULL_TREE;
10528                       }
10529                     {
10530                       RID_BIT_TYPE tmp_bits;
10531                       memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
10532                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10533                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10534                       if (RIDBIT_ANY_SET (tmp_bits))
10535                         error ("return value type specifier for constructor ignored");
10536                     }
10537                     if (decl_context == FIELD)
10538                       {
10539                         if (! member_function_or_else (ctype,
10540                                                        current_class_type,
10541                                                        flags))
10542                           return void_type_node;
10543                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10544                         if (sfk != sfk_constructor)
10545                           return NULL_TREE;
10546                       }
10547                   }
10548                 if (decl_context == FIELD)
10549                   staticp = 0;
10550               }
10551             else if (friendp)
10552               {
10553                 if (initialized)
10554                   error ("can't initialize friend function `%s'", name);
10555                 if (virtualp)
10556                   {
10557                     /* Cannot be both friend and virtual.  */
10558                     error ("virtual functions cannot be friends");
10559                     RIDBIT_RESET (RID_FRIEND, specbits);
10560                     friendp = 0;
10561                   }
10562                 if (decl_context == NORMAL)
10563                   error ("friend declaration not in class definition");
10564                 if (current_function_decl && funcdef_flag)
10565                   cp_error ("can't define friend function `%s' in a local class definition",
10566                             name);
10567               }
10568
10569             /* Construct the function type and go to the next
10570                inner layer of declarator.  */
10571
10572             declarator = TREE_OPERAND (declarator, 0);
10573
10574             /* FIXME: This is where default args should be fully
10575                processed.  */
10576
10577             arg_types = grokparms (inner_parms);
10578
10579             if (declarator && flags == DTOR_FLAG)
10580               {
10581                 /* A destructor declared in the body of a class will
10582                    be represented as a BIT_NOT_EXPR.  But, we just
10583                    want the underlying IDENTIFIER.  */
10584                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10585                   declarator = TREE_OPERAND (declarator, 0);
10586
10587                 if (arg_types != void_list_node)
10588                   {
10589                     cp_error ("destructors may not have parameters");
10590                     arg_types = void_list_node;
10591                     last_function_parms = NULL_TREE;
10592                   }
10593               }
10594
10595             /* ANSI says that `const int foo ();'
10596                does not make the function foo const.  */
10597             type = build_function_type (type, arg_types);
10598
10599             {
10600               tree t;
10601               for (t = arg_types; t; t = TREE_CHAIN (t))
10602                 if (TREE_PURPOSE (t)
10603                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10604                   {
10605                     add_defarg_fn (type);
10606                     break;
10607                   }
10608             }
10609           }
10610           break;
10611
10612         case ADDR_EXPR:
10613         case INDIRECT_REF:
10614           /* Filter out pointers-to-references and references-to-references.
10615              We can get these if a TYPE_DECL is used.  */
10616
10617           if (TREE_CODE (type) == REFERENCE_TYPE)
10618             {
10619               error ("cannot declare %s to references",
10620                      TREE_CODE (declarator) == ADDR_EXPR
10621                      ? "references" : "pointers");
10622               declarator = TREE_OPERAND (declarator, 0);
10623               continue;
10624             }
10625
10626           if (TREE_CODE (type) == OFFSET_TYPE
10627               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10628                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10629             {
10630               cp_error ("cannot declare pointer to `%#T' member",
10631                         TREE_TYPE (type));
10632               type = TREE_TYPE (type);
10633             }
10634
10635           /* Merge any constancy or volatility into the target type
10636              for the pointer.  */
10637
10638           /* We now know that the TYPE_QUALS don't apply to the decl,
10639              but to the target of the pointer.  */
10640           type_quals = TYPE_UNQUALIFIED;
10641
10642           if (TREE_CODE (declarator) == ADDR_EXPR)
10643             {
10644               if (TREE_CODE (type) == VOID_TYPE)
10645                 error ("invalid type: `void &'");
10646               else
10647                 type = build_reference_type (type);
10648             }
10649           else if (TREE_CODE (type) == METHOD_TYPE)
10650             type = build_ptrmemfunc_type (build_pointer_type (type));
10651           else
10652             type = build_pointer_type (type);
10653
10654           /* Process a list of type modifier keywords (such as
10655              const or volatile) that were given inside the `*' or `&'.  */
10656
10657           if (TREE_TYPE (declarator))
10658             {
10659               register tree typemodlist;
10660               int erred = 0;
10661
10662               constp = 0;
10663               volatilep = 0;
10664               restrictp = 0;
10665               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10666                    typemodlist = TREE_CHAIN (typemodlist))
10667                 {
10668                   tree qualifier = TREE_VALUE (typemodlist);
10669
10670                   if (qualifier == ridpointers[(int) RID_CONST])
10671                     constp++;
10672                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10673                     volatilep++;
10674                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10675                     restrictp++;
10676                   else if (!erred)
10677                     {
10678                       erred = 1;
10679                       error ("invalid type modifier within pointer declarator");
10680                     }
10681                 }
10682               if (constp > 1)
10683                 pedwarn ("duplicate `const'");
10684               if (volatilep > 1)
10685                 pedwarn ("duplicate `volatile'");
10686               if (restrictp > 1)
10687                 pedwarn ("duplicate `restrict'");
10688
10689               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10690                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10691                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10692               if (TREE_CODE (declarator) == ADDR_EXPR
10693                   && (constp || volatilep))
10694                 {
10695                   if (constp)
10696                     pedwarn ("discarding `const' applied to a reference");
10697                   if (volatilep)
10698                     pedwarn ("discarding `volatile' applied to a reference");
10699                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10700                 }
10701               type = cp_build_qualified_type (type, type_quals);
10702             }
10703           declarator = TREE_OPERAND (declarator, 0);
10704           ctype = NULL_TREE;
10705           break;
10706
10707         case SCOPE_REF:
10708           {
10709             /* We have converted type names to NULL_TREE if the
10710                name was bogus, or to a _TYPE node, if not.
10711
10712                The variable CTYPE holds the type we will ultimately
10713                resolve to.  The code here just needs to build
10714                up appropriate member types.  */
10715             tree sname = TREE_OPERAND (declarator, 1);
10716             tree t;
10717
10718             /* Destructors can have their visibilities changed as well.  */
10719             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10720               sname = TREE_OPERAND (sname, 0);
10721
10722             if (TREE_COMPLEXITY (declarator) == 0)
10723               /* This needs to be here, in case we are called
10724                  multiple times.  */ ;
10725             else if (TREE_COMPLEXITY (declarator) == -1)
10726               /* Namespace member. */
10727               pop_decl_namespace ();
10728             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10729               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10730             else if (! IS_AGGR_TYPE_CODE
10731                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10732               ;
10733             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10734               {
10735                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10736                    that refer to ctype.  They couldn't be resolved earlier
10737                    because we hadn't pushed into the class yet.
10738                    Example: resolve 'B<T>::type' in
10739                    'B<typename B<T>::type> B<T>::f () { }'.  */
10740                 if (current_template_parms
10741                     && uses_template_parms (type)
10742                     && uses_template_parms (current_class_type))
10743                   {
10744                     tree args = current_template_args ();
10745                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10746                   }
10747
10748                 /* This pop_nested_class corresponds to the
10749                    push_nested_class used to push into class scope for
10750                    parsing the argument list of a function decl, in
10751                    qualified_id.  */
10752                 pop_nested_class ();
10753                 TREE_COMPLEXITY (declarator) = current_class_depth;
10754               }
10755             else
10756               my_friendly_abort (16);
10757
10758             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10759               {
10760                 /* We had a reference to a global decl, or
10761                    perhaps we were given a non-aggregate typedef,
10762                    in which case we cleared this out, and should just
10763                    keep going as though it wasn't there.  */
10764                 declarator = sname;
10765                 continue;
10766               }
10767             ctype = TREE_OPERAND (declarator, 0);
10768
10769             t = ctype;
10770             while (t != NULL_TREE && CLASS_TYPE_P (t))
10771               {
10772                 /* You're supposed to have one `template <...>'
10773                    for every template class, but you don't need one
10774                    for a full specialization.  For example:
10775
10776                      template <class T> struct S{};
10777                      template <> struct S<int> { void f(); };
10778                      void S<int>::f () {}
10779
10780                    is correct; there shouldn't be a `template <>' for
10781                    the definition of `S<int>::f'.  */
10782                 if (CLASSTYPE_TEMPLATE_INFO (t)
10783                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10784                         || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
10785                     && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
10786                   template_count += 1;
10787
10788                 t = TYPE_MAIN_DECL (t);
10789                 t = DECL_CONTEXT (t);
10790               }
10791
10792             if (sname == NULL_TREE)
10793               goto done_scoping;
10794
10795             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10796               {
10797                 /* This is the `standard' use of the scoping operator:
10798                    basetype :: member .  */
10799
10800                 if (ctype == current_class_type)
10801                   {
10802                     /* class A {
10803                          void A::f ();
10804                        };
10805
10806                        Is this ill-formed?  */
10807
10808                     if (pedantic)
10809                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10810                                   ctype, name);
10811                   }
10812                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10813                   {
10814                     if (current_class_type == NULL_TREE || friendp)
10815                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10816                                                       TYPE_ARG_TYPES (type));
10817                     else
10818                       {
10819                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10820                                   ctype, name, current_class_type);
10821                         return void_type_node;
10822                       }
10823                   }
10824                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10825                          || COMPLETE_TYPE_P (complete_type (ctype)))
10826                   {
10827                     /* Have to move this code elsewhere in this function.
10828                        this code is used for i.e., typedef int A::M; M *pm;
10829
10830                        It is?  How? jason 10/2/94 */
10831
10832                     if (current_class_type)
10833                       {
10834                         cp_error ("cannot declare member `%T::%s' within `%T'",
10835                                   ctype, name, current_class_type);
10836                         return void_type_node;
10837                       }
10838                     type = build_offset_type (ctype, type);
10839                   }
10840                 else
10841                   {
10842                     incomplete_type_error (NULL_TREE, ctype);
10843                     return error_mark_node;
10844                   }
10845
10846                 declarator = sname;
10847               }
10848             else if (TREE_CODE (sname) == SCOPE_REF)
10849               my_friendly_abort (17);
10850             else
10851               {
10852               done_scoping:
10853                 declarator = TREE_OPERAND (declarator, 1);
10854                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10855                   /* In this case, we will deal with it later.  */
10856                   ;
10857                 else
10858                   {
10859                     if (TREE_CODE (type) == FUNCTION_TYPE)
10860                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10861                                                       TYPE_ARG_TYPES (type));
10862                     else
10863                       type = build_offset_type (ctype, type);
10864                   }
10865               }
10866           }
10867           break;
10868
10869         case BIT_NOT_EXPR:
10870           declarator = TREE_OPERAND (declarator, 0);
10871           break;
10872
10873         case RECORD_TYPE:
10874         case UNION_TYPE:
10875         case ENUMERAL_TYPE:
10876           declarator = NULL_TREE;
10877           break;
10878
10879         case ERROR_MARK:
10880           declarator = NULL_TREE;
10881           break;
10882
10883         default:
10884           my_friendly_abort (158);
10885         }
10886     }
10887
10888   /* See the comment for the TREE_LIST case, above.  */
10889   if (inner_attrs)
10890     {
10891       if (! ignore_attrs)
10892         decl_attributes (&type, inner_attrs, 0);
10893       else if (attrlist)
10894         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10895       else
10896         attrlist = build_tree_list (NULL_TREE, inner_attrs);
10897     }
10898
10899   /* Now TYPE has the actual type.  */
10900
10901   if (explicitp == 1 || (explicitp && friendp))
10902     {
10903       /* [dcl.fct.spec] The explicit specifier shall only be used in
10904          declarations of constructors within a class definition.  */
10905       error ("only declarations of constructors can be `explicit'");
10906       explicitp = 0;
10907     }
10908
10909   if (RIDBIT_SETP (RID_MUTABLE, specbits))
10910     {
10911       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
10912         {
10913           error ("non-member `%s' cannot be declared `mutable'", name);
10914           RIDBIT_RESET (RID_MUTABLE, specbits);
10915         }
10916       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
10917         {
10918           error ("non-object member `%s' cannot be declared `mutable'", name);
10919           RIDBIT_RESET (RID_MUTABLE, specbits);
10920         }
10921       else if (TREE_CODE (type) == FUNCTION_TYPE
10922                || TREE_CODE (type) == METHOD_TYPE)
10923         {
10924           error ("function `%s' cannot be declared `mutable'", name);
10925           RIDBIT_RESET (RID_MUTABLE, specbits);
10926         }
10927       else if (staticp)
10928         {
10929           error ("static `%s' cannot be declared `mutable'", name);
10930           RIDBIT_RESET (RID_MUTABLE, specbits);
10931         }
10932       else if (type_quals & TYPE_QUAL_CONST)
10933         {
10934           error ("const `%s' cannot be declared `mutable'", name);
10935           RIDBIT_RESET (RID_MUTABLE, specbits);
10936         }
10937     }
10938
10939   if (declarator == NULL_TREE
10940       || TREE_CODE (declarator) == IDENTIFIER_NODE
10941       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
10942           && (TREE_CODE (type) == FUNCTION_TYPE
10943               || TREE_CODE (type) == METHOD_TYPE)))
10944     /* OK */;
10945   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10946     {
10947       cp_error ("template-id `%D' used as a declarator", declarator);
10948       declarator = dname;
10949     }
10950   else
10951     /* Unexpected declarator format.  */
10952     my_friendly_abort (990210);
10953
10954   /* If this is declaring a typedef name, return a TYPE_DECL.  */
10955
10956   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
10957     {
10958       tree decl;
10959
10960       /* Note that the grammar rejects storage classes
10961          in typenames, fields or parameters.  */
10962       if (current_lang_name == lang_name_java)
10963         TYPE_FOR_JAVA (type) = 1;
10964
10965       if (decl_context == FIELD)
10966         {
10967           if (declarator == constructor_name (current_class_type))
10968             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
10969                         declarator);
10970           decl = build_lang_decl (TYPE_DECL, declarator, type);
10971         }
10972       else
10973         {
10974           decl = build_decl (TYPE_DECL, declarator, type);
10975           if (!current_function_decl)
10976             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
10977         }
10978
10979       /* If the user declares "typedef struct {...} foo" then the
10980          struct will have an anonymous name.  Fill that name in now.
10981          Nothing can refer to it, so nothing needs know about the name
10982          change.  */
10983       if (type != error_mark_node
10984           && declarator
10985           && TYPE_NAME (type)
10986           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10987           && TYPE_ANONYMOUS_P (type)
10988           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
10989         {
10990           tree oldname = TYPE_NAME (type);
10991           tree t;
10992
10993           /* Replace the anonymous name with the real name everywhere.  */
10994           lookup_tag_reverse (type, declarator);
10995           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10996             if (TYPE_NAME (t) == oldname)
10997               TYPE_NAME (t) = decl;
10998
10999           if (TYPE_LANG_SPECIFIC (type))
11000             TYPE_WAS_ANONYMOUS (type) = 1;
11001
11002           /* If this is a typedef within a template class, the nested
11003              type is a (non-primary) template.  The name for the
11004              template needs updating as well.  */
11005           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11006             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11007               = TYPE_IDENTIFIER (type);
11008
11009           /* FIXME remangle member functions; member functions of a
11010              type with external linkage have external linkage.  */
11011         }
11012
11013       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11014         {
11015           cp_error_at ("typedef name may not be class-qualified", decl);
11016           return NULL_TREE;
11017         }
11018       else if (quals)
11019         {
11020           if (ctype == NULL_TREE)
11021             {
11022               if (TREE_CODE (type) != METHOD_TYPE)
11023                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11024               else
11025                 ctype = TYPE_METHOD_BASETYPE (type);
11026             }
11027           if (ctype != NULL_TREE)
11028             grok_method_quals (ctype, decl, quals);
11029         }
11030
11031       if (RIDBIT_SETP (RID_SIGNED, specbits)
11032           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11033         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11034
11035       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11036                       inlinep, friendp, raises != NULL_TREE);
11037
11038       if (initialized)
11039         error ("typedef declaration includes an initializer");
11040
11041       return decl;
11042     }
11043
11044   /* Detect the case of an array type of unspecified size
11045      which came, as such, direct from a typedef name.
11046      We must copy the type, so that each identifier gets
11047      a distinct type, so that each identifier's size can be
11048      controlled separately by its own initializer.  */
11049
11050   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11051       && TYPE_DOMAIN (type) == NULL_TREE)
11052     {
11053       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11054     }
11055
11056   /* Detect where we're using a typedef of function type to declare a
11057      function. last_function_parms will not be set, so we must create
11058      it now.  */
11059
11060   if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
11061     {
11062       tree decls = NULL_TREE;
11063       tree args;
11064
11065       for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
11066         {
11067           tree decl = build_decl (PARM_DECL, NULL_TREE, TREE_VALUE (args));
11068
11069           TREE_CHAIN (decl) = decls;
11070           decls = decl;
11071         }
11072
11073       last_function_parms = nreverse (decls);
11074     }
11075
11076   /* If this is a type name (such as, in a cast or sizeof),
11077      compute the type and return it now.  */
11078
11079   if (decl_context == TYPENAME)
11080     {
11081       /* Note that the grammar rejects storage classes
11082          in typenames, fields or parameters.  */
11083       if (type_quals != TYPE_UNQUALIFIED)
11084         type_quals = TYPE_UNQUALIFIED;
11085
11086       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11087       if (friendp)
11088         {
11089           if (type_quals != TYPE_UNQUALIFIED)
11090             {
11091               cp_error ("type qualifiers specified for friend class declaration");
11092               type_quals = TYPE_UNQUALIFIED;
11093             }
11094           if (inlinep)
11095             {
11096               cp_error ("`inline' specified for friend class declaration");
11097               inlinep = 0;
11098             }
11099
11100           /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11101              But don't allow implicit typenames except with a class-key.  */
11102           if (!current_aggr && (TREE_CODE (type) != TYPENAME_TYPE
11103                                 || IMPLICIT_TYPENAME_P (type)))
11104             {
11105               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11106                 cp_pedwarn ("template parameters cannot be friends");
11107               else if (TREE_CODE (type) == TYPENAME_TYPE)
11108                 cp_pedwarn ("\
11109 friend declaration requires class-key, i.e. `friend class %T::%T'",
11110                             constructor_name (current_class_type),
11111                             TYPE_IDENTIFIER (type));
11112               else
11113                 cp_pedwarn ("\
11114 friend declaration requires class-key, i.e. `friend %#T'",
11115                             type);
11116             }
11117
11118           /* Only try to do this stuff if we didn't already give up.  */
11119           if (type != integer_type_node)
11120             {
11121               /* DR 209. The friendly class does not need to be accessible
11122                  in the scope of the class granting friendship. */
11123               skip_type_access_control ();
11124
11125               /* A friendly class?  */
11126               if (current_class_type)
11127                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11128               else
11129                 cp_error ("trying to make class `%T' a friend of global scope",
11130                           type);
11131
11132               type = void_type_node;
11133             }
11134         }
11135       else if (quals)
11136         {
11137           if (ctype == NULL_TREE)
11138             {
11139               if (TREE_CODE (type) != METHOD_TYPE)
11140                 cp_error ("invalid qualifiers on non-member function type");
11141               else
11142                 ctype = TYPE_METHOD_BASETYPE (type);
11143             }
11144           if (ctype)
11145             {
11146               tree dummy = build_decl (TYPE_DECL, declarator, type);
11147               grok_method_quals (ctype, dummy, quals);
11148               type = TREE_TYPE (dummy);
11149             }
11150         }
11151
11152       return type;
11153     }
11154   else if (declarator == NULL_TREE && decl_context != PARM
11155            && decl_context != CATCHPARM
11156            && TREE_CODE (type) != UNION_TYPE
11157            && ! bitfield)
11158     {
11159       cp_error ("abstract declarator `%T' used as declaration", type);
11160       declarator = make_anon_name ();
11161     }
11162
11163   /* `void' at top level (not within pointer)
11164      is allowed only in typedefs or type names.
11165      We don't complain about parms either, but that is because
11166      a better error message can be made later.  */
11167
11168   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11169     {
11170       if (! declarator)
11171         error ("unnamed variable or field declared void");
11172       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11173         {
11174           if (IDENTIFIER_OPNAME_P (declarator))
11175             my_friendly_abort (356);
11176           else
11177             error ("variable or field `%s' declared void", name);
11178         }
11179       else
11180         error ("variable or field declared void");
11181       type = integer_type_node;
11182     }
11183
11184   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11185      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11186
11187   if (decl_context == PARM || decl_context == CATCHPARM)
11188     {
11189       if (ctype || in_namespace)
11190         error ("cannot use `::' in parameter declaration");
11191
11192       /* A parameter declared as an array of T is really a pointer to T.
11193          One declared as a function is really a pointer to a function.
11194          One declared as a member is really a pointer to member.  */
11195
11196       if (TREE_CODE (type) == ARRAY_TYPE)
11197         {
11198           /* Transfer const-ness of array into that of type pointed to.  */
11199           type = build_pointer_type (TREE_TYPE (type));
11200           type_quals = TYPE_UNQUALIFIED;
11201         }
11202       else if (TREE_CODE (type) == FUNCTION_TYPE)
11203         type = build_pointer_type (type);
11204       else if (TREE_CODE (type) == OFFSET_TYPE)
11205         type = build_pointer_type (type);
11206     }
11207
11208   {
11209     register tree decl;
11210
11211     if (decl_context == PARM)
11212       {
11213         decl = build_decl (PARM_DECL, declarator, type);
11214
11215         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11216                         inlinep, friendp, raises != NULL_TREE);
11217
11218         /* Compute the type actually passed in the parmlist,
11219            for the case where there is no prototype.
11220            (For example, shorts and chars are passed as ints.)
11221            When there is a prototype, this is overridden later.  */
11222
11223         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11224       }
11225     else if (decl_context == FIELD)
11226       {
11227         if (type == error_mark_node)
11228           {
11229             /* Happens when declaring arrays of sizes which
11230                are error_mark_node, for example.  */
11231             decl = NULL_TREE;
11232           }
11233         else if (in_namespace && !friendp)
11234           {
11235             /* Something like struct S { int N::j; };  */
11236             cp_error ("invalid use of `::'");
11237             decl = NULL_TREE;
11238           }
11239         else if (TREE_CODE (type) == FUNCTION_TYPE)
11240           {
11241             int publicp = 0;
11242             tree function_context;
11243
11244             /* We catch the others as conflicts with the builtin
11245                typedefs.  */
11246             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11247               {
11248                 cp_error ("function `%D' cannot be declared friend",
11249                           declarator);
11250                 friendp = 0;
11251               }
11252
11253             if (friendp == 0)
11254               {
11255                 if (ctype == NULL_TREE)
11256                   ctype = current_class_type;
11257
11258                 if (ctype == NULL_TREE)
11259                   {
11260                     cp_error ("can't make `%D' into a method -- not in a class",
11261                               declarator);
11262                     return void_type_node;
11263                   }
11264
11265                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11266                    ARM 9.5 */
11267                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11268                   {
11269                     cp_error ("function `%D' declared virtual inside a union",
11270                               declarator);
11271                     return void_type_node;
11272                   }
11273
11274                 if (declarator == ansi_opname (NEW_EXPR)
11275                     || declarator == ansi_opname (VEC_NEW_EXPR)
11276                     || declarator == ansi_opname (DELETE_EXPR)
11277                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11278                   {
11279                     if (virtualp)
11280                       {
11281                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11282                                   declarator);
11283                         virtualp = 0;
11284                       }
11285                   }
11286                 else if (staticp < 2)
11287                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11288                                                   TYPE_ARG_TYPES (type));
11289               }
11290
11291             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11292             function_context = (ctype != NULL_TREE) ?
11293               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11294             publicp = (! friendp || ! staticp)
11295               && function_context == NULL_TREE;
11296             decl = grokfndecl (ctype, type,
11297                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11298                                ? declarator : dname,
11299                                declarator,
11300                                virtualp, flags, quals, raises,
11301                                friendp ? -1 : 0, friendp, publicp, inlinep,
11302                                funcdef_flag, template_count, in_namespace);
11303             if (decl == NULL_TREE)
11304               return decl;
11305 #if 0
11306             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11307             /* The decl and setting of decl_machine_attr is also turned off.  */
11308             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11309 #endif
11310
11311             /* [class.conv.ctor]
11312
11313                A constructor declared without the function-specifier
11314                explicit that can be called with a single parameter
11315                specifies a conversion from the type of its first
11316                parameter to the type of its class.  Such a constructor
11317                is called a converting constructor.  */
11318             if (explicitp == 2)
11319               DECL_NONCONVERTING_P (decl) = 1;
11320             else if (DECL_CONSTRUCTOR_P (decl))
11321               {
11322                 /* The constructor can be called with exactly one
11323                    parameter if there is at least one parameter, and
11324                    any subsequent parameters have default arguments.
11325                    Ignore any compiler-added parms.  */
11326                 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
11327
11328                 if (arg_types == void_list_node
11329                     || (arg_types
11330                         && TREE_CHAIN (arg_types)
11331                         && TREE_CHAIN (arg_types) != void_list_node
11332                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11333                   DECL_NONCONVERTING_P (decl) = 1;
11334               }
11335           }
11336         else if (TREE_CODE (type) == METHOD_TYPE)
11337           {
11338             /* We only get here for friend declarations of
11339                members of other classes.  */
11340             /* All method decls are public, so tell grokfndecl to set
11341                TREE_PUBLIC, also.  */
11342             decl = grokfndecl (ctype, type, declarator, declarator,
11343                                virtualp, flags, quals, raises,
11344                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11345                                template_count, in_namespace);
11346             if (decl == NULL_TREE)
11347               return NULL_TREE;
11348           }
11349         else if (!staticp && ! processing_template_decl
11350                  && !COMPLETE_TYPE_P (complete_type (type))
11351                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11352           {
11353             if (declarator)
11354               cp_error ("field `%D' has incomplete type", declarator);
11355             else
11356               cp_error ("name `%T' has incomplete type", type);
11357
11358             /* If we're instantiating a template, tell them which
11359                instantiation made the field's type be incomplete.  */
11360             if (current_class_type
11361                 && TYPE_NAME (current_class_type)
11362                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11363                 && declspecs && TREE_VALUE (declspecs)
11364                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11365               cp_error ("  in instantiation of template `%T'",
11366                         current_class_type);
11367
11368             type = error_mark_node;
11369             decl = NULL_TREE;
11370           }
11371         else
11372           {
11373             if (friendp)
11374               {
11375                 error ("`%s' is neither function nor member function; cannot be declared friend",
11376                        IDENTIFIER_POINTER (declarator));
11377                 friendp = 0;
11378               }
11379             decl = NULL_TREE;
11380           }
11381
11382         if (friendp)
11383           {
11384             /* Friends are treated specially.  */
11385             tree t = NULL_TREE;
11386
11387             /* DR 209. The friend does not need to be accessible at this
11388                point. */
11389             skip_type_access_control ();
11390
11391             if (ctype == current_class_type)
11392               warning ("member functions are implicitly friends of their class");
11393
11394             if (decl && DECL_NAME (decl))
11395               {
11396                 if (template_class_depth (current_class_type) == 0)
11397                   {
11398                     decl = check_explicit_specialization
11399                             (declarator, decl,
11400                              template_count, 2 * (funcdef_flag != 0) + 4);
11401                     if (decl == error_mark_node)
11402                       return error_mark_node;
11403                   }
11404
11405                 t = do_friend (ctype, declarator, decl,
11406                                last_function_parms, attrlist, flags, quals,
11407                                funcdef_flag);
11408               }
11409             if (t && funcdef_flag)
11410               return t;
11411             return void_type_node;
11412           }
11413
11414         /* Structure field.  It may not be a function, except for C++ */
11415
11416         if (decl == NULL_TREE)
11417           {
11418             if (initialized)
11419               {
11420                 if (!staticp)
11421                   {
11422                     /* An attempt is being made to initialize a non-static
11423                        member.  But, from [class.mem]:
11424
11425                        4 A member-declarator can contain a
11426                        constant-initializer only if it declares a static
11427                        member (_class.static_) of integral or enumeration
11428                        type, see _class.static.data_.
11429
11430                        This used to be relatively common practice, but
11431                        the rest of the compiler does not correctly
11432                        handle the initialization unless the member is
11433                        static so we make it static below.  */
11434                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11435                                 declarator);
11436                     cp_pedwarn ("making `%D' static", declarator);
11437                     staticp = 1;
11438                   }
11439
11440                 if (uses_template_parms (type))
11441                   /* We'll check at instantiation time.  */
11442                   ;
11443                 else if (check_static_variable_definition (declarator,
11444                                                            type))
11445                   /* If we just return the declaration, crashes
11446                      will sometimes occur.  We therefore return
11447                      void_type_node, as if this was a friend
11448                      declaration, to cause callers to completely
11449                      ignore this declaration.  */
11450                   return void_type_node;
11451               }
11452
11453             /* 9.2p13 [class.mem] */
11454             if (declarator == constructor_name (current_class_type)
11455                 /* The standard does not allow non-static data members
11456                    here either, but we agreed at the 10/99 meeting
11457                    to change that in TC 1 so that they are allowed in
11458                    classes with no user-defined constructors.  */
11459                 && staticp)
11460               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11461                           declarator);
11462
11463             if (staticp)
11464               {
11465                 /* C++ allows static class members.  All other work
11466                    for this is done by grokfield.  */
11467                 decl = build_lang_decl (VAR_DECL, declarator, type);
11468                 TREE_STATIC (decl) = 1;
11469                 /* In class context, 'static' means public access.  */
11470                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11471               }
11472             else
11473               {
11474                 decl = build_decl (FIELD_DECL, declarator, type);
11475                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11476                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11477                   {
11478                     DECL_MUTABLE_P (decl) = 1;
11479                     RIDBIT_RESET (RID_MUTABLE, specbits);
11480                   }
11481               }
11482
11483             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11484                             inlinep, friendp, raises != NULL_TREE);
11485           }
11486       }
11487     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11488       {
11489         tree original_name;
11490         int publicp = 0;
11491
11492         if (! declarator)
11493           return NULL_TREE;
11494
11495         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11496           original_name = dname;
11497         else
11498           original_name = declarator;
11499
11500         if (RIDBIT_SETP (RID_AUTO, specbits))
11501           error ("storage class `auto' invalid for function `%s'", name);
11502         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11503           error ("storage class `register' invalid for function `%s'", name);
11504
11505         /* Function declaration not at top level.
11506            Storage classes other than `extern' are not allowed
11507            and `extern' makes no difference.  */
11508         if (! toplevel_bindings_p ()
11509             && (RIDBIT_SETP (RID_STATIC, specbits)
11510                 || RIDBIT_SETP (RID_INLINE, specbits))
11511             && pedantic)
11512           {
11513             if (RIDBIT_SETP (RID_STATIC, specbits))
11514               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11515             else
11516               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11517           }
11518
11519         if (ctype == NULL_TREE)
11520           {
11521             if (virtualp)
11522               {
11523                 error ("virtual non-class function `%s'", name);
11524                 virtualp = 0;
11525               }
11526           }
11527         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11528           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11529                                           TYPE_ARG_TYPES (type));
11530
11531         /* Record presence of `static'.  */
11532         publicp = (ctype != NULL_TREE
11533                    || RIDBIT_SETP (RID_EXTERN, specbits)
11534                    || !RIDBIT_SETP (RID_STATIC, specbits));
11535
11536         decl = grokfndecl (ctype, type, original_name, declarator,
11537                            virtualp, flags, quals, raises,
11538                            1, friendp,
11539                            publicp, inlinep, funcdef_flag,
11540                            template_count, in_namespace);
11541         if (decl == NULL_TREE)
11542           return NULL_TREE;
11543
11544         if (staticp == 1)
11545           {
11546             int illegal_static = 0;
11547
11548             /* Don't allow a static member function in a class, and forbid
11549                declaring main to be static.  */
11550             if (TREE_CODE (type) == METHOD_TYPE)
11551               {
11552                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11553                 illegal_static = 1;
11554               }
11555             else if (current_function_decl)
11556               {
11557                 /* FIXME need arm citation */
11558                 error ("cannot declare static function inside another function");
11559                 illegal_static = 1;
11560               }
11561
11562             if (illegal_static)
11563               {
11564                 staticp = 0;
11565                 RIDBIT_RESET (RID_STATIC, specbits);
11566               }
11567           }
11568       }
11569     else
11570       {
11571         /* It's a variable.  */
11572
11573         /* An uninitialized decl with `extern' is a reference.  */
11574         decl = grokvardecl (type, declarator, &specbits,
11575                             initialized,
11576                             (type_quals & TYPE_QUAL_CONST) != 0,
11577                             in_namespace);
11578         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11579                         inlinep, friendp, raises != NULL_TREE);
11580
11581         if (ctype)
11582           {
11583             DECL_CONTEXT (decl) = ctype;
11584             if (staticp == 1)
11585               {
11586                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11587                 staticp = 0;
11588                 RIDBIT_RESET (RID_STATIC, specbits);
11589               }
11590             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11591               {
11592                 cp_error ("static member `%D' declared `register'", decl);
11593                 RIDBIT_RESET (RID_REGISTER, specbits);
11594               }
11595             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11596               {
11597                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11598                             decl);
11599                 RIDBIT_RESET (RID_EXTERN, specbits);
11600               }
11601           }
11602       }
11603
11604     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11605
11606     /* Record `register' declaration for warnings on &
11607        and in case doing stupid register allocation.  */
11608
11609     if (RIDBIT_SETP (RID_REGISTER, specbits))
11610       DECL_REGISTER (decl) = 1;
11611
11612     if (RIDBIT_SETP (RID_EXTERN, specbits))
11613       DECL_THIS_EXTERN (decl) = 1;
11614
11615     if (RIDBIT_SETP (RID_STATIC, specbits))
11616       DECL_THIS_STATIC (decl) = 1;
11617
11618     /* Record constancy and volatility.  There's no need to do this
11619        when processing a template; we'll do this for the instantiated
11620        declaration based on the type of DECL.  */
11621     if (!processing_template_decl)
11622       c_apply_type_quals_to_decl (type_quals, decl);
11623
11624     return decl;
11625   }
11626 }
11627 \f
11628 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11629    An empty exprlist is a parmlist.  An exprlist which
11630    contains only identifiers at the global level
11631    is a parmlist.  Otherwise, it is an exprlist.  */
11632
11633 int
11634 parmlist_is_exprlist (exprs)
11635      tree exprs;
11636 {
11637   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11638     return 0;
11639
11640   if (toplevel_bindings_p ())
11641     {
11642       /* At the global level, if these are all identifiers,
11643          then it is a parmlist.  */
11644       while (exprs)
11645         {
11646           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11647             return 1;
11648           exprs = TREE_CHAIN (exprs);
11649         }
11650       return 0;
11651     }
11652   return 1;
11653 }
11654
11655 /* Subroutine of start_function.  Ensure that each of the parameter
11656    types (as listed in PARMS) is complete, as is required for a
11657    function definition.  */
11658
11659 static void
11660 require_complete_types_for_parms (parms)
11661      tree parms;
11662 {
11663   for (; parms; parms = TREE_CHAIN (parms))
11664     {
11665       if (VOID_TYPE_P (TREE_TYPE (parms)))
11666         /* grokparms will have already issued an error */
11667         TREE_TYPE (parms) = error_mark_node;
11668       else if (complete_type_or_else (TREE_TYPE (parms), parms))
11669         layout_decl (parms, 0);
11670       else
11671         TREE_TYPE (parms) = error_mark_node;
11672     }
11673 }
11674
11675 /* Returns non-zero if T is a local variable.  */
11676
11677 int
11678 local_variable_p (t)
11679      tree t;
11680 {
11681   if ((TREE_CODE (t) == VAR_DECL
11682        /* A VAR_DECL with a context that is a _TYPE is a static data
11683           member.  */
11684        && !TYPE_P (CP_DECL_CONTEXT (t))
11685        /* Any other non-local variable must be at namespace scope.  */
11686        && !DECL_NAMESPACE_SCOPE_P (t))
11687       || (TREE_CODE (t) == PARM_DECL))
11688     return 1;
11689
11690   return 0;
11691 }
11692
11693 /* Returns non-zero if T is an automatic local variable or a label.
11694    (These are the declarations that need to be remapped when the code
11695    containing them is duplicated.)  */
11696
11697 int
11698 nonstatic_local_decl_p (t)
11699      tree t;
11700 {
11701   return ((local_variable_p (t) && !TREE_STATIC (t))
11702           || TREE_CODE (t) == LABEL_DECL
11703           || TREE_CODE (t) == RESULT_DECL);
11704 }
11705
11706 /* Like local_variable_p, but suitable for use as a tree-walking
11707    function.  */
11708
11709 static tree
11710 local_variable_p_walkfn (tp, walk_subtrees, data)
11711      tree *tp;
11712      int *walk_subtrees ATTRIBUTE_UNUSED;
11713      void *data ATTRIBUTE_UNUSED;
11714 {
11715   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11716           ? *tp : NULL_TREE);
11717 }
11718
11719 /* Check that ARG, which is a default-argument expression for a
11720    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11721    something goes wrong.  DECL may also be a _TYPE node, rather than a
11722    DECL, if there is no DECL available.  */
11723
11724 tree
11725 check_default_argument (decl, arg)
11726      tree decl;
11727      tree arg;
11728 {
11729   tree var;
11730   tree decl_type;
11731
11732   if (TREE_CODE (arg) == DEFAULT_ARG)
11733     /* We get a DEFAULT_ARG when looking at an in-class declaration
11734        with a default argument.  Ignore the argument for now; we'll
11735        deal with it after the class is complete.  */
11736     return arg;
11737
11738   if (processing_template_decl || uses_template_parms (arg))
11739     /* We don't do anything checking until instantiation-time.  Note
11740        that there may be uninstantiated arguments even for an
11741        instantiated function, since default arguments are not
11742        instantiated until they are needed.  */
11743     return arg;
11744
11745   if (TYPE_P (decl))
11746     {
11747       decl_type = decl;
11748       decl = NULL_TREE;
11749     }
11750   else
11751     decl_type = TREE_TYPE (decl);
11752
11753   if (arg == error_mark_node
11754       || decl == error_mark_node
11755       || TREE_TYPE (arg) == error_mark_node
11756       || decl_type == error_mark_node)
11757     /* Something already went wrong.  There's no need to check
11758        further.  */
11759     return error_mark_node;
11760
11761   /* [dcl.fct.default]
11762
11763      A default argument expression is implicitly converted to the
11764      parameter type.  */
11765   if (!TREE_TYPE (arg)
11766       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11767     {
11768       if (decl)
11769         cp_error ("default argument for `%#D' has type `%T'",
11770                   decl, TREE_TYPE (arg));
11771       else
11772         cp_error ("default argument for parameter of type `%T' has type `%T'",
11773                   decl_type, TREE_TYPE (arg));
11774
11775       return error_mark_node;
11776     }
11777
11778   /* [dcl.fct.default]
11779
11780      Local variables shall not be used in default argument
11781      expressions.
11782
11783      The keyword `this' shall not be used in a default argument of a
11784      member function.  */
11785   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
11786                                       NULL);
11787   if (var)
11788     {
11789       cp_error ("default argument `%E' uses local variable `%D'",
11790                 arg, var);
11791       return error_mark_node;
11792     }
11793
11794   /* All is well.  */
11795   return arg;
11796 }
11797
11798 /* Decode the list of parameter types for a function type.
11799    Given the list of things declared inside the parens,
11800    return a list of types.
11801
11802    We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
11803    flag. If unset, we append void_list_node. A parmlist declared
11804    as `(void)' is accepted as the empty parmlist.
11805
11806    Also set last_function_parms to the chain of PARM_DECLs.  */
11807
11808 static tree
11809 grokparms (first_parm)
11810      tree first_parm;
11811 {
11812   tree result = NULL_TREE;
11813   tree decls = NULL_TREE;
11814   int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
11815   tree parm, chain;
11816   int any_error = 0;
11817
11818   my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
11819
11820   for (parm = first_parm; parm != NULL_TREE; parm = chain)
11821     {
11822       tree type = NULL_TREE;
11823       register tree decl = TREE_VALUE (parm);
11824       tree init = TREE_PURPOSE (parm);
11825
11826       chain = TREE_CHAIN (parm);
11827       /* @@ weak defense against parse errors.  */
11828       if (TREE_CODE (decl) != VOID_TYPE
11829           && TREE_CODE (decl) != TREE_LIST)
11830         {
11831           /* Give various messages as the need arises.  */
11832           if (TREE_CODE (decl) == STRING_CST)
11833             cp_error ("invalid string constant `%E'", decl);
11834           else if (TREE_CODE (decl) == INTEGER_CST)
11835             error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11836           continue;
11837         }
11838
11839       if (parm == void_list_node)
11840         break;
11841
11842       decl = grokdeclarator (TREE_VALUE (decl), TREE_PURPOSE (decl),
11843                      PARM, init != NULL_TREE, NULL_TREE);
11844       if (! decl || TREE_TYPE (decl) == error_mark_node)
11845         continue;
11846
11847       type = TREE_TYPE (decl);
11848       if (VOID_TYPE_P (type))
11849         {
11850           if (same_type_p (type, void_type_node)
11851               && !DECL_NAME (decl) && !result && !chain && !ellipsis)
11852             /* this is a parmlist of `(void)', which is ok.  */
11853             break;
11854           incomplete_type_error (decl, type);
11855           /* It's not a good idea to actually create parameters of
11856              type `void'; other parts of the compiler assume that a
11857              void type terminates the parameter list.  */
11858           type = error_mark_node;
11859           TREE_TYPE (decl) = error_mark_node;
11860         }
11861
11862       if (type != error_mark_node)
11863         {
11864           /* Top-level qualifiers on the parameters are
11865              ignored for function types.  */
11866           type = TYPE_MAIN_VARIANT (type);
11867           if (TREE_CODE (type) == METHOD_TYPE)
11868             {
11869               cp_error ("parameter `%D' invalidly declared method type", decl);
11870               type = build_pointer_type (type);
11871               TREE_TYPE (decl) = type;
11872             }
11873           else if (TREE_CODE (type) == OFFSET_TYPE)
11874             {
11875               cp_error ("parameter `%D' invalidly declared offset type", decl);
11876               type = build_pointer_type (type);
11877               TREE_TYPE (decl) = type;
11878             }
11879           else if (abstract_virtuals_error (decl, type))
11880             any_error = 1;  /* Seems like a good idea. */
11881           else if (POINTER_TYPE_P (type))
11882             {
11883               /* [dcl.fct]/6, parameter types cannot contain pointers
11884                  (references) to arrays of unknown bound.  */
11885               tree t = TREE_TYPE (type);
11886               int ptr = TYPE_PTR_P (type);
11887
11888               while (1)
11889                 {
11890                   if (TYPE_PTR_P (t))
11891                     ptr = 1;
11892                   else if (TREE_CODE (t) != ARRAY_TYPE)
11893                     break;
11894                   else if (!TYPE_DOMAIN (t))
11895                     break;
11896                   t = TREE_TYPE (t);
11897                 }
11898               if (TREE_CODE (t) == ARRAY_TYPE)
11899                 cp_error ("parameter `%D' includes %s to array of unknown bound `%T'",
11900                           decl, ptr ? "pointer" : "reference", t);
11901             }
11902
11903           DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11904           if (PROMOTE_PROTOTYPES
11905               && INTEGRAL_TYPE_P (type)
11906               && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11907             DECL_ARG_TYPE (decl) = integer_type_node;
11908           if (!any_error && init)
11909             init = check_default_argument (decl, init);
11910           else
11911             init = NULL_TREE;
11912         }
11913
11914       TREE_CHAIN (decl) = decls;
11915       decls = decl;
11916       result = tree_cons (init, type, result);
11917     }
11918   decls = nreverse (decls);
11919   result = nreverse (result);
11920   if (!ellipsis)
11921     result = chainon (result, void_list_node);
11922   last_function_parms = decls;
11923
11924   return result;
11925 }
11926
11927 \f
11928 /* D is a constructor or overloaded `operator='.  Returns non-zero if
11929    D's arguments allow it to be a copy constructor, or copy assignment
11930    operator.  */
11931
11932 int
11933 copy_args_p (d)
11934      tree d;
11935 {
11936   tree t;
11937
11938   if (!DECL_FUNCTION_MEMBER_P (d))
11939     return 0;
11940
11941   t = FUNCTION_FIRST_USER_PARMTYPE (d);
11942   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
11943       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
11944           == DECL_CONTEXT (d))
11945       && (TREE_CHAIN (t) == NULL_TREE
11946           || TREE_CHAIN (t) == void_list_node
11947           || TREE_PURPOSE (TREE_CHAIN (t))))
11948     return 1;
11949   return 0;
11950 }
11951
11952 /* These memoizing functions keep track of special properties which
11953    a class may have.  `grok_ctor_properties' notices whether a class
11954    has a constructor of the form X(X&), and also complains
11955    if the class has a constructor of the form X(X).
11956    `grok_op_properties' takes notice of the various forms of
11957    operator= which are defined, as well as what sorts of type conversion
11958    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
11959
11960 int
11961 grok_ctor_properties (ctype, decl)
11962      tree ctype, decl;
11963 {
11964   tree parmtypes = FUNCTION_FIRST_USER_PARMTYPE (decl);
11965   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
11966
11967   /* [class.copy]
11968
11969      A non-template constructor for class X is a copy constructor if
11970      its first parameter is of type X&, const X&, volatile X& or const
11971      volatile X&, and either there are no other parameters or else all
11972      other parameters have default arguments.  */
11973   if (TREE_CODE (parmtype) == REFERENCE_TYPE
11974       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
11975       && sufficient_parms_p (TREE_CHAIN (parmtypes))
11976       && !(DECL_TEMPLATE_INSTANTIATION (decl)
11977            && is_member_template (DECL_TI_TEMPLATE (decl))))
11978     {
11979       TYPE_HAS_INIT_REF (ctype) = 1;
11980       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
11981         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
11982     }
11983   /* [class.copy]
11984
11985      A declaration of a constructor for a class X is ill-formed if its
11986      first parameter is of type (optionally cv-qualified) X and either
11987      there are no other parameters or else all other parameters have
11988      default arguments.
11989
11990      We *don't* complain about member template instantiations that
11991      have this form, though; they can occur as we try to decide what
11992      constructor to use during overload resolution.  Since overload
11993      resolution will never prefer such a constructor to the
11994      non-template copy constructor (which is either explicitly or
11995      implicitly defined), there's no need to worry about their
11996      existence.  Theoretically, they should never even be
11997      instantiated, but that's hard to forestall.  */
11998   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
11999            && sufficient_parms_p (TREE_CHAIN (parmtypes))
12000            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12001                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12002     {
12003       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12004                 ctype, ctype);
12005       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12006       return 0;
12007     }
12008   else if (TREE_CODE (parmtype) == VOID_TYPE
12009            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12010     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12011
12012   return 1;
12013 }
12014
12015 /* An operator with this code is unary, but can also be binary.  */
12016
12017 static int
12018 ambi_op_p (code)
12019      enum tree_code code;
12020 {
12021   return (code == INDIRECT_REF
12022           || code == ADDR_EXPR
12023           || code == CONVERT_EXPR
12024           || code == NEGATE_EXPR
12025           || code == PREINCREMENT_EXPR
12026           || code == PREDECREMENT_EXPR);
12027 }
12028
12029 /* An operator with this name can only be unary.  */
12030
12031 static int
12032 unary_op_p (code)
12033      enum tree_code code;
12034 {
12035   return (code == TRUTH_NOT_EXPR
12036           || code == BIT_NOT_EXPR
12037           || code == COMPONENT_REF
12038           || code == TYPE_EXPR);
12039 }
12040
12041 /* Do a little sanity-checking on how they declared their operator.  */
12042
12043 void
12044 grok_op_properties (decl, virtualp, friendp)
12045      tree decl;
12046      int virtualp, friendp;
12047 {
12048   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12049   tree argtype;
12050   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12051   tree name = DECL_NAME (decl);
12052   enum tree_code operator_code;
12053   int arity;
12054
12055   /* Count the number of arguments.  */
12056   for (argtype = argtypes, arity = 0;
12057        argtype && argtype != void_list_node;
12058        argtype = TREE_CHAIN (argtype))
12059     ++arity;
12060
12061   if (current_class_type == NULL_TREE)
12062     friendp = 1;
12063
12064   if (DECL_CONV_FN_P (decl))
12065     operator_code = TYPE_EXPR;
12066   else
12067     do
12068       {
12069 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)       \
12070         if (ansi_opname (CODE) == name)                         \
12071           {                                                     \
12072             operator_code = CODE;                               \
12073             break;                                              \
12074           }                                                     \
12075         else if (ansi_assopname (CODE) == name)                 \
12076           {                                                     \
12077             operator_code = CODE;                               \
12078             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;              \
12079             break;                                              \
12080           }
12081
12082 #include "operators.def"
12083 #undef DEF_OPERATOR
12084
12085         my_friendly_abort (20000527);
12086       }
12087     while (0);
12088   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12089   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12090
12091   if (! friendp)
12092     {
12093       switch (operator_code)
12094         {
12095         case CALL_EXPR:
12096           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12097           break;
12098
12099         case ARRAY_REF:
12100           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12101           break;
12102
12103         case COMPONENT_REF:
12104         case MEMBER_REF:
12105           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12106           break;
12107
12108         case NEW_EXPR:
12109           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12110           break;
12111
12112         case DELETE_EXPR:
12113           TYPE_GETS_DELETE (current_class_type) |= 1;
12114           break;
12115
12116         case VEC_NEW_EXPR:
12117           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12118           break;
12119
12120         case VEC_DELETE_EXPR:
12121           TYPE_GETS_DELETE (current_class_type) |= 2;
12122           break;
12123
12124         default:
12125           break;
12126         }
12127     }
12128
12129   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12130     {
12131       /* When the compiler encounters the definition of A::operator new, it
12132          doesn't look at the class declaration to find out if it's static.  */
12133       if (methodp)
12134         revert_static_member_fn (decl);
12135
12136       TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12137     }
12138   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12139     {
12140       if (methodp)
12141         revert_static_member_fn (decl);
12142
12143       TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12144     }
12145   else
12146     {
12147       /* An operator function must either be a non-static member function
12148          or have at least one parameter of a class, a reference to a class,
12149          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12150       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12151         {
12152           if (operator_code == TYPE_EXPR
12153               || operator_code == CALL_EXPR
12154               || operator_code == COMPONENT_REF
12155               || operator_code == ARRAY_REF
12156               || operator_code == NOP_EXPR)
12157             cp_error ("`%D' must be a nonstatic member function", decl);
12158           else
12159             {
12160               tree p = argtypes;
12161
12162               if (DECL_STATIC_FUNCTION_P (decl))
12163                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12164
12165               if (p)
12166                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12167                   {
12168                     tree arg = TREE_VALUE (p);
12169                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12170                       arg = TREE_TYPE (arg);
12171
12172                     /* This lets bad template code slip through.  */
12173                     if (IS_AGGR_TYPE (arg)
12174                         || TREE_CODE (arg) == ENUMERAL_TYPE
12175                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12176                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12177                       goto foundaggr;
12178                   }
12179               cp_error
12180                 ("`%D' must have an argument of class or enumerated type",
12181                  decl);
12182             foundaggr:
12183               ;
12184             }
12185         }
12186
12187       if (operator_code == CALL_EXPR)
12188         return;                 /* No restrictions on args. */
12189
12190       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12191         {
12192           tree t = TREE_TYPE (name);
12193           if (! friendp)
12194             {
12195               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12196               const char *what = 0;
12197
12198               if (ref)
12199                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12200
12201               if (TREE_CODE (t) == VOID_TYPE)
12202                 what = "void";
12203               else if (t == current_class_type)
12204                 what = "the same type";
12205               /* Don't force t to be complete here.  */
12206               else if (IS_AGGR_TYPE (t)
12207                        && COMPLETE_TYPE_P (t)
12208                        && DERIVED_FROM_P (t, current_class_type))
12209                 what = "a base class";
12210
12211               if (what)
12212                 warning ("conversion to %s%s will never use a type conversion operator",
12213                          ref ? "a reference to " : "", what);
12214             }
12215         }
12216
12217       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12218           && operator_code == NOP_EXPR)
12219         {
12220           tree parmtype;
12221
12222           if (arity != 2 && methodp)
12223             {
12224               cp_error ("`%D' must take exactly one argument", decl);
12225               return;
12226             }
12227           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12228
12229           /* [class.copy]
12230
12231              A user-declared copy assignment operator X::operator= is
12232              a non-static non-template member function of class X with
12233              exactly one parameter of type X, X&, const X&, volatile
12234              X& or const volatile X&.  */
12235           if (copy_assignment_arg_p (parmtype, virtualp)
12236               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12237                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12238               && ! friendp)
12239             {
12240               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12241               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12242                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12243                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12244             }
12245         }
12246       else if (operator_code == COND_EXPR)
12247         {
12248           /* 13.4.0.3 */
12249           cp_error ("ISO C++ prohibits overloading operator ?:");
12250         }
12251       else if (ambi_op_p (operator_code))
12252         {
12253           if (arity == 1)
12254             /* We pick the one-argument operator codes by default, so
12255                we don't have to change anything.  */
12256             ;
12257           else if (arity == 2)
12258             {
12259               /* If we thought this was a unary operator, we now know
12260                  it to be a binary operator.  */
12261               switch (operator_code)
12262                 {
12263                 case INDIRECT_REF:
12264                   operator_code = MULT_EXPR;
12265                   break;
12266
12267                 case ADDR_EXPR:
12268                   operator_code = BIT_AND_EXPR;
12269                   break;
12270
12271                 case CONVERT_EXPR:
12272                   operator_code = PLUS_EXPR;
12273                   break;
12274
12275                 case NEGATE_EXPR:
12276                   operator_code = MINUS_EXPR;
12277                   break;
12278
12279                 case PREINCREMENT_EXPR:
12280                   operator_code = POSTINCREMENT_EXPR;
12281                   break;
12282
12283                 case PREDECREMENT_EXPR:
12284                   operator_code = POSTDECREMENT_EXPR;
12285                   break;
12286
12287                 default:
12288                   my_friendly_abort (20000527);
12289                 }
12290
12291               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12292
12293               if ((operator_code == POSTINCREMENT_EXPR
12294                    || operator_code == POSTDECREMENT_EXPR)
12295                   && ! processing_template_decl
12296                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12297                 {
12298                   if (methodp)
12299                     cp_error ("postfix `%D' must take `int' as its argument",
12300                               decl);
12301                   else
12302                     cp_error
12303                       ("postfix `%D' must take `int' as its second argument",
12304                        decl);
12305                 }
12306             }
12307           else
12308             {
12309               if (methodp)
12310                 cp_error ("`%D' must take either zero or one argument", decl);
12311               else
12312                 cp_error ("`%D' must take either one or two arguments", decl);
12313             }
12314
12315           /* More Effective C++ rule 6.  */
12316           if (warn_ecpp
12317               && (operator_code == POSTINCREMENT_EXPR
12318                   || operator_code == POSTDECREMENT_EXPR
12319                   || operator_code == PREINCREMENT_EXPR
12320                   || operator_code == PREDECREMENT_EXPR))
12321             {
12322               tree arg = TREE_VALUE (argtypes);
12323               tree ret = TREE_TYPE (TREE_TYPE (decl));
12324               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12325                 arg = TREE_TYPE (arg);
12326               arg = TYPE_MAIN_VARIANT (arg);
12327               if (operator_code == PREINCREMENT_EXPR
12328                   || operator_code == PREDECREMENT_EXPR)
12329                 {
12330                   if (TREE_CODE (ret) != REFERENCE_TYPE
12331                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12332                                        arg))
12333                     cp_warning ("prefix `%D' should return `%T'", decl,
12334                                 build_reference_type (arg));
12335                 }
12336               else
12337                 {
12338                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12339                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12340                 }
12341             }
12342         }
12343       else if (unary_op_p (operator_code))
12344         {
12345           if (arity != 1)
12346             {
12347               if (methodp)
12348                 cp_error ("`%D' must take `void'", decl);
12349               else
12350                 cp_error ("`%D' must take exactly one argument", decl);
12351             }
12352         }
12353       else /* if (binary_op_p (operator_code)) */
12354         {
12355           if (arity != 2)
12356             {
12357               if (methodp)
12358                 cp_error ("`%D' must take exactly one argument", decl);
12359               else
12360                 cp_error ("`%D' must take exactly two arguments", decl);
12361             }
12362
12363           /* More Effective C++ rule 7.  */
12364           if (warn_ecpp
12365               && (operator_code == TRUTH_ANDIF_EXPR
12366                   || operator_code == TRUTH_ORIF_EXPR
12367                   || operator_code == COMPOUND_EXPR))
12368             cp_warning ("user-defined `%D' always evaluates both arguments",
12369                         decl);
12370         }
12371
12372       /* Effective C++ rule 23.  */
12373       if (warn_ecpp
12374           && arity == 2
12375           && (operator_code == PLUS_EXPR
12376               || operator_code == MINUS_EXPR
12377               || operator_code == TRUNC_DIV_EXPR
12378               || operator_code == MULT_EXPR)
12379           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12380         cp_warning ("`%D' should return by value", decl);
12381
12382       /* 13.4.0.8 */
12383       for (; argtypes && argtypes != void_list_node;
12384           argtypes = TREE_CHAIN (argtypes))
12385         if (TREE_PURPOSE (argtypes))
12386           {
12387             TREE_PURPOSE (argtypes) = NULL_TREE;
12388             if (operator_code == POSTINCREMENT_EXPR
12389                 || operator_code == POSTDECREMENT_EXPR)
12390               {
12391                 if (pedantic)
12392                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12393               }
12394             else
12395               cp_error ("`%D' cannot have default arguments", decl);
12396           }
12397
12398     }
12399 }
12400 \f
12401 static const char *
12402 tag_name (code)
12403      enum tag_types code;
12404 {
12405   switch (code)
12406     {
12407     case record_type:
12408       return "struct";
12409     case class_type:
12410       return "class";
12411     case union_type:
12412       return "union ";
12413     case enum_type:
12414       return "enum";
12415     default:
12416       my_friendly_abort (981122);
12417     }
12418 }
12419
12420 /* Get the struct, enum or union (CODE says which) with tag NAME.
12421    Define the tag as a forward-reference if it is not defined.
12422
12423    C++: If a class derivation is given, process it here, and report
12424    an error if multiple derivation declarations are not identical.
12425
12426    If this is a definition, come in through xref_tag and only look in
12427    the current frame for the name (since C++ allows new names in any
12428    scope.)  */
12429
12430 tree
12431 xref_tag (code_type_node, name, globalize)
12432      tree code_type_node;
12433      tree name;
12434      int globalize;
12435 {
12436   enum tag_types tag_code;
12437   enum tree_code code;
12438   register tree ref, t;
12439   struct binding_level *b = current_binding_level;
12440   int got_type = 0;
12441   tree attributes = NULL_TREE;
12442   tree context = NULL_TREE;
12443
12444   /* If we are called from the parser, code_type_node will sometimes be a
12445      TREE_LIST.  This indicates that the user wrote
12446      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12447      use them later.  */
12448   if (TREE_CODE (code_type_node) == TREE_LIST)
12449     {
12450       attributes = TREE_PURPOSE (code_type_node);
12451       code_type_node = TREE_VALUE (code_type_node);
12452     }
12453
12454   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12455   switch (tag_code)
12456     {
12457     case record_type:
12458     case class_type:
12459       code = RECORD_TYPE;
12460       break;
12461     case union_type:
12462       code = UNION_TYPE;
12463       break;
12464     case enum_type:
12465       code = ENUMERAL_TYPE;
12466       break;
12467     default:
12468       my_friendly_abort (18);
12469     }
12470
12471   /* If a cross reference is requested, look up the type
12472      already defined for this tag and return it.  */
12473   if (TYPE_P (name))
12474     {
12475       t = name;
12476       name = TYPE_IDENTIFIER (t);
12477       got_type = 1;
12478     }
12479   else
12480     t = IDENTIFIER_TYPE_VALUE (name);
12481
12482   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12483   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12484     {
12485       static int explained;
12486       tree shadowed;
12487
12488       cp_warning ("`%s %T' declares a new type at namespace scope",
12489                   tag_name (tag_code), name);
12490       if (!explained++)
12491         cp_warning ("  names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'",
12492                     tag_name (tag_code),
12493                     constructor_name (current_class_type),
12494                     TYPE_IDENTIFIER (t));
12495
12496       /* We need to remove the class scope binding for the
12497          TYPENAME_TYPE as otherwise poplevel_class gets confused. */
12498       for (shadowed = b->class_shadowed;
12499            shadowed;
12500            shadowed = TREE_CHAIN (shadowed))
12501         if (TREE_TYPE (shadowed) == TYPE_NAME (t))
12502           {
12503             TREE_PURPOSE (shadowed) = NULL_TREE;
12504             break;
12505           }
12506     }
12507
12508   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12509       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12510     t = NULL_TREE;
12511
12512   if (! globalize)
12513     {
12514       /* If we know we are defining this tag, only look it up in
12515          this scope and don't try to find it as a type.  */
12516       ref = lookup_tag (code, name, b, 1);
12517     }
12518   else
12519     {
12520       if (t)
12521         {
12522           /* [dcl.type.elab] If the identifier resolves to a
12523              typedef-name or a template type-parameter, the
12524              elaborated-type-specifier is ill-formed.  */
12525           if (t != TYPE_MAIN_VARIANT (t)
12526               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12527             cp_pedwarn ("using typedef-name `%D' after `%s'",
12528                         TYPE_NAME (t), tag_name (tag_code));
12529           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12530             cp_error ("using template type parameter `%T' after `%s'",
12531                       t, tag_name (tag_code));
12532
12533           ref = t;
12534         }
12535       else
12536         ref = lookup_tag (code, name, b, 0);
12537
12538       if (! ref)
12539         {
12540           /* Try finding it as a type declaration.  If that wins,
12541              use it.  */
12542           ref = lookup_name (name, 1);
12543
12544           if (ref != NULL_TREE
12545               && processing_template_decl
12546               && DECL_CLASS_TEMPLATE_P (ref)
12547               && template_class_depth (current_class_type) == 0)
12548             /* Since GLOBALIZE is true, we're declaring a global
12549                template, so we want this type.  */
12550             ref = DECL_TEMPLATE_RESULT (ref);
12551
12552           if (ref && TREE_CODE (ref) == TYPE_DECL
12553               && TREE_CODE (TREE_TYPE (ref)) == code)
12554             ref = TREE_TYPE (ref);
12555           else
12556             ref = NULL_TREE;
12557         }
12558
12559       if (ref && current_class_type
12560           && template_class_depth (current_class_type)
12561           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12562         {
12563           /* Since GLOBALIZE is non-zero, we are not looking at a
12564              definition of this tag.  Since, in addition, we are currently
12565              processing a (member) template declaration of a template
12566              class, we must be very careful; consider:
12567
12568                template <class X>
12569                struct S1
12570
12571                template <class U>
12572                struct S2
12573                { template <class V>
12574                friend struct S1; };
12575
12576              Here, the S2::S1 declaration should not be confused with the
12577              outer declaration.  In particular, the inner version should
12578              have a template parameter of level 2, not level 1.  This
12579              would be particularly important if the member declaration
12580              were instead:
12581
12582                template <class V = U> friend struct S1;
12583
12584              say, when we should tsubst into `U' when instantiating
12585              S2.  On the other hand, when presented with:
12586
12587                  template <class T>
12588                  struct S1 {
12589                    template <class U>
12590                    struct S2 {};
12591                    template <class U>
12592                    friend struct S2;
12593                  };
12594
12595               we must find the inner binding eventually.  We
12596               accomplish this by making sure that the new type we
12597               create to represent this declaration has the right
12598               TYPE_CONTEXT.  */
12599           context = TYPE_CONTEXT (ref);
12600           ref = NULL_TREE;
12601         }
12602     }
12603
12604   if (! ref)
12605     {
12606       /* If no such tag is yet defined, create a forward-reference node
12607          and record it as the "definition".
12608          When a real declaration of this type is found,
12609          the forward-reference will be altered into a real type.  */
12610       if (code == ENUMERAL_TYPE)
12611         {
12612           cp_error ("use of enum `%#D' without previous declaration", name);
12613
12614           ref = make_node (ENUMERAL_TYPE);
12615
12616           /* Give the type a default layout like unsigned int
12617              to avoid crashing if it does not get defined.  */
12618           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12619           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12620           TYPE_USER_ALIGN (ref) = 0;
12621           TREE_UNSIGNED (ref) = 1;
12622           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12623           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12624           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12625
12626           /* Enable us to recognize when a type is created in class context.
12627              To do nested classes correctly, this should probably be cleared
12628              out when we leave this classes scope.  Currently this in only
12629              done in `start_enum'.  */
12630
12631           pushtag (name, ref, globalize);
12632         }
12633       else
12634         {
12635           struct binding_level *old_b = class_binding_level;
12636
12637           ref = make_aggr_type (code);
12638           TYPE_CONTEXT (ref) = context;
12639
12640 #ifdef NONNESTED_CLASSES
12641           /* Class types don't nest the way enums do.  */
12642           class_binding_level = (struct binding_level *)0;
12643 #endif
12644           pushtag (name, ref, globalize);
12645           class_binding_level = old_b;
12646         }
12647     }
12648   else
12649     {
12650       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12651         redeclare_class_template (ref, current_template_parms);
12652     }
12653
12654   /* Until the type is defined, tentatively accept whatever
12655      structure tag the user hands us.  */
12656   if (!COMPLETE_TYPE_P (ref)
12657       && ref != current_class_type
12658       /* Have to check this, in case we have contradictory tag info.  */
12659       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12660     {
12661       if (tag_code == class_type)
12662         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12663       else if (tag_code == record_type)
12664         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12665     }
12666
12667   TREE_TYPE (ref) = attributes;
12668
12669   return ref;
12670 }
12671
12672 tree
12673 xref_tag_from_type (old, id, globalize)
12674      tree old, id;
12675      int globalize;
12676 {
12677   tree code_type_node;
12678
12679   if (TREE_CODE (old) == RECORD_TYPE)
12680     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12681                       ? class_type_node : record_type_node);
12682   else
12683     code_type_node = union_type_node;
12684
12685   if (id == NULL_TREE)
12686     id = TYPE_IDENTIFIER (old);
12687
12688   return xref_tag (code_type_node, id, globalize);
12689 }
12690
12691 /* REF is a type (named NAME), for which we have just seen some
12692    baseclasses.  BINFO is a list of those baseclasses; the
12693    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12694    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12695    struct, or union.  */
12696
12697 void
12698 xref_basetypes (code_type_node, name, ref, binfo)
12699      tree code_type_node;
12700      tree name, ref;
12701      tree binfo;
12702 {
12703   /* In the declaration `A : X, Y, ... Z' we mark all the types
12704      (A, X, Y, ..., Z) so we can check for duplicates.  */
12705   tree binfos;
12706   tree base;
12707
12708   int i, len;
12709   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12710
12711   if (tag_code == union_type)
12712     {
12713       cp_error ("derived union `%T' invalid", ref);
12714       return;
12715     }
12716
12717   len = list_length (binfo);
12718
12719   /* First, make sure that any templates in base-classes are
12720      instantiated.  This ensures that if we call ourselves recursively
12721      we do not get confused about which classes are marked and which
12722      are not.  */
12723   for (base = binfo; base; base = TREE_CHAIN (base))
12724     complete_type (TREE_VALUE (base));
12725
12726   SET_CLASSTYPE_MARKED (ref);
12727   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12728
12729   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12730     {
12731       /* The base of a derived struct is public by default.  */
12732       int via_public
12733         = (TREE_PURPOSE (binfo) == access_public_node
12734            || TREE_PURPOSE (binfo) == access_public_virtual_node
12735            || (tag_code != class_type
12736                && (TREE_PURPOSE (binfo) == access_default_node
12737                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12738       int via_protected
12739         = (TREE_PURPOSE (binfo) == access_protected_node
12740            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12741       int via_virtual
12742         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12743            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12744            || TREE_PURPOSE (binfo) == access_public_virtual_node
12745            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12746       tree basetype = TREE_VALUE (binfo);
12747       tree base_binfo;
12748
12749       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12750         basetype = TREE_TYPE (basetype);
12751       if (!basetype
12752           || (TREE_CODE (basetype) != RECORD_TYPE
12753               && TREE_CODE (basetype) != TYPENAME_TYPE
12754               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12755               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
12756         {
12757           cp_error ("base type `%T' fails to be a struct or class type",
12758                     TREE_VALUE (binfo));
12759           continue;
12760         }
12761
12762       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12763
12764       /* This code replaces similar code in layout_basetypes.
12765          We put the complete_type first for implicit `typename'.  */
12766       if (!COMPLETE_TYPE_P (basetype)
12767           && ! (current_template_parms && uses_template_parms (basetype)))
12768         {
12769           cp_error ("base class `%T' has incomplete type", basetype);
12770           continue;
12771         }
12772       else
12773         {
12774           if (CLASSTYPE_MARKED (basetype))
12775             {
12776               if (basetype == ref)
12777                 cp_error ("recursive type `%T' undefined", basetype);
12778               else
12779                 cp_error ("duplicate base type `%T' invalid", basetype);
12780               continue;
12781             }
12782
12783           if (TYPE_FOR_JAVA (basetype)
12784               && (current_lang_depth () == 0))
12785             TYPE_FOR_JAVA (ref) = 1;
12786
12787           /* Note that the BINFO records which describe individual
12788              inheritances are *not* shared in the lattice!  They
12789              cannot be shared because a given baseclass may be
12790              inherited with different `accessibility' by different
12791              derived classes.  (Each BINFO record describing an
12792              individual inheritance contains flags which say what
12793              the `accessibility' of that particular inheritance is.)  */
12794
12795           base_binfo
12796             = make_binfo (size_zero_node, basetype,
12797                           CLASS_TYPE_P (basetype)
12798                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12799                           CLASS_TYPE_P (basetype)
12800                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12801
12802           TREE_VEC_ELT (binfos, i) = base_binfo;
12803           TREE_VIA_PUBLIC (base_binfo) = via_public;
12804           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12805           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12806           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12807
12808           /* We need to unshare the binfos now so that lookups during class
12809              definition work.  */
12810           unshare_base_binfos (base_binfo);
12811
12812           SET_CLASSTYPE_MARKED (basetype);
12813
12814           /* We are free to modify these bits because they are meaningless
12815              at top level, and BASETYPE is a top-level type.  */
12816           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12817             {
12818               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12819               /* Converting to a virtual base class requires looking
12820                  up the offset of the virtual base.  */
12821               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12822             }
12823
12824           if (CLASS_TYPE_P (basetype))
12825             {
12826               TYPE_HAS_NEW_OPERATOR (ref)
12827                 |= TYPE_HAS_NEW_OPERATOR (basetype);
12828               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12829                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12830               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12831               /* If the base-class uses multiple inheritance, so do we.  */
12832               TYPE_USES_MULTIPLE_INHERITANCE (ref)
12833                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12834               /* Likewise, if converting to a base of the base may require
12835                  code, then we may need to generate code to convert to a
12836                  base as well.  */
12837               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12838                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12839             }
12840
12841           i += 1;
12842         }
12843     }
12844   if (i)
12845     TREE_VEC_LENGTH (binfos) = i;
12846   else
12847     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12848
12849   if (i > 1)
12850     {
12851       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12852       /* If there is more than one non-empty they cannot be at the same
12853          address.  */
12854       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12855     }
12856
12857   /* Unmark all the types.  */
12858   while (--i >= 0)
12859     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12860   CLEAR_CLASSTYPE_MARKED (ref);
12861
12862   /* Now that we know all the base-classes, set up the list of virtual
12863      bases.  */
12864   get_vbase_types (ref);
12865 }
12866
12867 \f
12868 /* Begin compiling the definition of an enumeration type.
12869    NAME is its name (or null if anonymous).
12870    Returns the type object, as yet incomplete.
12871    Also records info about it so that build_enumerator
12872    may be used to declare the individual values as they are read.  */
12873
12874 tree
12875 start_enum (name)
12876      tree name;
12877 {
12878   register tree enumtype = NULL_TREE;
12879   struct binding_level *b = current_binding_level;
12880
12881   /* If this is the real definition for a previous forward reference,
12882      fill in the contents in the same object that used to be the
12883      forward reference.  */
12884
12885   if (name != NULL_TREE)
12886     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12887
12888   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12889     {
12890       cp_error ("multiple definition of `%#T'", enumtype);
12891       cp_error_at ("previous definition here", enumtype);
12892       /* Clear out TYPE_VALUES, and start again.  */
12893       TYPE_VALUES (enumtype) = NULL_TREE;
12894     }
12895   else
12896     {
12897       enumtype = make_node (ENUMERAL_TYPE);
12898       pushtag (name, enumtype, 0);
12899     }
12900
12901   if (current_class_type)
12902     TREE_ADDRESSABLE (b->tags) = 1;
12903
12904   GNU_xref_decl (current_function_decl, enumtype);
12905   return enumtype;
12906 }
12907
12908 /* After processing and defining all the values of an enumeration type,
12909    install their decls in the enumeration type and finish it off.
12910    ENUMTYPE is the type object and VALUES a list of name-value pairs.  */
12911
12912 void
12913 finish_enum (enumtype)
12914      tree enumtype;
12915 {
12916   tree pair;
12917   tree minnode;
12918   tree maxnode;
12919   tree t;
12920   bool unsignedp;
12921   int lowprec;
12922   int highprec;
12923   int precision;
12924
12925   /* We built up the VALUES in reverse order.  */
12926   TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
12927
12928   /* [dcl.enum]
12929
12930      Following the closing brace of an enum-specifier, each
12931      enumerator has the type of its enumeration.  Prior to the
12932      closing brace, the type of each enumerator is the type of
12933      its initializing value.  */
12934   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
12935     TREE_TYPE (TREE_VALUE (pair)) = enumtype;
12936
12937   /* For a enum defined in a template, all further processing is
12938      postponed until the template is instantiated.  */
12939   if (processing_template_decl)
12940     {
12941       tree scope = current_scope ();
12942       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12943         add_stmt (build_min (TAG_DEFN, enumtype));
12944
12945
12946       return;
12947     }
12948
12949   /* Figure out what the minimum and maximum values of the enumerators
12950      are.  */
12951   if (TYPE_VALUES (enumtype))
12952     {
12953       minnode = maxnode = NULL_TREE;
12954
12955       for (pair = TYPE_VALUES (enumtype);
12956            pair;
12957            pair = TREE_CHAIN (pair))
12958         {
12959           tree value;
12960
12961           value = DECL_INITIAL (TREE_VALUE (pair));
12962
12963           if (!minnode)
12964             minnode = maxnode = value;
12965           else if (tree_int_cst_lt (maxnode, value))
12966             maxnode = value;
12967           else if (tree_int_cst_lt (value, minnode))
12968             minnode = value;
12969         }
12970     }
12971   else
12972     minnode = maxnode = integer_zero_node;
12973
12974   /* Compute the number of bits require to represent all values of the
12975      enumeration.  We must do this before the type of MINNODE and
12976      MAXNODE are transformed, since min_precision relies on the
12977      TREE_TYPE of the value it is passed.  */
12978   unsignedp = tree_int_cst_sgn (minnode) >= 0;
12979   lowprec = min_precision (minnode, unsignedp);
12980   highprec = min_precision (maxnode, unsignedp);
12981   precision = MAX (lowprec, highprec);
12982
12983   /* Set the TREE_TYPE for the values as well.  That's so that when we
12984      call decl_constant_value we get an entity of the right type (but
12985      with the constant value).  In addition, transform the TYPE_VALUES
12986      list to contain the values, rather than the CONST_DECLs for them.  */
12987   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
12988     {
12989       tree value = DECL_INITIAL (TREE_VALUE (pair));
12990
12991       TREE_TYPE (value) = enumtype;
12992       TREE_VALUE (pair) = value;
12993     }
12994
12995   /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
12996   TYPE_SIZE (enumtype) = NULL_TREE;
12997   TYPE_PRECISION (enumtype) = precision;
12998   if (unsignedp)
12999     fixup_unsigned_type (enumtype);
13000   else
13001     fixup_signed_type (enumtype);
13002
13003   if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13004     /* Use the width of the narrowest normal C type which is wide
13005        enough.  */
13006     TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13007                                                 (precision, 1));
13008   else
13009     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13010
13011   TYPE_SIZE (enumtype) = NULL_TREE;
13012   layout_type (enumtype);
13013
13014   /* Fix up all variant types of this enum type.  */
13015   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13016     {
13017       TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13018       TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
13019       TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
13020       TYPE_SIZE (t) = TYPE_SIZE (enumtype);
13021       TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
13022       TYPE_MODE (t) = TYPE_MODE (enumtype);
13023       TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
13024       TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
13025       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
13026       TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype);
13027     }
13028
13029   /* Finish debugging output for this type.  */
13030   rest_of_type_compilation (enumtype, namespace_bindings_p ());
13031 }
13032
13033 /* Build and install a CONST_DECL for an enumeration constant of the
13034    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13035    Assignment of sequential values by default is handled here.  */
13036
13037 void
13038 build_enumerator (name, value, enumtype)
13039      tree name;
13040      tree value;
13041      tree enumtype;
13042 {
13043   tree decl;
13044   tree context;
13045   tree type;
13046   tree values;
13047
13048   /* Remove no-op casts from the value.  */
13049   if (value)
13050     STRIP_TYPE_NOPS (value);
13051
13052   if (! processing_template_decl)
13053     {
13054       /* Validate and default VALUE.  */
13055       if (value != NULL_TREE)
13056         {
13057           value = decl_constant_value (value);
13058
13059           if (TREE_CODE (value) == INTEGER_CST)
13060             {
13061               value = default_conversion (value);
13062               constant_expression_warning (value);
13063             }
13064           else
13065             {
13066               cp_error ("enumerator value for `%D' not integer constant", name);
13067               value = NULL_TREE;
13068             }
13069         }
13070
13071       /* Default based on previous value.  */
13072       if (value == NULL_TREE && ! processing_template_decl)
13073         {
13074           tree prev_value;
13075
13076           if (TYPE_VALUES (enumtype))
13077             {
13078               /* The next value is the previous value ... */
13079               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13080               /* ... plus one.  */
13081               value = cp_build_binary_op (PLUS_EXPR,
13082                                           prev_value,
13083                                           integer_one_node);
13084
13085               if (tree_int_cst_lt (value, prev_value))
13086                 cp_error ("overflow in enumeration values at `%D'", name);
13087             }
13088           else
13089             value = integer_zero_node;
13090         }
13091
13092       /* Remove no-op casts from the value.  */
13093       if (value)
13094         STRIP_TYPE_NOPS (value);
13095 #if 0
13096       /* To fix MAX_VAL enum consts. (bkoz)  */
13097       TREE_TYPE (value) = integer_type_node;
13098 #endif
13099     }
13100
13101   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13102      Even in other cases, we will later (in finish_enum) be setting
13103      the type of VALUE.  But, we don't need to make a copy if this
13104      VALUE is one of the enumeration constants for this same
13105      enumeration type.  */
13106   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13107     if (TREE_VALUE (values) == value)
13108       break;
13109   /* If we didn't break out of the loop, then we do need a copy.  */
13110   if (!values && value)
13111     value = copy_node (value);
13112
13113   /* C++ associates enums with global, function, or class declarations.  */
13114   context = current_scope ();
13115
13116   /* Build the actual enumeration constant.  Note that the enumeration
13117     constants have the type of their initializers until the
13118     enumeration is complete:
13119
13120       [ dcl.enum ]
13121
13122       Following the closing brace of an enum-specifier, each enumer-
13123       ator has the type of its enumeration.  Prior to the closing
13124       brace, the type of each enumerator is the type of its
13125       initializing value.
13126
13127     In finish_enum we will reset the type.  Of course, if we're
13128     processing a template, there may be no value.   */
13129   type = value ? TREE_TYPE (value) : NULL_TREE;
13130
13131   if (context && context == current_class_type)
13132     /* This enum declaration is local to the class.  We need the full
13133        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13134     decl = build_lang_decl (CONST_DECL, name, type);
13135   else
13136     /* It's a global enum, or it's local to a function.  (Note local to
13137       a function could mean local to a class method.  */
13138     decl = build_decl (CONST_DECL, name, type);
13139
13140   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13141   DECL_INITIAL (decl) = value;
13142   TREE_READONLY (decl) = 1;
13143
13144   if (context && context == current_class_type)
13145     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13146       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13147       things like `S::i' later.)  */
13148     finish_member_declaration (decl);
13149   else
13150     {
13151       pushdecl (decl);
13152       GNU_xref_decl (current_function_decl, decl);
13153     }
13154
13155   /* Add this enumeration constant to the list for this type.  */
13156   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13157 }
13158
13159 \f
13160 /* We're defining DECL.  Make sure that it's type is OK.  */
13161
13162 static void
13163 check_function_type (decl, current_function_parms)
13164      tree decl;
13165      tree current_function_parms;
13166 {
13167   tree fntype = TREE_TYPE (decl);
13168   tree return_type = complete_type (TREE_TYPE (fntype));
13169
13170   /* In a function definition, arg types must be complete.  */
13171   require_complete_types_for_parms (current_function_parms);
13172
13173   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13174     {
13175       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13176
13177       /* Make it return void instead, but don't change the
13178          type of the DECL_RESULT, in case we have a named return value.  */
13179       if (TREE_CODE (fntype) == METHOD_TYPE)
13180         {
13181           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13182           TREE_TYPE (decl)
13183             = build_cplus_method_type (ctype,
13184                                        void_type_node,
13185                                        FUNCTION_ARG_CHAIN (decl));
13186         }
13187       else
13188         TREE_TYPE (decl)
13189           = build_function_type (void_type_node,
13190                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13191       TREE_TYPE (decl)
13192         = build_exception_variant (fntype,
13193                                    TYPE_RAISES_EXCEPTIONS (fntype));
13194     }
13195   else
13196     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13197 }
13198
13199 /* Create the FUNCTION_DECL for a function definition.
13200    DECLSPECS and DECLARATOR are the parts of the declaration;
13201    they describe the function's name and the type it returns,
13202    but twisted together in a fashion that parallels the syntax of C.
13203
13204    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13205    DECLARATOR is really the DECL for the function we are about to
13206    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13207    indicating that the function is an inline defined in-class.
13208
13209    This function creates a binding context for the function body
13210    as well as setting up the FUNCTION_DECL in current_function_decl.
13211
13212    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13213    (it defines a datum instead), we return 0, which tells
13214    yyparse to report a parse error.
13215
13216    For C++, we must first check whether that datum makes any sense.
13217    For example, "class A local_a(1,2);" means that variable local_a
13218    is an aggregate of type A, which should have a constructor
13219    applied to it with the argument list [1, 2].  */
13220
13221 int
13222 start_function (declspecs, declarator, attrs, flags)
13223      tree declspecs, declarator, attrs;
13224      int flags;
13225 {
13226   tree decl1;
13227   tree ctype = NULL_TREE;
13228   tree fntype;
13229   tree restype;
13230   extern int have_extern_spec;
13231   extern int used_extern_spec;
13232   int doing_friend = 0;
13233   struct binding_level *bl;
13234   tree current_function_parms;
13235
13236   /* Sanity check.  */
13237   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13238   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13239
13240   /* This should only be done once on the top most decl.  */
13241   if (have_extern_spec && !used_extern_spec)
13242     {
13243       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13244       used_extern_spec = 1;
13245     }
13246
13247   if (flags & SF_PRE_PARSED)
13248     {
13249       decl1 = declarator;
13250
13251       fntype = TREE_TYPE (decl1);
13252       if (TREE_CODE (fntype) == METHOD_TYPE)
13253         ctype = TYPE_METHOD_BASETYPE (fntype);
13254
13255       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13256          the (lexical) scope of the class in which it is defined.  */
13257       if (!ctype && DECL_FRIEND_P (decl1))
13258         {
13259           ctype = DECL_FRIEND_CONTEXT (decl1);
13260
13261           /* CTYPE could be null here if we're dealing with a template;
13262              for example, `inline friend float foo()' inside a template
13263              will have no CTYPE set.  */
13264           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13265             ctype = NULL_TREE;
13266           else
13267             doing_friend = 1;
13268         }
13269
13270       last_function_parms = DECL_ARGUMENTS (decl1);
13271     }
13272   else
13273     {
13274       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13275       /* If the declarator is not suitable for a function definition,
13276          cause a syntax error.  */
13277       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13278
13279       fntype = TREE_TYPE (decl1);
13280
13281       restype = TREE_TYPE (fntype);
13282       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13283         {
13284           cp_error ("semicolon missing after declaration of `%#T'", restype);
13285           shadow_tag (build_tree_list (NULL_TREE, restype));
13286           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13287           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13288             fntype = build_function_type (integer_type_node,
13289                                           TYPE_ARG_TYPES (fntype));
13290           else
13291             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13292                                               integer_type_node,
13293                                               TYPE_ARG_TYPES (fntype));
13294           TREE_TYPE (decl1) = fntype;
13295         }
13296
13297       if (TREE_CODE (fntype) == METHOD_TYPE)
13298         ctype = TYPE_METHOD_BASETYPE (fntype);
13299       else if (DECL_MAIN_P (decl1))
13300         {
13301           /* If this doesn't return integer_type, complain.  */
13302           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13303             {
13304               if (pedantic || warn_return_type)
13305                 pedwarn ("return type for `main' changed to `int'");
13306               TREE_TYPE (decl1) = fntype = default_function_type;
13307             }
13308         }
13309     }
13310
13311   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13312     /* This is a constructor, we must ensure that any default args
13313        introduced by this definition are propagated to the clones
13314        now. The clones are used directly in overload resolution.  */
13315     adjust_clone_args (decl1);
13316
13317   /* Sometimes we don't notice that a function is a static member, and
13318      build a METHOD_TYPE for it.  Fix that up now.  */
13319   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13320       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13321     {
13322       revert_static_member_fn (decl1);
13323       last_function_parms = TREE_CHAIN (last_function_parms);
13324       ctype = NULL_TREE;
13325     }
13326
13327   /* Warn if function was previously implicitly declared
13328      (but not if we warned then).  */
13329   if (! warn_implicit
13330       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13331     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13332
13333   /* Set up current_class_type, and enter the scope of the class, if
13334      appropriate.  */
13335   if (ctype)
13336     push_nested_class (ctype, 1);
13337   else if (DECL_STATIC_FUNCTION_P (decl1))
13338     push_nested_class (DECL_CONTEXT (decl1), 2);
13339
13340   /* Now that we have entered the scope of the class, we must restore
13341      the bindings for any template parameters surrounding DECL1, if it
13342      is an inline member template.  (Order is important; consider the
13343      case where a template parameter has the same name as a field of
13344      the class.)  It is not until after this point that
13345      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13346   if (flags & SF_INCLASS_INLINE)
13347     maybe_begin_member_template_processing (decl1);
13348
13349   /* Effective C++ rule 15.  */
13350   if (warn_ecpp
13351       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13352       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13353     cp_warning ("`operator=' should return a reference to `*this'");
13354
13355   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13356      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13357   if (!DECL_INITIAL (decl1))
13358     DECL_INITIAL (decl1) = error_mark_node;
13359
13360   /* This function exists in static storage.
13361      (This does not mean `static' in the C sense!)  */
13362   TREE_STATIC (decl1) = 1;
13363
13364   /* We must call push_template_decl after current_class_type is set
13365      up.  (If we are processing inline definitions after exiting a
13366      class scope, current_class_type will be NULL_TREE until set above
13367      by push_nested_class.)  */
13368   if (processing_template_decl)
13369     decl1 = push_template_decl (decl1);
13370
13371   /* We are now in the scope of the function being defined.  */
13372   current_function_decl = decl1;
13373
13374   /* Save the parm names or decls from this function's declarator
13375      where store_parm_decls will find them.  */
13376   current_function_parms = last_function_parms;
13377
13378   /* Make sure the parameter and return types are reasonable.  When
13379      you declare a function, these types can be incomplete, but they
13380      must be complete when you define the function.  */
13381   if (! processing_template_decl)
13382     check_function_type (decl1, current_function_parms);
13383
13384   /* Build the return declaration for the function.  */
13385   restype = TREE_TYPE (fntype);
13386   if (!processing_template_decl)
13387     {
13388       if (!DECL_RESULT (decl1))
13389         {
13390           DECL_RESULT (decl1)
13391             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13392           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13393                                       DECL_RESULT (decl1));
13394         }
13395     }
13396   else
13397     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13398     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13399
13400   /* Initialize RTL machinery.  We cannot do this until
13401      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13402      even when processing a template; this is how we get
13403      CFUN set up, and our per-function variables initialized.
13404      FIXME factor out the non-RTL stuff.  */
13405   bl = current_binding_level;
13406   init_function_start (decl1, input_filename, lineno);
13407   current_binding_level = bl;
13408
13409   /* Even though we're inside a function body, we still don't want to
13410      call expand_expr to calculate the size of a variable-sized array.
13411      We haven't necessarily assigned RTL to all variables yet, so it's
13412      not safe to try to expand expressions involving them.  */
13413   immediate_size_expand = 0;
13414   cfun->x_dont_save_pending_sizes_p = 1;
13415
13416   /* Start the statement-tree, start the tree now.  */
13417   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13418
13419   /* Let the user know we're compiling this function.  */
13420   announce_function (decl1);
13421
13422   /* Record the decl so that the function name is defined.
13423      If we already have a decl for this name, and it is a FUNCTION_DECL,
13424      use the old decl.  */
13425   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13426     {
13427       /* A specialization is not used to guide overload resolution.  */
13428       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13429           && ! DECL_FUNCTION_MEMBER_P (decl1))
13430         decl1 = pushdecl (decl1);
13431       else
13432         {
13433           /* We need to set the DECL_CONTEXT. */
13434           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13435             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13436           /* And make sure we have enough default args.  */
13437           check_default_args (decl1);
13438         }
13439       fntype = TREE_TYPE (decl1);
13440     }
13441
13442   /* Reset these in case the call to pushdecl changed them.  */
13443   current_function_decl = decl1;
13444   cfun->decl = decl1;
13445
13446   /* If we are (erroneously) defining a function that we have already
13447      defined before, wipe out what we knew before.  */
13448   if (!DECL_PENDING_INLINE_P (decl1)
13449       && DECL_SAVED_FUNCTION_DATA (decl1))
13450     {
13451       free (DECL_SAVED_FUNCTION_DATA (decl1));
13452       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13453     }
13454
13455   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13456     {
13457       /* We know that this was set up by `grokclassfn'.  We do not
13458          wait until `store_parm_decls', since evil parse errors may
13459          never get us to that point.  Here we keep the consistency
13460          between `current_class_type' and `current_class_ptr'.  */
13461       tree t = DECL_ARGUMENTS (decl1);
13462
13463       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13464                           162);
13465       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13466                           19990811);
13467
13468       cp_function_chain->x_current_class_ref
13469         = build_indirect_ref (t, NULL);
13470       cp_function_chain->x_current_class_ptr = t;
13471
13472       /* Constructors and destructors need to know whether they're "in
13473          charge" of initializing virtual base classes.  */
13474       t = TREE_CHAIN (t);
13475       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13476         {
13477           current_in_charge_parm = t;
13478           t = TREE_CHAIN (t);
13479         }
13480       if (DECL_HAS_VTT_PARM_P (decl1))
13481         {
13482           if (DECL_NAME (t) != vtt_parm_identifier)
13483             abort ();
13484           current_vtt_parm = t;
13485         }
13486     }
13487
13488   if (DECL_INTERFACE_KNOWN (decl1))
13489     {
13490       tree ctx = decl_function_context (decl1);
13491
13492       if (DECL_NOT_REALLY_EXTERN (decl1))
13493         DECL_EXTERNAL (decl1) = 0;
13494
13495       if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
13496           && TREE_PUBLIC (ctx))
13497         /* This is a function in a local class in an extern inline
13498            function.  */
13499         comdat_linkage (decl1);
13500     }
13501   /* If this function belongs to an interface, it is public.
13502      If it belongs to someone else's interface, it is also external.
13503      This only affects inlines and template instantiations.  */
13504   else if (interface_unknown == 0
13505            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13506                || flag_alt_external_templates))
13507     {
13508       if (DECL_DECLARED_INLINE_P (decl1)
13509           || DECL_TEMPLATE_INSTANTIATION (decl1)
13510           || processing_template_decl)
13511         {
13512           DECL_EXTERNAL (decl1)
13513             = (interface_only
13514                || (DECL_DECLARED_INLINE_P (decl1)
13515                    && ! flag_implement_inlines
13516                    && !DECL_VINDEX (decl1)));
13517
13518           /* For WIN32 we also want to put these in linkonce sections.  */
13519           maybe_make_one_only (decl1);
13520         }
13521       else
13522         DECL_EXTERNAL (decl1) = 0;
13523       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13524       DECL_INTERFACE_KNOWN (decl1) = 1;
13525     }
13526   else if (interface_unknown && interface_only
13527            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13528                || flag_alt_external_templates))
13529     {
13530       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13531          interface, we will have interface_only set but not
13532          interface_known.  In that case, we don't want to use the normal
13533          heuristics because someone will supply a #pragma implementation
13534          elsewhere, and deducing it here would produce a conflict.  */
13535       comdat_linkage (decl1);
13536       DECL_EXTERNAL (decl1) = 0;
13537       DECL_INTERFACE_KNOWN (decl1) = 1;
13538       DECL_DEFER_OUTPUT (decl1) = 1;
13539     }
13540   else
13541     {
13542       /* This is a definition, not a reference.
13543          So clear DECL_EXTERNAL.  */
13544       DECL_EXTERNAL (decl1) = 0;
13545
13546       if ((DECL_DECLARED_INLINE_P (decl1)
13547            || DECL_TEMPLATE_INSTANTIATION (decl1))
13548           && ! DECL_INTERFACE_KNOWN (decl1)
13549           /* Don't try to defer nested functions for now.  */
13550           && ! decl_function_context (decl1))
13551         DECL_DEFER_OUTPUT (decl1) = 1;
13552       else
13553         DECL_INTERFACE_KNOWN (decl1) = 1;
13554     }
13555
13556   pushlevel (0);
13557   current_binding_level->parm_flag = 1;
13558
13559   cplus_decl_attributes (&decl1, NULL_TREE, attrs, 0);
13560
13561   /* Promote the value to int before returning it.  */
13562   if (c_promoting_integer_type_p (restype))
13563     restype = type_promotes_to (restype);
13564
13565   if (DECL_RESULT (decl1) == NULL_TREE)
13566     {
13567       DECL_RESULT (decl1)
13568         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13569       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13570       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13571     }
13572
13573   ++function_depth;
13574
13575   if (DECL_DESTRUCTOR_P (decl1))
13576     {
13577       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13578       DECL_CONTEXT (dtor_label) = current_function_decl;
13579     }
13580
13581   start_fname_decls ();
13582
13583   store_parm_decls (current_function_parms);
13584
13585   return 1;
13586 }
13587 \f
13588 /* Store the parameter declarations into the current function declaration.
13589    This is called after parsing the parameter declarations, before
13590    digesting the body of the function.
13591
13592    Also install to binding contour return value identifier, if any.  */
13593
13594 static void
13595 store_parm_decls (current_function_parms)
13596      tree current_function_parms;
13597 {
13598   register tree fndecl = current_function_decl;
13599   register tree parm;
13600   int parms_have_cleanups = 0;
13601   tree cleanups = NULL_TREE;
13602
13603   /* This is a chain of any other decls that came in among the parm
13604      declarations.  If a parm is declared with  enum {foo, bar} x;
13605      then CONST_DECLs for foo and bar are put here.  */
13606   tree nonparms = NULL_TREE;
13607
13608   if (current_function_parms)
13609     {
13610       /* This case is when the function was defined with an ANSI prototype.
13611          The parms already have decls, so we need not do anything here
13612          except record them as in effect
13613          and complain if any redundant old-style parm decls were written.  */
13614
13615       tree specparms = current_function_parms;
13616       tree next;
13617
13618       /* Must clear this because it might contain TYPE_DECLs declared
13619              at class level.  */
13620       storedecls (NULL_TREE);
13621
13622       /* If we're doing semantic analysis, then we'll call pushdecl
13623              for each of these.  We must do them in reverse order so that
13624              they end in the correct forward order.  */
13625       specparms = nreverse (specparms);
13626
13627       for (parm = specparms; parm; parm = next)
13628         {
13629           next = TREE_CHAIN (parm);
13630           if (TREE_CODE (parm) == PARM_DECL)
13631             {
13632               tree cleanup;
13633
13634               if (DECL_NAME (parm) == NULL_TREE
13635                   || TREE_CODE (parm) != VOID_TYPE)
13636                 pushdecl (parm);
13637               else
13638                 cp_error ("parameter `%D' declared void", parm);
13639
13640               cleanup = (processing_template_decl
13641                          ? NULL_TREE
13642                          : maybe_build_cleanup (parm));
13643
13644               if (cleanup)
13645                 cleanups = tree_cons (parm, cleanup, cleanups);
13646             }
13647           else
13648             {
13649               /* If we find an enum constant or a type tag,
13650                  put it aside for the moment.  */
13651               TREE_CHAIN (parm) = NULL_TREE;
13652               nonparms = chainon (nonparms, parm);
13653             }
13654         }
13655
13656       /* Get the decls in their original chain order and record in the
13657          function.  This is all and only the PARM_DECLs that were
13658          pushed into scope by the loop above.  */
13659       DECL_ARGUMENTS (fndecl) = getdecls ();
13660       storetags (gettags ());
13661     }
13662   else
13663     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13664
13665   /* Now store the final chain of decls for the arguments
13666      as the decl-chain of the current lexical scope.
13667      Put the enumerators in as well, at the front so that
13668      DECL_ARGUMENTS is not modified.  */
13669   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13670
13671   /* Now that we have initialized the parms, we can start their
13672      cleanups.  We cannot do this before, since expand_decl_cleanup
13673      should not be called before the parm can be used.  */
13674   while (cleanups)
13675     {
13676       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13677                            TREE_VALUE (cleanups));
13678       cleanups = TREE_CHAIN (cleanups);
13679     }
13680
13681   /* Create a binding contour which can be used to catch
13682      cleanup-generated temporaries.  */
13683   if (parms_have_cleanups)
13684     pushlevel (0);
13685
13686   /* Do the starting of the exception specifications, if we have any.  */
13687   if (flag_exceptions && !processing_template_decl
13688       && flag_enforce_eh_specs
13689       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13690     current_eh_spec_block = begin_eh_spec_block ();
13691 }
13692
13693 \f
13694 /* We have finished doing semantic analysis on DECL, but have not yet
13695    generated RTL for its body.  Save away our current state, so that
13696    when we want to generate RTL later we know what to do.  */
13697
13698 static void
13699 save_function_data (decl)
13700      tree decl;
13701 {
13702   struct cp_language_function *f;
13703
13704   /* Save the language-specific per-function data so that we can
13705      get it back when we really expand this function.  */
13706   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13707                       19990908);
13708
13709   /* Make a copy.  */
13710   f = ((struct cp_language_function *)
13711        xmalloc (sizeof (struct cp_language_function)));
13712   memcpy (f, cp_function_chain, sizeof (struct cp_language_function));
13713   DECL_SAVED_FUNCTION_DATA (decl) = f;
13714
13715   /* Clear out the bits we don't need.  */
13716   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
13717   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
13718   f->x_named_label_uses = NULL;
13719   f->bindings = NULL;
13720   f->x_local_names = NULL;
13721
13722   /* When we get back here again, we will be expanding.  */
13723   f->x_expanding_p = 1;
13724
13725   /* If we've already decided that we cannot inline this function, we
13726      must remember that fact when we actually go to expand the
13727      function.  */
13728   if (current_function_cannot_inline)
13729     {
13730       f->cannot_inline = current_function_cannot_inline;
13731       DECL_INLINE (decl) = 0;
13732     }
13733 }
13734
13735 /* At the end of every constructor we generate to code to return
13736    `this'.  Do that now.  */
13737
13738 static void
13739 finish_constructor_body ()
13740 {
13741   /* Any return from a constructor will end up here.  */
13742   if (ctor_label)
13743     add_stmt (build_stmt (LABEL_STMT, ctor_label));
13744
13745   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13746      generate the return, rather than a goto to CTOR_LABEL.  */
13747   ctor_label = NULL_TREE;
13748   /* In check_return_expr we translate an empty return from a
13749      constructor to a return of `this'.  */
13750   finish_return_stmt (NULL_TREE);
13751   /* Mark the end of the constructor.  */
13752   add_stmt (build_stmt (CTOR_STMT));
13753 }
13754
13755 /* At the end of every destructor we generate code to restore virtual
13756    function tables to the values desired by base classes and to call
13757    to base class destructors.  Do that now.  */
13758
13759 static void
13760 finish_destructor_body ()
13761 {
13762   tree compound_stmt;
13763   tree exprstmt;
13764
13765   /* Create a block to contain all the extra code.  */
13766   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13767
13768   /* Any return from a destructor will end up here.  */
13769   add_stmt (build_stmt (LABEL_STMT, dtor_label));
13770
13771   /* Generate the code to call destructor on base class.  If this
13772      destructor belongs to a class with virtual functions, then set
13773      the virtual function table pointer to represent the type of our
13774      base class.  */
13775
13776   /* This side-effect makes call to `build_delete' generate the code
13777      we have to have at the end of this destructor.  `build_delete'
13778      will set the flag again.  */
13779   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13780
13781   exprstmt = build_delete (current_class_type,
13782                            current_class_ref,
13783                            sfk_base_destructor,
13784                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13785                            0);
13786
13787   if (exprstmt != error_mark_node
13788       && (TREE_CODE (exprstmt) != NOP_EXPR
13789           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13790           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13791     {
13792       if (exprstmt != void_zero_node)
13793         /* Don't call `expand_expr_stmt' if we're not going to do
13794            anything, since -Wall will give a diagnostic.  */
13795         finish_expr_stmt (exprstmt);
13796
13797       /* Run destructors for all virtual baseclasses.  */
13798       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13799         {
13800           tree vbases;
13801           tree if_stmt;
13802
13803           if_stmt = begin_if_stmt ();
13804           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13805                                       current_in_charge_parm,
13806                                       integer_two_node),
13807                                if_stmt);
13808
13809           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
13810           /* The CLASSTYPE_VBASECLASSES list is in initialization
13811              order, so we have to march through it in reverse order.  */
13812           for (vbases = nreverse (copy_list (vbases));
13813                vbases;
13814                vbases = TREE_CHAIN (vbases))
13815             {
13816               tree vbase = TREE_VALUE (vbases);
13817               tree base_type = BINFO_TYPE (vbase);
13818
13819               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (base_type))
13820                 {
13821                   tree base_ptr_type = build_pointer_type (base_type);
13822                   tree expr = current_class_ptr;
13823
13824                   /* Convert to the basetype here, as we know the layout is
13825                      fixed. What is more, if we let build_method_call do it,
13826                      it will use the vtable, which may have been clobbered
13827                      by the deletion of our primary base.  */
13828
13829                   expr = build1 (NOP_EXPR, base_ptr_type, expr);
13830                   expr = build (PLUS_EXPR, base_ptr_type, expr,
13831                                 BINFO_OFFSET (vbase));
13832                   expr = build_indirect_ref (expr, NULL);
13833                   expr = build_method_call (expr, base_dtor_identifier,
13834                                             NULL_TREE, vbase,
13835                                             LOOKUP_NORMAL);
13836                   finish_expr_stmt (expr);
13837                 }
13838             }
13839
13840           finish_then_clause (if_stmt);
13841           finish_if_stmt ();
13842         }
13843     }
13844
13845   /* In a virtual destructor, we must call delete.  */
13846   if (DECL_VIRTUAL_P (current_function_decl))
13847     {
13848       tree if_stmt;
13849       tree virtual_size = c_sizeof (current_class_type);
13850
13851       /* [class.dtor]
13852
13853          At the point of definition of a virtual destructor (including
13854          an implicit definition), non-placement operator delete shall
13855          be looked up in the scope of the destructor's class and if
13856          found shall be accessible and unambiguous.  */
13857       exprstmt = build_op_delete_call
13858         (DELETE_EXPR, current_class_ptr, virtual_size,
13859          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13860
13861       if_stmt = begin_if_stmt ();
13862       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13863                                   current_in_charge_parm,
13864                                   integer_one_node),
13865                            if_stmt);
13866       finish_expr_stmt (exprstmt);
13867       finish_then_clause (if_stmt);
13868       finish_if_stmt ();
13869     }
13870
13871   /* Close the block we started above.  */
13872   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13873 }
13874
13875 /* Finish up a function declaration and compile that function
13876    all the way to assembler language output.  The free the storage
13877    for the function definition.
13878
13879    FLAGS is a bitwise or of the following values:
13880      1 - CALL_POPLEVEL
13881        An extra call to poplevel (and expand_end_bindings) must be
13882        made to take care of the binding contour for the base
13883        initializers.  This is only relevant for constructors.
13884      2 - INCLASS_INLINE
13885        We just finished processing the body of an in-class inline
13886        function definition.  (This processing will have taken place
13887        after the class definition is complete.)  */
13888
13889 tree
13890 finish_function (flags)
13891      int flags;
13892 {
13893   register tree fndecl = current_function_decl;
13894   tree fntype, ctype = NULL_TREE;
13895   int call_poplevel = (flags & 1) != 0;
13896   int inclass_inline = (flags & 2) != 0;
13897   int nested;
13898
13899   /* When we get some parse errors, we can end up without a
13900      current_function_decl, so cope.  */
13901   if (fndecl == NULL_TREE)
13902     return error_mark_node;
13903
13904   nested = function_depth > 1;
13905   fntype = TREE_TYPE (fndecl);
13906
13907   /*  TREE_READONLY (fndecl) = 1;
13908       This caused &foo to be of type ptr-to-const-function
13909       which then got a warning when stored in a ptr-to-function variable.  */
13910
13911   my_friendly_assert (building_stmt_tree (), 20000911);
13912
13913   finish_fname_decls ();
13914
13915   /* For a cloned function, we've already got all the code we need;
13916      there's no need to add any extra bits.  */
13917   if (!DECL_CLONED_FUNCTION_P (fndecl))
13918     {
13919       if (DECL_CONSTRUCTOR_P (fndecl))
13920         {
13921           finish_constructor_body ();
13922           if (call_poplevel)
13923             do_poplevel ();
13924         }
13925       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
13926         finish_destructor_body ();
13927       else if (DECL_MAIN_P (fndecl))
13928         {
13929           /* Make it so that `main' always returns 0 by default.  */
13930 #ifdef VMS
13931           finish_return_stmt (integer_one_node);
13932 #else
13933           finish_return_stmt (integer_zero_node);
13934 #endif
13935         }
13936
13937       /* Finish dealing with exception specifiers.  */
13938       if (flag_exceptions && !processing_template_decl
13939           && flag_enforce_eh_specs
13940           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13941         finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
13942                               (TREE_TYPE (current_function_decl)),
13943                               current_eh_spec_block);
13944     }
13945
13946   /* If we're saving up tree structure, tie off the function now.  */
13947   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
13948
13949   /* This must come after expand_function_end because cleanups might
13950      have declarations (from inline functions) that need to go into
13951      this function's blocks.  */
13952   if (current_binding_level->parm_flag != 1)
13953     my_friendly_abort (122);
13954   poplevel (1, 0, 1);
13955
13956   /* Remember that we were in class scope.  */
13957   if (current_class_name)
13958     ctype = current_class_type;
13959
13960   /* Must mark the RESULT_DECL as being in this function.  */
13961   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
13962
13963   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13964      to the FUNCTION_DECL node itself.  */
13965   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
13966
13967   /* Save away current state, if appropriate.  */
13968   if (!processing_template_decl)
13969     save_function_data (fndecl);
13970
13971   /* If this function calls `setjmp' it cannot be inlined.  When
13972      `longjmp' is called it is not guaranteed to restore the value of
13973      local variables that have been modified since the call to
13974      `setjmp'.  So, if were to inline this function into some caller
13975      `c', then when we `longjmp', we might not restore all variables
13976      in `c'.  (It might seem, at first blush, that there's no way for
13977      this function to modify local variables in `c', but their
13978      addresses may have been stored somewhere accessible to this
13979      function.)  */
13980   if (!processing_template_decl && calls_setjmp_p (fndecl))
13981     DECL_UNINLINABLE (fndecl) = 1;
13982
13983   /* Clear out memory we no longer need.  */
13984   free_after_parsing (cfun);
13985   /* Since we never call rest_of_compilation, we never clear
13986      CFUN.  Do so explicitly.  */
13987   free_after_compilation (cfun);
13988   cfun = NULL;
13989
13990   /* If this is a in-class inline definition, we may have to pop the
13991      bindings for the template parameters that we added in
13992      maybe_begin_member_template_processing when start_function was
13993      called.  */
13994   if (inclass_inline)
13995     maybe_end_member_template_processing ();
13996
13997   /* Leave the scope of the class.  */
13998   if (ctype)
13999     pop_nested_class ();
14000
14001   --function_depth;
14002
14003   /* Clean up.  */
14004   if (! nested)
14005     /* Let the error reporting routines know that we're outside a
14006        function.  For a nested function, this value is used in
14007        pop_cp_function_context and then reset via pop_function_context.  */
14008     current_function_decl = NULL_TREE;
14009
14010   return fndecl;
14011 }
14012 \f
14013 /* Create the FUNCTION_DECL for a function definition.
14014    DECLSPECS and DECLARATOR are the parts of the declaration;
14015    they describe the return type and the name of the function,
14016    but twisted together in a fashion that parallels the syntax of C.
14017
14018    This function creates a binding context for the function body
14019    as well as setting up the FUNCTION_DECL in current_function_decl.
14020
14021    Returns a FUNCTION_DECL on success.
14022
14023    If the DECLARATOR is not suitable for a function (it defines a datum
14024    instead), we return 0, which tells yyparse to report a parse error.
14025
14026    May return void_type_node indicating that this method is actually
14027    a friend.  See grokfield for more details.
14028
14029    Came here with a `.pushlevel' .
14030
14031    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14032    CHANGES TO CODE IN `grokfield'.  */
14033
14034 tree
14035 start_method (declspecs, declarator, attrlist)
14036      tree declarator, declspecs, attrlist;
14037 {
14038   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14039                                 attrlist);
14040
14041   /* Something too ugly to handle.  */
14042   if (fndecl == NULL_TREE)
14043     return NULL_TREE;
14044
14045   /* Pass friends other than inline friend functions back.  */
14046   if (fndecl == void_type_node)
14047     return fndecl;
14048
14049   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14050     /* Not a function, tell parser to report parse error.  */
14051     return NULL_TREE;
14052
14053   if (DECL_IN_AGGR_P (fndecl))
14054     {
14055       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14056         {
14057           if (DECL_CONTEXT (fndecl)
14058               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14059             cp_error ("`%D' is already defined in class `%T'", fndecl,
14060                       DECL_CONTEXT (fndecl));
14061         }
14062       return void_type_node;
14063     }
14064
14065   check_template_shadow (fndecl);
14066
14067   DECL_DECLARED_INLINE_P (fndecl) = 1;
14068
14069   if (flag_default_inline)
14070     DECL_INLINE (fndecl) = 1;
14071
14072   /* We process method specializations in finish_struct_1.  */
14073   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14074     fndecl = push_template_decl (fndecl);
14075
14076   if (! DECL_FRIEND_P (fndecl))
14077     {
14078       if (TREE_CHAIN (fndecl))
14079         {
14080           fndecl = copy_node (fndecl);
14081           TREE_CHAIN (fndecl) = NULL_TREE;
14082         }
14083
14084       if (DECL_CONSTRUCTOR_P (fndecl))
14085         {
14086           if (! grok_ctor_properties (current_class_type, fndecl))
14087             return void_type_node;
14088         }
14089       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14090         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14091     }
14092
14093   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14094
14095   /* Make a place for the parms */
14096   pushlevel (0);
14097   current_binding_level->parm_flag = 1;
14098
14099   DECL_IN_AGGR_P (fndecl) = 1;
14100   return fndecl;
14101 }
14102
14103 /* Go through the motions of finishing a function definition.
14104    We don't compile this method until after the whole class has
14105    been processed.
14106
14107    FINISH_METHOD must return something that looks as though it
14108    came from GROKFIELD (since we are defining a method, after all).
14109
14110    This is called after parsing the body of the function definition.
14111    STMTS is the chain of statements that makes up the function body.
14112
14113    DECL is the ..._DECL that `start_method' provided.  */
14114
14115 tree
14116 finish_method (decl)
14117      tree decl;
14118 {
14119   register tree fndecl = decl;
14120   tree old_initial;
14121
14122   register tree link;
14123
14124   if (decl == void_type_node)
14125     return decl;
14126
14127   old_initial = DECL_INITIAL (fndecl);
14128
14129   /* Undo the level for the parms (from start_method).
14130      This is like poplevel, but it causes nothing to be
14131      saved.  Saving information here confuses symbol-table
14132      output routines.  Besides, this information will
14133      be correctly output when this method is actually
14134      compiled.  */
14135
14136   /* Clear out the meanings of the local variables of this level;
14137      also record in each decl which block it belongs to.  */
14138
14139   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14140     {
14141       if (DECL_NAME (link) != NULL_TREE)
14142         pop_binding (DECL_NAME (link), link);
14143       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14144       DECL_CONTEXT (link) = NULL_TREE;
14145     }
14146
14147   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14148                       (HOST_WIDE_INT) current_binding_level->level_chain,
14149                       current_binding_level->parm_flag,
14150                       current_binding_level->keep);
14151
14152   poplevel (0, 0, 0);
14153
14154   DECL_INITIAL (fndecl) = old_initial;
14155
14156   /* We used to check if the context of FNDECL was different from
14157      current_class_type as another way to get inside here.  This didn't work
14158      for String.cc in libg++.  */
14159   if (DECL_FRIEND_P (fndecl))
14160     {
14161       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14162         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14163       decl = void_type_node;
14164     }
14165
14166   return decl;
14167 }
14168 \f
14169 /* Called when a new struct TYPE is defined.
14170    If this structure or union completes the type of any previous
14171    variable declaration, lay it out and output its rtl.  */
14172
14173 void
14174 hack_incomplete_structures (type)
14175      tree type;
14176 {
14177   tree *list;
14178   struct binding_level *level;
14179
14180   if (!type) /* Don't do this for class templates.  */
14181     return;
14182
14183   if (namespace_bindings_p ())
14184     {
14185       level = 0;
14186       list = &namespace_scope_incomplete;
14187     }
14188   else
14189     {
14190       level = innermost_nonclass_level ();
14191       list = &level->incomplete;
14192     }
14193
14194   while (1)
14195     {
14196       while (*list)
14197         {
14198           tree decl = TREE_VALUE (*list);
14199           if ((decl && TREE_TYPE (decl) == type)
14200               || (TREE_TYPE (decl)
14201                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14202                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14203             {
14204               int toplevel = toplevel_bindings_p ();
14205               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14206                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14207                 layout_type (TREE_TYPE (decl));
14208               layout_decl (decl, 0);
14209               rest_of_decl_compilation (decl, NULL, toplevel, 0);
14210               if (! toplevel)
14211                 {
14212                   tree cleanup;
14213                   expand_decl (decl);
14214                   cleanup = maybe_build_cleanup (decl);
14215                   expand_decl_init (decl);
14216                   if (! expand_decl_cleanup (decl, cleanup))
14217                     cp_error ("parser lost in parsing declaration of `%D'",
14218                               decl);
14219                 }
14220               *list = TREE_CHAIN (*list);
14221             }
14222           else
14223             list = &TREE_CHAIN (*list);
14224         }
14225
14226       /* Keep looking through artificial binding levels generated
14227          for local variables.  */
14228       if (level && level->keep == 2)
14229         {
14230           level = level->level_chain;
14231           list = &level->incomplete;
14232         }
14233       else
14234         break;
14235     }
14236 }
14237
14238 /* If DECL is of a type which needs a cleanup, build that cleanup
14239    here.  */
14240
14241 tree
14242 maybe_build_cleanup (decl)
14243      tree decl;
14244 {
14245   tree type = TREE_TYPE (decl);
14246
14247   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14248     {
14249       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14250       tree rval;
14251
14252       if (TREE_CODE (type) == ARRAY_TYPE)
14253         rval = decl;
14254       else
14255         {
14256           mark_addressable (decl);
14257           rval = build_unary_op (ADDR_EXPR, decl, 0);
14258         }
14259
14260       /* Optimize for space over speed here.  */
14261       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14262           || flag_expensive_optimizations)
14263         flags |= LOOKUP_NONVIRTUAL;
14264
14265       rval = build_delete (TREE_TYPE (rval), rval,
14266                            sfk_complete_destructor, flags, 0);
14267
14268       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14269           && ! TYPE_HAS_DESTRUCTOR (type))
14270         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14271                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14272
14273       return rval;
14274     }
14275   return 0;
14276 }
14277 \f
14278 /* When a stmt has been parsed, this function is called.  */
14279
14280 void
14281 finish_stmt ()
14282 {
14283   /* Always assume this statement was not an expression statement.  If
14284      it actually was an expression statement, its our callers
14285      responsibility to fix this up.  */
14286   last_expr_type = NULL_TREE;
14287 }
14288
14289 /* DECL was originally constructed as a non-static member function,
14290    but turned out to be static.  Update it accordingly.  */
14291
14292 void
14293 revert_static_member_fn (decl)
14294      tree decl;
14295 {
14296   tree tmp;
14297   tree function = TREE_TYPE (decl);
14298   tree args = TYPE_ARG_TYPES (function);
14299
14300   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14301       != TYPE_UNQUALIFIED)
14302     cp_error ("static member function `%#D' declared with type qualifiers",
14303               decl);
14304
14305   args = TREE_CHAIN (args);
14306   tmp = build_function_type (TREE_TYPE (function), args);
14307   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14308   tmp = build_exception_variant (tmp,
14309                                  TYPE_RAISES_EXCEPTIONS (function));
14310   TREE_TYPE (decl) = tmp;
14311   if (DECL_ARGUMENTS (decl))
14312     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14313   DECL_STATIC_FUNCTION_P (decl) = 1;
14314 }
14315
14316 /* Initialize the variables used during compilation of a C++
14317    function.  */
14318
14319 static void
14320 push_cp_function_context (f)
14321      struct function *f;
14322 {
14323   struct cp_language_function *p
14324     = ((struct cp_language_function *)
14325        xcalloc (1, sizeof (struct cp_language_function)));
14326   f->language = (struct language_function *) p;
14327
14328   /* It takes an explicit call to expand_body to generate RTL for a
14329      function.  */
14330   expanding_p = 0;
14331
14332   /* Whenever we start a new function, we destroy temporaries in the
14333      usual way.  */
14334   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14335 }
14336
14337 /* Free the language-specific parts of F, now that we've finished
14338    compiling the function.  */
14339
14340 static void
14341 pop_cp_function_context (f)
14342      struct function *f;
14343 {
14344   if (f->language)
14345     {
14346       struct cp_language_function *cp =
14347         (struct cp_language_function *) f->language;
14348       if (cp->x_local_names)
14349         VARRAY_FREE (cp->x_local_names);
14350       free (f->language);
14351     }
14352   f->language = 0;
14353 }
14354
14355 /* Mark P for GC.  */
14356
14357 static void
14358 mark_lang_function (p)
14359      struct cp_language_function *p;
14360 {
14361   if (!p)
14362     return;
14363
14364   mark_c_language_function (&p->base);
14365
14366   ggc_mark_tree (p->x_ctor_label);
14367   ggc_mark_tree (p->x_dtor_label);
14368   ggc_mark_tree (p->x_current_class_ptr);
14369   ggc_mark_tree (p->x_current_class_ref);
14370   ggc_mark_tree (p->x_eh_spec_block);
14371   ggc_mark_tree_varray (p->x_local_names);
14372
14373   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14374   mark_binding_level (&p->bindings);
14375 }
14376
14377 /* Mark the language-specific data in F for GC.  */
14378
14379 static void
14380 mark_cp_function_context (f)
14381      struct function *f;
14382 {
14383   mark_lang_function ((struct cp_language_function *) f->language);
14384 }
14385
14386 void
14387 lang_mark_tree (t)
14388      tree t;
14389 {
14390   enum tree_code code = TREE_CODE (t);
14391   if (code == IDENTIFIER_NODE)
14392     {
14393       struct lang_identifier *li = (struct lang_identifier *) t;
14394       struct lang_id2 *li2 = li->x;
14395       ggc_mark_tree (li->namespace_bindings);
14396       ggc_mark_tree (li->bindings);
14397       ggc_mark_tree (li->class_value);
14398       ggc_mark_tree (li->class_template_info);
14399
14400       if (li2)
14401         {
14402           ggc_mark_tree (li2->label_value);
14403           ggc_mark_tree (li2->implicit_decl);
14404           ggc_mark_tree (li2->error_locus);
14405         }
14406     }
14407   else if (code == CPLUS_BINDING)
14408     {
14409       if (BINDING_HAS_LEVEL_P (t))
14410         mark_binding_level (&BINDING_LEVEL (t));
14411       else
14412         ggc_mark_tree (BINDING_SCOPE (t));
14413       ggc_mark_tree (BINDING_VALUE (t));
14414     }
14415   else if (code == OVERLOAD)
14416     ggc_mark_tree (OVL_FUNCTION (t));
14417   else if (code == TEMPLATE_PARM_INDEX)
14418     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14419   else if (TREE_CODE_CLASS (code) == 'd')
14420     {
14421       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14422
14423       if (ld)
14424         {
14425           ggc_mark (ld);
14426           c_mark_lang_decl (&ld->decl_flags.base);
14427           if (!DECL_GLOBAL_CTOR_P (t)
14428               && !DECL_GLOBAL_DTOR_P (t)
14429               && !DECL_THUNK_P (t)
14430               && !DECL_DISCRIMINATOR_P (t))
14431             ggc_mark_tree (ld->decl_flags.u2.access);
14432           else if (DECL_THUNK_P (t))
14433             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14434           if (TREE_CODE (t) != NAMESPACE_DECL)
14435             ggc_mark_tree (ld->decl_flags.u.template_info);
14436           else
14437             mark_binding_level (&NAMESPACE_LEVEL (t));
14438           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14439             {
14440               ggc_mark_tree (ld->befriending_classes);
14441               ggc_mark_tree (ld->context);
14442               ggc_mark_tree (ld->cloned_function);
14443               ggc_mark_tree (ld->inlined_fns);
14444               if (TREE_CODE (t) == TYPE_DECL)
14445                 ggc_mark_tree (ld->u.sorted_fields);
14446               else if (TREE_CODE (t) == FUNCTION_DECL
14447                        && !DECL_PENDING_INLINE_P (t))
14448                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14449             }
14450         }
14451     }
14452   else if (TREE_CODE_CLASS (code) == 't')
14453     {
14454       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14455
14456       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14457                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14458         {
14459           ggc_mark (lt);
14460           ggc_mark_tree (lt->primary_base);
14461           ggc_mark_tree (lt->vfields);
14462           ggc_mark_tree (lt->vbases);
14463           ggc_mark_tree (lt->tags);
14464           ggc_mark_tree (lt->size);
14465           ggc_mark_tree (lt->pure_virtuals);
14466           ggc_mark_tree (lt->friend_classes);
14467           ggc_mark_tree (lt->rtti);
14468           ggc_mark_tree (lt->methods);
14469           ggc_mark_tree (lt->template_info);
14470           ggc_mark_tree (lt->befriending_classes);
14471         }
14472       else if (lt)
14473         /* In the case of pointer-to-member function types, the
14474            TYPE_LANG_SPECIFIC is really just a tree.  */
14475         ggc_mark_tree ((tree) lt);
14476     }
14477 }
14478
14479 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14480    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
14481
14482 tree
14483 identifier_global_value (t)
14484      tree t;
14485 {
14486   return IDENTIFIER_GLOBAL_VALUE (t);
14487 }
14488
14489 /* Build the void_list_node (void_type_node having been created).  */
14490 tree
14491 build_void_list_node ()
14492 {
14493   tree t = build_tree_list (NULL_TREE, void_type_node);
14494   TREE_PARMLIST (t) = 1;
14495   return t;
14496 }
14497
14498 static int
14499 cp_missing_noreturn_ok_p (decl)
14500      tree decl;
14501 {
14502   /* A missing noreturn is ok for the `main' function.  */
14503   return DECL_MAIN_P (decl);
14504 }