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 ((size_t) 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 ((size_t) current_binding_level,
1283                       (size_t) 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 ((size_t) class_binding_level,
1709                       (size_t) 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.  This needs to happen
8037      after the call to check_initializer so that the DECL_STMT for a
8038      reference temp is added before the DECL_STMT for the reference itself.  */
8039   if (building_stmt_tree ()
8040       && at_function_scope_p ()
8041       && TREE_CODE (decl) != RESULT_DECL)
8042     add_decl_stmt (decl);
8043
8044   if (TREE_CODE (decl) == VAR_DECL)
8045     layout_var_decl (decl);
8046
8047   /* Output the assembler code and/or RTL code for variables and functions,
8048      unless the type is an undefined structure or union.
8049      If not, it will get done when the type is completed.  */
8050   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8051       || TREE_CODE (decl) == RESULT_DECL)
8052     {
8053       if (TREE_CODE (decl) == VAR_DECL)
8054         maybe_commonize_var (decl);
8055
8056       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8057
8058       if (TREE_CODE (type) == FUNCTION_TYPE
8059           || TREE_CODE (type) == METHOD_TYPE)
8060         abstract_virtuals_error (decl,
8061                                  strip_array_types (TREE_TYPE (type)));
8062       else
8063         abstract_virtuals_error (decl, strip_array_types (type));
8064
8065       if (TREE_CODE (decl) == FUNCTION_DECL)
8066         ;
8067       else if (DECL_EXTERNAL (decl)
8068                && ! (DECL_LANG_SPECIFIC (decl)
8069                      && DECL_NOT_REALLY_EXTERN (decl)))
8070         {
8071           if (init)
8072             DECL_INITIAL (decl) = init;
8073         }
8074       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8075         {
8076           /* This is a local declaration.  */
8077           if (doing_semantic_analysis_p ())
8078             maybe_inject_for_scope_var (decl);
8079           /* Initialize the local variable.  But, if we're building a
8080              statement-tree, we'll do the initialization when we
8081              expand the tree.  */
8082           if (processing_template_decl)
8083             {
8084               if (init || DECL_INITIAL (decl) == error_mark_node)
8085                 DECL_INITIAL (decl) = init;
8086             }
8087           else
8088             {
8089               /* If we're not building RTL, then we need to do so
8090                  now.  */
8091               my_friendly_assert (building_stmt_tree (), 20000906);
8092               /* Initialize the variable.  */
8093               initialize_local_var (decl, init, flags);
8094               /* Clean up the variable.  */
8095               destroy_local_var (decl);
8096             }
8097         }
8098       else if (TREE_STATIC (decl) && type != error_mark_node)
8099         {
8100           /* Cleanups for static variables are handled by `finish_file'.  */
8101           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8102               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8103             expand_static_init (decl, init);
8104         }
8105     finish_end0:
8106
8107       /* Undo call to `pushclass' that was done in `start_decl'
8108          due to initialization of qualified member variable.
8109          I.e., Foo::x = 10;  */
8110       {
8111         tree context = CP_DECL_CONTEXT (decl);
8112         if (context
8113             && TYPE_P (context)
8114             && (TREE_CODE (decl) == VAR_DECL
8115                 /* We also have a pushclass done that we need to undo here
8116                    if we're at top level and declare a method.  */
8117                 || TREE_CODE (decl) == FUNCTION_DECL)
8118             /* If size hasn't been set, we're still defining it,
8119                and therefore inside the class body; don't pop
8120                the binding level..  */
8121             && COMPLETE_TYPE_P (context)
8122             && context == current_class_type)
8123           pop_nested_class ();
8124       }
8125     }
8126
8127  finish_end:
8128
8129   if (was_readonly)
8130     TREE_READONLY (decl) = 1;
8131 }
8132
8133 /* This is here for a midend callback from c-common.c */
8134
8135 void
8136 finish_decl (decl, init, asmspec_tree)
8137      tree decl, init;
8138      tree asmspec_tree;
8139 {
8140   cp_finish_decl (decl, init, asmspec_tree, 0);
8141 }
8142
8143 /* Returns a declaration for a VAR_DECL as if:
8144
8145      extern "C" TYPE NAME;
8146
8147    had been seen.  Used to create compiler-generated global
8148    variables.  */
8149
8150 tree
8151 declare_global_var (name, type)
8152      tree name;
8153      tree type;
8154 {
8155   tree decl;
8156
8157   push_to_top_level ();
8158   decl = build_decl (VAR_DECL, name, type);
8159   TREE_PUBLIC (decl) = 1;
8160   DECL_EXTERNAL (decl) = 1;
8161   DECL_ARTIFICIAL (decl) = 1;
8162   pushdecl (decl);
8163   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8164   pop_from_top_level ();
8165
8166   return decl;
8167 }
8168
8169 /* Returns a pointer to the `atexit' function.  Note that if
8170    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8171    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8172
8173 static tree
8174 get_atexit_node ()
8175 {
8176   tree atexit_fndecl;
8177   tree arg_types;
8178   tree fn_type;
8179   tree fn_ptr_type;
8180   const char *name;
8181
8182   if (atexit_node)
8183     return atexit_node;
8184
8185   if (flag_use_cxa_atexit)
8186     {
8187       /* The declaration for `__cxa_atexit' is:
8188
8189            int __cxa_atexit (void (*)(void *), void *, void *)
8190
8191          We build up the argument types and then then function type
8192          itself.  */
8193
8194       /* First, build the pointer-to-function type for the first
8195          argument.  */
8196       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8197       fn_type = build_function_type (void_type_node, arg_types);
8198       fn_ptr_type = build_pointer_type (fn_type);
8199       /* Then, build the rest of the argument types.  */
8200       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8201       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8202       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8203       /* And the final __cxa_atexit type.  */
8204       fn_type = build_function_type (integer_type_node, arg_types);
8205       fn_ptr_type = build_pointer_type (fn_type);
8206       name = "__cxa_atexit";
8207     }
8208   else
8209     {
8210       /* The declaration for `atexit' is:
8211
8212            int atexit (void (*)());
8213
8214          We build up the argument types and then then function type
8215          itself.  */
8216       fn_type = build_function_type (void_type_node, void_list_node);
8217       fn_ptr_type = build_pointer_type (fn_type);
8218       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8219       /* Build the final atexit type.  */
8220       fn_type = build_function_type (integer_type_node, arg_types);
8221       name = "atexit";
8222     }
8223
8224   /* Now, build the function declaration.  */
8225   push_lang_context (lang_name_c);
8226   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8227   mark_used (atexit_fndecl);
8228   pop_lang_context ();
8229   atexit_node = default_conversion (atexit_fndecl);
8230
8231   return atexit_node;
8232 }
8233
8234 /* Returns the __dso_handle VAR_DECL.  */
8235
8236 static tree
8237 get_dso_handle_node ()
8238 {
8239   if (dso_handle_node)
8240     return dso_handle_node;
8241
8242   /* Declare the variable.  */
8243   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8244                                         ptr_type_node);
8245
8246   return dso_handle_node;
8247 }
8248
8249 /* Begin a new function with internal linkage whose job will be simply
8250    to destroy some particular variable.  */
8251
8252 static tree
8253 start_cleanup_fn ()
8254 {
8255   static int counter = 0;
8256   int old_interface_unknown = interface_unknown;
8257   char name[32];
8258   tree parmtypes;
8259   tree fntype;
8260   tree fndecl;
8261
8262   push_to_top_level ();
8263
8264   /* No need to mangle this.  */
8265   push_lang_context (lang_name_c);
8266
8267   interface_unknown = 1;
8268
8269   /* Build the parameter-types.  */
8270   parmtypes = void_list_node;
8271   /* Functions passed to __cxa_atexit take an additional parameter.
8272      We'll just ignore it.  After we implement the new calling
8273      convention for destructors, we can eliminate the use of
8274      additional cleanup functions entirely in the -fnew-abi case.  */
8275   if (flag_use_cxa_atexit)
8276     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8277   /* Build the function type itself.  */
8278   fntype = build_function_type (void_type_node, parmtypes);
8279   /* Build the name of the function.  */
8280   sprintf (name, "__tcf_%d", counter++);
8281   /* Build the function declaration.  */
8282   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8283   /* It's a function with internal linkage, generated by the
8284      compiler.  */
8285   TREE_PUBLIC (fndecl) = 0;
8286   DECL_ARTIFICIAL (fndecl) = 1;
8287   /* Make the function `inline' so that it is only emitted if it is
8288      actually needed.  It is unlikely that it will be inlined, since
8289      it is only called via a function pointer, but we avoid unncessary
8290      emissions this way.  */
8291   DECL_INLINE (fndecl) = 1;
8292   /* Build the parameter.  */
8293   if (flag_use_cxa_atexit)
8294     {
8295       tree parmdecl;
8296
8297       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8298       DECL_CONTEXT (parmdecl) = fndecl;
8299       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8300       TREE_USED (parmdecl) = 1;
8301       DECL_ARGUMENTS (fndecl) = parmdecl;
8302     }
8303
8304   pushdecl (fndecl);
8305   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8306   do_pushlevel ();
8307
8308   interface_unknown = old_interface_unknown;
8309
8310   pop_lang_context ();
8311
8312   return current_function_decl;
8313 }
8314
8315 /* Finish the cleanup function begun by start_cleanup_fn.  */
8316
8317 static void
8318 end_cleanup_fn ()
8319 {
8320   do_poplevel ();
8321
8322   expand_body (finish_function (0));
8323
8324   pop_from_top_level ();
8325 }
8326
8327 /* Generate code to handle the destruction of DECL, an object with
8328    static storage duration.  */
8329
8330 void
8331 register_dtor_fn (decl)
8332      tree decl;
8333 {
8334   tree cleanup;
8335   tree compound_stmt;
8336   tree args;
8337   tree fcall;
8338
8339   int saved_flag_access_control;
8340
8341   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8342     return;
8343
8344   /* Call build_cleanup before we enter the anonymous function so that
8345      any access checks will be done relative to the current scope,
8346      rather than the scope of the anonymous function.  */
8347   build_cleanup (decl);
8348
8349   /* Now start the function.  */
8350   cleanup = start_cleanup_fn ();
8351
8352   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8353      to the original function, rather than the anonymous one.  That
8354      will make the back-end think that nested functions are in use,
8355      which causes confusion.  */
8356   saved_flag_access_control = flag_access_control;
8357   flag_access_control = 0;
8358   fcall = build_cleanup (decl);
8359   flag_access_control = saved_flag_access_control;
8360
8361   /* Create the body of the anonymous function.  */
8362   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8363   finish_expr_stmt (fcall);
8364   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8365   end_cleanup_fn ();
8366
8367   /* Call atexit with the cleanup function.  */
8368   mark_addressable (cleanup);
8369   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8370   if (flag_use_cxa_atexit)
8371     {
8372       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8373       args = tree_cons (NULL_TREE, null_pointer_node, args);
8374       args = tree_cons (NULL_TREE, cleanup, args);
8375     }
8376   else
8377     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8378   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8379 }
8380
8381 void
8382 expand_static_init (decl, init)
8383      tree decl;
8384      tree init;
8385 {
8386   tree oldstatic = value_member (decl, static_aggregates);
8387
8388   if (oldstatic)
8389     {
8390       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8391         cp_error ("multiple initializations given for `%D'", decl);
8392     }
8393   else if (! toplevel_bindings_p ())
8394     {
8395       /* Emit code to perform this initialization but once.  */
8396       tree if_stmt;
8397       tree then_clause;
8398       tree assignment;
8399       tree guard;
8400       tree guard_init;
8401
8402       /* Emit code to perform this initialization but once.  This code
8403          looks like:
8404
8405            static int guard = 0;
8406            if (!guard) {
8407              // Do initialization.
8408              guard = 1;
8409              // Register variable for destruction at end of program.
8410            }
8411
8412          Note that the `temp' variable is only set to 1 *after* the
8413          initialization is complete.  This ensures that an exception,
8414          thrown during the construction, will cause the variable to
8415          reinitialized when we pass through this code again, as per:
8416
8417            [stmt.dcl]
8418
8419            If the initialization exits by throwing an exception, the
8420            initialization is not complete, so it will be tried again
8421            the next time control enters the declaration.
8422
8423          In theory, this process should be thread-safe, too; multiple
8424          threads should not be able to initialize the variable more
8425          than once.  We don't yet attempt to ensure thread-safety.  */
8426
8427       /* Create the guard variable.  */
8428       guard = get_guard (decl);
8429
8430       /* Begin the conditional initialization.  */
8431       if_stmt = begin_if_stmt ();
8432       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8433       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8434
8435       /* Do the initialization itself.  */
8436       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8437           || (init && TREE_CODE (init) == TREE_LIST))
8438         assignment = build_aggr_init (decl, init, 0);
8439       else if (init)
8440         /* The initialization we're doing here is just a bitwise
8441            copy.  */
8442         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8443       else
8444         assignment = NULL_TREE;
8445
8446       /* Once the assignment is complete, set TEMP to 1.  Since the
8447          construction of the static object is complete at this point,
8448          we want to make sure TEMP is set to 1 even if a temporary
8449          constructed during the initialization throws an exception
8450          when it is destroyed.  So, we combine the initialization and
8451          the assignment to TEMP into a single expression, ensuring
8452          that when we call finish_expr_stmt the cleanups will not be
8453          run until after TEMP is set to 1.  */
8454       guard_init = set_guard (guard);
8455       if (assignment)
8456         {
8457           assignment = tree_cons (NULL_TREE, assignment,
8458                                   build_tree_list (NULL_TREE,
8459                                                    guard_init));
8460           assignment = build_compound_expr (assignment);
8461         }
8462       else
8463         assignment = guard_init;
8464       finish_expr_stmt (assignment);
8465
8466       /* Use atexit to register a function for destroying this static
8467          variable.  */
8468       register_dtor_fn (decl);
8469
8470       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8471       finish_then_clause (if_stmt);
8472       finish_if_stmt ();
8473     }
8474   else
8475     static_aggregates = tree_cons (init, decl, static_aggregates);
8476 }
8477
8478 /* Finish the declaration of a catch-parameter.  */
8479
8480 tree
8481 start_handler_parms (declspecs, declarator)
8482      tree declspecs;
8483      tree declarator;
8484 {
8485   tree decl;
8486   if (declspecs)
8487     {
8488       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8489                              1, NULL_TREE);
8490       if (decl == NULL_TREE)
8491         error ("invalid catch parameter");
8492     }
8493   else
8494     decl = NULL_TREE;
8495
8496   return decl;
8497 }
8498
8499 \f
8500 /* Make TYPE a complete type based on INITIAL_VALUE.
8501    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8502    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8503
8504 int
8505 complete_array_type (type, initial_value, do_default)
8506      tree type, initial_value;
8507      int do_default;
8508 {
8509   register tree maxindex = NULL_TREE;
8510   int value = 0;
8511
8512   if (initial_value)
8513     {
8514       /* An array of character type can be initialized from a
8515          brace-enclosed string constant.  */
8516       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8517           && TREE_CODE (initial_value) == CONSTRUCTOR
8518           && CONSTRUCTOR_ELTS (initial_value)
8519           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8520               == STRING_CST)
8521           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8522         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8523
8524       /* Note MAXINDEX is really the maximum index, one less than the
8525          size.  */
8526       if (TREE_CODE (initial_value) == STRING_CST)
8527         {
8528           int eltsize
8529             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8530           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8531                                    / eltsize) - 1, 0);
8532         }
8533       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8534         {
8535           tree elts = CONSTRUCTOR_ELTS (initial_value);
8536
8537           maxindex = ssize_int (-1);
8538           for (; elts; elts = TREE_CHAIN (elts))
8539             {
8540               if (TREE_PURPOSE (elts))
8541                 maxindex = TREE_PURPOSE (elts);
8542               else
8543                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8544             }
8545           maxindex = copy_node (maxindex);
8546         }
8547       else
8548         {
8549           /* Make an error message unless that happened already.  */
8550           if (initial_value != error_mark_node)
8551             value = 1;
8552           else
8553             initial_value = NULL_TREE;
8554
8555           /* Prevent further error messages.  */
8556           maxindex = build_int_2 (0, 0);
8557         }
8558     }
8559
8560   if (!maxindex)
8561     {
8562       if (do_default)
8563         maxindex = build_int_2 (0, 0);
8564       value = 2;
8565     }
8566
8567   if (maxindex)
8568     {
8569       tree itype;
8570       tree domain;
8571
8572       domain = build_index_type (maxindex);
8573       TYPE_DOMAIN (type) = domain;
8574
8575       if (! TREE_TYPE (maxindex))
8576         TREE_TYPE (maxindex) = domain;
8577       if (initial_value)
8578         itype = TREE_TYPE (initial_value);
8579       else
8580         itype = NULL;
8581       if (itype && !TYPE_DOMAIN (itype))
8582         TYPE_DOMAIN (itype) = domain;
8583       /* The type of the main variant should never be used for arrays
8584          of different sizes.  It should only ever be completed with the
8585          size of the array.  */
8586       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8587         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8588     }
8589
8590   /* Lay out the type now that we can get the real answer.  */
8591
8592   layout_type (type);
8593
8594   return value;
8595 }
8596 \f
8597 /* Return zero if something is declared to be a member of type
8598    CTYPE when in the context of CUR_TYPE.  STRING is the error
8599    message to print in that case.  Otherwise, quietly return 1.  */
8600
8601 static int
8602 member_function_or_else (ctype, cur_type, flags)
8603      tree ctype, cur_type;
8604      enum overload_flags flags;
8605 {
8606   if (ctype && ctype != cur_type)
8607     {
8608       if (flags == DTOR_FLAG)
8609         cp_error ("destructor for alien class `%T' cannot be a member",
8610                   ctype);
8611       else
8612         cp_error ("constructor for alien class `%T' cannot be a member",
8613                   ctype);
8614       return 0;
8615     }
8616   return 1;
8617 }
8618 \f
8619 /* Subroutine of `grokdeclarator'.  */
8620
8621 /* Generate errors possibly applicable for a given set of specifiers.
8622    This is for ARM $7.1.2.  */
8623
8624 static void
8625 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8626      tree object;
8627      const char *type;
8628      int virtualp, quals, friendp, raises, inlinep;
8629 {
8630   if (virtualp)
8631     cp_error ("`%D' declared as a `virtual' %s", object, type);
8632   if (inlinep)
8633     cp_error ("`%D' declared as an `inline' %s", object, type);
8634   if (quals)
8635     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8636               object, type);
8637   if (friendp)
8638     cp_error_at ("`%D' declared as a friend", object);
8639   if (raises && !TYPE_PTRFN_P (TREE_TYPE (object))
8640       && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))
8641     cp_error_at ("`%D' declared with an exception specification", object);
8642 }
8643
8644 /* CTYPE is class type, or null if non-class.
8645    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8646    or METHOD_TYPE.
8647    DECLARATOR is the function's name.
8648    VIRTUALP is truthvalue of whether the function is virtual or not.
8649    FLAGS are to be passed through to `grokclassfn'.
8650    QUALS are qualifiers indicating whether the function is `const'
8651    or `volatile'.
8652    RAISES is a list of exceptions that this function can raise.
8653    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8654    not look, and -1 if we should not call `grokclassfn' at all.
8655
8656    Returns `NULL_TREE' if something goes wrong, after issuing
8657    applicable error messages.  */
8658
8659 static tree
8660 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8661             raises, check, friendp, publicp, inlinep, funcdef_flag,
8662             template_count, in_namespace)
8663      tree ctype, type;
8664      tree declarator;
8665      tree orig_declarator;
8666      int virtualp;
8667      enum overload_flags flags;
8668      tree quals, raises;
8669      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8670      tree in_namespace;
8671 {
8672   tree decl;
8673   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8674   int has_default_arg = 0;
8675   tree t;
8676
8677   if (raises)
8678     {
8679       type = build_exception_variant (type, raises);
8680     }
8681
8682   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8683   /* Propagate volatile out from type to decl. */
8684   if (TYPE_VOLATILE (type))
8685     TREE_THIS_VOLATILE (decl) = 1;
8686
8687   /* If this decl has namespace scope, set that up.  */
8688   if (in_namespace)
8689     set_decl_namespace (decl, in_namespace, friendp);
8690   else if (!ctype)
8691     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8692
8693   /* `main' and builtins have implicit 'C' linkage.  */
8694   if ((MAIN_NAME_P (declarator)
8695        || (IDENTIFIER_LENGTH (declarator) > 10
8696            && IDENTIFIER_POINTER (declarator)[0] == '_'
8697            && IDENTIFIER_POINTER (declarator)[1] == '_'
8698            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8699       && current_lang_name == lang_name_cplusplus
8700       && ctype == NULL_TREE
8701       /* NULL_TREE means global namespace.  */
8702       && DECL_CONTEXT (decl) == NULL_TREE)
8703     SET_DECL_LANGUAGE (decl, lang_c);
8704
8705   /* Should probably propagate const out from type to decl I bet (mrs).  */
8706   if (staticp)
8707     {
8708       DECL_STATIC_FUNCTION_P (decl) = 1;
8709       DECL_CONTEXT (decl) = ctype;
8710     }
8711
8712   if (ctype)
8713     DECL_CONTEXT (decl) = ctype;
8714
8715   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8716     {
8717       if (processing_template_decl)
8718         error ("cannot declare `::main' to be a template");
8719       if (inlinep)
8720         error ("cannot declare `::main' to be inline");
8721       if (!publicp)
8722         error ("cannot declare `::main' to be static");
8723       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8724                         integer_type_node))
8725         error ("`main' must return `int'");
8726       inlinep = 0;
8727       publicp = 1;
8728     }
8729
8730   /* Members of anonymous types and local classes have no linkage; make
8731      them internal.  */
8732   /* FIXME what if it gets a name from typedef?  */
8733   if (ctype && (TYPE_ANONYMOUS_P (ctype)
8734                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8735     publicp = 0;
8736
8737   if (publicp)
8738     {
8739       /* [basic.link]: A name with no linkage (notably, the name of a class
8740          or enumeration declared in a local scope) shall not be used to
8741          declare an entity with linkage.
8742
8743          Only check this for public decls for now.  */
8744       t = no_linkage_check (TREE_TYPE (decl));
8745       if (t)
8746         {
8747           if (TYPE_ANONYMOUS_P (t))
8748             {
8749               if (DECL_EXTERN_C_P (decl))
8750                 /* Allow this; it's pretty common in C.  */;
8751               else
8752                 {
8753                   cp_pedwarn ("non-local function `%#D' uses anonymous type",
8754                               decl);
8755                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
8756                     cp_pedwarn_at ("\
8757 `%#D' does not refer to the unqualified type, so it is not used for linkage",
8758                                 TYPE_NAME (t));
8759                 }
8760             }
8761           else
8762             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8763                         decl, t);
8764         }
8765     }
8766
8767   TREE_PUBLIC (decl) = publicp;
8768   if (! publicp)
8769     {
8770       DECL_INTERFACE_KNOWN (decl) = 1;
8771       DECL_NOT_REALLY_EXTERN (decl) = 1;
8772     }
8773
8774   /* If the declaration was declared inline, mark it as such.  */
8775   if (inlinep)
8776     DECL_DECLARED_INLINE_P (decl) = 1;
8777   /* We inline functions that are explicitly declared inline, or, when
8778      the user explicitly asks us to, all functions.  */
8779   if (DECL_DECLARED_INLINE_P (decl) || flag_inline_trees == 2)
8780     DECL_INLINE (decl) = 1;
8781
8782   DECL_EXTERNAL (decl) = 1;
8783   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8784     {
8785       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8786                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8787       quals = NULL_TREE;
8788     }
8789
8790   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8791     grok_op_properties (decl, virtualp, check < 0);
8792
8793   if (ctype && decl_function_context (decl))
8794     DECL_NO_STATIC_CHAIN (decl) = 1;
8795
8796   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8797     if (TREE_PURPOSE (t)
8798         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8799       {
8800         has_default_arg = 1;
8801         break;
8802       }
8803
8804   if (friendp
8805       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8806     {
8807       if (funcdef_flag)
8808         cp_error
8809           ("defining explicit specialization `%D' in friend declaration",
8810            orig_declarator);
8811       else
8812         {
8813           tree fns = TREE_OPERAND (orig_declarator, 0);
8814           tree args = TREE_OPERAND (orig_declarator, 1);
8815
8816           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8817             {
8818               /* Something like `template <class T> friend void f<T>()'.  */
8819               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8820                         orig_declarator);
8821               return NULL_TREE;
8822             }
8823
8824
8825           /* A friend declaration of the form friend void f<>().  Record
8826              the information in the TEMPLATE_ID_EXPR.  */
8827           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8828
8829           if (TREE_CODE (fns) == COMPONENT_REF)
8830             {
8831               /* Due to bison parser ickiness, we will have already looked
8832                  up an operator_name or PFUNCNAME within the current class
8833                  (see template_id in parse.y). If the current class contains
8834                  such a name, we'll get a COMPONENT_REF here. Undo that. */
8835
8836               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
8837                                   == current_class_type, 20001120);
8838               fns = TREE_OPERAND (fns, 1);
8839             }
8840           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
8841                               || TREE_CODE (fns) == LOOKUP_EXPR
8842                               || TREE_CODE (fns) == OVERLOAD, 20001120);
8843           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
8844
8845           if (has_default_arg)
8846             {
8847               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8848                         decl);
8849               return NULL_TREE;
8850             }
8851
8852           if (inlinep)
8853             {
8854               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8855                         decl);
8856               return NULL_TREE;
8857             }
8858         }
8859     }
8860
8861   if (has_default_arg)
8862     add_defarg_fn (decl);
8863
8864   if (funcdef_flag)
8865     /* Make the init_value nonzero so pushdecl knows this is not
8866        tentative.  error_mark_node is replaced later with the BLOCK.  */
8867     DECL_INITIAL (decl) = error_mark_node;
8868
8869   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8870     TREE_NOTHROW (decl) = 1;
8871
8872   /* Caller will do the rest of this.  */
8873   if (check < 0)
8874     return decl;
8875
8876   if (flags == NO_SPECIAL && ctype && constructor_name (ctype) == declarator)
8877     DECL_CONSTRUCTOR_P (decl) = 1;
8878
8879   /* Function gets the ugly name, field gets the nice one.  This call
8880      may change the type of the function (because of default
8881      parameters)!  */
8882   if (ctype != NULL_TREE)
8883     grokclassfn (ctype, decl, flags, quals);
8884
8885   decl = check_explicit_specialization (orig_declarator, decl,
8886                                         template_count,
8887                                         2 * (funcdef_flag != 0) +
8888                                         4 * (friendp != 0));
8889   if (decl == error_mark_node)
8890     return NULL_TREE;
8891
8892   if (ctype != NULL_TREE
8893       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8894       && check)
8895     {
8896       tree old_decl;
8897
8898       old_decl = check_classfn (ctype, decl);
8899
8900       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
8901         /* Because grokfndecl is always supposed to return a
8902            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8903            here.  We depend on our callers to figure out that its
8904            really a template that's being returned.  */
8905         old_decl = DECL_TEMPLATE_RESULT (old_decl);
8906
8907       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
8908           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8909         {
8910           /* Remove the `this' parm added by grokclassfn.
8911              XXX Isn't this done in start_function, too?  */
8912           revert_static_member_fn (decl);
8913           last_function_parms = TREE_CHAIN (last_function_parms);
8914         }
8915       if (old_decl && DECL_ARTIFICIAL (old_decl))
8916         cp_error ("definition of implicitly-declared `%D'", old_decl);
8917
8918       if (old_decl)
8919         {
8920           /* Since we've smashed OLD_DECL to its
8921              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
8922           if (TREE_CODE (decl) == TEMPLATE_DECL)
8923             decl = DECL_TEMPLATE_RESULT (decl);
8924
8925           /* Attempt to merge the declarations.  This can fail, in
8926              the case of some illegal specialization declarations.  */
8927           if (!duplicate_decls (decl, old_decl))
8928             cp_error ("no `%#D' member function declared in class `%T'",
8929                       decl, ctype);
8930           return old_decl;
8931         }
8932     }
8933
8934   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
8935     return NULL_TREE;
8936
8937   if (ctype == NULL_TREE || check)
8938     return decl;
8939
8940   if (virtualp)
8941     DECL_VIRTUAL_P (decl) = 1;
8942
8943   return decl;
8944 }
8945
8946 static tree
8947 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
8948      tree type;
8949      tree declarator;
8950      RID_BIT_TYPE *specbits_in;
8951      int initialized;
8952      int constp;
8953      tree in_namespace;
8954 {
8955   tree decl;
8956   RID_BIT_TYPE specbits;
8957
8958   specbits = *specbits_in;
8959
8960   if (TREE_CODE (type) == OFFSET_TYPE)
8961     {
8962       /* If you declare a static member so that it
8963          can be initialized, the code will reach here.  */
8964       tree basetype = TYPE_OFFSET_BASETYPE (type);
8965       type = TREE_TYPE (type);
8966       decl = build_lang_decl (VAR_DECL, declarator, type);
8967       DECL_CONTEXT (decl) = basetype;
8968     }
8969   else
8970     {
8971       tree context;
8972
8973       if (in_namespace)
8974         context = in_namespace;
8975       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
8976         context = current_namespace;
8977       else
8978         context = NULL_TREE;
8979
8980       /* For namespace-scope variables, declared in a template, we
8981          need the full lang_decl.  The same is true for
8982          namespace-scope variables that do not have C++ language
8983          linkage.  */
8984       if (context
8985           && (processing_template_decl
8986               || current_lang_name != lang_name_cplusplus))
8987         decl = build_lang_decl (VAR_DECL, declarator, type);
8988       else
8989         decl = build_decl (VAR_DECL, declarator, type);
8990
8991       if (context)
8992         set_decl_namespace (decl, context, 0);
8993
8994       context = DECL_CONTEXT (decl);
8995       if (declarator && context && current_lang_name != lang_name_c)
8996         /* We can't mangle lazily here because we don't have any
8997            way to recover whether or not a variable was `extern
8998            "C"' later.  */
8999         mangle_decl (decl);
9000     }
9001
9002   if (in_namespace)
9003     set_decl_namespace (decl, in_namespace, 0);
9004
9005   if (RIDBIT_SETP (RID_EXTERN, specbits))
9006     {
9007       DECL_THIS_EXTERN (decl) = 1;
9008       DECL_EXTERNAL (decl) = !initialized;
9009     }
9010
9011   /* In class context, static means one per class,
9012      public access, and static storage.  */
9013   if (DECL_CLASS_SCOPE_P (decl))
9014     {
9015       TREE_PUBLIC (decl) = 1;
9016       TREE_STATIC (decl) = 1;
9017       DECL_EXTERNAL (decl) = 0;
9018     }
9019   /* At top level, either `static' or no s.c. makes a definition
9020      (perhaps tentative), and absence of `static' makes it public.  */
9021   else if (toplevel_bindings_p ())
9022     {
9023       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9024                             && (DECL_THIS_EXTERN (decl) || ! constp));
9025       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9026     }
9027   /* Not at top level, only `static' makes a static definition.  */
9028   else
9029     {
9030       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9031       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9032     }
9033
9034   if (TREE_PUBLIC (decl))
9035     {
9036       /* [basic.link]: A name with no linkage (notably, the name of a class
9037          or enumeration declared in a local scope) shall not be used to
9038          declare an entity with linkage.
9039
9040          Only check this for public decls for now.  */
9041       tree t = no_linkage_check (TREE_TYPE (decl));
9042       if (t)
9043         {
9044           if (TYPE_ANONYMOUS_P (t))
9045             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9046           else
9047             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9048                         decl, t);
9049         }
9050     }
9051
9052   return decl;
9053 }
9054
9055 /* Create and return a canonical pointer to member function type, for
9056    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9057
9058 tree
9059 build_ptrmemfunc_type (type)
9060      tree type;
9061 {
9062   tree fields[4];
9063   tree t;
9064   tree unqualified_variant = NULL_TREE;
9065
9066   if (type == error_mark_node)
9067     return type;
9068
9069   /* If a canonical type already exists for this type, use it.  We use
9070      this method instead of type_hash_canon, because it only does a
9071      simple equality check on the list of field members.  */
9072
9073   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9074     return t;
9075
9076   /* Make sure that we always have the unqualified pointer-to-member
9077      type first.  */
9078   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9079     unqualified_variant
9080       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9081
9082   t = make_aggr_type (RECORD_TYPE);
9083   /* Let the front-end know this is a pointer to member function...  */
9084   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9085   /* ... and not really an aggregate.  */
9086   SET_IS_AGGR_TYPE (t, 0);
9087
9088   fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9089   fields[1] = build_decl (FIELD_DECL, delta_identifier,
9090                           delta_type_node);
9091   finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9092
9093   /* Zap out the name so that the back-end will give us the debugging
9094      information for this anonymous RECORD_TYPE.  */
9095   TYPE_NAME (t) = NULL_TREE;
9096
9097   /* If this is not the unqualified form of this pointer-to-member
9098      type, set the TYPE_MAIN_VARIANT for this type to be the
9099      unqualified type.  Since they are actually RECORD_TYPEs that are
9100      not variants of each other, we must do this manually.  */
9101   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9102     {
9103       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9104       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9105       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9106       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9107     }
9108
9109   /* Cache this pointer-to-member type so that we can find it again
9110      later.  */
9111   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9112
9113   /* Seems to be wanted.  */
9114   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9115
9116   return t;
9117 }
9118
9119 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9120    Check to see that the definition is valid.  Issue appropriate error
9121    messages.  Return 1 if the definition is particularly bad, or 0
9122    otherwise.  */
9123
9124 int
9125 check_static_variable_definition (decl, type)
9126      tree decl;
9127      tree type;
9128 {
9129   /* Motion 10 at San Diego: If a static const integral data member is
9130      initialized with an integral constant expression, the initializer
9131      may appear either in the declaration (within the class), or in
9132      the definition, but not both.  If it appears in the class, the
9133      member is a member constant.  The file-scope definition is always
9134      required.  */
9135   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9136     {
9137       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9138                 type);
9139       /* If we just return the declaration, crashes will sometimes
9140          occur.  We therefore return void_type_node, as if this was a
9141          friend declaration, to cause callers to completely ignore
9142          this declaration.  */
9143       return 1;
9144     }
9145   else if (!CP_TYPE_CONST_P (type))
9146     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9147               decl);
9148   else if (pedantic && !INTEGRAL_TYPE_P (type))
9149     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9150
9151   return 0;
9152 }
9153
9154 /* Given the SIZE (i.e., number of elements) in an array, compute an
9155    appropriate index type for the array.  If non-NULL, NAME is the
9156    name of the thing being declared.  */
9157
9158 tree
9159 compute_array_index_type (name, size)
9160      tree name;
9161      tree size;
9162 {
9163   tree itype;
9164
9165   /* If this involves a template parameter, it will be a constant at
9166      instantiation time, but we don't know what the value is yet.
9167      Even if no template parameters are involved, we may an expression
9168      that is not a constant; we don't even simplify `1 + 2' when
9169      processing a template.  */
9170   if (processing_template_decl)
9171     {
9172       /* Resolve a qualified reference to an enumerator or static
9173          const data member of ours.  */
9174       if (TREE_CODE (size) == SCOPE_REF
9175           && TREE_OPERAND (size, 0) == current_class_type)
9176         {
9177           tree t = lookup_field (current_class_type,
9178                                  TREE_OPERAND (size, 1), 0, 0);
9179           if (t)
9180             size = t;
9181         }
9182
9183       return build_index_type (build_min (MINUS_EXPR, sizetype,
9184                                           size, integer_one_node));
9185     }
9186
9187   /* The size might be the result of a cast. */
9188   STRIP_TYPE_NOPS (size);
9189
9190   /* It might be a const variable or enumeration constant.  */
9191   size = decl_constant_value (size);
9192
9193   /* The array bound must be an integer type.  */
9194   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9195       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9196       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9197     {
9198       if (name)
9199         cp_error ("size of array `%D' has non-integer type", name);
9200       else
9201         cp_error ("size of array has non-integer type");
9202       size = integer_one_node;
9203     }
9204
9205   /* Normally, the array-bound will be a constant.  */
9206   if (TREE_CODE (size) == INTEGER_CST)
9207     {
9208       /* Check to see if the array bound overflowed.  Make that an
9209          error, no matter how generous we're being.  */
9210       int old_flag_pedantic_errors = flag_pedantic_errors;
9211       int old_pedantic = pedantic;
9212       pedantic = flag_pedantic_errors = 1;
9213       constant_expression_warning (size);
9214       pedantic = old_pedantic;
9215       flag_pedantic_errors = old_flag_pedantic_errors;
9216
9217       /* An array must have a positive number of elements.  */
9218       if (INT_CST_LT (size, integer_zero_node))
9219         {
9220           if (name)
9221             cp_error ("size of array `%D' is negative", name);
9222           else
9223             cp_error ("size of array is negative");
9224           size = integer_one_node;
9225         }
9226       /* Except that an extension we allow zero-sized arrays.  We
9227          always allow them in system headers because glibc uses
9228          them.  */
9229       else if (integer_zerop (size) && pedantic && !in_system_header)
9230         {
9231           if (name)
9232             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9233           else
9234             cp_pedwarn ("ISO C++ forbids zero-size array");
9235         }
9236     }
9237   else if (TREE_CONSTANT (size))
9238     {
9239       /* `(int) &fn' is not a valid array bound.  */
9240       if (name)
9241         cp_error ("size of array `%D' is not an integral constant-expression",
9242                   name);
9243       else
9244         cp_error ("size of array is not an integral constant-expression");
9245     }
9246
9247   /* Compute the index of the largest element in the array.  It is
9248      one less than the number of elements in the array.  */
9249   itype
9250     = fold (cp_build_binary_op (MINUS_EXPR,
9251                                 cp_convert (ssizetype, size),
9252                                 cp_convert (ssizetype,
9253                                             integer_one_node)));
9254
9255   /* Check for variable-sized arrays.  We allow such things as an
9256      extension, even though they are not allowed in ANSI/ISO C++.  */
9257   if (!TREE_CONSTANT (itype))
9258     {
9259       if (pedantic)
9260         {
9261           if (name)
9262             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9263                         name);
9264           else
9265             cp_pedwarn ("ISO C++ forbids variable-size array");
9266         }
9267
9268       /* Create a variable-sized array index type.  */
9269       itype = variable_size (itype);
9270     }
9271   /* Make sure that there was no overflow when creating to a signed
9272      index type.  (For example, on a 32-bit machine, an array with
9273      size 2^32 - 1 is too big.)  */
9274   else if (TREE_OVERFLOW (itype))
9275     {
9276       error ("overflow in array dimension");
9277       TREE_OVERFLOW (itype) = 0;
9278     }
9279
9280   /* Create and return the appropriate index type.  */
9281   return build_index_type (itype);
9282 }
9283
9284 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9285    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9286    with this type.  */
9287
9288 static tree
9289 create_array_type_for_decl (name, type, size)
9290      tree name;
9291      tree type;
9292      tree size;
9293 {
9294   tree itype = NULL_TREE;
9295   const char* error_msg;
9296
9297   /* If things have already gone awry, bail now.  */
9298   if (type == error_mark_node || size == error_mark_node)
9299     return error_mark_node;
9300
9301   /* Assume that everything will go OK.  */
9302   error_msg = NULL;
9303
9304   /* There are some types which cannot be array elements.  */
9305   switch (TREE_CODE (type))
9306     {
9307     case VOID_TYPE:
9308       error_msg = "array of void";
9309       break;
9310
9311     case FUNCTION_TYPE:
9312       error_msg = "array of functions";
9313       break;
9314
9315     case REFERENCE_TYPE:
9316       error_msg = "array of references";
9317       break;
9318
9319     case OFFSET_TYPE:
9320       error_msg = "array of data members";
9321       break;
9322
9323     case METHOD_TYPE:
9324       error_msg = "array of function members";
9325       break;
9326
9327     default:
9328       break;
9329     }
9330
9331   /* If something went wrong, issue an error-message and return.  */
9332   if (error_msg)
9333     {
9334       if (name)
9335         cp_error ("declaration of `%D' as %s", name, error_msg);
9336       else
9337         cp_error ("creating %s", error_msg);
9338
9339       return error_mark_node;
9340     }
9341
9342   /* [dcl.array]
9343
9344      The constant expressions that specify the bounds of the arrays
9345      can be omitted only for the first member of the sequence.  */
9346   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9347     {
9348       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9349                 name);
9350
9351       return error_mark_node;
9352     }
9353
9354   /* Figure out the index type for the array.  */
9355   if (size)
9356     itype = compute_array_index_type (name, size);
9357
9358   return build_cplus_array_type (type, itype);
9359 }
9360
9361 /* Check that it's OK to declare a function with the indicated TYPE.
9362    SFK indicates the kind of special function (if any) that this
9363    function is.  OPTYPE is the type given in a conversion operator
9364    declaration.  Returns the actual return type of the function; that
9365    may be different than TYPE if an error occurs, or for certain
9366    special functions.  */
9367
9368 static tree
9369 check_special_function_return_type (sfk, type, optype)
9370      special_function_kind sfk;
9371      tree type;
9372      tree optype;
9373 {
9374   switch (sfk)
9375     {
9376     case sfk_constructor:
9377       if (type)
9378         cp_error ("return type specification for constructor invalid");
9379
9380       type = void_type_node;
9381       break;
9382
9383     case sfk_destructor:
9384       if (type)
9385         cp_error ("return type specification for destructor invalid");
9386       type = void_type_node;
9387       break;
9388
9389     case sfk_conversion:
9390       if (type && !same_type_p (type, optype))
9391         cp_error ("operator `%T' declared to return `%T'", optype, type);
9392       else if (type)
9393         cp_pedwarn ("return type specified for `operator %T'",  optype);
9394       type = optype;
9395       break;
9396
9397     default:
9398       my_friendly_abort (20000408);
9399       break;
9400     }
9401
9402   return type;
9403 }
9404
9405 /* Given declspecs and a declarator,
9406    determine the name and type of the object declared
9407    and construct a ..._DECL node for it.
9408    (In one case we can return a ..._TYPE node instead.
9409     For invalid input we sometimes return 0.)
9410
9411    DECLSPECS is a chain of tree_list nodes whose value fields
9412     are the storage classes and type specifiers.
9413
9414    DECL_CONTEXT says which syntactic context this declaration is in:
9415      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9416      FUNCDEF for a function definition.  Like NORMAL but a few different
9417       error messages in each case.  Return value may be zero meaning
9418       this definition is too screwy to try to parse.
9419      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9420       handle member functions (which have FIELD context).
9421       Return value may be zero meaning this definition is too screwy to
9422       try to parse.
9423      PARM for a parameter declaration (either within a function prototype
9424       or before a function body).  Make a PARM_DECL, or return void_type_node.
9425      CATCHPARM for a parameter declaration before a catch clause.
9426      TYPENAME if for a typename (in a cast or sizeof).
9427       Don't make a DECL node; just return the ..._TYPE node.
9428      FIELD for a struct or union field; make a FIELD_DECL.
9429      BITFIELD for a field with specified width.
9430    INITIALIZED is 1 if the decl has an initializer.
9431
9432    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9433    normal attributes in TREE_PURPOSE, or NULL_TREE.
9434
9435    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9436    It may also be so in the PARM case, for a prototype where the
9437    argument type is specified but not the name.
9438
9439    This function is where the complicated C meanings of `static'
9440    and `extern' are interpreted.
9441
9442    For C++, if there is any monkey business to do, the function which
9443    calls this one must do it, i.e., prepending instance variables,
9444    renaming overloaded function names, etc.
9445
9446    Note that for this C++, it is an error to define a method within a class
9447    which does not belong to that class.
9448
9449    Except in the case where SCOPE_REFs are implicitly known (such as
9450    methods within a class being redundantly qualified),
9451    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9452    (class_name::decl_name).  The caller must also deal with this.
9453
9454    If a constructor or destructor is seen, and the context is FIELD,
9455    then the type gains the attribute TREE_HAS_x.  If such a declaration
9456    is erroneous, NULL_TREE is returned.
9457
9458    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9459    function, these are the qualifiers to give to the `this' pointer. We
9460    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9461
9462    May return void_type_node if the declarator turned out to be a friend.
9463    See grokfield for details.  */
9464
9465 tree
9466 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9467      tree declspecs;
9468      tree declarator;
9469      enum decl_context decl_context;
9470      int initialized;
9471      tree attrlist;
9472 {
9473   RID_BIT_TYPE specbits;
9474   int nclasses = 0;
9475   tree spec;
9476   tree type = NULL_TREE;
9477   int longlong = 0;
9478   int constp;
9479   int restrictp;
9480   int volatilep;
9481   int type_quals;
9482   int virtualp, explicitp, friendp, inlinep, staticp;
9483   int explicit_int = 0;
9484   int explicit_char = 0;
9485   int defaulted_int = 0;
9486   tree typedef_decl = NULL_TREE;
9487   const char *name;
9488   tree typedef_type = NULL_TREE;
9489   int funcdef_flag = 0;
9490   enum tree_code innermost_code = ERROR_MARK;
9491   int bitfield = 0;
9492 #if 0
9493   /* See the code below that used this.  */
9494   tree decl_machine_attr = NULL_TREE;
9495 #endif
9496   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9497      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9498   tree init = NULL_TREE;
9499
9500   /* Keep track of what sort of function is being processed
9501      so that we can warn about default return values, or explicit
9502      return values which do not match prescribed defaults.  */
9503   special_function_kind sfk = sfk_none;
9504
9505   tree dname = NULL_TREE;
9506   tree ctype = current_class_type;
9507   tree ctor_return_type = NULL_TREE;
9508   enum overload_flags flags = NO_SPECIAL;
9509   tree quals = NULL_TREE;
9510   tree raises = NULL_TREE;
9511   int template_count = 0;
9512   tree in_namespace = NULL_TREE;
9513   tree inner_attrs;
9514   int ignore_attrs;
9515
9516   RIDBIT_RESET_ALL (specbits);
9517   if (decl_context == FUNCDEF)
9518     funcdef_flag = 1, decl_context = NORMAL;
9519   else if (decl_context == MEMFUNCDEF)
9520     funcdef_flag = -1, decl_context = FIELD;
9521   else if (decl_context == BITFIELD)
9522     bitfield = 1, decl_context = FIELD;
9523
9524   /* Look inside a declarator for the name being declared
9525      and get it as a string, for an error message.  */
9526   {
9527     tree *next = &declarator;
9528     register tree decl;
9529     name = NULL;
9530
9531     while (next && *next)
9532       {
9533         decl = *next;
9534         switch (TREE_CODE (decl))
9535           {
9536           case TREE_LIST:
9537             /* For attributes.  */
9538             next = &TREE_VALUE (decl);
9539             break;
9540
9541           case COND_EXPR:
9542             ctype = NULL_TREE;
9543             next = &TREE_OPERAND (decl, 0);
9544             break;
9545
9546           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9547             {
9548               tree name = TREE_OPERAND (decl, 0);
9549               tree rename = NULL_TREE;
9550
9551               my_friendly_assert (flags == NO_SPECIAL, 152);
9552               flags = DTOR_FLAG;
9553               sfk = sfk_destructor;
9554               if (TREE_CODE (name) == TYPE_DECL)
9555                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9556               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9557               if (ctype == NULL_TREE)
9558                 {
9559                   if (current_class_type == NULL_TREE)
9560                     {
9561                       error ("destructors must be member functions");
9562                       flags = NO_SPECIAL;
9563                     }
9564                   else
9565                     {
9566                       tree t = constructor_name (current_class_name);
9567                       if (t != name)
9568                         rename = t;
9569                     }
9570                 }
9571               else
9572                 {
9573                   tree t = constructor_name (ctype);
9574                   if (t != name)
9575                     rename = t;
9576                 }
9577
9578               if (rename)
9579                 {
9580                   cp_error ("destructor `%T' must match class name `%T'",
9581                             name, rename);
9582                   TREE_OPERAND (decl, 0) = rename;
9583                 }
9584               next = &name;
9585             }
9586             break;
9587
9588           case ADDR_EXPR:       /* C++ reference declaration */
9589             /* Fall through. */
9590           case ARRAY_REF:
9591           case INDIRECT_REF:
9592             ctype = NULL_TREE;
9593             innermost_code = TREE_CODE (decl);
9594             next = &TREE_OPERAND (decl, 0);
9595             break;
9596
9597           case CALL_EXPR:
9598             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9599               {
9600                 /* This is actually a variable declaration using
9601                    constructor syntax.  We need to call start_decl and
9602                    cp_finish_decl so we can get the variable
9603                    initialized...  */
9604
9605                 tree attributes, prefix_attributes;
9606
9607                 *next = TREE_OPERAND (decl, 0);
9608                 init = CALL_DECLARATOR_PARMS (decl);
9609
9610                 if (attrlist)
9611                   {
9612                     attributes = TREE_PURPOSE (attrlist);
9613                     prefix_attributes = TREE_VALUE (attrlist);
9614                   }
9615                 else
9616                   {
9617                     attributes = NULL_TREE;
9618                     prefix_attributes = NULL_TREE;
9619                   }
9620
9621                 decl = start_decl (declarator, declspecs, 1,
9622                                    attributes, prefix_attributes);
9623                 decl_type_access_control (decl);
9624                 if (decl)
9625                   {
9626                     /* Look for __unused__ attribute */
9627                     if (TREE_USED (TREE_TYPE (decl)))
9628                       TREE_USED (decl) = 1;
9629                     finish_decl (decl, init, NULL_TREE);
9630                   }
9631                 else
9632                   cp_error ("invalid declarator");
9633                 return 0;
9634               }
9635             innermost_code = TREE_CODE (decl);
9636             if (decl_context == FIELD && ctype == NULL_TREE)
9637               ctype = current_class_type;
9638             if (ctype
9639                 && TREE_OPERAND (decl, 0)
9640                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9641                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9642                          == constructor_name_full (ctype))
9643                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9644                             == constructor_name (ctype)))))
9645               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9646             next = &TREE_OPERAND (decl, 0);
9647             decl = *next;
9648             if (ctype != NULL_TREE
9649                 && decl != NULL_TREE && flags != DTOR_FLAG
9650                 && decl == constructor_name (ctype))
9651               {
9652                 sfk = sfk_constructor;
9653                 ctor_return_type = ctype;
9654               }
9655             ctype = NULL_TREE;
9656             break;
9657
9658           case TEMPLATE_ID_EXPR:
9659               {
9660                 tree fns = TREE_OPERAND (decl, 0);
9661
9662                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9663                   fns = TREE_OPERAND (fns, 0);
9664
9665                 dname = fns;
9666                 if (TREE_CODE (dname) == COMPONENT_REF)
9667                   dname = TREE_OPERAND (dname, 1);
9668                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9669                   {
9670                     my_friendly_assert (is_overloaded_fn (dname),
9671                                         19990331);
9672                     dname = DECL_NAME (get_first_fn (dname));
9673                   }
9674               }
9675           /* Fall through. */
9676
9677           case IDENTIFIER_NODE:
9678             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9679               dname = decl;
9680
9681             next = 0;
9682
9683             if (C_IS_RESERVED_WORD (dname))
9684               {
9685                 cp_error ("declarator-id missing; using reserved word `%D'",
9686                           dname);
9687                 name = IDENTIFIER_POINTER (dname);
9688               }
9689             else if (!IDENTIFIER_TYPENAME_P (dname))
9690               name = IDENTIFIER_POINTER (dname);
9691             else
9692               {
9693                 my_friendly_assert (flags == NO_SPECIAL, 154);
9694                 flags = TYPENAME_FLAG;
9695                 ctor_return_type = TREE_TYPE (dname);
9696                 sfk = sfk_conversion;
9697                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9698                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9699                         == TYPE_DECL))
9700                   name = IDENTIFIER_POINTER (dname);
9701                 else
9702                   name = "<invalid operator>";
9703               }
9704             break;
9705
9706             /* C++ extension */
9707           case SCOPE_REF:
9708             {
9709               /* Perform error checking, and decide on a ctype.  */
9710               tree cname = TREE_OPERAND (decl, 0);
9711               if (cname == NULL_TREE)
9712                 ctype = NULL_TREE;
9713               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9714                 {
9715                   ctype = NULL_TREE;
9716                   in_namespace = TREE_OPERAND (decl, 0);
9717                   TREE_OPERAND (decl, 0) = NULL_TREE;
9718                 }
9719               else if (! is_aggr_type (cname, 1))
9720                 TREE_OPERAND (decl, 0) = NULL_TREE;
9721               /* Must test TREE_OPERAND (decl, 1), in case user gives
9722                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9723               else if (TREE_OPERAND (decl, 1)
9724                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9725                 ctype = cname;
9726               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9727                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9728                 {
9729                   cp_error ("`%T::%D' is not a valid declarator", cname,
9730                             TREE_OPERAND (decl, 1));
9731                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9732                             cname, TREE_OPERAND (decl, 1));
9733                   return void_type_node;
9734                 }
9735               else if (ctype == NULL_TREE)
9736                 ctype = cname;
9737               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9738                 TREE_OPERAND (decl, 0) = ctype;
9739               else
9740                 {
9741                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9742                     {
9743                       cp_error ("type `%T' is not derived from type `%T'",
9744                                 cname, ctype);
9745                       TREE_OPERAND (decl, 0) = NULL_TREE;
9746                     }
9747                   else
9748                     ctype = cname;
9749                 }
9750
9751               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9752                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9753                        == constructor_name_full (ctype))
9754                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9755                           == constructor_name (ctype))))
9756                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9757               next = &TREE_OPERAND (decl, 1);
9758               decl = *next;
9759               if (ctype)
9760                 {
9761                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9762                       && constructor_name (ctype) == decl)
9763                     {
9764                       sfk = sfk_constructor;
9765                       ctor_return_type = ctype;
9766                     }
9767                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9768                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9769                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9770                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9771                     {
9772                       sfk = sfk_destructor;
9773                       ctor_return_type = ctype;
9774                       flags = DTOR_FLAG;
9775                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9776                       next = &TREE_OPERAND (decl, 0);
9777                     }
9778                 }
9779             }
9780             break;
9781
9782           case ERROR_MARK:
9783             next = 0;
9784             break;
9785
9786           case TYPE_DECL:
9787             /* Parse error puts this typespec where
9788                a declarator should go.  */
9789             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9790             if (TREE_TYPE (decl) == current_class_type)
9791               cp_error ("  perhaps you want `%T' for a constructor",
9792                         current_class_name);
9793             dname = DECL_NAME (decl);
9794             name = IDENTIFIER_POINTER (dname);
9795
9796             /* Avoid giving two errors for this.  */
9797             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9798
9799             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9800             *next = dname;
9801             next = 0;
9802             break;
9803
9804           default:
9805             cp_compiler_error ("`%D' as declarator", decl);
9806             return 0; /* We used to do a 155 abort here.  */
9807           }
9808       }
9809   }
9810
9811   /* A function definition's declarator must have the form of
9812      a function declarator.  */
9813
9814   if (funcdef_flag && innermost_code != CALL_EXPR)
9815     return 0;
9816
9817   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9818       && innermost_code != CALL_EXPR
9819       && ! (ctype && declspecs == NULL_TREE))
9820     {
9821       cp_error ("declaration of `%D' as non-function", dname);
9822       return void_type_node;
9823     }
9824
9825   /* Anything declared one level down from the top level
9826      must be one of the parameters of a function
9827      (because the body is at least two levels down).  */
9828
9829   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9830      by not allowing C++ class definitions to specify their parameters
9831      with xdecls (must be spec.d in the parmlist).
9832
9833      Since we now wait to push a class scope until we are sure that
9834      we are in a legitimate method context, we must set oldcname
9835      explicitly (since current_class_name is not yet alive).
9836
9837      We also want to avoid calling this a PARM if it is in a namespace.  */
9838
9839   if (decl_context == NORMAL && !toplevel_bindings_p ())
9840     {
9841       struct binding_level *b = current_binding_level;
9842       current_binding_level = b->level_chain;
9843       if (current_binding_level != 0 && toplevel_bindings_p ())
9844         decl_context = PARM;
9845       current_binding_level = b;
9846     }
9847
9848   if (name == NULL)
9849     name = decl_context == PARM ? "parameter" : "type name";
9850
9851   /* Look through the decl specs and record which ones appear.
9852      Some typespecs are defined as built-in typenames.
9853      Others, the ones that are modifiers of other types,
9854      are represented by bits in SPECBITS: set the bits for
9855      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9856
9857      If there is a typedef name or a type, store the type in TYPE.
9858      This includes builtin typedefs such as `int'.
9859
9860      Set EXPLICIT_INT if the type is `int' or `char' and did not
9861      come from a user typedef.
9862
9863      Set LONGLONG if `long' is mentioned twice.
9864
9865      For C++, constructors and destructors have their own fast treatment.  */
9866
9867   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9868     {
9869       register int i;
9870       register tree id;
9871
9872       /* Certain parse errors slip through.  For example,
9873          `int class;' is not caught by the parser. Try
9874          weakly to recover here.  */
9875       if (TREE_CODE (spec) != TREE_LIST)
9876         return 0;
9877
9878       id = TREE_VALUE (spec);
9879
9880       if (TREE_CODE (id) == IDENTIFIER_NODE)
9881         {
9882           if (id == ridpointers[(int) RID_INT]
9883               || id == ridpointers[(int) RID_CHAR]
9884               || id == ridpointers[(int) RID_BOOL]
9885               || id == ridpointers[(int) RID_WCHAR])
9886             {
9887               if (type)
9888                 {
9889                   if (id == ridpointers[(int) RID_BOOL])
9890                     error ("`bool' is now a keyword");
9891                   else
9892                     cp_error ("extraneous `%T' ignored", id);
9893                 }
9894               else
9895                 {
9896                   if (id == ridpointers[(int) RID_INT])
9897                     explicit_int = 1;
9898                   else if (id == ridpointers[(int) RID_CHAR])
9899                     explicit_char = 1;
9900                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9901                 }
9902               goto found;
9903             }
9904           /* C++ aggregate types.  */
9905           if (IDENTIFIER_HAS_TYPE_VALUE (id))
9906             {
9907               if (type)
9908                 cp_error ("multiple declarations `%T' and `%T'", type, id);
9909               else
9910                 type = IDENTIFIER_TYPE_VALUE (id);
9911               goto found;
9912             }
9913
9914           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
9915             {
9916               if (ridpointers[i] == id)
9917                 {
9918                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
9919                     {
9920                       if (pedantic && ! in_system_header && warn_long_long)
9921                         pedwarn ("ISO C++ does not support `long long'");
9922                       if (longlong)
9923                         error ("`long long long' is too long for GCC");
9924                       else
9925                         longlong = 1;
9926                     }
9927                   else if (RIDBIT_SETP (i, specbits))
9928                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
9929                   RIDBIT_SET (i, specbits);
9930                   goto found;
9931                 }
9932             }
9933         }
9934       /* C++ aggregate types.  */
9935       else if (TREE_CODE (id) == TYPE_DECL)
9936         {
9937           if (type)
9938             cp_error ("multiple declarations `%T' and `%T'", type,
9939                       TREE_TYPE (id));
9940           else
9941             {
9942               type = TREE_TYPE (id);
9943               TREE_VALUE (spec) = type;
9944             }
9945           goto found;
9946         }
9947       if (type)
9948         error ("two or more data types in declaration of `%s'", name);
9949       else if (TREE_CODE (id) == IDENTIFIER_NODE)
9950         {
9951           register tree t = lookup_name (id, 1);
9952           if (!t || TREE_CODE (t) != TYPE_DECL)
9953             error ("`%s' fails to be a typedef or built in type",
9954                    IDENTIFIER_POINTER (id));
9955           else
9956             {
9957               type = TREE_TYPE (t);
9958 #if 0
9959               /* See the code below that used this.  */
9960               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
9961 #endif
9962               typedef_decl = t;
9963             }
9964         }
9965       else if (id != error_mark_node)
9966         /* Can't change CLASS nodes into RECORD nodes here!  */
9967         type = id;
9968
9969     found: ;
9970     }
9971
9972   typedef_type = type;
9973
9974   /* No type at all: default to `int', and set DEFAULTED_INT
9975      because it was not a user-defined typedef.  */
9976
9977   if (type == NULL_TREE
9978       && (RIDBIT_SETP (RID_SIGNED, specbits)
9979           || RIDBIT_SETP (RID_UNSIGNED, specbits)
9980           || RIDBIT_SETP (RID_LONG, specbits)
9981           || RIDBIT_SETP (RID_SHORT, specbits)))
9982     {
9983       /* These imply 'int'.  */
9984       type = integer_type_node;
9985       defaulted_int = 1;
9986     }
9987
9988   if (sfk != sfk_none)
9989     type = check_special_function_return_type (sfk, type,
9990                                                ctor_return_type);
9991   else if (type == NULL_TREE)
9992     {
9993       int is_main;
9994
9995       explicit_int = -1;
9996
9997       /* We handle `main' specially here, because 'main () { }' is so
9998          common.  With no options, it is allowed.  With -Wreturn-type,
9999          it is a warning.  It is only an error with -pedantic-errors.  */
10000       is_main = (funcdef_flag
10001                  && MAIN_NAME_P (dname)
10002                  && ctype == NULL_TREE
10003                  && in_namespace == NULL_TREE
10004                  && current_namespace == global_namespace);
10005
10006       if (in_system_header || flag_ms_extensions)
10007         /* Allow it, sigh.  */;
10008       else if (pedantic || ! is_main)
10009         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10010                     name);
10011       else if (warn_return_type)
10012         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10013                     name);
10014
10015       type = integer_type_node;
10016     }
10017
10018   ctype = NULL_TREE;
10019
10020   /* Now process the modifiers that were specified
10021      and check for invalid combinations.  */
10022
10023   /* Long double is a special combination.  */
10024
10025   if (RIDBIT_SETP (RID_LONG, specbits)
10026       && TYPE_MAIN_VARIANT (type) == double_type_node)
10027     {
10028       RIDBIT_RESET (RID_LONG, specbits);
10029       type = build_qualified_type (long_double_type_node,
10030                                    CP_TYPE_QUALS (type));
10031     }
10032
10033   /* Check all other uses of type modifiers.  */
10034
10035   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10036       || RIDBIT_SETP (RID_SIGNED, specbits)
10037       || RIDBIT_SETP (RID_LONG, specbits)
10038       || RIDBIT_SETP (RID_SHORT, specbits))
10039     {
10040       int ok = 0;
10041
10042       if (TREE_CODE (type) == REAL_TYPE)
10043         error ("short, signed or unsigned invalid for `%s'", name);
10044       else if (TREE_CODE (type) != INTEGER_TYPE)
10045         error ("long, short, signed or unsigned invalid for `%s'", name);
10046       else if (RIDBIT_SETP (RID_LONG, specbits)
10047                && RIDBIT_SETP (RID_SHORT, specbits))
10048         error ("long and short specified together for `%s'", name);
10049       else if ((RIDBIT_SETP (RID_LONG, specbits)
10050                 || RIDBIT_SETP (RID_SHORT, specbits))
10051                && explicit_char)
10052         error ("long or short specified with char for `%s'", name);
10053       else if ((RIDBIT_SETP (RID_LONG, specbits)
10054                 || RIDBIT_SETP (RID_SHORT, specbits))
10055                && TREE_CODE (type) == REAL_TYPE)
10056         error ("long or short specified with floating type for `%s'", name);
10057       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10058                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10059         error ("signed and unsigned given together for `%s'", name);
10060       else
10061         {
10062           ok = 1;
10063           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10064             {
10065               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10066                        name);
10067               if (flag_pedantic_errors)
10068                 ok = 0;
10069             }
10070         }
10071
10072       /* Discard the type modifiers if they are invalid.  */
10073       if (! ok)
10074         {
10075           RIDBIT_RESET (RID_UNSIGNED, specbits);
10076           RIDBIT_RESET (RID_SIGNED, specbits);
10077           RIDBIT_RESET (RID_LONG, specbits);
10078           RIDBIT_RESET (RID_SHORT, specbits);
10079           longlong = 0;
10080         }
10081     }
10082
10083   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10084       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10085     {
10086       error ("complex invalid for `%s'", name);
10087       RIDBIT_RESET (RID_COMPLEX, specbits);
10088     }
10089
10090   /* Decide whether an integer type is signed or not.
10091      Optionally treat bitfields as signed by default.  */
10092   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10093       /* [class.bit]
10094
10095          It is implementation-defined whether a plain (neither
10096          explicitly signed or unsigned) char, short, int, or long
10097          bit-field is signed or unsigned.
10098
10099          Naturally, we extend this to long long as well.  Note that
10100          this does not include wchar_t.  */
10101       || (bitfield && !flag_signed_bitfields
10102           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10103           /* A typedef for plain `int' without `signed' can be
10104              controlled just like plain `int', but a typedef for
10105              `signed int' cannot be so controlled.  */
10106           && !(typedef_decl
10107                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10108           && (TREE_CODE (type) == INTEGER_TYPE
10109               || TREE_CODE (type) == CHAR_TYPE)
10110           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10111     {
10112       if (longlong)
10113         type = long_long_unsigned_type_node;
10114       else if (RIDBIT_SETP (RID_LONG, specbits))
10115         type = long_unsigned_type_node;
10116       else if (RIDBIT_SETP (RID_SHORT, specbits))
10117         type = short_unsigned_type_node;
10118       else if (type == char_type_node)
10119         type = unsigned_char_type_node;
10120       else if (typedef_decl)
10121         type = unsigned_type (type);
10122       else
10123         type = unsigned_type_node;
10124     }
10125   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10126            && type == char_type_node)
10127     type = signed_char_type_node;
10128   else if (longlong)
10129     type = long_long_integer_type_node;
10130   else if (RIDBIT_SETP (RID_LONG, specbits))
10131     type = long_integer_type_node;
10132   else if (RIDBIT_SETP (RID_SHORT, specbits))
10133     type = short_integer_type_node;
10134
10135   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10136     {
10137       /* If we just have "complex", it is equivalent to
10138          "complex double", but if any modifiers at all are specified it is
10139          the complex form of TYPE.  E.g, "complex short" is
10140          "complex short int".  */
10141
10142       if (defaulted_int && ! longlong
10143           && ! (RIDBIT_SETP (RID_LONG, specbits)
10144                 || RIDBIT_SETP (RID_SHORT, specbits)
10145                 || RIDBIT_SETP (RID_SIGNED, specbits)
10146                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10147         type = complex_double_type_node;
10148       else if (type == integer_type_node)
10149         type = complex_integer_type_node;
10150       else if (type == float_type_node)
10151         type = complex_float_type_node;
10152       else if (type == double_type_node)
10153         type = complex_double_type_node;
10154       else if (type == long_double_type_node)
10155         type = complex_long_double_type_node;
10156       else
10157         type = build_complex_type (type);
10158     }
10159
10160   if (sfk == sfk_conversion
10161       && (RIDBIT_SETP (RID_CONST, specbits)
10162           || RIDBIT_SETP (RID_VOLATILE, specbits)
10163           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10164     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10165               ctor_return_type);
10166
10167   /* Set CONSTP if this declaration is `const', whether by
10168      explicit specification or via a typedef.
10169      Likewise for VOLATILEP.  */
10170
10171   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10172   restrictp =
10173     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10174   volatilep =
10175     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10176   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10177                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10178                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10179   type = cp_build_qualified_type (type, type_quals);
10180   staticp = 0;
10181   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10182   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10183   RIDBIT_RESET (RID_VIRTUAL, specbits);
10184   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10185   RIDBIT_RESET (RID_EXPLICIT, specbits);
10186
10187   if (RIDBIT_SETP (RID_STATIC, specbits))
10188     staticp = 1 + (decl_context == FIELD);
10189
10190   if (virtualp && staticp == 2)
10191     {
10192       cp_error ("member `%D' cannot be declared both virtual and static",
10193                 dname);
10194       staticp = 0;
10195     }
10196   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10197   RIDBIT_RESET (RID_FRIEND, specbits);
10198
10199   /* Warn if two storage classes are given. Default to `auto'.  */
10200
10201   if (RIDBIT_ANY_SET (specbits))
10202     {
10203       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10204       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10205       if (decl_context == PARM && nclasses > 0)
10206         error ("storage class specifiers invalid in parameter declarations");
10207       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10208         {
10209           if (decl_context == PARM)
10210             error ("typedef declaration invalid in parameter declaration");
10211           nclasses++;
10212         }
10213       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10214       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10215     }
10216
10217   /* Give error if `virtual' is used outside of class declaration.  */
10218   if (virtualp
10219       && (current_class_name == NULL_TREE || decl_context != FIELD))
10220     {
10221       error ("virtual outside class declaration");
10222       virtualp = 0;
10223     }
10224
10225   /* Static anonymous unions are dealt with here.  */
10226   if (staticp && decl_context == TYPENAME
10227       && TREE_CODE (declspecs) == TREE_LIST
10228       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10229     decl_context = FIELD;
10230
10231   /* Warn about storage classes that are invalid for certain
10232      kinds of declarations (parameters, typenames, etc.).  */
10233
10234   if (nclasses > 1)
10235     error ("multiple storage classes in declaration of `%s'", name);
10236   else if (decl_context != NORMAL && nclasses > 0)
10237     {
10238       if ((decl_context == PARM || decl_context == CATCHPARM)
10239           && (RIDBIT_SETP (RID_REGISTER, specbits)
10240               || RIDBIT_SETP (RID_AUTO, specbits)))
10241         ;
10242       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10243         ;
10244       else if (decl_context == FIELD
10245                /* C++ allows static class elements  */
10246                && RIDBIT_SETP (RID_STATIC, specbits))
10247         /* C++ also allows inlines and signed and unsigned elements,
10248            but in those cases we don't come in here.  */
10249         ;
10250       else
10251         {
10252           if (decl_context == FIELD)
10253             {
10254               tree tmp = NULL_TREE;
10255               register int op = 0;
10256
10257               if (declarator)
10258                 {
10259                   /* Avoid trying to get an operand off an identifier node.  */
10260                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10261                     tmp = declarator;
10262                   else
10263                     tmp = TREE_OPERAND (declarator, 0);
10264                   op = IDENTIFIER_OPNAME_P (tmp);
10265                   if (IDENTIFIER_TYPENAME_P (tmp))
10266                     {
10267                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10268                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10269                               == TYPE_DECL))
10270                         name = IDENTIFIER_POINTER (tmp);
10271                       else
10272                         name = "<invalid operator>";
10273                     }
10274                 }
10275               error ("storage class specified for %s `%s'",
10276                      op ? "member operator" : "field",
10277                      name);
10278             }
10279           else
10280             {
10281               if (decl_context == PARM || decl_context == CATCHPARM)
10282                 error ("storage class specified for parameter `%s'", name);
10283               else
10284                 error ("storage class specified for typename");
10285             }
10286           RIDBIT_RESET (RID_REGISTER, specbits);
10287           RIDBIT_RESET (RID_AUTO, specbits);
10288           RIDBIT_RESET (RID_EXTERN, specbits);
10289         }
10290     }
10291   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10292     {
10293       if (toplevel_bindings_p ())
10294         {
10295           /* It's common practice (and completely valid) to have a const
10296              be initialized and declared extern.  */
10297           if (!(type_quals & TYPE_QUAL_CONST))
10298             warning ("`%s' initialized and declared `extern'", name);
10299         }
10300       else
10301         error ("`%s' has both `extern' and initializer", name);
10302     }
10303   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10304            && ! toplevel_bindings_p ())
10305     error ("nested function `%s' declared `extern'", name);
10306   else if (toplevel_bindings_p ())
10307     {
10308       if (RIDBIT_SETP (RID_AUTO, specbits))
10309         error ("top-level declaration of `%s' specifies `auto'", name);
10310     }
10311
10312   if (nclasses > 0 && friendp)
10313     error ("storage class specifiers invalid in friend function declarations");
10314
10315   /* Now figure out the structure of the declarator proper.
10316      Descend through it, creating more complex types, until we reach
10317      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10318
10319   inner_attrs = NULL_TREE;
10320   ignore_attrs = 0;
10321
10322   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10323          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10324     {
10325       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10326          an INDIRECT_REF (for *...),
10327          a CALL_EXPR (for ...(...)),
10328          an identifier (for the name being declared)
10329          or a null pointer (for the place in an absolute declarator
10330          where the name was omitted).
10331          For the last two cases, we have just exited the loop.
10332
10333          For C++ it could also be
10334          a SCOPE_REF (for class :: ...).  In this case, we have converted
10335          sensible names to types, and those are the values we use to
10336          qualify the member name.
10337          an ADDR_EXPR (for &...),
10338          a BIT_NOT_EXPR (for destructors)
10339
10340          At this point, TYPE is the type of elements of an array,
10341          or for a function to return, or for a pointer to point to.
10342          After this sequence of ifs, TYPE is the type of the
10343          array or function or pointer, and DECLARATOR has had its
10344          outermost layer removed.  */
10345
10346       if (type == error_mark_node)
10347         {
10348           if (TREE_CODE (declarator) == SCOPE_REF)
10349             declarator = TREE_OPERAND (declarator, 1);
10350           else
10351             declarator = TREE_OPERAND (declarator, 0);
10352           continue;
10353         }
10354       if (quals != NULL_TREE
10355           && (declarator == NULL_TREE
10356               || TREE_CODE (declarator) != SCOPE_REF))
10357         {
10358           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10359             ctype = TYPE_METHOD_BASETYPE (type);
10360           if (ctype != NULL_TREE)
10361             {
10362               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10363               grok_method_quals (ctype, dummy, quals);
10364               type = TREE_TYPE (dummy);
10365               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10366               quals = NULL_TREE;
10367             }
10368         }
10369
10370       /* See the comment for the TREE_LIST case, below.  */
10371       if (ignore_attrs)
10372         ignore_attrs = 0;
10373       else if (inner_attrs)
10374         {
10375           decl_attributes (&type, inner_attrs, 0);
10376           inner_attrs = NULL_TREE;
10377         }
10378
10379       switch (TREE_CODE (declarator))
10380         {
10381         case TREE_LIST:
10382           {
10383             /* We encode a declarator with embedded attributes using
10384                a TREE_LIST.  The attributes apply to the declarator
10385                directly inside them, so we have to skip an iteration
10386                before applying them to the type.  If the declarator just
10387                inside is the declarator-id, we apply the attrs to the
10388                decl itself.  */
10389             inner_attrs = TREE_PURPOSE (declarator);
10390             ignore_attrs = 1;
10391             declarator = TREE_VALUE (declarator);
10392           }
10393           break;
10394
10395         case ARRAY_REF:
10396           {
10397             register tree size;
10398
10399             size = TREE_OPERAND (declarator, 1);
10400
10401             /* VC++ spells a zero-sized array with [].  */
10402             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10403                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10404               size = integer_zero_node;
10405
10406             declarator = TREE_OPERAND (declarator, 0);
10407
10408             type = create_array_type_for_decl (dname, type, size);
10409
10410             /* VLAs never work as fields. */
10411             if (decl_context == FIELD && !processing_template_decl
10412                 && TREE_CODE (type) == ARRAY_TYPE
10413                 && TYPE_DOMAIN (type) != NULL_TREE
10414                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10415               {
10416                 cp_error ("size of member `%D' is not constant", dname);
10417                 /* Proceed with arbitrary constant size, so that offset
10418                    computations don't get confused. */
10419                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10420                                                    integer_one_node);
10421               }
10422
10423             ctype = NULL_TREE;
10424           }
10425           break;
10426
10427         case CALL_EXPR:
10428           {
10429             tree arg_types;
10430             int funcdecl_p;
10431             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10432             tree inner_decl = TREE_OPERAND (declarator, 0);
10433
10434             /* Declaring a function type.
10435                Make sure we have a valid type for the function to return.  */
10436
10437             /* We now know that the TYPE_QUALS don't apply to the
10438                decl, but to its return type.  */
10439             type_quals = TYPE_UNQUALIFIED;
10440
10441             /* Warn about some types functions can't return.  */
10442
10443             if (TREE_CODE (type) == FUNCTION_TYPE)
10444               {
10445                 error ("`%s' declared as function returning a function", name);
10446                 type = integer_type_node;
10447               }
10448             if (TREE_CODE (type) == ARRAY_TYPE)
10449               {
10450                 error ("`%s' declared as function returning an array", name);
10451                 type = integer_type_node;
10452               }
10453
10454             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10455               inner_decl = TREE_OPERAND (inner_decl, 1);
10456
10457             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10458               inner_decl = dname;
10459
10460             /* Pick up type qualifiers which should be applied to `this'.  */
10461             quals = CALL_DECLARATOR_QUALS (declarator);
10462
10463             /* Pick up the exception specifications.  */
10464             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10465
10466             /* Say it's a definition only for the CALL_EXPR
10467                closest to the identifier.  */
10468             funcdecl_p
10469               = inner_decl
10470               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10471                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10472                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10473
10474             if (ctype == NULL_TREE
10475                 && decl_context == FIELD
10476                 && funcdecl_p
10477                 && (friendp == 0 || dname == current_class_name))
10478               ctype = current_class_type;
10479
10480             if (ctype && sfk == sfk_conversion)
10481               TYPE_HAS_CONVERSION (ctype) = 1;
10482             if (ctype && constructor_name (ctype) == dname)
10483               {
10484                 /* We are within a class's scope. If our declarator name
10485                    is the same as the class name, and we are defining
10486                    a function, then it is a constructor/destructor, and
10487                    therefore returns a void type.  */
10488
10489                 if (flags == DTOR_FLAG)
10490                   {
10491                     /* ISO C++ 12.4/2.  A destructor may not be
10492                        declared const or volatile.  A destructor may
10493                        not be static.  */
10494                     if (staticp == 2)
10495                       error ("destructor cannot be static member function");
10496                     if (quals)
10497                       {
10498                         cp_error ("destructors may not be `%s'",
10499                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10500                         quals = NULL_TREE;
10501                       }
10502                     if (decl_context == FIELD)
10503                       {
10504                         if (! member_function_or_else (ctype,
10505                                                        current_class_type,
10506                                                        flags))
10507                           return void_type_node;
10508                       }
10509                   }
10510                 else            /* It's a constructor.  */
10511                   {
10512                     if (explicitp == 1)
10513                       explicitp = 2;
10514                     /* ISO C++ 12.1.  A constructor may not be
10515                        declared const or volatile.  A constructor may
10516                        not be virtual.  A constructor may not be
10517                        static.  */
10518                     if (staticp == 2)
10519                       error ("constructor cannot be static member function");
10520                     if (virtualp)
10521                       {
10522                         pedwarn ("constructors cannot be declared virtual");
10523                         virtualp = 0;
10524                       }
10525                     if (quals)
10526                       {
10527                         cp_error ("constructors may not be `%s'",
10528                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10529                         quals = NULL_TREE;
10530                       }
10531                     {
10532                       RID_BIT_TYPE tmp_bits;
10533                       memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
10534                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10535                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10536                       if (RIDBIT_ANY_SET (tmp_bits))
10537                         error ("return value type specifier for constructor ignored");
10538                     }
10539                     if (decl_context == FIELD)
10540                       {
10541                         if (! member_function_or_else (ctype,
10542                                                        current_class_type,
10543                                                        flags))
10544                           return void_type_node;
10545                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10546                         if (sfk != sfk_constructor)
10547                           return NULL_TREE;
10548                       }
10549                   }
10550                 if (decl_context == FIELD)
10551                   staticp = 0;
10552               }
10553             else if (friendp)
10554               {
10555                 if (initialized)
10556                   error ("can't initialize friend function `%s'", name);
10557                 if (virtualp)
10558                   {
10559                     /* Cannot be both friend and virtual.  */
10560                     error ("virtual functions cannot be friends");
10561                     RIDBIT_RESET (RID_FRIEND, specbits);
10562                     friendp = 0;
10563                   }
10564                 if (decl_context == NORMAL)
10565                   error ("friend declaration not in class definition");
10566                 if (current_function_decl && funcdef_flag)
10567                   cp_error ("can't define friend function `%s' in a local class definition",
10568                             name);
10569               }
10570
10571             /* Construct the function type and go to the next
10572                inner layer of declarator.  */
10573
10574             declarator = TREE_OPERAND (declarator, 0);
10575
10576             /* FIXME: This is where default args should be fully
10577                processed.  */
10578
10579             arg_types = grokparms (inner_parms);
10580
10581             if (declarator && flags == DTOR_FLAG)
10582               {
10583                 /* A destructor declared in the body of a class will
10584                    be represented as a BIT_NOT_EXPR.  But, we just
10585                    want the underlying IDENTIFIER.  */
10586                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10587                   declarator = TREE_OPERAND (declarator, 0);
10588
10589                 if (arg_types != void_list_node)
10590                   {
10591                     cp_error ("destructors may not have parameters");
10592                     arg_types = void_list_node;
10593                     last_function_parms = NULL_TREE;
10594                   }
10595               }
10596
10597             /* ANSI says that `const int foo ();'
10598                does not make the function foo const.  */
10599             type = build_function_type (type, arg_types);
10600
10601             {
10602               tree t;
10603               for (t = arg_types; t; t = TREE_CHAIN (t))
10604                 if (TREE_PURPOSE (t)
10605                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10606                   {
10607                     add_defarg_fn (type);
10608                     break;
10609                   }
10610             }
10611           }
10612           break;
10613
10614         case ADDR_EXPR:
10615         case INDIRECT_REF:
10616           /* Filter out pointers-to-references and references-to-references.
10617              We can get these if a TYPE_DECL is used.  */
10618
10619           if (TREE_CODE (type) == REFERENCE_TYPE)
10620             {
10621               error ("cannot declare %s to references",
10622                      TREE_CODE (declarator) == ADDR_EXPR
10623                      ? "references" : "pointers");
10624               declarator = TREE_OPERAND (declarator, 0);
10625               continue;
10626             }
10627
10628           if (TREE_CODE (type) == OFFSET_TYPE
10629               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10630                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10631             {
10632               cp_error ("cannot declare pointer to `%#T' member",
10633                         TREE_TYPE (type));
10634               type = TREE_TYPE (type);
10635             }
10636
10637           /* Merge any constancy or volatility into the target type
10638              for the pointer.  */
10639
10640           /* We now know that the TYPE_QUALS don't apply to the decl,
10641              but to the target of the pointer.  */
10642           type_quals = TYPE_UNQUALIFIED;
10643
10644           if (TREE_CODE (declarator) == ADDR_EXPR)
10645             {
10646               if (TREE_CODE (type) == VOID_TYPE)
10647                 error ("invalid type: `void &'");
10648               else
10649                 type = build_reference_type (type);
10650             }
10651           else if (TREE_CODE (type) == METHOD_TYPE)
10652             type = build_ptrmemfunc_type (build_pointer_type (type));
10653           else
10654             type = build_pointer_type (type);
10655
10656           /* Process a list of type modifier keywords (such as
10657              const or volatile) that were given inside the `*' or `&'.  */
10658
10659           if (TREE_TYPE (declarator))
10660             {
10661               register tree typemodlist;
10662               int erred = 0;
10663
10664               constp = 0;
10665               volatilep = 0;
10666               restrictp = 0;
10667               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10668                    typemodlist = TREE_CHAIN (typemodlist))
10669                 {
10670                   tree qualifier = TREE_VALUE (typemodlist);
10671
10672                   if (qualifier == ridpointers[(int) RID_CONST])
10673                     constp++;
10674                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10675                     volatilep++;
10676                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10677                     restrictp++;
10678                   else if (!erred)
10679                     {
10680                       erred = 1;
10681                       error ("invalid type modifier within pointer declarator");
10682                     }
10683                 }
10684               if (constp > 1)
10685                 pedwarn ("duplicate `const'");
10686               if (volatilep > 1)
10687                 pedwarn ("duplicate `volatile'");
10688               if (restrictp > 1)
10689                 pedwarn ("duplicate `restrict'");
10690
10691               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10692                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10693                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10694               if (TREE_CODE (declarator) == ADDR_EXPR
10695                   && (constp || volatilep))
10696                 {
10697                   if (constp)
10698                     pedwarn ("discarding `const' applied to a reference");
10699                   if (volatilep)
10700                     pedwarn ("discarding `volatile' applied to a reference");
10701                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10702                 }
10703               type = cp_build_qualified_type (type, type_quals);
10704             }
10705           declarator = TREE_OPERAND (declarator, 0);
10706           ctype = NULL_TREE;
10707           break;
10708
10709         case SCOPE_REF:
10710           {
10711             /* We have converted type names to NULL_TREE if the
10712                name was bogus, or to a _TYPE node, if not.
10713
10714                The variable CTYPE holds the type we will ultimately
10715                resolve to.  The code here just needs to build
10716                up appropriate member types.  */
10717             tree sname = TREE_OPERAND (declarator, 1);
10718             tree t;
10719
10720             /* Destructors can have their visibilities changed as well.  */
10721             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10722               sname = TREE_OPERAND (sname, 0);
10723
10724             if (TREE_COMPLEXITY (declarator) == 0)
10725               /* This needs to be here, in case we are called
10726                  multiple times.  */ ;
10727             else if (TREE_COMPLEXITY (declarator) == -1)
10728               /* Namespace member. */
10729               pop_decl_namespace ();
10730             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10731               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10732             else if (! IS_AGGR_TYPE_CODE
10733                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10734               ;
10735             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10736               {
10737                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10738                    that refer to ctype.  They couldn't be resolved earlier
10739                    because we hadn't pushed into the class yet.
10740                    Example: resolve 'B<T>::type' in
10741                    'B<typename B<T>::type> B<T>::f () { }'.  */
10742                 if (current_template_parms
10743                     && uses_template_parms (type)
10744                     && uses_template_parms (current_class_type))
10745                   {
10746                     tree args = current_template_args ();
10747                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10748                   }
10749
10750                 /* This pop_nested_class corresponds to the
10751                    push_nested_class used to push into class scope for
10752                    parsing the argument list of a function decl, in
10753                    qualified_id.  */
10754                 pop_nested_class ();
10755                 TREE_COMPLEXITY (declarator) = current_class_depth;
10756               }
10757             else
10758               my_friendly_abort (16);
10759
10760             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10761               {
10762                 /* We had a reference to a global decl, or
10763                    perhaps we were given a non-aggregate typedef,
10764                    in which case we cleared this out, and should just
10765                    keep going as though it wasn't there.  */
10766                 declarator = sname;
10767                 continue;
10768               }
10769             ctype = TREE_OPERAND (declarator, 0);
10770
10771             t = ctype;
10772             while (t != NULL_TREE && CLASS_TYPE_P (t))
10773               {
10774                 /* You're supposed to have one `template <...>'
10775                    for every template class, but you don't need one
10776                    for a full specialization.  For example:
10777
10778                      template <class T> struct S{};
10779                      template <> struct S<int> { void f(); };
10780                      void S<int>::f () {}
10781
10782                    is correct; there shouldn't be a `template <>' for
10783                    the definition of `S<int>::f'.  */
10784                 if (CLASSTYPE_TEMPLATE_INFO (t)
10785                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10786                         || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
10787                     && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
10788                   template_count += 1;
10789
10790                 t = TYPE_MAIN_DECL (t);
10791                 t = DECL_CONTEXT (t);
10792               }
10793
10794             if (sname == NULL_TREE)
10795               goto done_scoping;
10796
10797             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10798               {
10799                 /* This is the `standard' use of the scoping operator:
10800                    basetype :: member .  */
10801
10802                 if (ctype == current_class_type)
10803                   {
10804                     /* class A {
10805                          void A::f ();
10806                        };
10807
10808                        Is this ill-formed?  */
10809
10810                     if (pedantic)
10811                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10812                                   ctype, name);
10813                   }
10814                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10815                   {
10816                     if (current_class_type == NULL_TREE || friendp)
10817                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10818                                                       TYPE_ARG_TYPES (type));
10819                     else
10820                       {
10821                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10822                                   ctype, name, current_class_type);
10823                         return void_type_node;
10824                       }
10825                   }
10826                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10827                          || COMPLETE_TYPE_P (complete_type (ctype)))
10828                   {
10829                     /* Have to move this code elsewhere in this function.
10830                        this code is used for i.e., typedef int A::M; M *pm;
10831
10832                        It is?  How? jason 10/2/94 */
10833
10834                     if (current_class_type)
10835                       {
10836                         cp_error ("cannot declare member `%T::%s' within `%T'",
10837                                   ctype, name, current_class_type);
10838                         return void_type_node;
10839                       }
10840                     type = build_offset_type (ctype, type);
10841                   }
10842                 else
10843                   {
10844                     incomplete_type_error (NULL_TREE, ctype);
10845                     return error_mark_node;
10846                   }
10847
10848                 declarator = sname;
10849               }
10850             else if (TREE_CODE (sname) == SCOPE_REF)
10851               my_friendly_abort (17);
10852             else
10853               {
10854               done_scoping:
10855                 declarator = TREE_OPERAND (declarator, 1);
10856                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10857                   /* In this case, we will deal with it later.  */
10858                   ;
10859                 else
10860                   {
10861                     if (TREE_CODE (type) == FUNCTION_TYPE)
10862                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10863                                                       TYPE_ARG_TYPES (type));
10864                     else
10865                       type = build_offset_type (ctype, type);
10866                   }
10867               }
10868           }
10869           break;
10870
10871         case BIT_NOT_EXPR:
10872           declarator = TREE_OPERAND (declarator, 0);
10873           break;
10874
10875         case RECORD_TYPE:
10876         case UNION_TYPE:
10877         case ENUMERAL_TYPE:
10878           declarator = NULL_TREE;
10879           break;
10880
10881         case ERROR_MARK:
10882           declarator = NULL_TREE;
10883           break;
10884
10885         default:
10886           my_friendly_abort (158);
10887         }
10888     }
10889
10890   /* See the comment for the TREE_LIST case, above.  */
10891   if (inner_attrs)
10892     {
10893       if (! ignore_attrs)
10894         decl_attributes (&type, inner_attrs, 0);
10895       else if (attrlist)
10896         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10897       else
10898         attrlist = build_tree_list (NULL_TREE, inner_attrs);
10899     }
10900
10901   /* Now TYPE has the actual type.  */
10902
10903   if (explicitp == 1 || (explicitp && friendp))
10904     {
10905       /* [dcl.fct.spec] The explicit specifier shall only be used in
10906          declarations of constructors within a class definition.  */
10907       error ("only declarations of constructors can be `explicit'");
10908       explicitp = 0;
10909     }
10910
10911   if (RIDBIT_SETP (RID_MUTABLE, specbits))
10912     {
10913       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
10914         {
10915           error ("non-member `%s' cannot be declared `mutable'", name);
10916           RIDBIT_RESET (RID_MUTABLE, specbits);
10917         }
10918       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
10919         {
10920           error ("non-object member `%s' cannot be declared `mutable'", name);
10921           RIDBIT_RESET (RID_MUTABLE, specbits);
10922         }
10923       else if (TREE_CODE (type) == FUNCTION_TYPE
10924                || TREE_CODE (type) == METHOD_TYPE)
10925         {
10926           error ("function `%s' cannot be declared `mutable'", name);
10927           RIDBIT_RESET (RID_MUTABLE, specbits);
10928         }
10929       else if (staticp)
10930         {
10931           error ("static `%s' cannot be declared `mutable'", name);
10932           RIDBIT_RESET (RID_MUTABLE, specbits);
10933         }
10934       else if (type_quals & TYPE_QUAL_CONST)
10935         {
10936           error ("const `%s' cannot be declared `mutable'", name);
10937           RIDBIT_RESET (RID_MUTABLE, specbits);
10938         }
10939     }
10940
10941   if (declarator == NULL_TREE
10942       || TREE_CODE (declarator) == IDENTIFIER_NODE
10943       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
10944           && (TREE_CODE (type) == FUNCTION_TYPE
10945               || TREE_CODE (type) == METHOD_TYPE)))
10946     /* OK */;
10947   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10948     {
10949       cp_error ("template-id `%D' used as a declarator", declarator);
10950       declarator = dname;
10951     }
10952   else
10953     /* Unexpected declarator format.  */
10954     my_friendly_abort (990210);
10955
10956   /* If this is declaring a typedef name, return a TYPE_DECL.  */
10957
10958   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
10959     {
10960       tree decl;
10961
10962       /* Note that the grammar rejects storage classes
10963          in typenames, fields or parameters.  */
10964       if (current_lang_name == lang_name_java)
10965         TYPE_FOR_JAVA (type) = 1;
10966
10967       if (decl_context == FIELD)
10968         {
10969           if (declarator == constructor_name (current_class_type))
10970             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
10971                         declarator);
10972           decl = build_lang_decl (TYPE_DECL, declarator, type);
10973         }
10974       else
10975         {
10976           decl = build_decl (TYPE_DECL, declarator, type);
10977           if (!current_function_decl)
10978             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
10979         }
10980
10981       /* If the user declares "typedef struct {...} foo" then the
10982          struct will have an anonymous name.  Fill that name in now.
10983          Nothing can refer to it, so nothing needs know about the name
10984          change.  */
10985       if (type != error_mark_node
10986           && declarator
10987           && TYPE_NAME (type)
10988           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10989           && TYPE_ANONYMOUS_P (type)
10990           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
10991         {
10992           tree oldname = TYPE_NAME (type);
10993           tree t;
10994
10995           /* Replace the anonymous name with the real name everywhere.  */
10996           lookup_tag_reverse (type, declarator);
10997           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10998             if (TYPE_NAME (t) == oldname)
10999               TYPE_NAME (t) = decl;
11000
11001           if (TYPE_LANG_SPECIFIC (type))
11002             TYPE_WAS_ANONYMOUS (type) = 1;
11003
11004           /* If this is a typedef within a template class, the nested
11005              type is a (non-primary) template.  The name for the
11006              template needs updating as well.  */
11007           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11008             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11009               = TYPE_IDENTIFIER (type);
11010
11011           /* FIXME remangle member functions; member functions of a
11012              type with external linkage have external linkage.  */
11013         }
11014
11015       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11016         {
11017           cp_error_at ("typedef name may not be class-qualified", decl);
11018           return NULL_TREE;
11019         }
11020       else if (quals)
11021         {
11022           if (ctype == NULL_TREE)
11023             {
11024               if (TREE_CODE (type) != METHOD_TYPE)
11025                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11026               else
11027                 ctype = TYPE_METHOD_BASETYPE (type);
11028             }
11029           if (ctype != NULL_TREE)
11030             grok_method_quals (ctype, decl, quals);
11031         }
11032
11033       if (RIDBIT_SETP (RID_SIGNED, specbits)
11034           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11035         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11036
11037       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11038                       inlinep, friendp, raises != NULL_TREE);
11039
11040       if (initialized)
11041         error ("typedef declaration includes an initializer");
11042
11043       return decl;
11044     }
11045
11046   /* Detect the case of an array type of unspecified size
11047      which came, as such, direct from a typedef name.
11048      We must copy the type, so that each identifier gets
11049      a distinct type, so that each identifier's size can be
11050      controlled separately by its own initializer.  */
11051
11052   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11053       && TYPE_DOMAIN (type) == NULL_TREE)
11054     {
11055       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11056     }
11057
11058   /* Detect where we're using a typedef of function type to declare a
11059      function. last_function_parms will not be set, so we must create
11060      it now.  */
11061
11062   if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
11063     {
11064       tree decls = NULL_TREE;
11065       tree args;
11066
11067       for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
11068         {
11069           tree decl = build_decl (PARM_DECL, NULL_TREE, TREE_VALUE (args));
11070
11071           TREE_CHAIN (decl) = decls;
11072           decls = decl;
11073         }
11074
11075       last_function_parms = nreverse (decls);
11076     }
11077
11078   /* If this is a type name (such as, in a cast or sizeof),
11079      compute the type and return it now.  */
11080
11081   if (decl_context == TYPENAME)
11082     {
11083       /* Note that the grammar rejects storage classes
11084          in typenames, fields or parameters.  */
11085       if (type_quals != TYPE_UNQUALIFIED)
11086         type_quals = TYPE_UNQUALIFIED;
11087
11088       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11089       if (friendp)
11090         {
11091           if (type_quals != TYPE_UNQUALIFIED)
11092             {
11093               cp_error ("type qualifiers specified for friend class declaration");
11094               type_quals = TYPE_UNQUALIFIED;
11095             }
11096           if (inlinep)
11097             {
11098               cp_error ("`inline' specified for friend class declaration");
11099               inlinep = 0;
11100             }
11101
11102           /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11103              But don't allow implicit typenames except with a class-key.  */
11104           if (!current_aggr && (TREE_CODE (type) != TYPENAME_TYPE
11105                                 || IMPLICIT_TYPENAME_P (type)))
11106             {
11107               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11108                 cp_pedwarn ("template parameters cannot be friends");
11109               else if (TREE_CODE (type) == TYPENAME_TYPE)
11110                 cp_pedwarn ("\
11111 friend declaration requires class-key, i.e. `friend class %T::%T'",
11112                             constructor_name (current_class_type),
11113                             TYPE_IDENTIFIER (type));
11114               else
11115                 cp_pedwarn ("\
11116 friend declaration requires class-key, i.e. `friend %#T'",
11117                             type);
11118             }
11119
11120           /* Only try to do this stuff if we didn't already give up.  */
11121           if (type != integer_type_node)
11122             {
11123               /* DR 209. The friendly class does not need to be accessible
11124                  in the scope of the class granting friendship. */
11125               skip_type_access_control ();
11126
11127               /* A friendly class?  */
11128               if (current_class_type)
11129                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11130               else
11131                 cp_error ("trying to make class `%T' a friend of global scope",
11132                           type);
11133
11134               type = void_type_node;
11135             }
11136         }
11137       else if (quals)
11138         {
11139           if (ctype == NULL_TREE)
11140             {
11141               if (TREE_CODE (type) != METHOD_TYPE)
11142                 cp_error ("invalid qualifiers on non-member function type");
11143               else
11144                 ctype = TYPE_METHOD_BASETYPE (type);
11145             }
11146           if (ctype)
11147             {
11148               tree dummy = build_decl (TYPE_DECL, declarator, type);
11149               grok_method_quals (ctype, dummy, quals);
11150               type = TREE_TYPE (dummy);
11151             }
11152         }
11153
11154       return type;
11155     }
11156   else if (declarator == NULL_TREE && decl_context != PARM
11157            && decl_context != CATCHPARM
11158            && TREE_CODE (type) != UNION_TYPE
11159            && ! bitfield)
11160     {
11161       cp_error ("abstract declarator `%T' used as declaration", type);
11162       declarator = make_anon_name ();
11163     }
11164
11165   /* `void' at top level (not within pointer)
11166      is allowed only in typedefs or type names.
11167      We don't complain about parms either, but that is because
11168      a better error message can be made later.  */
11169
11170   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11171     {
11172       if (! declarator)
11173         error ("unnamed variable or field declared void");
11174       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11175         {
11176           if (IDENTIFIER_OPNAME_P (declarator))
11177             my_friendly_abort (356);
11178           else
11179             error ("variable or field `%s' declared void", name);
11180         }
11181       else
11182         error ("variable or field declared void");
11183       type = integer_type_node;
11184     }
11185
11186   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11187      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11188
11189   if (decl_context == PARM || decl_context == CATCHPARM)
11190     {
11191       if (ctype || in_namespace)
11192         error ("cannot use `::' in parameter declaration");
11193
11194       /* A parameter declared as an array of T is really a pointer to T.
11195          One declared as a function is really a pointer to a function.
11196          One declared as a member is really a pointer to member.  */
11197
11198       if (TREE_CODE (type) == ARRAY_TYPE)
11199         {
11200           /* Transfer const-ness of array into that of type pointed to.  */
11201           type = build_pointer_type (TREE_TYPE (type));
11202           type_quals = TYPE_UNQUALIFIED;
11203         }
11204       else if (TREE_CODE (type) == FUNCTION_TYPE)
11205         type = build_pointer_type (type);
11206       else if (TREE_CODE (type) == OFFSET_TYPE)
11207         type = build_pointer_type (type);
11208     }
11209
11210   {
11211     register tree decl;
11212
11213     if (decl_context == PARM)
11214       {
11215         decl = build_decl (PARM_DECL, declarator, type);
11216
11217         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11218                         inlinep, friendp, raises != NULL_TREE);
11219
11220         /* Compute the type actually passed in the parmlist,
11221            for the case where there is no prototype.
11222            (For example, shorts and chars are passed as ints.)
11223            When there is a prototype, this is overridden later.  */
11224
11225         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11226       }
11227     else if (decl_context == FIELD)
11228       {
11229         if (type == error_mark_node)
11230           {
11231             /* Happens when declaring arrays of sizes which
11232                are error_mark_node, for example.  */
11233             decl = NULL_TREE;
11234           }
11235         else if (in_namespace && !friendp)
11236           {
11237             /* Something like struct S { int N::j; };  */
11238             cp_error ("invalid use of `::'");
11239             decl = NULL_TREE;
11240           }
11241         else if (TREE_CODE (type) == FUNCTION_TYPE)
11242           {
11243             int publicp = 0;
11244             tree function_context;
11245
11246             /* We catch the others as conflicts with the builtin
11247                typedefs.  */
11248             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11249               {
11250                 cp_error ("function `%D' cannot be declared friend",
11251                           declarator);
11252                 friendp = 0;
11253               }
11254
11255             if (friendp == 0)
11256               {
11257                 if (ctype == NULL_TREE)
11258                   ctype = current_class_type;
11259
11260                 if (ctype == NULL_TREE)
11261                   {
11262                     cp_error ("can't make `%D' into a method -- not in a class",
11263                               declarator);
11264                     return void_type_node;
11265                   }
11266
11267                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11268                    ARM 9.5 */
11269                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11270                   {
11271                     cp_error ("function `%D' declared virtual inside a union",
11272                               declarator);
11273                     return void_type_node;
11274                   }
11275
11276                 if (declarator == ansi_opname (NEW_EXPR)
11277                     || declarator == ansi_opname (VEC_NEW_EXPR)
11278                     || declarator == ansi_opname (DELETE_EXPR)
11279                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11280                   {
11281                     if (virtualp)
11282                       {
11283                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11284                                   declarator);
11285                         virtualp = 0;
11286                       }
11287                   }
11288                 else if (staticp < 2)
11289                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11290                                                   TYPE_ARG_TYPES (type));
11291               }
11292
11293             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11294             function_context = (ctype != NULL_TREE) ?
11295               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11296             publicp = (! friendp || ! staticp)
11297               && function_context == NULL_TREE;
11298             decl = grokfndecl (ctype, type,
11299                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11300                                ? declarator : dname,
11301                                declarator,
11302                                virtualp, flags, quals, raises,
11303                                friendp ? -1 : 0, friendp, publicp, inlinep,
11304                                funcdef_flag, template_count, in_namespace);
11305             if (decl == NULL_TREE)
11306               return decl;
11307 #if 0
11308             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11309             /* The decl and setting of decl_machine_attr is also turned off.  */
11310             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11311 #endif
11312
11313             /* [class.conv.ctor]
11314
11315                A constructor declared without the function-specifier
11316                explicit that can be called with a single parameter
11317                specifies a conversion from the type of its first
11318                parameter to the type of its class.  Such a constructor
11319                is called a converting constructor.  */
11320             if (explicitp == 2)
11321               DECL_NONCONVERTING_P (decl) = 1;
11322             else if (DECL_CONSTRUCTOR_P (decl))
11323               {
11324                 /* The constructor can be called with exactly one
11325                    parameter if there is at least one parameter, and
11326                    any subsequent parameters have default arguments.
11327                    Ignore any compiler-added parms.  */
11328                 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
11329
11330                 if (arg_types == void_list_node
11331                     || (arg_types
11332                         && TREE_CHAIN (arg_types)
11333                         && TREE_CHAIN (arg_types) != void_list_node
11334                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11335                   DECL_NONCONVERTING_P (decl) = 1;
11336               }
11337           }
11338         else if (TREE_CODE (type) == METHOD_TYPE)
11339           {
11340             /* We only get here for friend declarations of
11341                members of other classes.  */
11342             /* All method decls are public, so tell grokfndecl to set
11343                TREE_PUBLIC, also.  */
11344             decl = grokfndecl (ctype, type, declarator, declarator,
11345                                virtualp, flags, quals, raises,
11346                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11347                                template_count, in_namespace);
11348             if (decl == NULL_TREE)
11349               return NULL_TREE;
11350           }
11351         else if (!staticp && ! processing_template_decl
11352                  && !COMPLETE_TYPE_P (complete_type (type))
11353                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11354           {
11355             if (declarator)
11356               cp_error ("field `%D' has incomplete type", declarator);
11357             else
11358               cp_error ("name `%T' has incomplete type", type);
11359
11360             /* If we're instantiating a template, tell them which
11361                instantiation made the field's type be incomplete.  */
11362             if (current_class_type
11363                 && TYPE_NAME (current_class_type)
11364                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11365                 && declspecs && TREE_VALUE (declspecs)
11366                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11367               cp_error ("  in instantiation of template `%T'",
11368                         current_class_type);
11369
11370             type = error_mark_node;
11371             decl = NULL_TREE;
11372           }
11373         else
11374           {
11375             if (friendp)
11376               {
11377                 error ("`%s' is neither function nor member function; cannot be declared friend",
11378                        IDENTIFIER_POINTER (declarator));
11379                 friendp = 0;
11380               }
11381             decl = NULL_TREE;
11382           }
11383
11384         if (friendp)
11385           {
11386             /* Friends are treated specially.  */
11387             tree t = NULL_TREE;
11388
11389             /* DR 209. The friend does not need to be accessible at this
11390                point. */
11391             skip_type_access_control ();
11392
11393             if (ctype == current_class_type)
11394               warning ("member functions are implicitly friends of their class");
11395
11396             if (decl && DECL_NAME (decl))
11397               {
11398                 if (template_class_depth (current_class_type) == 0)
11399                   {
11400                     decl = check_explicit_specialization
11401                             (declarator, decl,
11402                              template_count, 2 * (funcdef_flag != 0) + 4);
11403                     if (decl == error_mark_node)
11404                       return error_mark_node;
11405                   }
11406
11407                 t = do_friend (ctype, declarator, decl,
11408                                last_function_parms, attrlist, flags, quals,
11409                                funcdef_flag);
11410               }
11411             if (t && funcdef_flag)
11412               return t;
11413             return void_type_node;
11414           }
11415
11416         /* Structure field.  It may not be a function, except for C++ */
11417
11418         if (decl == NULL_TREE)
11419           {
11420             if (initialized)
11421               {
11422                 if (!staticp)
11423                   {
11424                     /* An attempt is being made to initialize a non-static
11425                        member.  But, from [class.mem]:
11426
11427                        4 A member-declarator can contain a
11428                        constant-initializer only if it declares a static
11429                        member (_class.static_) of integral or enumeration
11430                        type, see _class.static.data_.
11431
11432                        This used to be relatively common practice, but
11433                        the rest of the compiler does not correctly
11434                        handle the initialization unless the member is
11435                        static so we make it static below.  */
11436                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11437                                 declarator);
11438                     cp_pedwarn ("making `%D' static", declarator);
11439                     staticp = 1;
11440                   }
11441
11442                 if (uses_template_parms (type))
11443                   /* We'll check at instantiation time.  */
11444                   ;
11445                 else if (check_static_variable_definition (declarator,
11446                                                            type))
11447                   /* If we just return the declaration, crashes
11448                      will sometimes occur.  We therefore return
11449                      void_type_node, as if this was a friend
11450                      declaration, to cause callers to completely
11451                      ignore this declaration.  */
11452                   return void_type_node;
11453               }
11454
11455             /* 9.2p13 [class.mem] */
11456             if (declarator == constructor_name (current_class_type)
11457                 /* The standard does not allow non-static data members
11458                    here either, but we agreed at the 10/99 meeting
11459                    to change that in TC 1 so that they are allowed in
11460                    classes with no user-defined constructors.  */
11461                 && staticp)
11462               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11463                           declarator);
11464
11465             if (staticp)
11466               {
11467                 /* C++ allows static class members.  All other work
11468                    for this is done by grokfield.  */
11469                 decl = build_lang_decl (VAR_DECL, declarator, type);
11470                 TREE_STATIC (decl) = 1;
11471                 /* In class context, 'static' means public access.  */
11472                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11473               }
11474             else
11475               {
11476                 decl = build_decl (FIELD_DECL, declarator, type);
11477                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11478                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11479                   {
11480                     DECL_MUTABLE_P (decl) = 1;
11481                     RIDBIT_RESET (RID_MUTABLE, specbits);
11482                   }
11483               }
11484
11485             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11486                             inlinep, friendp, raises != NULL_TREE);
11487           }
11488       }
11489     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11490       {
11491         tree original_name;
11492         int publicp = 0;
11493
11494         if (! declarator)
11495           return NULL_TREE;
11496
11497         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11498           original_name = dname;
11499         else
11500           original_name = declarator;
11501
11502         if (RIDBIT_SETP (RID_AUTO, specbits))
11503           error ("storage class `auto' invalid for function `%s'", name);
11504         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11505           error ("storage class `register' invalid for function `%s'", name);
11506
11507         /* Function declaration not at top level.
11508            Storage classes other than `extern' are not allowed
11509            and `extern' makes no difference.  */
11510         if (! toplevel_bindings_p ()
11511             && (RIDBIT_SETP (RID_STATIC, specbits)
11512                 || RIDBIT_SETP (RID_INLINE, specbits))
11513             && pedantic)
11514           {
11515             if (RIDBIT_SETP (RID_STATIC, specbits))
11516               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11517             else
11518               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11519           }
11520
11521         if (ctype == NULL_TREE)
11522           {
11523             if (virtualp)
11524               {
11525                 error ("virtual non-class function `%s'", name);
11526                 virtualp = 0;
11527               }
11528           }
11529         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11530           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11531                                           TYPE_ARG_TYPES (type));
11532
11533         /* Record presence of `static'.  */
11534         publicp = (ctype != NULL_TREE
11535                    || RIDBIT_SETP (RID_EXTERN, specbits)
11536                    || !RIDBIT_SETP (RID_STATIC, specbits));
11537
11538         decl = grokfndecl (ctype, type, original_name, declarator,
11539                            virtualp, flags, quals, raises,
11540                            1, friendp,
11541                            publicp, inlinep, funcdef_flag,
11542                            template_count, in_namespace);
11543         if (decl == NULL_TREE)
11544           return NULL_TREE;
11545
11546         if (staticp == 1)
11547           {
11548             int illegal_static = 0;
11549
11550             /* Don't allow a static member function in a class, and forbid
11551                declaring main to be static.  */
11552             if (TREE_CODE (type) == METHOD_TYPE)
11553               {
11554                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11555                 illegal_static = 1;
11556               }
11557             else if (current_function_decl)
11558               {
11559                 /* FIXME need arm citation */
11560                 error ("cannot declare static function inside another function");
11561                 illegal_static = 1;
11562               }
11563
11564             if (illegal_static)
11565               {
11566                 staticp = 0;
11567                 RIDBIT_RESET (RID_STATIC, specbits);
11568               }
11569           }
11570       }
11571     else
11572       {
11573         /* It's a variable.  */
11574
11575         /* An uninitialized decl with `extern' is a reference.  */
11576         decl = grokvardecl (type, declarator, &specbits,
11577                             initialized,
11578                             (type_quals & TYPE_QUAL_CONST) != 0,
11579                             in_namespace);
11580         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11581                         inlinep, friendp, raises != NULL_TREE);
11582
11583         if (ctype)
11584           {
11585             DECL_CONTEXT (decl) = ctype;
11586             if (staticp == 1)
11587               {
11588                 cp_pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
11589                 staticp = 0;
11590                 RIDBIT_RESET (RID_STATIC, specbits);
11591               }
11592             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11593               {
11594                 cp_error ("static member `%D' declared `register'", decl);
11595                 RIDBIT_RESET (RID_REGISTER, specbits);
11596               }
11597             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11598               {
11599                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11600                             decl);
11601                 RIDBIT_RESET (RID_EXTERN, specbits);
11602               }
11603           }
11604       }
11605
11606     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11607
11608     /* Record `register' declaration for warnings on &
11609        and in case doing stupid register allocation.  */
11610
11611     if (RIDBIT_SETP (RID_REGISTER, specbits))
11612       DECL_REGISTER (decl) = 1;
11613
11614     if (RIDBIT_SETP (RID_EXTERN, specbits))
11615       DECL_THIS_EXTERN (decl) = 1;
11616
11617     if (RIDBIT_SETP (RID_STATIC, specbits))
11618       DECL_THIS_STATIC (decl) = 1;
11619
11620     /* Record constancy and volatility.  There's no need to do this
11621        when processing a template; we'll do this for the instantiated
11622        declaration based on the type of DECL.  */
11623     if (!processing_template_decl)
11624       c_apply_type_quals_to_decl (type_quals, decl);
11625
11626     return decl;
11627   }
11628 }
11629 \f
11630 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11631    An empty exprlist is a parmlist.  An exprlist which
11632    contains only identifiers at the global level
11633    is a parmlist.  Otherwise, it is an exprlist.  */
11634
11635 int
11636 parmlist_is_exprlist (exprs)
11637      tree exprs;
11638 {
11639   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11640     return 0;
11641
11642   if (toplevel_bindings_p ())
11643     {
11644       /* At the global level, if these are all identifiers,
11645          then it is a parmlist.  */
11646       while (exprs)
11647         {
11648           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11649             return 1;
11650           exprs = TREE_CHAIN (exprs);
11651         }
11652       return 0;
11653     }
11654   return 1;
11655 }
11656
11657 /* Subroutine of start_function.  Ensure that each of the parameter
11658    types (as listed in PARMS) is complete, as is required for a
11659    function definition.  */
11660
11661 static void
11662 require_complete_types_for_parms (parms)
11663      tree parms;
11664 {
11665   for (; parms; parms = TREE_CHAIN (parms))
11666     {
11667       if (VOID_TYPE_P (TREE_TYPE (parms)))
11668         /* grokparms will have already issued an error */
11669         TREE_TYPE (parms) = error_mark_node;
11670       else if (complete_type_or_else (TREE_TYPE (parms), parms))
11671         layout_decl (parms, 0);
11672       else
11673         TREE_TYPE (parms) = error_mark_node;
11674     }
11675 }
11676
11677 /* Returns non-zero if T is a local variable.  */
11678
11679 int
11680 local_variable_p (t)
11681      tree t;
11682 {
11683   if ((TREE_CODE (t) == VAR_DECL
11684        /* A VAR_DECL with a context that is a _TYPE is a static data
11685           member.  */
11686        && !TYPE_P (CP_DECL_CONTEXT (t))
11687        /* Any other non-local variable must be at namespace scope.  */
11688        && !DECL_NAMESPACE_SCOPE_P (t))
11689       || (TREE_CODE (t) == PARM_DECL))
11690     return 1;
11691
11692   return 0;
11693 }
11694
11695 /* Returns non-zero if T is an automatic local variable or a label.
11696    (These are the declarations that need to be remapped when the code
11697    containing them is duplicated.)  */
11698
11699 int
11700 nonstatic_local_decl_p (t)
11701      tree t;
11702 {
11703   return ((local_variable_p (t) && !TREE_STATIC (t))
11704           || TREE_CODE (t) == LABEL_DECL
11705           || TREE_CODE (t) == RESULT_DECL);
11706 }
11707
11708 /* Like local_variable_p, but suitable for use as a tree-walking
11709    function.  */
11710
11711 static tree
11712 local_variable_p_walkfn (tp, walk_subtrees, data)
11713      tree *tp;
11714      int *walk_subtrees ATTRIBUTE_UNUSED;
11715      void *data ATTRIBUTE_UNUSED;
11716 {
11717   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11718           ? *tp : NULL_TREE);
11719 }
11720
11721 /* Check that ARG, which is a default-argument expression for a
11722    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11723    something goes wrong.  DECL may also be a _TYPE node, rather than a
11724    DECL, if there is no DECL available.  */
11725
11726 tree
11727 check_default_argument (decl, arg)
11728      tree decl;
11729      tree arg;
11730 {
11731   tree var;
11732   tree decl_type;
11733
11734   if (TREE_CODE (arg) == DEFAULT_ARG)
11735     /* We get a DEFAULT_ARG when looking at an in-class declaration
11736        with a default argument.  Ignore the argument for now; we'll
11737        deal with it after the class is complete.  */
11738     return arg;
11739
11740   if (processing_template_decl || uses_template_parms (arg))
11741     /* We don't do anything checking until instantiation-time.  Note
11742        that there may be uninstantiated arguments even for an
11743        instantiated function, since default arguments are not
11744        instantiated until they are needed.  */
11745     return arg;
11746
11747   if (TYPE_P (decl))
11748     {
11749       decl_type = decl;
11750       decl = NULL_TREE;
11751     }
11752   else
11753     decl_type = TREE_TYPE (decl);
11754
11755   if (arg == error_mark_node
11756       || decl == error_mark_node
11757       || TREE_TYPE (arg) == error_mark_node
11758       || decl_type == error_mark_node)
11759     /* Something already went wrong.  There's no need to check
11760        further.  */
11761     return error_mark_node;
11762
11763   /* [dcl.fct.default]
11764
11765      A default argument expression is implicitly converted to the
11766      parameter type.  */
11767   if (!TREE_TYPE (arg)
11768       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11769     {
11770       if (decl)
11771         cp_error ("default argument for `%#D' has type `%T'",
11772                   decl, TREE_TYPE (arg));
11773       else
11774         cp_error ("default argument for parameter of type `%T' has type `%T'",
11775                   decl_type, TREE_TYPE (arg));
11776
11777       return error_mark_node;
11778     }
11779
11780   /* [dcl.fct.default]
11781
11782      Local variables shall not be used in default argument
11783      expressions.
11784
11785      The keyword `this' shall not be used in a default argument of a
11786      member function.  */
11787   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
11788                                       NULL);
11789   if (var)
11790     {
11791       cp_error ("default argument `%E' uses local variable `%D'",
11792                 arg, var);
11793       return error_mark_node;
11794     }
11795
11796   /* All is well.  */
11797   return arg;
11798 }
11799
11800 /* Decode the list of parameter types for a function type.
11801    Given the list of things declared inside the parens,
11802    return a list of types.
11803
11804    We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
11805    flag. If unset, we append void_list_node. A parmlist declared
11806    as `(void)' is accepted as the empty parmlist.
11807
11808    Also set last_function_parms to the chain of PARM_DECLs.  */
11809
11810 static tree
11811 grokparms (first_parm)
11812      tree first_parm;
11813 {
11814   tree result = NULL_TREE;
11815   tree decls = NULL_TREE;
11816   int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
11817   tree parm, chain;
11818   int any_error = 0;
11819
11820   my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
11821
11822   for (parm = first_parm; parm != NULL_TREE; parm = chain)
11823     {
11824       tree type = NULL_TREE;
11825       register tree decl = TREE_VALUE (parm);
11826       tree init = TREE_PURPOSE (parm);
11827
11828       chain = TREE_CHAIN (parm);
11829       /* @@ weak defense against parse errors.  */
11830       if (TREE_CODE (decl) != VOID_TYPE
11831           && TREE_CODE (decl) != TREE_LIST)
11832         {
11833           /* Give various messages as the need arises.  */
11834           if (TREE_CODE (decl) == STRING_CST)
11835             cp_error ("invalid string constant `%E'", decl);
11836           else if (TREE_CODE (decl) == INTEGER_CST)
11837             error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11838           continue;
11839         }
11840
11841       if (parm == void_list_node)
11842         break;
11843
11844       decl = grokdeclarator (TREE_VALUE (decl), TREE_PURPOSE (decl),
11845                      PARM, init != NULL_TREE, NULL_TREE);
11846       if (! decl || TREE_TYPE (decl) == error_mark_node)
11847         continue;
11848
11849       type = TREE_TYPE (decl);
11850       if (VOID_TYPE_P (type))
11851         {
11852           if (same_type_p (type, void_type_node)
11853               && !DECL_NAME (decl) && !result && !chain && !ellipsis)
11854             /* this is a parmlist of `(void)', which is ok.  */
11855             break;
11856           incomplete_type_error (decl, type);
11857           /* It's not a good idea to actually create parameters of
11858              type `void'; other parts of the compiler assume that a
11859              void type terminates the parameter list.  */
11860           type = error_mark_node;
11861           TREE_TYPE (decl) = error_mark_node;
11862         }
11863
11864       if (type != error_mark_node)
11865         {
11866           /* Top-level qualifiers on the parameters are
11867              ignored for function types.  */
11868           type = TYPE_MAIN_VARIANT (type);
11869           if (TREE_CODE (type) == METHOD_TYPE)
11870             {
11871               cp_error ("parameter `%D' invalidly declared method type", decl);
11872               type = build_pointer_type (type);
11873               TREE_TYPE (decl) = type;
11874             }
11875           else if (TREE_CODE (type) == OFFSET_TYPE)
11876             {
11877               cp_error ("parameter `%D' invalidly declared offset type", decl);
11878               type = build_pointer_type (type);
11879               TREE_TYPE (decl) = type;
11880             }
11881           else if (abstract_virtuals_error (decl, type))
11882             any_error = 1;  /* Seems like a good idea. */
11883           else if (POINTER_TYPE_P (type))
11884             {
11885               /* [dcl.fct]/6, parameter types cannot contain pointers
11886                  (references) to arrays of unknown bound.  */
11887               tree t = TREE_TYPE (type);
11888               int ptr = TYPE_PTR_P (type);
11889
11890               while (1)
11891                 {
11892                   if (TYPE_PTR_P (t))
11893                     ptr = 1;
11894                   else if (TREE_CODE (t) != ARRAY_TYPE)
11895                     break;
11896                   else if (!TYPE_DOMAIN (t))
11897                     break;
11898                   t = TREE_TYPE (t);
11899                 }
11900               if (TREE_CODE (t) == ARRAY_TYPE)
11901                 cp_error ("parameter `%D' includes %s to array of unknown bound `%T'",
11902                           decl, ptr ? "pointer" : "reference", t);
11903             }
11904
11905           DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11906           if (PROMOTE_PROTOTYPES
11907               && INTEGRAL_TYPE_P (type)
11908               && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11909             DECL_ARG_TYPE (decl) = integer_type_node;
11910           if (!any_error && init)
11911             init = check_default_argument (decl, init);
11912           else
11913             init = NULL_TREE;
11914         }
11915
11916       TREE_CHAIN (decl) = decls;
11917       decls = decl;
11918       result = tree_cons (init, type, result);
11919     }
11920   decls = nreverse (decls);
11921   result = nreverse (result);
11922   if (!ellipsis)
11923     result = chainon (result, void_list_node);
11924   last_function_parms = decls;
11925
11926   return result;
11927 }
11928
11929 \f
11930 /* D is a constructor or overloaded `operator='.  Returns non-zero if
11931    D's arguments allow it to be a copy constructor, or copy assignment
11932    operator.  */
11933
11934 int
11935 copy_args_p (d)
11936      tree d;
11937 {
11938   tree t;
11939
11940   if (!DECL_FUNCTION_MEMBER_P (d))
11941     return 0;
11942
11943   t = FUNCTION_FIRST_USER_PARMTYPE (d);
11944   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
11945       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
11946           == DECL_CONTEXT (d))
11947       && (TREE_CHAIN (t) == NULL_TREE
11948           || TREE_CHAIN (t) == void_list_node
11949           || TREE_PURPOSE (TREE_CHAIN (t))))
11950     return 1;
11951   return 0;
11952 }
11953
11954 /* These memoizing functions keep track of special properties which
11955    a class may have.  `grok_ctor_properties' notices whether a class
11956    has a constructor of the form X(X&), and also complains
11957    if the class has a constructor of the form X(X).
11958    `grok_op_properties' takes notice of the various forms of
11959    operator= which are defined, as well as what sorts of type conversion
11960    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
11961
11962 int
11963 grok_ctor_properties (ctype, decl)
11964      tree ctype, decl;
11965 {
11966   tree parmtypes = FUNCTION_FIRST_USER_PARMTYPE (decl);
11967   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
11968
11969   /* [class.copy]
11970
11971      A non-template constructor for class X is a copy constructor if
11972      its first parameter is of type X&, const X&, volatile X& or const
11973      volatile X&, and either there are no other parameters or else all
11974      other parameters have default arguments.  */
11975   if (TREE_CODE (parmtype) == REFERENCE_TYPE
11976       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
11977       && sufficient_parms_p (TREE_CHAIN (parmtypes))
11978       && !(DECL_TEMPLATE_INSTANTIATION (decl)
11979            && is_member_template (DECL_TI_TEMPLATE (decl))))
11980     {
11981       TYPE_HAS_INIT_REF (ctype) = 1;
11982       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
11983         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
11984     }
11985   /* [class.copy]
11986
11987      A declaration of a constructor for a class X is ill-formed if its
11988      first parameter is of type (optionally cv-qualified) X and either
11989      there are no other parameters or else all other parameters have
11990      default arguments.
11991
11992      We *don't* complain about member template instantiations that
11993      have this form, though; they can occur as we try to decide what
11994      constructor to use during overload resolution.  Since overload
11995      resolution will never prefer such a constructor to the
11996      non-template copy constructor (which is either explicitly or
11997      implicitly defined), there's no need to worry about their
11998      existence.  Theoretically, they should never even be
11999      instantiated, but that's hard to forestall.  */
12000   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12001            && sufficient_parms_p (TREE_CHAIN (parmtypes))
12002            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12003                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12004     {
12005       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12006                 ctype, ctype);
12007       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12008       return 0;
12009     }
12010   else if (TREE_CODE (parmtype) == VOID_TYPE
12011            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12012     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12013
12014   return 1;
12015 }
12016
12017 /* An operator with this code is unary, but can also be binary.  */
12018
12019 static int
12020 ambi_op_p (code)
12021      enum tree_code code;
12022 {
12023   return (code == INDIRECT_REF
12024           || code == ADDR_EXPR
12025           || code == CONVERT_EXPR
12026           || code == NEGATE_EXPR
12027           || code == PREINCREMENT_EXPR
12028           || code == PREDECREMENT_EXPR);
12029 }
12030
12031 /* An operator with this name can only be unary.  */
12032
12033 static int
12034 unary_op_p (code)
12035      enum tree_code code;
12036 {
12037   return (code == TRUTH_NOT_EXPR
12038           || code == BIT_NOT_EXPR
12039           || code == COMPONENT_REF
12040           || code == TYPE_EXPR);
12041 }
12042
12043 /* Do a little sanity-checking on how they declared their operator.  */
12044
12045 void
12046 grok_op_properties (decl, virtualp, friendp)
12047      tree decl;
12048      int virtualp, friendp;
12049 {
12050   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12051   tree argtype;
12052   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12053   tree name = DECL_NAME (decl);
12054   enum tree_code operator_code;
12055   int arity;
12056
12057   /* Count the number of arguments.  */
12058   for (argtype = argtypes, arity = 0;
12059        argtype && argtype != void_list_node;
12060        argtype = TREE_CHAIN (argtype))
12061     ++arity;
12062
12063   if (current_class_type == NULL_TREE)
12064     friendp = 1;
12065
12066   if (DECL_CONV_FN_P (decl))
12067     operator_code = TYPE_EXPR;
12068   else
12069     do
12070       {
12071 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)       \
12072         if (ansi_opname (CODE) == name)                         \
12073           {                                                     \
12074             operator_code = CODE;                               \
12075             break;                                              \
12076           }                                                     \
12077         else if (ansi_assopname (CODE) == name)                 \
12078           {                                                     \
12079             operator_code = CODE;                               \
12080             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;              \
12081             break;                                              \
12082           }
12083
12084 #include "operators.def"
12085 #undef DEF_OPERATOR
12086
12087         my_friendly_abort (20000527);
12088       }
12089     while (0);
12090   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12091   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12092
12093   if (! friendp)
12094     {
12095       switch (operator_code)
12096         {
12097         case CALL_EXPR:
12098           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12099           break;
12100
12101         case ARRAY_REF:
12102           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12103           break;
12104
12105         case COMPONENT_REF:
12106         case MEMBER_REF:
12107           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12108           break;
12109
12110         case NEW_EXPR:
12111           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12112           break;
12113
12114         case DELETE_EXPR:
12115           TYPE_GETS_DELETE (current_class_type) |= 1;
12116           break;
12117
12118         case VEC_NEW_EXPR:
12119           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12120           break;
12121
12122         case VEC_DELETE_EXPR:
12123           TYPE_GETS_DELETE (current_class_type) |= 2;
12124           break;
12125
12126         default:
12127           break;
12128         }
12129     }
12130
12131   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12132     {
12133       /* When the compiler encounters the definition of A::operator new, it
12134          doesn't look at the class declaration to find out if it's static.  */
12135       if (methodp)
12136         revert_static_member_fn (decl);
12137
12138       TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12139     }
12140   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12141     {
12142       if (methodp)
12143         revert_static_member_fn (decl);
12144
12145       TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12146     }
12147   else
12148     {
12149       /* An operator function must either be a non-static member function
12150          or have at least one parameter of a class, a reference to a class,
12151          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12152       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12153         {
12154           if (operator_code == TYPE_EXPR
12155               || operator_code == CALL_EXPR
12156               || operator_code == COMPONENT_REF
12157               || operator_code == ARRAY_REF
12158               || operator_code == NOP_EXPR)
12159             cp_error ("`%D' must be a nonstatic member function", decl);
12160           else
12161             {
12162               tree p = argtypes;
12163
12164               if (DECL_STATIC_FUNCTION_P (decl))
12165                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12166
12167               if (p)
12168                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12169                   {
12170                     tree arg = TREE_VALUE (p);
12171                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12172                       arg = TREE_TYPE (arg);
12173
12174                     /* This lets bad template code slip through.  */
12175                     if (IS_AGGR_TYPE (arg)
12176                         || TREE_CODE (arg) == ENUMERAL_TYPE
12177                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12178                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12179                       goto foundaggr;
12180                   }
12181               cp_error
12182                 ("`%D' must have an argument of class or enumerated type",
12183                  decl);
12184             foundaggr:
12185               ;
12186             }
12187         }
12188
12189       if (operator_code == CALL_EXPR)
12190         return;                 /* No restrictions on args. */
12191
12192       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12193         {
12194           tree t = TREE_TYPE (name);
12195           if (! friendp)
12196             {
12197               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12198               const char *what = 0;
12199
12200               if (ref)
12201                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12202
12203               if (TREE_CODE (t) == VOID_TYPE)
12204                 what = "void";
12205               else if (t == current_class_type)
12206                 what = "the same type";
12207               /* Don't force t to be complete here.  */
12208               else if (IS_AGGR_TYPE (t)
12209                        && COMPLETE_TYPE_P (t)
12210                        && DERIVED_FROM_P (t, current_class_type))
12211                 what = "a base class";
12212
12213               if (what)
12214                 warning ("conversion to %s%s will never use a type conversion operator",
12215                          ref ? "a reference to " : "", what);
12216             }
12217         }
12218
12219       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12220           && operator_code == NOP_EXPR)
12221         {
12222           tree parmtype;
12223
12224           if (arity != 2 && methodp)
12225             {
12226               cp_error ("`%D' must take exactly one argument", decl);
12227               return;
12228             }
12229           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12230
12231           /* [class.copy]
12232
12233              A user-declared copy assignment operator X::operator= is
12234              a non-static non-template member function of class X with
12235              exactly one parameter of type X, X&, const X&, volatile
12236              X& or const volatile X&.  */
12237           if (copy_assignment_arg_p (parmtype, virtualp)
12238               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12239                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12240               && ! friendp)
12241             {
12242               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12243               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12244                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12245                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12246             }
12247         }
12248       else if (operator_code == COND_EXPR)
12249         {
12250           /* 13.4.0.3 */
12251           cp_error ("ISO C++ prohibits overloading operator ?:");
12252         }
12253       else if (ambi_op_p (operator_code))
12254         {
12255           if (arity == 1)
12256             /* We pick the one-argument operator codes by default, so
12257                we don't have to change anything.  */
12258             ;
12259           else if (arity == 2)
12260             {
12261               /* If we thought this was a unary operator, we now know
12262                  it to be a binary operator.  */
12263               switch (operator_code)
12264                 {
12265                 case INDIRECT_REF:
12266                   operator_code = MULT_EXPR;
12267                   break;
12268
12269                 case ADDR_EXPR:
12270                   operator_code = BIT_AND_EXPR;
12271                   break;
12272
12273                 case CONVERT_EXPR:
12274                   operator_code = PLUS_EXPR;
12275                   break;
12276
12277                 case NEGATE_EXPR:
12278                   operator_code = MINUS_EXPR;
12279                   break;
12280
12281                 case PREINCREMENT_EXPR:
12282                   operator_code = POSTINCREMENT_EXPR;
12283                   break;
12284
12285                 case PREDECREMENT_EXPR:
12286                   operator_code = POSTDECREMENT_EXPR;
12287                   break;
12288
12289                 default:
12290                   my_friendly_abort (20000527);
12291                 }
12292
12293               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12294
12295               if ((operator_code == POSTINCREMENT_EXPR
12296                    || operator_code == POSTDECREMENT_EXPR)
12297                   && ! processing_template_decl
12298                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12299                 {
12300                   if (methodp)
12301                     cp_error ("postfix `%D' must take `int' as its argument",
12302                               decl);
12303                   else
12304                     cp_error
12305                       ("postfix `%D' must take `int' as its second argument",
12306                        decl);
12307                 }
12308             }
12309           else
12310             {
12311               if (methodp)
12312                 cp_error ("`%D' must take either zero or one argument", decl);
12313               else
12314                 cp_error ("`%D' must take either one or two arguments", decl);
12315             }
12316
12317           /* More Effective C++ rule 6.  */
12318           if (warn_ecpp
12319               && (operator_code == POSTINCREMENT_EXPR
12320                   || operator_code == POSTDECREMENT_EXPR
12321                   || operator_code == PREINCREMENT_EXPR
12322                   || operator_code == PREDECREMENT_EXPR))
12323             {
12324               tree arg = TREE_VALUE (argtypes);
12325               tree ret = TREE_TYPE (TREE_TYPE (decl));
12326               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12327                 arg = TREE_TYPE (arg);
12328               arg = TYPE_MAIN_VARIANT (arg);
12329               if (operator_code == PREINCREMENT_EXPR
12330                   || operator_code == PREDECREMENT_EXPR)
12331                 {
12332                   if (TREE_CODE (ret) != REFERENCE_TYPE
12333                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12334                                        arg))
12335                     cp_warning ("prefix `%D' should return `%T'", decl,
12336                                 build_reference_type (arg));
12337                 }
12338               else
12339                 {
12340                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12341                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12342                 }
12343             }
12344         }
12345       else if (unary_op_p (operator_code))
12346         {
12347           if (arity != 1)
12348             {
12349               if (methodp)
12350                 cp_error ("`%D' must take `void'", decl);
12351               else
12352                 cp_error ("`%D' must take exactly one argument", decl);
12353             }
12354         }
12355       else /* if (binary_op_p (operator_code)) */
12356         {
12357           if (arity != 2)
12358             {
12359               if (methodp)
12360                 cp_error ("`%D' must take exactly one argument", decl);
12361               else
12362                 cp_error ("`%D' must take exactly two arguments", decl);
12363             }
12364
12365           /* More Effective C++ rule 7.  */
12366           if (warn_ecpp
12367               && (operator_code == TRUTH_ANDIF_EXPR
12368                   || operator_code == TRUTH_ORIF_EXPR
12369                   || operator_code == COMPOUND_EXPR))
12370             cp_warning ("user-defined `%D' always evaluates both arguments",
12371                         decl);
12372         }
12373
12374       /* Effective C++ rule 23.  */
12375       if (warn_ecpp
12376           && arity == 2
12377           && (operator_code == PLUS_EXPR
12378               || operator_code == MINUS_EXPR
12379               || operator_code == TRUNC_DIV_EXPR
12380               || operator_code == MULT_EXPR)
12381           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12382         cp_warning ("`%D' should return by value", decl);
12383
12384       /* 13.4.0.8 */
12385       for (; argtypes && argtypes != void_list_node;
12386           argtypes = TREE_CHAIN (argtypes))
12387         if (TREE_PURPOSE (argtypes))
12388           {
12389             TREE_PURPOSE (argtypes) = NULL_TREE;
12390             if (operator_code == POSTINCREMENT_EXPR
12391                 || operator_code == POSTDECREMENT_EXPR)
12392               {
12393                 if (pedantic)
12394                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12395               }
12396             else
12397               cp_error ("`%D' cannot have default arguments", decl);
12398           }
12399
12400     }
12401 }
12402 \f
12403 static const char *
12404 tag_name (code)
12405      enum tag_types code;
12406 {
12407   switch (code)
12408     {
12409     case record_type:
12410       return "struct";
12411     case class_type:
12412       return "class";
12413     case union_type:
12414       return "union ";
12415     case enum_type:
12416       return "enum";
12417     default:
12418       my_friendly_abort (981122);
12419     }
12420 }
12421
12422 /* Get the struct, enum or union (CODE says which) with tag NAME.
12423    Define the tag as a forward-reference if it is not defined.
12424
12425    C++: If a class derivation is given, process it here, and report
12426    an error if multiple derivation declarations are not identical.
12427
12428    If this is a definition, come in through xref_tag and only look in
12429    the current frame for the name (since C++ allows new names in any
12430    scope.)  */
12431
12432 tree
12433 xref_tag (code_type_node, name, globalize)
12434      tree code_type_node;
12435      tree name;
12436      int globalize;
12437 {
12438   enum tag_types tag_code;
12439   enum tree_code code;
12440   register tree ref, t;
12441   struct binding_level *b = current_binding_level;
12442   int got_type = 0;
12443   tree attributes = NULL_TREE;
12444   tree context = NULL_TREE;
12445
12446   /* If we are called from the parser, code_type_node will sometimes be a
12447      TREE_LIST.  This indicates that the user wrote
12448      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12449      use them later.  */
12450   if (TREE_CODE (code_type_node) == TREE_LIST)
12451     {
12452       attributes = TREE_PURPOSE (code_type_node);
12453       code_type_node = TREE_VALUE (code_type_node);
12454     }
12455
12456   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12457   switch (tag_code)
12458     {
12459     case record_type:
12460     case class_type:
12461       code = RECORD_TYPE;
12462       break;
12463     case union_type:
12464       code = UNION_TYPE;
12465       break;
12466     case enum_type:
12467       code = ENUMERAL_TYPE;
12468       break;
12469     default:
12470       my_friendly_abort (18);
12471     }
12472
12473   /* If a cross reference is requested, look up the type
12474      already defined for this tag and return it.  */
12475   if (TYPE_P (name))
12476     {
12477       t = name;
12478       name = TYPE_IDENTIFIER (t);
12479       got_type = 1;
12480     }
12481   else
12482     t = IDENTIFIER_TYPE_VALUE (name);
12483
12484   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12485   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12486     {
12487       static int explained;
12488       tree shadowed;
12489
12490       cp_warning ("`%s %T' declares a new type at namespace scope",
12491                   tag_name (tag_code), name);
12492       if (!explained++)
12493         cp_warning ("  names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'",
12494                     tag_name (tag_code),
12495                     constructor_name (current_class_type),
12496                     TYPE_IDENTIFIER (t));
12497
12498       /* We need to remove the class scope binding for the
12499          TYPENAME_TYPE as otherwise poplevel_class gets confused. */
12500       for (shadowed = b->class_shadowed;
12501            shadowed;
12502            shadowed = TREE_CHAIN (shadowed))
12503         if (TREE_TYPE (shadowed) == TYPE_NAME (t))
12504           {
12505             TREE_PURPOSE (shadowed) = NULL_TREE;
12506             break;
12507           }
12508     }
12509
12510   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12511       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12512     t = NULL_TREE;
12513
12514   if (! globalize)
12515     {
12516       /* If we know we are defining this tag, only look it up in
12517          this scope and don't try to find it as a type.  */
12518       ref = lookup_tag (code, name, b, 1);
12519     }
12520   else
12521     {
12522       if (t)
12523         {
12524           /* [dcl.type.elab] If the identifier resolves to a
12525              typedef-name or a template type-parameter, the
12526              elaborated-type-specifier is ill-formed.  */
12527           if (t != TYPE_MAIN_VARIANT (t)
12528               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12529             cp_pedwarn ("using typedef-name `%D' after `%s'",
12530                         TYPE_NAME (t), tag_name (tag_code));
12531           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12532             cp_error ("using template type parameter `%T' after `%s'",
12533                       t, tag_name (tag_code));
12534
12535           ref = t;
12536         }
12537       else
12538         ref = lookup_tag (code, name, b, 0);
12539
12540       if (! ref)
12541         {
12542           /* Try finding it as a type declaration.  If that wins,
12543              use it.  */
12544           ref = lookup_name (name, 1);
12545
12546           if (ref != NULL_TREE
12547               && processing_template_decl
12548               && DECL_CLASS_TEMPLATE_P (ref)
12549               && template_class_depth (current_class_type) == 0)
12550             /* Since GLOBALIZE is true, we're declaring a global
12551                template, so we want this type.  */
12552             ref = DECL_TEMPLATE_RESULT (ref);
12553
12554           if (ref && TREE_CODE (ref) == TYPE_DECL
12555               && TREE_CODE (TREE_TYPE (ref)) == code)
12556             ref = TREE_TYPE (ref);
12557           else
12558             ref = NULL_TREE;
12559         }
12560
12561       if (ref && current_class_type
12562           && template_class_depth (current_class_type)
12563           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12564         {
12565           /* Since GLOBALIZE is non-zero, we are not looking at a
12566              definition of this tag.  Since, in addition, we are currently
12567              processing a (member) template declaration of a template
12568              class, we must be very careful; consider:
12569
12570                template <class X>
12571                struct S1
12572
12573                template <class U>
12574                struct S2
12575                { template <class V>
12576                friend struct S1; };
12577
12578              Here, the S2::S1 declaration should not be confused with the
12579              outer declaration.  In particular, the inner version should
12580              have a template parameter of level 2, not level 1.  This
12581              would be particularly important if the member declaration
12582              were instead:
12583
12584                template <class V = U> friend struct S1;
12585
12586              say, when we should tsubst into `U' when instantiating
12587              S2.  On the other hand, when presented with:
12588
12589                  template <class T>
12590                  struct S1 {
12591                    template <class U>
12592                    struct S2 {};
12593                    template <class U>
12594                    friend struct S2;
12595                  };
12596
12597               we must find the inner binding eventually.  We
12598               accomplish this by making sure that the new type we
12599               create to represent this declaration has the right
12600               TYPE_CONTEXT.  */
12601           context = TYPE_CONTEXT (ref);
12602           ref = NULL_TREE;
12603         }
12604     }
12605
12606   if (! ref)
12607     {
12608       /* If no such tag is yet defined, create a forward-reference node
12609          and record it as the "definition".
12610          When a real declaration of this type is found,
12611          the forward-reference will be altered into a real type.  */
12612       if (code == ENUMERAL_TYPE)
12613         {
12614           cp_error ("use of enum `%#D' without previous declaration", name);
12615
12616           ref = make_node (ENUMERAL_TYPE);
12617
12618           /* Give the type a default layout like unsigned int
12619              to avoid crashing if it does not get defined.  */
12620           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12621           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12622           TYPE_USER_ALIGN (ref) = 0;
12623           TREE_UNSIGNED (ref) = 1;
12624           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12625           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12626           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12627
12628           /* Enable us to recognize when a type is created in class context.
12629              To do nested classes correctly, this should probably be cleared
12630              out when we leave this classes scope.  Currently this in only
12631              done in `start_enum'.  */
12632
12633           pushtag (name, ref, globalize);
12634         }
12635       else
12636         {
12637           struct binding_level *old_b = class_binding_level;
12638
12639           ref = make_aggr_type (code);
12640           TYPE_CONTEXT (ref) = context;
12641
12642 #ifdef NONNESTED_CLASSES
12643           /* Class types don't nest the way enums do.  */
12644           class_binding_level = (struct binding_level *)0;
12645 #endif
12646           pushtag (name, ref, globalize);
12647           class_binding_level = old_b;
12648         }
12649     }
12650   else
12651     {
12652       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12653         redeclare_class_template (ref, current_template_parms);
12654     }
12655
12656   /* Until the type is defined, tentatively accept whatever
12657      structure tag the user hands us.  */
12658   if (!COMPLETE_TYPE_P (ref)
12659       && ref != current_class_type
12660       /* Have to check this, in case we have contradictory tag info.  */
12661       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12662     {
12663       if (tag_code == class_type)
12664         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12665       else if (tag_code == record_type)
12666         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12667     }
12668
12669   TREE_TYPE (ref) = attributes;
12670
12671   return ref;
12672 }
12673
12674 tree
12675 xref_tag_from_type (old, id, globalize)
12676      tree old, id;
12677      int globalize;
12678 {
12679   tree code_type_node;
12680
12681   if (TREE_CODE (old) == RECORD_TYPE)
12682     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12683                       ? class_type_node : record_type_node);
12684   else
12685     code_type_node = union_type_node;
12686
12687   if (id == NULL_TREE)
12688     id = TYPE_IDENTIFIER (old);
12689
12690   return xref_tag (code_type_node, id, globalize);
12691 }
12692
12693 /* REF is a type (named NAME), for which we have just seen some
12694    baseclasses.  BINFO is a list of those baseclasses; the
12695    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12696    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12697    struct, or union.  */
12698
12699 void
12700 xref_basetypes (code_type_node, name, ref, binfo)
12701      tree code_type_node;
12702      tree name, ref;
12703      tree binfo;
12704 {
12705   /* In the declaration `A : X, Y, ... Z' we mark all the types
12706      (A, X, Y, ..., Z) so we can check for duplicates.  */
12707   tree binfos;
12708   tree base;
12709
12710   int i, len;
12711   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12712
12713   if (tag_code == union_type)
12714     {
12715       cp_error ("derived union `%T' invalid", ref);
12716       return;
12717     }
12718
12719   len = list_length (binfo);
12720
12721   /* First, make sure that any templates in base-classes are
12722      instantiated.  This ensures that if we call ourselves recursively
12723      we do not get confused about which classes are marked and which
12724      are not.  */
12725   for (base = binfo; base; base = TREE_CHAIN (base))
12726     complete_type (TREE_VALUE (base));
12727
12728   SET_CLASSTYPE_MARKED (ref);
12729   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12730
12731   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12732     {
12733       /* The base of a derived struct is public by default.  */
12734       int via_public
12735         = (TREE_PURPOSE (binfo) == access_public_node
12736            || TREE_PURPOSE (binfo) == access_public_virtual_node
12737            || (tag_code != class_type
12738                && (TREE_PURPOSE (binfo) == access_default_node
12739                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12740       int via_protected
12741         = (TREE_PURPOSE (binfo) == access_protected_node
12742            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12743       int via_virtual
12744         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12745            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12746            || TREE_PURPOSE (binfo) == access_public_virtual_node
12747            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12748       tree basetype = TREE_VALUE (binfo);
12749       tree base_binfo;
12750
12751       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12752         basetype = TREE_TYPE (basetype);
12753       if (!basetype
12754           || (TREE_CODE (basetype) != RECORD_TYPE
12755               && TREE_CODE (basetype) != TYPENAME_TYPE
12756               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12757               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
12758         {
12759           cp_error ("base type `%T' fails to be a struct or class type",
12760                     TREE_VALUE (binfo));
12761           continue;
12762         }
12763
12764       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12765
12766       /* This code replaces similar code in layout_basetypes.
12767          We put the complete_type first for implicit `typename'.  */
12768       if (!COMPLETE_TYPE_P (basetype)
12769           && ! (current_template_parms && uses_template_parms (basetype)))
12770         {
12771           cp_error ("base class `%T' has incomplete type", basetype);
12772           continue;
12773         }
12774       else
12775         {
12776           if (CLASSTYPE_MARKED (basetype))
12777             {
12778               if (basetype == ref)
12779                 cp_error ("recursive type `%T' undefined", basetype);
12780               else
12781                 cp_error ("duplicate base type `%T' invalid", basetype);
12782               continue;
12783             }
12784
12785           if (TYPE_FOR_JAVA (basetype)
12786               && (current_lang_depth () == 0))
12787             TYPE_FOR_JAVA (ref) = 1;
12788
12789           /* Note that the BINFO records which describe individual
12790              inheritances are *not* shared in the lattice!  They
12791              cannot be shared because a given baseclass may be
12792              inherited with different `accessibility' by different
12793              derived classes.  (Each BINFO record describing an
12794              individual inheritance contains flags which say what
12795              the `accessibility' of that particular inheritance is.)  */
12796
12797           base_binfo
12798             = make_binfo (size_zero_node, basetype,
12799                           CLASS_TYPE_P (basetype)
12800                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12801                           CLASS_TYPE_P (basetype)
12802                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12803
12804           TREE_VEC_ELT (binfos, i) = base_binfo;
12805           TREE_VIA_PUBLIC (base_binfo) = via_public;
12806           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12807           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12808           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12809
12810           /* We need to unshare the binfos now so that lookups during class
12811              definition work.  */
12812           unshare_base_binfos (base_binfo);
12813
12814           SET_CLASSTYPE_MARKED (basetype);
12815
12816           /* We are free to modify these bits because they are meaningless
12817              at top level, and BASETYPE is a top-level type.  */
12818           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12819             {
12820               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12821               /* Converting to a virtual base class requires looking
12822                  up the offset of the virtual base.  */
12823               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12824             }
12825
12826           if (CLASS_TYPE_P (basetype))
12827             {
12828               TYPE_HAS_NEW_OPERATOR (ref)
12829                 |= TYPE_HAS_NEW_OPERATOR (basetype);
12830               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12831                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12832               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12833               /* If the base-class uses multiple inheritance, so do we.  */
12834               TYPE_USES_MULTIPLE_INHERITANCE (ref)
12835                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12836               /* Likewise, if converting to a base of the base may require
12837                  code, then we may need to generate code to convert to a
12838                  base as well.  */
12839               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12840                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12841             }
12842
12843           i += 1;
12844         }
12845     }
12846   if (i)
12847     TREE_VEC_LENGTH (binfos) = i;
12848   else
12849     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12850
12851   if (i > 1)
12852     {
12853       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12854       /* If there is more than one non-empty they cannot be at the same
12855          address.  */
12856       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12857     }
12858
12859   /* Unmark all the types.  */
12860   while (--i >= 0)
12861     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12862   CLEAR_CLASSTYPE_MARKED (ref);
12863
12864   /* Now that we know all the base-classes, set up the list of virtual
12865      bases.  */
12866   get_vbase_types (ref);
12867 }
12868
12869 \f
12870 /* Begin compiling the definition of an enumeration type.
12871    NAME is its name (or null if anonymous).
12872    Returns the type object, as yet incomplete.
12873    Also records info about it so that build_enumerator
12874    may be used to declare the individual values as they are read.  */
12875
12876 tree
12877 start_enum (name)
12878      tree name;
12879 {
12880   register tree enumtype = NULL_TREE;
12881   struct binding_level *b = current_binding_level;
12882
12883   /* If this is the real definition for a previous forward reference,
12884      fill in the contents in the same object that used to be the
12885      forward reference.  */
12886
12887   if (name != NULL_TREE)
12888     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12889
12890   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12891     {
12892       cp_error ("multiple definition of `%#T'", enumtype);
12893       cp_error_at ("previous definition here", enumtype);
12894       /* Clear out TYPE_VALUES, and start again.  */
12895       TYPE_VALUES (enumtype) = NULL_TREE;
12896     }
12897   else
12898     {
12899       enumtype = make_node (ENUMERAL_TYPE);
12900       pushtag (name, enumtype, 0);
12901     }
12902
12903   if (current_class_type)
12904     TREE_ADDRESSABLE (b->tags) = 1;
12905
12906   GNU_xref_decl (current_function_decl, enumtype);
12907   return enumtype;
12908 }
12909
12910 /* After processing and defining all the values of an enumeration type,
12911    install their decls in the enumeration type and finish it off.
12912    ENUMTYPE is the type object and VALUES a list of name-value pairs.  */
12913
12914 void
12915 finish_enum (enumtype)
12916      tree enumtype;
12917 {
12918   tree pair;
12919   tree minnode;
12920   tree maxnode;
12921   tree t;
12922   bool unsignedp;
12923   int lowprec;
12924   int highprec;
12925   int precision;
12926
12927   /* We built up the VALUES in reverse order.  */
12928   TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
12929
12930   /* [dcl.enum]
12931
12932      Following the closing brace of an enum-specifier, each
12933      enumerator has the type of its enumeration.  Prior to the
12934      closing brace, the type of each enumerator is the type of
12935      its initializing value.  */
12936   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
12937     TREE_TYPE (TREE_VALUE (pair)) = enumtype;
12938
12939   /* For a enum defined in a template, all further processing is
12940      postponed until the template is instantiated.  */
12941   if (processing_template_decl)
12942     {
12943       tree scope = current_scope ();
12944       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12945         add_stmt (build_min (TAG_DEFN, enumtype));
12946
12947
12948       return;
12949     }
12950
12951   /* Figure out what the minimum and maximum values of the enumerators
12952      are.  */
12953   if (TYPE_VALUES (enumtype))
12954     {
12955       minnode = maxnode = NULL_TREE;
12956
12957       for (pair = TYPE_VALUES (enumtype);
12958            pair;
12959            pair = TREE_CHAIN (pair))
12960         {
12961           tree value;
12962
12963           value = DECL_INITIAL (TREE_VALUE (pair));
12964
12965           if (!minnode)
12966             minnode = maxnode = value;
12967           else if (tree_int_cst_lt (maxnode, value))
12968             maxnode = value;
12969           else if (tree_int_cst_lt (value, minnode))
12970             minnode = value;
12971         }
12972     }
12973   else
12974     minnode = maxnode = integer_zero_node;
12975
12976   /* Compute the number of bits require to represent all values of the
12977      enumeration.  We must do this before the type of MINNODE and
12978      MAXNODE are transformed, since min_precision relies on the
12979      TREE_TYPE of the value it is passed.  */
12980   unsignedp = tree_int_cst_sgn (minnode) >= 0;
12981   lowprec = min_precision (minnode, unsignedp);
12982   highprec = min_precision (maxnode, unsignedp);
12983   precision = MAX (lowprec, highprec);
12984
12985   /* Set the TREE_TYPE for the values as well.  That's so that when we
12986      call decl_constant_value we get an entity of the right type (but
12987      with the constant value).  In addition, transform the TYPE_VALUES
12988      list to contain the values, rather than the CONST_DECLs for them.  */
12989   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
12990     {
12991       tree value = DECL_INITIAL (TREE_VALUE (pair));
12992
12993       TREE_TYPE (value) = enumtype;
12994       TREE_VALUE (pair) = value;
12995     }
12996
12997   /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
12998   TYPE_SIZE (enumtype) = NULL_TREE;
12999   TYPE_PRECISION (enumtype) = precision;
13000   if (unsignedp)
13001     fixup_unsigned_type (enumtype);
13002   else
13003     fixup_signed_type (enumtype);
13004
13005   if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13006     /* Use the width of the narrowest normal C type which is wide
13007        enough.  */
13008     TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13009                                                 (precision, 1));
13010   else
13011     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13012
13013   TYPE_SIZE (enumtype) = NULL_TREE;
13014   layout_type (enumtype);
13015
13016   /* Fix up all variant types of this enum type.  */
13017   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13018     {
13019       TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13020       TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
13021       TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
13022       TYPE_SIZE (t) = TYPE_SIZE (enumtype);
13023       TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
13024       TYPE_MODE (t) = TYPE_MODE (enumtype);
13025       TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
13026       TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
13027       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
13028       TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype);
13029     }
13030
13031   /* Finish debugging output for this type.  */
13032   rest_of_type_compilation (enumtype, namespace_bindings_p ());
13033 }
13034
13035 /* Build and install a CONST_DECL for an enumeration constant of the
13036    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13037    Assignment of sequential values by default is handled here.  */
13038
13039 void
13040 build_enumerator (name, value, enumtype)
13041      tree name;
13042      tree value;
13043      tree enumtype;
13044 {
13045   tree decl;
13046   tree context;
13047   tree type;
13048   tree values;
13049
13050   /* Remove no-op casts from the value.  */
13051   if (value)
13052     STRIP_TYPE_NOPS (value);
13053
13054   if (! processing_template_decl)
13055     {
13056       /* Validate and default VALUE.  */
13057       if (value != NULL_TREE)
13058         {
13059           value = decl_constant_value (value);
13060
13061           if (TREE_CODE (value) == INTEGER_CST)
13062             {
13063               value = default_conversion (value);
13064               constant_expression_warning (value);
13065             }
13066           else
13067             {
13068               cp_error ("enumerator value for `%D' not integer constant", name);
13069               value = NULL_TREE;
13070             }
13071         }
13072
13073       /* Default based on previous value.  */
13074       if (value == NULL_TREE && ! processing_template_decl)
13075         {
13076           tree prev_value;
13077
13078           if (TYPE_VALUES (enumtype))
13079             {
13080               /* The next value is the previous value ... */
13081               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13082               /* ... plus one.  */
13083               value = cp_build_binary_op (PLUS_EXPR,
13084                                           prev_value,
13085                                           integer_one_node);
13086
13087               if (tree_int_cst_lt (value, prev_value))
13088                 cp_error ("overflow in enumeration values at `%D'", name);
13089             }
13090           else
13091             value = integer_zero_node;
13092         }
13093
13094       /* Remove no-op casts from the value.  */
13095       if (value)
13096         STRIP_TYPE_NOPS (value);
13097 #if 0
13098       /* To fix MAX_VAL enum consts. (bkoz)  */
13099       TREE_TYPE (value) = integer_type_node;
13100 #endif
13101     }
13102
13103   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13104      Even in other cases, we will later (in finish_enum) be setting
13105      the type of VALUE.  But, we don't need to make a copy if this
13106      VALUE is one of the enumeration constants for this same
13107      enumeration type.  */
13108   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13109     if (TREE_VALUE (values) == value)
13110       break;
13111   /* If we didn't break out of the loop, then we do need a copy.  */
13112   if (!values && value)
13113     value = copy_node (value);
13114
13115   /* C++ associates enums with global, function, or class declarations.  */
13116   context = current_scope ();
13117
13118   /* Build the actual enumeration constant.  Note that the enumeration
13119     constants have the type of their initializers until the
13120     enumeration is complete:
13121
13122       [ dcl.enum ]
13123
13124       Following the closing brace of an enum-specifier, each enumer-
13125       ator has the type of its enumeration.  Prior to the closing
13126       brace, the type of each enumerator is the type of its
13127       initializing value.
13128
13129     In finish_enum we will reset the type.  Of course, if we're
13130     processing a template, there may be no value.   */
13131   type = value ? TREE_TYPE (value) : NULL_TREE;
13132
13133   if (context && context == current_class_type)
13134     /* This enum declaration is local to the class.  We need the full
13135        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13136     decl = build_lang_decl (CONST_DECL, name, type);
13137   else
13138     /* It's a global enum, or it's local to a function.  (Note local to
13139       a function could mean local to a class method.  */
13140     decl = build_decl (CONST_DECL, name, type);
13141
13142   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13143   DECL_INITIAL (decl) = value;
13144   TREE_READONLY (decl) = 1;
13145
13146   if (context && context == current_class_type)
13147     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13148       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13149       things like `S::i' later.)  */
13150     finish_member_declaration (decl);
13151   else
13152     {
13153       pushdecl (decl);
13154       GNU_xref_decl (current_function_decl, decl);
13155     }
13156
13157   /* Add this enumeration constant to the list for this type.  */
13158   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13159 }
13160
13161 \f
13162 /* We're defining DECL.  Make sure that it's type is OK.  */
13163
13164 static void
13165 check_function_type (decl, current_function_parms)
13166      tree decl;
13167      tree current_function_parms;
13168 {
13169   tree fntype = TREE_TYPE (decl);
13170   tree return_type = complete_type (TREE_TYPE (fntype));
13171
13172   /* In a function definition, arg types must be complete.  */
13173   require_complete_types_for_parms (current_function_parms);
13174
13175   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13176     {
13177       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13178
13179       /* Make it return void instead, but don't change the
13180          type of the DECL_RESULT, in case we have a named return value.  */
13181       if (TREE_CODE (fntype) == METHOD_TYPE)
13182         {
13183           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13184           TREE_TYPE (decl)
13185             = build_cplus_method_type (ctype,
13186                                        void_type_node,
13187                                        FUNCTION_ARG_CHAIN (decl));
13188         }
13189       else
13190         TREE_TYPE (decl)
13191           = build_function_type (void_type_node,
13192                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13193       TREE_TYPE (decl)
13194         = build_exception_variant (fntype,
13195                                    TYPE_RAISES_EXCEPTIONS (fntype));
13196     }
13197   else
13198     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13199 }
13200
13201 /* Create the FUNCTION_DECL for a function definition.
13202    DECLSPECS and DECLARATOR are the parts of the declaration;
13203    they describe the function's name and the type it returns,
13204    but twisted together in a fashion that parallels the syntax of C.
13205
13206    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13207    DECLARATOR is really the DECL for the function we are about to
13208    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13209    indicating that the function is an inline defined in-class.
13210
13211    This function creates a binding context for the function body
13212    as well as setting up the FUNCTION_DECL in current_function_decl.
13213
13214    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13215    (it defines a datum instead), we return 0, which tells
13216    yyparse to report a parse error.
13217
13218    For C++, we must first check whether that datum makes any sense.
13219    For example, "class A local_a(1,2);" means that variable local_a
13220    is an aggregate of type A, which should have a constructor
13221    applied to it with the argument list [1, 2].  */
13222
13223 int
13224 start_function (declspecs, declarator, attrs, flags)
13225      tree declspecs, declarator, attrs;
13226      int flags;
13227 {
13228   tree decl1;
13229   tree ctype = NULL_TREE;
13230   tree fntype;
13231   tree restype;
13232   extern int have_extern_spec;
13233   extern int used_extern_spec;
13234   int doing_friend = 0;
13235   struct binding_level *bl;
13236   tree current_function_parms;
13237
13238   /* Sanity check.  */
13239   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13240   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13241
13242   /* This should only be done once on the top most decl.  */
13243   if (have_extern_spec && !used_extern_spec)
13244     {
13245       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13246       used_extern_spec = 1;
13247     }
13248
13249   if (flags & SF_PRE_PARSED)
13250     {
13251       decl1 = declarator;
13252
13253       fntype = TREE_TYPE (decl1);
13254       if (TREE_CODE (fntype) == METHOD_TYPE)
13255         ctype = TYPE_METHOD_BASETYPE (fntype);
13256
13257       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13258          the (lexical) scope of the class in which it is defined.  */
13259       if (!ctype && DECL_FRIEND_P (decl1))
13260         {
13261           ctype = DECL_FRIEND_CONTEXT (decl1);
13262
13263           /* CTYPE could be null here if we're dealing with a template;
13264              for example, `inline friend float foo()' inside a template
13265              will have no CTYPE set.  */
13266           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13267             ctype = NULL_TREE;
13268           else
13269             doing_friend = 1;
13270         }
13271
13272       last_function_parms = DECL_ARGUMENTS (decl1);
13273     }
13274   else
13275     {
13276       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13277       /* If the declarator is not suitable for a function definition,
13278          cause a syntax error.  */
13279       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13280
13281       fntype = TREE_TYPE (decl1);
13282
13283       restype = TREE_TYPE (fntype);
13284       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13285         {
13286           cp_error ("semicolon missing after declaration of `%#T'", restype);
13287           shadow_tag (build_tree_list (NULL_TREE, restype));
13288           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13289           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13290             fntype = build_function_type (integer_type_node,
13291                                           TYPE_ARG_TYPES (fntype));
13292           else
13293             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13294                                               integer_type_node,
13295                                               TYPE_ARG_TYPES (fntype));
13296           TREE_TYPE (decl1) = fntype;
13297         }
13298
13299       if (TREE_CODE (fntype) == METHOD_TYPE)
13300         ctype = TYPE_METHOD_BASETYPE (fntype);
13301       else if (DECL_MAIN_P (decl1))
13302         {
13303           /* If this doesn't return integer_type, complain.  */
13304           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13305             {
13306               if (pedantic || warn_return_type)
13307                 pedwarn ("return type for `main' changed to `int'");
13308               TREE_TYPE (decl1) = fntype = default_function_type;
13309             }
13310         }
13311     }
13312
13313   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13314     /* This is a constructor, we must ensure that any default args
13315        introduced by this definition are propagated to the clones
13316        now. The clones are used directly in overload resolution.  */
13317     adjust_clone_args (decl1);
13318
13319   /* Sometimes we don't notice that a function is a static member, and
13320      build a METHOD_TYPE for it.  Fix that up now.  */
13321   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13322       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13323     {
13324       revert_static_member_fn (decl1);
13325       last_function_parms = TREE_CHAIN (last_function_parms);
13326       ctype = NULL_TREE;
13327     }
13328
13329   /* Warn if function was previously implicitly declared
13330      (but not if we warned then).  */
13331   if (! warn_implicit
13332       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13333     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13334
13335   /* Set up current_class_type, and enter the scope of the class, if
13336      appropriate.  */
13337   if (ctype)
13338     push_nested_class (ctype, 1);
13339   else if (DECL_STATIC_FUNCTION_P (decl1))
13340     push_nested_class (DECL_CONTEXT (decl1), 2);
13341
13342   /* Now that we have entered the scope of the class, we must restore
13343      the bindings for any template parameters surrounding DECL1, if it
13344      is an inline member template.  (Order is important; consider the
13345      case where a template parameter has the same name as a field of
13346      the class.)  It is not until after this point that
13347      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13348   if (flags & SF_INCLASS_INLINE)
13349     maybe_begin_member_template_processing (decl1);
13350
13351   /* Effective C++ rule 15.  */
13352   if (warn_ecpp
13353       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13354       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13355     cp_warning ("`operator=' should return a reference to `*this'");
13356
13357   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13358      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13359   if (!DECL_INITIAL (decl1))
13360     DECL_INITIAL (decl1) = error_mark_node;
13361
13362   /* This function exists in static storage.
13363      (This does not mean `static' in the C sense!)  */
13364   TREE_STATIC (decl1) = 1;
13365
13366   /* We must call push_template_decl after current_class_type is set
13367      up.  (If we are processing inline definitions after exiting a
13368      class scope, current_class_type will be NULL_TREE until set above
13369      by push_nested_class.)  */
13370   if (processing_template_decl)
13371     decl1 = push_template_decl (decl1);
13372
13373   /* We are now in the scope of the function being defined.  */
13374   current_function_decl = decl1;
13375
13376   /* Save the parm names or decls from this function's declarator
13377      where store_parm_decls will find them.  */
13378   current_function_parms = last_function_parms;
13379
13380   /* Make sure the parameter and return types are reasonable.  When
13381      you declare a function, these types can be incomplete, but they
13382      must be complete when you define the function.  */
13383   if (! processing_template_decl)
13384     check_function_type (decl1, current_function_parms);
13385
13386   /* Build the return declaration for the function.  */
13387   restype = TREE_TYPE (fntype);
13388   if (!processing_template_decl)
13389     {
13390       if (!DECL_RESULT (decl1))
13391         {
13392           DECL_RESULT (decl1)
13393             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13394           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13395                                       DECL_RESULT (decl1));
13396         }
13397     }
13398   else
13399     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13400     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13401
13402   /* Initialize RTL machinery.  We cannot do this until
13403      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13404      even when processing a template; this is how we get
13405      CFUN set up, and our per-function variables initialized.
13406      FIXME factor out the non-RTL stuff.  */
13407   bl = current_binding_level;
13408   init_function_start (decl1, input_filename, lineno);
13409   current_binding_level = bl;
13410
13411   /* Even though we're inside a function body, we still don't want to
13412      call expand_expr to calculate the size of a variable-sized array.
13413      We haven't necessarily assigned RTL to all variables yet, so it's
13414      not safe to try to expand expressions involving them.  */
13415   immediate_size_expand = 0;
13416   cfun->x_dont_save_pending_sizes_p = 1;
13417
13418   /* Start the statement-tree, start the tree now.  */
13419   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13420
13421   /* Let the user know we're compiling this function.  */
13422   announce_function (decl1);
13423
13424   /* Record the decl so that the function name is defined.
13425      If we already have a decl for this name, and it is a FUNCTION_DECL,
13426      use the old decl.  */
13427   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13428     {
13429       /* A specialization is not used to guide overload resolution.  */
13430       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13431           && ! DECL_FUNCTION_MEMBER_P (decl1))
13432         decl1 = pushdecl (decl1);
13433       else
13434         {
13435           /* We need to set the DECL_CONTEXT. */
13436           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13437             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13438           /* And make sure we have enough default args.  */
13439           check_default_args (decl1);
13440         }
13441       fntype = TREE_TYPE (decl1);
13442     }
13443
13444   /* Reset these in case the call to pushdecl changed them.  */
13445   current_function_decl = decl1;
13446   cfun->decl = decl1;
13447
13448   /* If we are (erroneously) defining a function that we have already
13449      defined before, wipe out what we knew before.  */
13450   if (!DECL_PENDING_INLINE_P (decl1)
13451       && DECL_SAVED_FUNCTION_DATA (decl1))
13452     {
13453       free (DECL_SAVED_FUNCTION_DATA (decl1));
13454       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13455     }
13456
13457   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13458     {
13459       /* We know that this was set up by `grokclassfn'.  We do not
13460          wait until `store_parm_decls', since evil parse errors may
13461          never get us to that point.  Here we keep the consistency
13462          between `current_class_type' and `current_class_ptr'.  */
13463       tree t = DECL_ARGUMENTS (decl1);
13464
13465       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13466                           162);
13467       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13468                           19990811);
13469
13470       cp_function_chain->x_current_class_ref
13471         = build_indirect_ref (t, NULL);
13472       cp_function_chain->x_current_class_ptr = t;
13473
13474       /* Constructors and destructors need to know whether they're "in
13475          charge" of initializing virtual base classes.  */
13476       t = TREE_CHAIN (t);
13477       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13478         {
13479           current_in_charge_parm = t;
13480           t = TREE_CHAIN (t);
13481         }
13482       if (DECL_HAS_VTT_PARM_P (decl1))
13483         {
13484           if (DECL_NAME (t) != vtt_parm_identifier)
13485             abort ();
13486           current_vtt_parm = t;
13487         }
13488     }
13489
13490   if (DECL_INTERFACE_KNOWN (decl1))
13491     {
13492       tree ctx = decl_function_context (decl1);
13493
13494       if (DECL_NOT_REALLY_EXTERN (decl1))
13495         DECL_EXTERNAL (decl1) = 0;
13496
13497       if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
13498           && TREE_PUBLIC (ctx))
13499         /* This is a function in a local class in an extern inline
13500            function.  */
13501         comdat_linkage (decl1);
13502     }
13503   /* If this function belongs to an interface, it is public.
13504      If it belongs to someone else's interface, it is also external.
13505      This only affects inlines and template instantiations.  */
13506   else if (interface_unknown == 0
13507            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13508                || flag_alt_external_templates))
13509     {
13510       if (DECL_DECLARED_INLINE_P (decl1)
13511           || DECL_TEMPLATE_INSTANTIATION (decl1)
13512           || processing_template_decl)
13513         {
13514           DECL_EXTERNAL (decl1)
13515             = (interface_only
13516                || (DECL_DECLARED_INLINE_P (decl1)
13517                    && ! flag_implement_inlines
13518                    && !DECL_VINDEX (decl1)));
13519
13520           /* For WIN32 we also want to put these in linkonce sections.  */
13521           maybe_make_one_only (decl1);
13522         }
13523       else
13524         DECL_EXTERNAL (decl1) = 0;
13525       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13526       DECL_INTERFACE_KNOWN (decl1) = 1;
13527     }
13528   else if (interface_unknown && interface_only
13529            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13530                || flag_alt_external_templates))
13531     {
13532       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13533          interface, we will have interface_only set but not
13534          interface_known.  In that case, we don't want to use the normal
13535          heuristics because someone will supply a #pragma implementation
13536          elsewhere, and deducing it here would produce a conflict.  */
13537       comdat_linkage (decl1);
13538       DECL_EXTERNAL (decl1) = 0;
13539       DECL_INTERFACE_KNOWN (decl1) = 1;
13540       DECL_DEFER_OUTPUT (decl1) = 1;
13541     }
13542   else
13543     {
13544       /* This is a definition, not a reference.
13545          So clear DECL_EXTERNAL.  */
13546       DECL_EXTERNAL (decl1) = 0;
13547
13548       if ((DECL_DECLARED_INLINE_P (decl1)
13549            || DECL_TEMPLATE_INSTANTIATION (decl1))
13550           && ! DECL_INTERFACE_KNOWN (decl1)
13551           /* Don't try to defer nested functions for now.  */
13552           && ! decl_function_context (decl1))
13553         DECL_DEFER_OUTPUT (decl1) = 1;
13554       else
13555         DECL_INTERFACE_KNOWN (decl1) = 1;
13556     }
13557
13558   pushlevel (0);
13559   current_binding_level->parm_flag = 1;
13560
13561   cplus_decl_attributes (&decl1, NULL_TREE, attrs, 0);
13562
13563   /* Promote the value to int before returning it.  */
13564   if (c_promoting_integer_type_p (restype))
13565     restype = type_promotes_to (restype);
13566
13567   if (DECL_RESULT (decl1) == NULL_TREE)
13568     {
13569       DECL_RESULT (decl1)
13570         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13571       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13572       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13573     }
13574
13575   ++function_depth;
13576
13577   if (DECL_DESTRUCTOR_P (decl1))
13578     {
13579       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13580       DECL_CONTEXT (dtor_label) = current_function_decl;
13581     }
13582
13583   start_fname_decls ();
13584
13585   store_parm_decls (current_function_parms);
13586
13587   return 1;
13588 }
13589 \f
13590 /* Store the parameter declarations into the current function declaration.
13591    This is called after parsing the parameter declarations, before
13592    digesting the body of the function.
13593
13594    Also install to binding contour return value identifier, if any.  */
13595
13596 static void
13597 store_parm_decls (current_function_parms)
13598      tree current_function_parms;
13599 {
13600   register tree fndecl = current_function_decl;
13601   register tree parm;
13602   int parms_have_cleanups = 0;
13603   tree cleanups = NULL_TREE;
13604
13605   /* This is a chain of any other decls that came in among the parm
13606      declarations.  If a parm is declared with  enum {foo, bar} x;
13607      then CONST_DECLs for foo and bar are put here.  */
13608   tree nonparms = NULL_TREE;
13609
13610   if (current_function_parms)
13611     {
13612       /* This case is when the function was defined with an ANSI prototype.
13613          The parms already have decls, so we need not do anything here
13614          except record them as in effect
13615          and complain if any redundant old-style parm decls were written.  */
13616
13617       tree specparms = current_function_parms;
13618       tree next;
13619
13620       /* Must clear this because it might contain TYPE_DECLs declared
13621              at class level.  */
13622       storedecls (NULL_TREE);
13623
13624       /* If we're doing semantic analysis, then we'll call pushdecl
13625              for each of these.  We must do them in reverse order so that
13626              they end in the correct forward order.  */
13627       specparms = nreverse (specparms);
13628
13629       for (parm = specparms; parm; parm = next)
13630         {
13631           next = TREE_CHAIN (parm);
13632           if (TREE_CODE (parm) == PARM_DECL)
13633             {
13634               tree cleanup;
13635
13636               if (DECL_NAME (parm) == NULL_TREE
13637                   || TREE_CODE (parm) != VOID_TYPE)
13638                 pushdecl (parm);
13639               else
13640                 cp_error ("parameter `%D' declared void", parm);
13641
13642               cleanup = (processing_template_decl
13643                          ? NULL_TREE
13644                          : maybe_build_cleanup (parm));
13645
13646               if (cleanup)
13647                 cleanups = tree_cons (parm, cleanup, cleanups);
13648             }
13649           else
13650             {
13651               /* If we find an enum constant or a type tag,
13652                  put it aside for the moment.  */
13653               TREE_CHAIN (parm) = NULL_TREE;
13654               nonparms = chainon (nonparms, parm);
13655             }
13656         }
13657
13658       /* Get the decls in their original chain order and record in the
13659          function.  This is all and only the PARM_DECLs that were
13660          pushed into scope by the loop above.  */
13661       DECL_ARGUMENTS (fndecl) = getdecls ();
13662       storetags (gettags ());
13663     }
13664   else
13665     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13666
13667   /* Now store the final chain of decls for the arguments
13668      as the decl-chain of the current lexical scope.
13669      Put the enumerators in as well, at the front so that
13670      DECL_ARGUMENTS is not modified.  */
13671   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13672
13673   /* Now that we have initialized the parms, we can start their
13674      cleanups.  We cannot do this before, since expand_decl_cleanup
13675      should not be called before the parm can be used.  */
13676   while (cleanups)
13677     {
13678       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13679                            TREE_VALUE (cleanups));
13680       cleanups = TREE_CHAIN (cleanups);
13681     }
13682
13683   /* Create a binding contour which can be used to catch
13684      cleanup-generated temporaries.  */
13685   if (parms_have_cleanups)
13686     pushlevel (0);
13687
13688   /* Do the starting of the exception specifications, if we have any.  */
13689   if (flag_exceptions && !processing_template_decl
13690       && flag_enforce_eh_specs
13691       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13692     current_eh_spec_block = begin_eh_spec_block ();
13693 }
13694
13695 \f
13696 /* We have finished doing semantic analysis on DECL, but have not yet
13697    generated RTL for its body.  Save away our current state, so that
13698    when we want to generate RTL later we know what to do.  */
13699
13700 static void
13701 save_function_data (decl)
13702      tree decl;
13703 {
13704   struct cp_language_function *f;
13705
13706   /* Save the language-specific per-function data so that we can
13707      get it back when we really expand this function.  */
13708   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13709                       19990908);
13710
13711   /* Make a copy.  */
13712   f = ((struct cp_language_function *)
13713        xmalloc (sizeof (struct cp_language_function)));
13714   memcpy (f, cp_function_chain, sizeof (struct cp_language_function));
13715   DECL_SAVED_FUNCTION_DATA (decl) = f;
13716
13717   /* Clear out the bits we don't need.  */
13718   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
13719   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
13720   f->x_named_label_uses = NULL;
13721   f->bindings = NULL;
13722   f->x_local_names = NULL;
13723
13724   /* When we get back here again, we will be expanding.  */
13725   f->x_expanding_p = 1;
13726
13727   /* If we've already decided that we cannot inline this function, we
13728      must remember that fact when we actually go to expand the
13729      function.  */
13730   if (current_function_cannot_inline)
13731     {
13732       f->cannot_inline = current_function_cannot_inline;
13733       DECL_INLINE (decl) = 0;
13734     }
13735 }
13736
13737 /* At the end of every constructor we generate to code to return
13738    `this'.  Do that now.  */
13739
13740 static void
13741 finish_constructor_body ()
13742 {
13743   /* Any return from a constructor will end up here.  */
13744   if (ctor_label)
13745     add_stmt (build_stmt (LABEL_STMT, ctor_label));
13746
13747   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13748      generate the return, rather than a goto to CTOR_LABEL.  */
13749   ctor_label = NULL_TREE;
13750   /* In check_return_expr we translate an empty return from a
13751      constructor to a return of `this'.  */
13752   finish_return_stmt (NULL_TREE);
13753   /* Mark the end of the constructor.  */
13754   add_stmt (build_stmt (CTOR_STMT));
13755 }
13756
13757 /* At the end of every destructor we generate code to restore virtual
13758    function tables to the values desired by base classes and to call
13759    to base class destructors.  Do that now.  */
13760
13761 static void
13762 finish_destructor_body ()
13763 {
13764   tree compound_stmt;
13765   tree exprstmt;
13766
13767   /* Create a block to contain all the extra code.  */
13768   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13769
13770   /* Any return from a destructor will end up here.  */
13771   add_stmt (build_stmt (LABEL_STMT, dtor_label));
13772
13773   /* Generate the code to call destructor on base class.  If this
13774      destructor belongs to a class with virtual functions, then set
13775      the virtual function table pointer to represent the type of our
13776      base class.  */
13777
13778   /* This side-effect makes call to `build_delete' generate the code
13779      we have to have at the end of this destructor.  `build_delete'
13780      will set the flag again.  */
13781   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13782
13783   exprstmt = build_delete (current_class_type,
13784                            current_class_ref,
13785                            sfk_base_destructor,
13786                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13787                            0);
13788
13789   if (exprstmt != error_mark_node
13790       && (TREE_CODE (exprstmt) != NOP_EXPR
13791           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13792           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13793     {
13794       if (exprstmt != void_zero_node)
13795         /* Don't call `expand_expr_stmt' if we're not going to do
13796            anything, since -Wall will give a diagnostic.  */
13797         finish_expr_stmt (exprstmt);
13798
13799       /* Run destructors for all virtual baseclasses.  */
13800       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13801         {
13802           tree vbases;
13803           tree if_stmt;
13804
13805           if_stmt = begin_if_stmt ();
13806           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13807                                       current_in_charge_parm,
13808                                       integer_two_node),
13809                                if_stmt);
13810
13811           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
13812           /* The CLASSTYPE_VBASECLASSES list is in initialization
13813              order, so we have to march through it in reverse order.  */
13814           for (vbases = nreverse (copy_list (vbases));
13815                vbases;
13816                vbases = TREE_CHAIN (vbases))
13817             {
13818               tree vbase = TREE_VALUE (vbases);
13819               tree base_type = BINFO_TYPE (vbase);
13820
13821               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (base_type))
13822                 {
13823                   tree base_ptr_type = build_pointer_type (base_type);
13824                   tree expr = current_class_ptr;
13825
13826                   /* Convert to the basetype here, as we know the layout is
13827                      fixed. What is more, if we let build_method_call do it,
13828                      it will use the vtable, which may have been clobbered
13829                      by the deletion of our primary base.  */
13830
13831                   expr = build1 (NOP_EXPR, base_ptr_type, expr);
13832                   expr = build (PLUS_EXPR, base_ptr_type, expr,
13833                                 BINFO_OFFSET (vbase));
13834                   expr = build_indirect_ref (expr, NULL);
13835                   expr = build_method_call (expr, base_dtor_identifier,
13836                                             NULL_TREE, vbase,
13837                                             LOOKUP_NORMAL);
13838                   finish_expr_stmt (expr);
13839                 }
13840             }
13841
13842           finish_then_clause (if_stmt);
13843           finish_if_stmt ();
13844         }
13845     }
13846
13847   /* In a virtual destructor, we must call delete.  */
13848   if (DECL_VIRTUAL_P (current_function_decl))
13849     {
13850       tree if_stmt;
13851       tree virtual_size = c_sizeof (current_class_type);
13852
13853       /* [class.dtor]
13854
13855          At the point of definition of a virtual destructor (including
13856          an implicit definition), non-placement operator delete shall
13857          be looked up in the scope of the destructor's class and if
13858          found shall be accessible and unambiguous.  */
13859       exprstmt = build_op_delete_call
13860         (DELETE_EXPR, current_class_ptr, virtual_size,
13861          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13862
13863       if_stmt = begin_if_stmt ();
13864       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13865                                   current_in_charge_parm,
13866                                   integer_one_node),
13867                            if_stmt);
13868       finish_expr_stmt (exprstmt);
13869       finish_then_clause (if_stmt);
13870       finish_if_stmt ();
13871     }
13872
13873   /* Close the block we started above.  */
13874   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13875 }
13876
13877 /* Finish up a function declaration and compile that function
13878    all the way to assembler language output.  The free the storage
13879    for the function definition.
13880
13881    FLAGS is a bitwise or of the following values:
13882      1 - CALL_POPLEVEL
13883        An extra call to poplevel (and expand_end_bindings) must be
13884        made to take care of the binding contour for the base
13885        initializers.  This is only relevant for constructors.
13886      2 - INCLASS_INLINE
13887        We just finished processing the body of an in-class inline
13888        function definition.  (This processing will have taken place
13889        after the class definition is complete.)  */
13890
13891 tree
13892 finish_function (flags)
13893      int flags;
13894 {
13895   register tree fndecl = current_function_decl;
13896   tree fntype, ctype = NULL_TREE;
13897   int call_poplevel = (flags & 1) != 0;
13898   int inclass_inline = (flags & 2) != 0;
13899   int nested;
13900
13901   /* When we get some parse errors, we can end up without a
13902      current_function_decl, so cope.  */
13903   if (fndecl == NULL_TREE)
13904     return error_mark_node;
13905
13906   nested = function_depth > 1;
13907   fntype = TREE_TYPE (fndecl);
13908
13909   /*  TREE_READONLY (fndecl) = 1;
13910       This caused &foo to be of type ptr-to-const-function
13911       which then got a warning when stored in a ptr-to-function variable.  */
13912
13913   my_friendly_assert (building_stmt_tree (), 20000911);
13914
13915   finish_fname_decls ();
13916
13917   /* For a cloned function, we've already got all the code we need;
13918      there's no need to add any extra bits.  */
13919   if (!DECL_CLONED_FUNCTION_P (fndecl))
13920     {
13921       if (DECL_CONSTRUCTOR_P (fndecl))
13922         {
13923           finish_constructor_body ();
13924           if (call_poplevel)
13925             do_poplevel ();
13926         }
13927       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
13928         finish_destructor_body ();
13929       else if (DECL_MAIN_P (fndecl))
13930         {
13931           /* Make it so that `main' always returns 0 by default.  */
13932 #ifdef VMS
13933           finish_return_stmt (integer_one_node);
13934 #else
13935           finish_return_stmt (integer_zero_node);
13936 #endif
13937         }
13938
13939       /* Finish dealing with exception specifiers.  */
13940       if (flag_exceptions && !processing_template_decl
13941           && flag_enforce_eh_specs
13942           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13943         finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
13944                               (TREE_TYPE (current_function_decl)),
13945                               current_eh_spec_block);
13946     }
13947
13948   /* If we're saving up tree structure, tie off the function now.  */
13949   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
13950
13951   /* This must come after expand_function_end because cleanups might
13952      have declarations (from inline functions) that need to go into
13953      this function's blocks.  */
13954   if (current_binding_level->parm_flag != 1)
13955     my_friendly_abort (122);
13956   poplevel (1, 0, 1);
13957
13958   /* Set up the named return value optimization, if we can.  Here, we
13959      eliminate the copy from the nrv into the RESULT_DECL and any cleanup
13960      for the nrv.  genrtl_start_function and declare_return_variable
13961      handle making the nrv and RESULT_DECL share space.  */
13962   if (current_function_return_value)
13963     {
13964       tree r = current_function_return_value;
13965       /* This is only worth doing for fns that return in memory--and
13966          simpler, since we don't have to worry about promoted modes.  */
13967       if (r != error_mark_node
13968           && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl))))
13969         {
13970           DECL_ALIGN (r) = DECL_ALIGN (DECL_RESULT (fndecl));
13971           walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl),
13972                                         nullify_returns_r, r);
13973         }
13974       else
13975         /* Clear it so genrtl_start_function and declare_return_variable
13976            know we're not optimizing.  */
13977         current_function_return_value = NULL_TREE;
13978     }
13979
13980   /* Remember that we were in class scope.  */
13981   if (current_class_name)
13982     ctype = current_class_type;
13983
13984   /* Must mark the RESULT_DECL as being in this function.  */
13985   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
13986
13987   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13988      to the FUNCTION_DECL node itself.  */
13989   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
13990
13991   /* Save away current state, if appropriate.  */
13992   if (!processing_template_decl)
13993     save_function_data (fndecl);
13994
13995   /* If this function calls `setjmp' it cannot be inlined.  When
13996      `longjmp' is called it is not guaranteed to restore the value of
13997      local variables that have been modified since the call to
13998      `setjmp'.  So, if were to inline this function into some caller
13999      `c', then when we `longjmp', we might not restore all variables
14000      in `c'.  (It might seem, at first blush, that there's no way for
14001      this function to modify local variables in `c', but their
14002      addresses may have been stored somewhere accessible to this
14003      function.)  */
14004   if (!processing_template_decl && calls_setjmp_p (fndecl))
14005     DECL_UNINLINABLE (fndecl) = 1;
14006
14007   /* Clear out memory we no longer need.  */
14008   free_after_parsing (cfun);
14009   /* Since we never call rest_of_compilation, we never clear
14010      CFUN.  Do so explicitly.  */
14011   free_after_compilation (cfun);
14012   cfun = NULL;
14013
14014   /* If this is a in-class inline definition, we may have to pop the
14015      bindings for the template parameters that we added in
14016      maybe_begin_member_template_processing when start_function was
14017      called.  */
14018   if (inclass_inline)
14019     maybe_end_member_template_processing ();
14020
14021   /* Leave the scope of the class.  */
14022   if (ctype)
14023     pop_nested_class ();
14024
14025   --function_depth;
14026
14027   /* Clean up.  */
14028   if (! nested)
14029     /* Let the error reporting routines know that we're outside a
14030        function.  For a nested function, this value is used in
14031        pop_cp_function_context and then reset via pop_function_context.  */
14032     current_function_decl = NULL_TREE;
14033
14034   return fndecl;
14035 }
14036 \f
14037 /* Create the FUNCTION_DECL for a function definition.
14038    DECLSPECS and DECLARATOR are the parts of the declaration;
14039    they describe the return type and the name of the function,
14040    but twisted together in a fashion that parallels the syntax of C.
14041
14042    This function creates a binding context for the function body
14043    as well as setting up the FUNCTION_DECL in current_function_decl.
14044
14045    Returns a FUNCTION_DECL on success.
14046
14047    If the DECLARATOR is not suitable for a function (it defines a datum
14048    instead), we return 0, which tells yyparse to report a parse error.
14049
14050    May return void_type_node indicating that this method is actually
14051    a friend.  See grokfield for more details.
14052
14053    Came here with a `.pushlevel' .
14054
14055    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14056    CHANGES TO CODE IN `grokfield'.  */
14057
14058 tree
14059 start_method (declspecs, declarator, attrlist)
14060      tree declarator, declspecs, attrlist;
14061 {
14062   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14063                                 attrlist);
14064
14065   /* Something too ugly to handle.  */
14066   if (fndecl == NULL_TREE)
14067     return NULL_TREE;
14068
14069   /* Pass friends other than inline friend functions back.  */
14070   if (fndecl == void_type_node)
14071     return fndecl;
14072
14073   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14074     /* Not a function, tell parser to report parse error.  */
14075     return NULL_TREE;
14076
14077   if (DECL_IN_AGGR_P (fndecl))
14078     {
14079       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14080         {
14081           if (DECL_CONTEXT (fndecl)
14082               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14083             cp_error ("`%D' is already defined in class `%T'", fndecl,
14084                       DECL_CONTEXT (fndecl));
14085         }
14086       return void_type_node;
14087     }
14088
14089   check_template_shadow (fndecl);
14090
14091   DECL_DECLARED_INLINE_P (fndecl) = 1;
14092
14093   if (flag_default_inline)
14094     DECL_INLINE (fndecl) = 1;
14095
14096   /* We process method specializations in finish_struct_1.  */
14097   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14098     fndecl = push_template_decl (fndecl);
14099
14100   if (! DECL_FRIEND_P (fndecl))
14101     {
14102       if (TREE_CHAIN (fndecl))
14103         {
14104           fndecl = copy_node (fndecl);
14105           TREE_CHAIN (fndecl) = NULL_TREE;
14106         }
14107
14108       if (DECL_CONSTRUCTOR_P (fndecl))
14109         {
14110           if (! grok_ctor_properties (current_class_type, fndecl))
14111             return void_type_node;
14112         }
14113       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14114         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14115     }
14116
14117   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14118
14119   /* Make a place for the parms */
14120   pushlevel (0);
14121   current_binding_level->parm_flag = 1;
14122
14123   DECL_IN_AGGR_P (fndecl) = 1;
14124   return fndecl;
14125 }
14126
14127 /* Go through the motions of finishing a function definition.
14128    We don't compile this method until after the whole class has
14129    been processed.
14130
14131    FINISH_METHOD must return something that looks as though it
14132    came from GROKFIELD (since we are defining a method, after all).
14133
14134    This is called after parsing the body of the function definition.
14135    STMTS is the chain of statements that makes up the function body.
14136
14137    DECL is the ..._DECL that `start_method' provided.  */
14138
14139 tree
14140 finish_method (decl)
14141      tree decl;
14142 {
14143   register tree fndecl = decl;
14144   tree old_initial;
14145
14146   register tree link;
14147
14148   if (decl == void_type_node)
14149     return decl;
14150
14151   old_initial = DECL_INITIAL (fndecl);
14152
14153   /* Undo the level for the parms (from start_method).
14154      This is like poplevel, but it causes nothing to be
14155      saved.  Saving information here confuses symbol-table
14156      output routines.  Besides, this information will
14157      be correctly output when this method is actually
14158      compiled.  */
14159
14160   /* Clear out the meanings of the local variables of this level;
14161      also record in each decl which block it belongs to.  */
14162
14163   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14164     {
14165       if (DECL_NAME (link) != NULL_TREE)
14166         pop_binding (DECL_NAME (link), link);
14167       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14168       DECL_CONTEXT (link) = NULL_TREE;
14169     }
14170
14171   GNU_xref_end_scope ((size_t) current_binding_level,
14172                       (size_t) current_binding_level->level_chain,
14173                       current_binding_level->parm_flag,
14174                       current_binding_level->keep);
14175
14176   poplevel (0, 0, 0);
14177
14178   DECL_INITIAL (fndecl) = old_initial;
14179
14180   /* We used to check if the context of FNDECL was different from
14181      current_class_type as another way to get inside here.  This didn't work
14182      for String.cc in libg++.  */
14183   if (DECL_FRIEND_P (fndecl))
14184     {
14185       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14186         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14187       decl = void_type_node;
14188     }
14189
14190   return decl;
14191 }
14192 \f
14193 /* Called when a new struct TYPE is defined.
14194    If this structure or union completes the type of any previous
14195    variable declaration, lay it out and output its rtl.  */
14196
14197 void
14198 hack_incomplete_structures (type)
14199      tree type;
14200 {
14201   tree *list;
14202   struct binding_level *level;
14203
14204   if (!type) /* Don't do this for class templates.  */
14205     return;
14206
14207   if (namespace_bindings_p ())
14208     {
14209       level = 0;
14210       list = &namespace_scope_incomplete;
14211     }
14212   else
14213     {
14214       level = innermost_nonclass_level ();
14215       list = &level->incomplete;
14216     }
14217
14218   while (1)
14219     {
14220       while (*list)
14221         {
14222           tree decl = TREE_VALUE (*list);
14223           if ((decl && TREE_TYPE (decl) == type)
14224               || (TREE_TYPE (decl)
14225                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14226                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14227             {
14228               int toplevel = toplevel_bindings_p ();
14229               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14230                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14231                 layout_type (TREE_TYPE (decl));
14232               layout_decl (decl, 0);
14233               rest_of_decl_compilation (decl, NULL, toplevel, 0);
14234               if (! toplevel)
14235                 {
14236                   tree cleanup;
14237                   expand_decl (decl);
14238                   cleanup = maybe_build_cleanup (decl);
14239                   expand_decl_init (decl);
14240                   if (! expand_decl_cleanup (decl, cleanup))
14241                     cp_error ("parser lost in parsing declaration of `%D'",
14242                               decl);
14243                 }
14244               *list = TREE_CHAIN (*list);
14245             }
14246           else
14247             list = &TREE_CHAIN (*list);
14248         }
14249
14250       /* Keep looking through artificial binding levels generated
14251          for local variables.  */
14252       if (level && level->keep == 2)
14253         {
14254           level = level->level_chain;
14255           list = &level->incomplete;
14256         }
14257       else
14258         break;
14259     }
14260 }
14261
14262 /* If DECL is of a type which needs a cleanup, build that cleanup
14263    here.  */
14264
14265 tree
14266 maybe_build_cleanup (decl)
14267      tree decl;
14268 {
14269   tree type = TREE_TYPE (decl);
14270
14271   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14272     {
14273       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14274       tree rval;
14275
14276       if (TREE_CODE (type) == ARRAY_TYPE)
14277         rval = decl;
14278       else
14279         {
14280           mark_addressable (decl);
14281           rval = build_unary_op (ADDR_EXPR, decl, 0);
14282         }
14283
14284       /* Optimize for space over speed here.  */
14285       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14286           || flag_expensive_optimizations)
14287         flags |= LOOKUP_NONVIRTUAL;
14288
14289       rval = build_delete (TREE_TYPE (rval), rval,
14290                            sfk_complete_destructor, flags, 0);
14291
14292       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14293           && ! TYPE_HAS_DESTRUCTOR (type))
14294         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14295                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14296
14297       return rval;
14298     }
14299   return 0;
14300 }
14301 \f
14302 /* When a stmt has been parsed, this function is called.  */
14303
14304 void
14305 finish_stmt ()
14306 {
14307   /* Always assume this statement was not an expression statement.  If
14308      it actually was an expression statement, its our callers
14309      responsibility to fix this up.  */
14310   last_expr_type = NULL_TREE;
14311 }
14312
14313 /* DECL was originally constructed as a non-static member function,
14314    but turned out to be static.  Update it accordingly.  */
14315
14316 void
14317 revert_static_member_fn (decl)
14318      tree decl;
14319 {
14320   tree tmp;
14321   tree function = TREE_TYPE (decl);
14322   tree args = TYPE_ARG_TYPES (function);
14323
14324   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14325       != TYPE_UNQUALIFIED)
14326     cp_error ("static member function `%#D' declared with type qualifiers",
14327               decl);
14328
14329   args = TREE_CHAIN (args);
14330   tmp = build_function_type (TREE_TYPE (function), args);
14331   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14332   tmp = build_exception_variant (tmp,
14333                                  TYPE_RAISES_EXCEPTIONS (function));
14334   TREE_TYPE (decl) = tmp;
14335   if (DECL_ARGUMENTS (decl))
14336     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14337   DECL_STATIC_FUNCTION_P (decl) = 1;
14338 }
14339
14340 /* Initialize the variables used during compilation of a C++
14341    function.  */
14342
14343 static void
14344 push_cp_function_context (f)
14345      struct function *f;
14346 {
14347   struct cp_language_function *p
14348     = ((struct cp_language_function *)
14349        xcalloc (1, sizeof (struct cp_language_function)));
14350   f->language = (struct language_function *) p;
14351
14352   /* It takes an explicit call to expand_body to generate RTL for a
14353      function.  */
14354   expanding_p = 0;
14355
14356   /* Whenever we start a new function, we destroy temporaries in the
14357      usual way.  */
14358   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14359 }
14360
14361 /* Free the language-specific parts of F, now that we've finished
14362    compiling the function.  */
14363
14364 static void
14365 pop_cp_function_context (f)
14366      struct function *f;
14367 {
14368   if (f->language)
14369     {
14370       struct cp_language_function *cp =
14371         (struct cp_language_function *) f->language;
14372       if (cp->x_local_names)
14373         VARRAY_FREE (cp->x_local_names);
14374       free (f->language);
14375     }
14376   f->language = 0;
14377 }
14378
14379 /* Mark P for GC.  */
14380
14381 static void
14382 mark_lang_function (p)
14383      struct cp_language_function *p;
14384 {
14385   if (!p)
14386     return;
14387
14388   mark_c_language_function (&p->base);
14389
14390   ggc_mark_tree (p->x_ctor_label);
14391   ggc_mark_tree (p->x_dtor_label);
14392   ggc_mark_tree (p->x_current_class_ptr);
14393   ggc_mark_tree (p->x_current_class_ref);
14394   ggc_mark_tree (p->x_eh_spec_block);
14395   ggc_mark_tree_varray (p->x_local_names);
14396
14397   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14398   mark_binding_level (&p->bindings);
14399 }
14400
14401 /* Mark the language-specific data in F for GC.  */
14402
14403 static void
14404 mark_cp_function_context (f)
14405      struct function *f;
14406 {
14407   mark_lang_function ((struct cp_language_function *) f->language);
14408 }
14409
14410 void
14411 lang_mark_tree (t)
14412      tree t;
14413 {
14414   enum tree_code code = TREE_CODE (t);
14415   if (code == IDENTIFIER_NODE)
14416     {
14417       struct lang_identifier *li = (struct lang_identifier *) t;
14418       struct lang_id2 *li2 = li->x;
14419       ggc_mark_tree (li->namespace_bindings);
14420       ggc_mark_tree (li->bindings);
14421       ggc_mark_tree (li->class_value);
14422       ggc_mark_tree (li->class_template_info);
14423
14424       if (li2)
14425         {
14426           ggc_mark_tree (li2->label_value);
14427           ggc_mark_tree (li2->implicit_decl);
14428           ggc_mark_tree (li2->error_locus);
14429         }
14430     }
14431   else if (code == CPLUS_BINDING)
14432     {
14433       if (BINDING_HAS_LEVEL_P (t))
14434         mark_binding_level (&BINDING_LEVEL (t));
14435       else
14436         ggc_mark_tree (BINDING_SCOPE (t));
14437       ggc_mark_tree (BINDING_VALUE (t));
14438     }
14439   else if (code == OVERLOAD)
14440     ggc_mark_tree (OVL_FUNCTION (t));
14441   else if (code == TEMPLATE_PARM_INDEX)
14442     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14443   else if (TREE_CODE_CLASS (code) == 'd')
14444     {
14445       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14446
14447       if (ld)
14448         {
14449           ggc_mark (ld);
14450           c_mark_lang_decl (&ld->decl_flags.base);
14451           if (!DECL_GLOBAL_CTOR_P (t)
14452               && !DECL_GLOBAL_DTOR_P (t)
14453               && !DECL_THUNK_P (t)
14454               && !DECL_DISCRIMINATOR_P (t))
14455             ggc_mark_tree (ld->decl_flags.u2.access);
14456           else if (DECL_THUNK_P (t))
14457             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14458           if (TREE_CODE (t) != NAMESPACE_DECL)
14459             ggc_mark_tree (ld->decl_flags.u.template_info);
14460           else
14461             mark_binding_level (&NAMESPACE_LEVEL (t));
14462           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14463             {
14464               ggc_mark_tree (ld->befriending_classes);
14465               ggc_mark_tree (ld->context);
14466               ggc_mark_tree (ld->cloned_function);
14467               ggc_mark_tree (ld->inlined_fns);
14468               if (TREE_CODE (t) == TYPE_DECL)
14469                 ggc_mark_tree (ld->u.sorted_fields);
14470               else if (TREE_CODE (t) == FUNCTION_DECL
14471                        && !DECL_PENDING_INLINE_P (t))
14472                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14473             }
14474         }
14475     }
14476   else if (TREE_CODE_CLASS (code) == 't')
14477     {
14478       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14479
14480       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14481                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14482         {
14483           ggc_mark (lt);
14484           ggc_mark_tree (lt->primary_base);
14485           ggc_mark_tree (lt->vfields);
14486           ggc_mark_tree (lt->vbases);
14487           ggc_mark_tree (lt->tags);
14488           ggc_mark_tree (lt->size);
14489           ggc_mark_tree (lt->pure_virtuals);
14490           ggc_mark_tree (lt->friend_classes);
14491           ggc_mark_tree (lt->rtti);
14492           ggc_mark_tree (lt->methods);
14493           ggc_mark_tree (lt->template_info);
14494           ggc_mark_tree (lt->befriending_classes);
14495         }
14496       else if (lt)
14497         /* In the case of pointer-to-member function types, the
14498            TYPE_LANG_SPECIFIC is really just a tree.  */
14499         ggc_mark_tree ((tree) lt);
14500     }
14501 }
14502
14503 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14504    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
14505
14506 tree
14507 identifier_global_value (t)
14508      tree t;
14509 {
14510   return IDENTIFIER_GLOBAL_VALUE (t);
14511 }
14512
14513 /* Build the void_list_node (void_type_node having been created).  */
14514 tree
14515 build_void_list_node ()
14516 {
14517   tree t = build_tree_list (NULL_TREE, void_type_node);
14518   TREE_PARMLIST (t) = 1;
14519   return t;
14520 }
14521
14522 static int
14523 cp_missing_noreturn_ok_p (decl)
14524      tree decl;
14525 {
14526   /* A missing noreturn is ok for the `main' function.  */
14527   return DECL_MAIN_P (decl);
14528 }