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 *const explicit_extern_static_warning
3032     = "`%D' was declared `extern' and later `static'";
3033   static const char *const 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           /* Don't clear out the arguments if we're redefining a function.  */
3680           if (DECL_ARGUMENTS (olddecl))
3681             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3682         }
3683     }
3684   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3685     NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3686
3687   /* Now preserve various other info from the definition.  */
3688   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3689   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3690   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3691   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3692
3693   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3694     {
3695       int function_size;
3696
3697       function_size = sizeof (struct tree_decl);
3698
3699       memcpy ((char *) olddecl + sizeof (struct tree_common),
3700               (char *) newdecl + sizeof (struct tree_common),
3701               function_size - sizeof (struct tree_common));
3702
3703       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3704         {
3705           /* If newdecl is a template instantiation, it is possible that
3706              the following sequence of events has occurred:
3707
3708              o A friend function was declared in a class template.  The
3709              class template was instantiated.
3710
3711              o The instantiation of the friend declaration was
3712              recorded on the instantiation list, and is newdecl.
3713
3714              o Later, however, instantiate_class_template called pushdecl
3715              on the newdecl to perform name injection.  But, pushdecl in
3716              turn called duplicate_decls when it discovered that another
3717              declaration of a global function with the same name already
3718              existed.
3719
3720              o Here, in duplicate_decls, we decided to clobber newdecl.
3721
3722              If we're going to do that, we'd better make sure that
3723              olddecl, and not newdecl, is on the list of
3724              instantiations so that if we try to do the instantiation
3725              again we won't get the clobbered declaration.  */
3726
3727           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3728           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3729
3730           for (; decls; decls = TREE_CHAIN (decls))
3731             if (TREE_VALUE (decls) == newdecl)
3732               TREE_VALUE (decls) = olddecl;
3733         }
3734     }
3735   else
3736     {
3737       memcpy ((char *) olddecl + sizeof (struct tree_common),
3738               (char *) newdecl + sizeof (struct tree_common),
3739               sizeof (struct tree_decl) - sizeof (struct tree_common)
3740               + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3741     }
3742
3743   DECL_UID (olddecl) = olddecl_uid;
3744   if (olddecl_friend)
3745     DECL_FRIEND_P (olddecl) = 1;
3746
3747   /* NEWDECL contains the merged attribute lists.
3748      Update OLDDECL to be the same.  */
3749   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3750
3751   return 1;
3752 }
3753
3754 /* Record a decl-node X as belonging to the current lexical scope.
3755    Check for errors (such as an incompatible declaration for the same
3756    name already seen in the same scope).
3757
3758    Returns either X or an old decl for the same name.
3759    If an old decl is returned, it may have been smashed
3760    to agree with what X says.  */
3761
3762 tree
3763 pushdecl (x)
3764      tree x;
3765 {
3766   register tree t;
3767   register tree name;
3768   int need_new_binding;
3769
3770   /* We shouldn't be calling pushdecl when we're generating RTL for a
3771      function that we already did semantic analysis on previously.  */
3772   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3773                       19990913);
3774
3775   need_new_binding = 1;
3776
3777   if (DECL_TEMPLATE_PARM_P (x))
3778     /* Template parameters have no context; they are not X::T even
3779        when declared within a class or namespace.  */
3780     ;
3781   else
3782     {
3783       if (current_function_decl && x != current_function_decl
3784           /* A local declaration for a function doesn't constitute
3785              nesting.  */
3786           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3787           /* A local declaration for an `extern' variable is in the
3788              scope of the current namespace, not the current
3789              function.  */
3790           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3791           && !DECL_CONTEXT (x))
3792         DECL_CONTEXT (x) = current_function_decl;
3793
3794       /* If this is the declaration for a namespace-scope function,
3795          but the declaration itself is in a local scope, mark the
3796          declaration.  */
3797       if (TREE_CODE (x) == FUNCTION_DECL
3798           && DECL_NAMESPACE_SCOPE_P (x)
3799           && current_function_decl
3800           && x != current_function_decl)
3801         DECL_LOCAL_FUNCTION_P (x) = 1;
3802     }
3803
3804   name = DECL_NAME (x);
3805   if (name)
3806     {
3807       int different_binding_level = 0;
3808
3809       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3810         name = TREE_OPERAND (name, 0);
3811
3812       /* In case this decl was explicitly namespace-qualified, look it
3813          up in its namespace context.  */
3814       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3815           && namespace_bindings_p ())
3816         t = namespace_binding (name, DECL_CONTEXT (x));
3817       else
3818         t = lookup_name_current_level (name);
3819
3820       /* [basic.link] If there is a visible declaration of an entity
3821          with linkage having the same name and type, ignoring entities
3822          declared outside the innermost enclosing namespace scope, the
3823          block scope declaration declares that same entity and
3824          receives the linkage of the previous declaration.  */
3825       if (! t && current_function_decl && x != current_function_decl
3826           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3827           && DECL_EXTERNAL (x))
3828         {
3829           /* Look in block scope.  */
3830           t = IDENTIFIER_VALUE (name);
3831           /* Or in the innermost namespace.  */
3832           if (! t)
3833             t = namespace_binding (name, DECL_CONTEXT (x));
3834           /* Does it have linkage?  Note that if this isn't a DECL, it's an
3835              OVERLOAD, which is OK.  */
3836           if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3837             t = NULL_TREE;
3838           if (t)
3839             different_binding_level = 1;
3840         }
3841
3842       /* If we are declaring a function, and the result of name-lookup
3843          was an OVERLOAD, look for an overloaded instance that is
3844          actually the same as the function we are declaring.  (If
3845          there is one, we have to merge our declaration with the
3846          previous declaration.)  */
3847       if (t && TREE_CODE (t) == OVERLOAD)
3848         {
3849           tree match;
3850
3851           if (TREE_CODE (x) == FUNCTION_DECL)
3852             for (match = t; match; match = OVL_NEXT (match))
3853               {
3854                 if (decls_match (OVL_CURRENT (match), x))
3855                   break;
3856               }
3857           else
3858             /* Just choose one.  */
3859             match = t;
3860
3861           if (match)
3862             t = OVL_CURRENT (match);
3863           else
3864             t = NULL_TREE;
3865         }
3866
3867       if (t == error_mark_node)
3868         {
3869           /* error_mark_node is 0 for a while during initialization!  */
3870           t = NULL_TREE;
3871           cp_error_at ("`%#D' used prior to declaration", x);
3872         }
3873       else if (t != NULL_TREE)
3874         {
3875           if (different_binding_level)
3876             {
3877               if (decls_match (x, t))
3878                 /* The standard only says that the local extern
3879                    inherits linkage from the previous decl; in
3880                    particular, default args are not shared.  It would
3881                    be nice to propagate inlining info, though.  FIXME.  */
3882                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3883             }
3884           else if (TREE_CODE (t) == PARM_DECL)
3885             {
3886               if (DECL_CONTEXT (t) == NULL_TREE)
3887                 /* This is probaby caused by too many errors, but calling
3888                    abort will say that if errors have occurred.  */
3889                 abort ();
3890
3891               /* Check for duplicate params.  */
3892               if (duplicate_decls (x, t))
3893                 return t;
3894             }
3895           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3896                     || DECL_FUNCTION_TEMPLATE_P (x))
3897                    && is_overloaded_fn (t))
3898             /* Don't do anything just yet. */;
3899           else if (t == wchar_decl_node)
3900             {
3901               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3902                 cp_pedwarn ("redeclaration of `wchar_t' as `%T'",
3903                             TREE_TYPE (x));
3904
3905               /* Throw away the redeclaration.  */
3906               return t;
3907             }
3908           else if (TREE_CODE (t) != TREE_CODE (x))
3909             {
3910               if (duplicate_decls (x, t))
3911                 return t;
3912             }
3913           else if (duplicate_decls (x, t))
3914             {
3915               if (TREE_CODE (t) == TYPE_DECL)
3916                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3917               else if (TREE_CODE (t) == FUNCTION_DECL)
3918                 check_default_args (t);
3919
3920               return t;
3921             }
3922           else if (DECL_MAIN_P (x))
3923             {
3924               /* A redeclaration of main, but not a duplicate of the
3925                  previous one.
3926
3927                  [basic.start.main]
3928
3929                  This function shall not be overloaded.  */
3930               cp_error_at ("invalid redeclaration of `%D'", t);
3931               cp_error ("as `%D'", x);
3932               /* We don't try to push this declaration since that
3933                  causes a crash.  */
3934               return x;
3935             }
3936         }
3937
3938       check_template_shadow (x);
3939
3940       /* If this is a function conjured up by the backend, massage it
3941          so it looks friendly.  */
3942       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3943         {
3944           retrofit_lang_decl (x);
3945           SET_DECL_LANGUAGE (x, lang_c);
3946         }
3947
3948       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3949         {
3950           t = push_overloaded_decl (x, PUSH_LOCAL);
3951           if (t != x)
3952             return t;
3953           if (!namespace_bindings_p ())
3954             /* We do not need to create a binding for this name;
3955                push_overloaded_decl will have already done so if
3956                necessary.  */
3957             need_new_binding = 0;
3958         }
3959       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3960         {
3961           t = push_overloaded_decl (x, PUSH_GLOBAL);
3962           if (t == x)
3963             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3964           return t;
3965         }
3966
3967       /* If declaring a type as a typedef, copy the type (unless we're
3968          at line 0), and install this TYPE_DECL as the new type's typedef
3969          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3970       if (TREE_CODE (x) == TYPE_DECL)
3971         {
3972           tree type = TREE_TYPE (x);
3973           if (DECL_SOURCE_LINE (x) == 0)
3974             {
3975               if (TYPE_NAME (type) == 0)
3976                 TYPE_NAME (type) = x;
3977             }
3978           else if (type != error_mark_node && TYPE_NAME (type) != x
3979                    /* We don't want to copy the type when all we're
3980                       doing is making a TYPE_DECL for the purposes of
3981                       inlining.  */
3982                    && (!TYPE_NAME (type)
3983                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3984             {
3985               DECL_ORIGINAL_TYPE (x) = type;
3986               type = build_type_copy (type);
3987               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3988               TYPE_NAME (type) = x;
3989               TREE_TYPE (x) = type;
3990             }
3991
3992           if (type != error_mark_node
3993               && TYPE_NAME (type)
3994               && TYPE_IDENTIFIER (type))
3995             set_identifier_type_value_with_scope (DECL_NAME (x), type,
3996                                                   current_binding_level);
3997
3998         }
3999
4000       /* Multiple external decls of the same identifier ought to match.
4001
4002          We get warnings about inline functions where they are defined.
4003          We get warnings about other functions from push_overloaded_decl.
4004
4005          Avoid duplicate warnings where they are used.  */
4006       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4007         {
4008           tree decl;
4009
4010           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4011           if (decl && TREE_CODE (decl) == OVERLOAD)
4012             decl = OVL_FUNCTION (decl);
4013
4014           if (decl && decl != error_mark_node
4015               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4016               /* If different sort of thing, we already gave an error.  */
4017               && TREE_CODE (decl) == TREE_CODE (x)
4018               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4019             {
4020               cp_pedwarn ("type mismatch with previous external decl", x);
4021               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4022             }
4023         }
4024
4025       /* This name is new in its binding level.
4026          Install the new declaration and return it.  */
4027       if (namespace_bindings_p ())
4028         {
4029           /* Install a global value.  */
4030
4031           /* If the first global decl has external linkage,
4032              warn if we later see static one.  */
4033           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4034             TREE_PUBLIC (name) = 1;
4035
4036           /* Bind the name for the entity.  */
4037           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4038                 && t != NULL_TREE)
4039               && (TREE_CODE (x) == TYPE_DECL
4040                   || TREE_CODE (x) == VAR_DECL
4041                   || TREE_CODE (x) == NAMESPACE_DECL
4042                   || TREE_CODE (x) == CONST_DECL
4043                   || TREE_CODE (x) == TEMPLATE_DECL))
4044             SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
4045
4046           /* Don't forget if the function was used via an implicit decl.  */
4047           if (IDENTIFIER_IMPLICIT_DECL (name)
4048               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4049             TREE_USED (x) = 1;
4050
4051           /* Don't forget if its address was taken in that way.  */
4052           if (IDENTIFIER_IMPLICIT_DECL (name)
4053               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4054             TREE_ADDRESSABLE (x) = 1;
4055
4056           /* Warn about mismatches against previous implicit decl.  */
4057           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4058               /* If this real decl matches the implicit, don't complain.  */
4059               && ! (TREE_CODE (x) == FUNCTION_DECL
4060                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4061             cp_warning
4062               ("`%D' was previously implicitly declared to return `int'", x);
4063
4064           /* If new decl is `static' and an `extern' was seen previously,
4065              warn about it.  */
4066           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4067             warn_extern_redeclared_static (x, t);
4068         }
4069       else
4070         {
4071           /* Here to install a non-global value.  */
4072           tree oldlocal = IDENTIFIER_VALUE (name);
4073           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4074
4075           if (need_new_binding)
4076             {
4077               push_local_binding (name, x, 0);
4078               /* Because push_local_binding will hook X on to the
4079                  current_binding_level's name list, we don't want to
4080                  do that again below.  */
4081               need_new_binding = 0;
4082             }
4083
4084           /* If this is a TYPE_DECL, push it into the type value slot.  */
4085           if (TREE_CODE (x) == TYPE_DECL)
4086             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4087                                                   current_binding_level);
4088
4089           /* Clear out any TYPE_DECL shadowed by a namespace so that
4090              we won't think this is a type.  The C struct hack doesn't
4091              go through namespaces.  */
4092           if (TREE_CODE (x) == NAMESPACE_DECL)
4093             set_identifier_type_value_with_scope (name, NULL_TREE,
4094                                                   current_binding_level);
4095
4096           if (oldlocal)
4097             {
4098               tree d = oldlocal;
4099
4100               while (oldlocal
4101                      && TREE_CODE (oldlocal) == VAR_DECL
4102                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4103                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4104
4105               if (oldlocal == NULL_TREE)
4106                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4107             }
4108
4109           /* If this is an extern function declaration, see if we
4110              have a global definition or declaration for the function.  */
4111           if (oldlocal == NULL_TREE
4112               && DECL_EXTERNAL (x)
4113               && oldglobal != NULL_TREE
4114               && TREE_CODE (x) == FUNCTION_DECL
4115               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4116             {
4117               /* We have one.  Their types must agree.  */
4118               if (decls_match (x, oldglobal))
4119                 /* OK */;
4120               else
4121                 {
4122                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4123                   cp_warning_at ("global declaration `%#D'", oldglobal);
4124                 }
4125             }
4126           /* If we have a local external declaration,
4127              and no file-scope declaration has yet been seen,
4128              then if we later have a file-scope decl it must not be static.  */
4129           if (oldlocal == NULL_TREE
4130               && oldglobal == NULL_TREE
4131               && DECL_EXTERNAL (x)
4132               && TREE_PUBLIC (x))
4133             TREE_PUBLIC (name) = 1;
4134
4135           /* Warn if shadowing an argument at the top level of the body.  */
4136           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4137               /* Inline decls shadow nothing.  */
4138               && !DECL_FROM_INLINE (x)
4139               && TREE_CODE (oldlocal) == PARM_DECL
4140               /* Don't complain if it's from an enclosing function.  */
4141               && DECL_CONTEXT (oldlocal) == current_function_decl
4142               && TREE_CODE (x) != PARM_DECL)
4143             {
4144               /* Go to where the parms should be and see if we
4145                  find them there.  */
4146               struct binding_level *b = current_binding_level->level_chain;
4147
4148               if (cleanup_label)
4149                 b = b->level_chain;
4150
4151               /* ARM $8.3 */
4152               if (b->parm_flag == 1)
4153                 cp_error ("declaration of `%#D' shadows a parameter", name);
4154             }
4155
4156           /* Maybe warn if shadowing something else.  */
4157           if (warn_shadow && !DECL_EXTERNAL (x)
4158               /* Inline decls shadow nothing.  */
4159               && !DECL_FROM_INLINE (x)
4160               /* No shadow warnings for internally generated vars.  */
4161               && ! DECL_ARTIFICIAL (x)
4162               /* No shadow warnings for vars made for inlining.  */
4163               && ! DECL_FROM_INLINE (x))
4164             {
4165               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4166                 warning ("declaration of `%s' shadows a parameter",
4167                         IDENTIFIER_POINTER (name));
4168               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4169                        && current_class_ptr
4170                        && !TREE_STATIC (name))
4171                 warning ("declaration of `%s' shadows a member of `this'",
4172                         IDENTIFIER_POINTER (name));
4173               else if (oldlocal != NULL_TREE)
4174                 warning ("declaration of `%s' shadows previous local",
4175                         IDENTIFIER_POINTER (name));
4176               else if (oldglobal != NULL_TREE)
4177                 /* XXX shadow warnings in outer-more namespaces */
4178                 warning ("declaration of `%s' shadows global declaration",
4179                         IDENTIFIER_POINTER (name));
4180             }
4181         }
4182
4183       if (TREE_CODE (x) == FUNCTION_DECL)
4184         check_default_args (x);
4185
4186       /* Keep count of variables in this level with incomplete type.  */
4187       if (TREE_CODE (x) == VAR_DECL
4188           && TREE_TYPE (x) != error_mark_node
4189           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4190                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4191               /* RTTI TD entries are created while defining the type_info.  */
4192               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4193                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4194         {
4195           if (namespace_bindings_p ())
4196             namespace_scope_incomplete
4197               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4198           else
4199             current_binding_level->incomplete
4200               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4201         }
4202     }
4203
4204   if (need_new_binding)
4205     add_decl_to_level (x,
4206                        DECL_NAMESPACE_SCOPE_P (x)
4207                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4208                        : current_binding_level);
4209
4210   return x;
4211 }
4212
4213 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4214    caller to set DECL_CONTEXT properly.  */
4215
4216 static tree
4217 pushdecl_with_scope (x, level)
4218      tree x;
4219      struct binding_level *level;
4220 {
4221   register struct binding_level *b;
4222   tree function_decl = current_function_decl;
4223
4224   current_function_decl = NULL_TREE;
4225   if (level->parm_flag == 2)
4226     {
4227       b = class_binding_level;
4228       class_binding_level = level;
4229       pushdecl_class_level (x);
4230       class_binding_level = b;
4231     }
4232   else
4233     {
4234       b = current_binding_level;
4235       current_binding_level = level;
4236       x = pushdecl (x);
4237       current_binding_level = b;
4238     }
4239   current_function_decl = function_decl;
4240   return x;
4241 }
4242
4243 /* Like pushdecl, only it places X in the current namespace,
4244    if appropriate.  */
4245
4246 tree
4247 pushdecl_namespace_level (x)
4248      tree x;
4249 {
4250   register struct binding_level *b = current_binding_level;
4251   register tree t;
4252
4253   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4254
4255   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4256      what we want.  */
4257   if (TREE_CODE (x) == TYPE_DECL)
4258     {
4259       tree name = DECL_NAME (x);
4260       tree newval;
4261       tree *ptr = (tree *)0;
4262       for (; b != global_binding_level; b = b->level_chain)
4263         {
4264           tree shadowed = b->type_shadowed;
4265           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4266             if (TREE_PURPOSE (shadowed) == name)
4267               {
4268                 ptr = &TREE_VALUE (shadowed);
4269                 /* Can't break out of the loop here because sometimes
4270                    a binding level will have duplicate bindings for
4271                    PT names.  It's gross, but I haven't time to fix it.  */
4272               }
4273         }
4274       newval = TREE_TYPE (x);
4275       if (ptr == (tree *)0)
4276         {
4277           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4278              up here if this is changed to an assertion.  --KR  */
4279           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4280         }
4281       else
4282         {
4283           *ptr = newval;
4284         }
4285     }
4286   return t;
4287 }
4288
4289 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4290    if appropriate.  */
4291
4292 tree
4293 pushdecl_top_level (x)
4294      tree x;
4295 {
4296   push_to_top_level ();
4297   x = pushdecl_namespace_level (x);
4298   pop_from_top_level ();
4299   return x;
4300 }
4301
4302 /* Make the declaration of X appear in CLASS scope.  */
4303
4304 void
4305 pushdecl_class_level (x)
4306      tree x;
4307 {
4308   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4309      scope looks for the pre-mangled name.  */
4310   register tree name;
4311
4312   if (TREE_CODE (x) == OVERLOAD)
4313     x = OVL_CURRENT (x);
4314   name = DECL_NAME (x);
4315
4316   if (name)
4317     {
4318       push_class_level_binding (name, x);
4319       if (TREE_CODE (x) == TYPE_DECL)
4320         set_identifier_type_value (name, TREE_TYPE (x));
4321     }
4322   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4323     {
4324       tree f;
4325
4326       for (f = TYPE_FIELDS (TREE_TYPE (x));
4327            f;
4328            f = TREE_CHAIN (f))
4329         pushdecl_class_level (f);
4330     }
4331 }
4332
4333 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4334    DECL, or a modified version thereof.  */
4335
4336 tree
4337 maybe_push_decl (decl)
4338      tree decl;
4339 {
4340   tree type = TREE_TYPE (decl);
4341
4342   /* Add this decl to the current binding level, but not if it comes
4343      from another scope, e.g. a static member variable.  TEM may equal
4344      DECL or it may be a previous decl of the same name.  */
4345   if (decl == error_mark_node
4346       || (TREE_CODE (decl) != PARM_DECL
4347           && DECL_CONTEXT (decl) != NULL_TREE
4348           /* Definitions of namespace members outside their namespace are
4349              possible. */
4350           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4351       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4352       || TREE_CODE (type) == UNKNOWN_TYPE
4353       /* The declaration of a template specialization does not affect
4354          the functions available for overload resolution, so we do not
4355          call pushdecl.  */
4356       || (TREE_CODE (decl) == FUNCTION_DECL
4357           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4358     return decl;
4359   else
4360     return pushdecl (decl);
4361 }
4362
4363 /* Make the declaration(s) of X appear in CLASS scope
4364    under the name NAME.  */
4365
4366 void
4367 push_class_level_binding (name, x)
4368      tree name;
4369      tree x;
4370 {
4371   tree binding;
4372   /* The class_binding_level will be NULL if x is a template
4373      parameter name in a member template.  */
4374   if (!class_binding_level)
4375     return;
4376
4377   /* Make sure that this new member does not have the same name
4378      as a template parameter.  */
4379   if (TYPE_BEING_DEFINED (current_class_type))
4380     check_template_shadow (x);
4381
4382   /* If this declaration shadows a declaration from an enclosing
4383      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4384      we leave this class.  Record the shadowed declaration here.  */
4385   binding = IDENTIFIER_BINDING (name);
4386   if (binding
4387       && ((TREE_CODE (x) == OVERLOAD
4388            && BINDING_VALUE (binding)
4389            && is_overloaded_fn (BINDING_VALUE (binding)))
4390           || INHERITED_VALUE_BINDING_P (binding)))
4391     {
4392       tree shadow;
4393       tree old_decl;
4394
4395       /* If the old binding was from a base class, and was for a tag
4396          name, slide it over to make room for the new binding.  The
4397          old binding is still visible if explicitly qualified with a
4398          class-key.  */
4399       if (INHERITED_VALUE_BINDING_P (binding)
4400           && BINDING_VALUE (binding)
4401           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4402           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4403           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4404         {
4405           old_decl = BINDING_TYPE (binding);
4406           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4407           BINDING_VALUE (binding) = NULL_TREE;
4408           INHERITED_VALUE_BINDING_P (binding) = 0;
4409         }
4410       else
4411         old_decl = BINDING_VALUE (binding);
4412
4413       /* Find the previous binding of name on the class-shadowed
4414          list, and update it.  */
4415       for (shadow = class_binding_level->class_shadowed;
4416            shadow;
4417            shadow = TREE_CHAIN (shadow))
4418         if (TREE_PURPOSE (shadow) == name
4419             && TREE_TYPE (shadow) == old_decl)
4420           {
4421             BINDING_VALUE (binding) = x;
4422             INHERITED_VALUE_BINDING_P (binding) = 0;
4423             TREE_TYPE (shadow) = x;
4424             IDENTIFIER_CLASS_VALUE (name) = x;
4425             return;
4426           }
4427     }
4428
4429   /* If we didn't replace an existing binding, put the binding on the
4430      stack of bindings for the identifier, and update the shadowed list.  */
4431   if (push_class_binding (name, x))
4432     {
4433       class_binding_level->class_shadowed
4434         = tree_cons (name, NULL,
4435                      class_binding_level->class_shadowed);
4436       /* Record the value we are binding NAME to so that we can know
4437          what to pop later.  */
4438       TREE_TYPE (class_binding_level->class_shadowed) = x;
4439     }
4440 }
4441
4442 /* Insert another USING_DECL into the current binding level, returning
4443    this declaration. If this is a redeclaration, do nothing, and
4444    return NULL_TREE if this not in namespace scope (in namespace
4445    scope, a using decl might extend any previous bindings).  */
4446
4447 tree
4448 push_using_decl (scope, name)
4449      tree scope;
4450      tree name;
4451 {
4452   tree decl;
4453
4454   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4455   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4456   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4457     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4458       break;
4459   if (decl)
4460     return namespace_bindings_p () ? decl : NULL_TREE;
4461   decl = build_lang_decl (USING_DECL, name, void_type_node);
4462   DECL_INITIAL (decl) = scope;
4463   TREE_CHAIN (decl) = current_binding_level->usings;
4464   current_binding_level->usings = decl;
4465   return decl;
4466 }
4467
4468 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4469    changed (i.e. there was already a directive), or the fresh
4470    TREE_LIST otherwise.  */
4471
4472 tree
4473 push_using_directive (used)
4474      tree used;
4475 {
4476   tree ud = current_binding_level->using_directives;
4477   tree iter, ancestor;
4478
4479   /* Check if we already have this. */
4480   if (purpose_member (used, ud) != NULL_TREE)
4481     return NULL_TREE;
4482
4483   /* Recursively add all namespaces used. */
4484   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4485     push_using_directive (TREE_PURPOSE (iter));
4486
4487   ancestor = namespace_ancestor (current_decl_namespace (), used);
4488   ud = current_binding_level->using_directives;
4489   ud = tree_cons (used, ancestor, ud);
4490   current_binding_level->using_directives = ud;
4491   return ud;
4492 }
4493
4494 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4495    other definitions already in place.  We get around this by making
4496    the value of the identifier point to a list of all the things that
4497    want to be referenced by that name.  It is then up to the users of
4498    that name to decide what to do with that list.
4499
4500    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4501    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4502
4503    FLAGS is a bitwise-or of the following values:
4504      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4505                  namespace scope.
4506      PUSH_USING: DECL is being pushed as the result of a using
4507                  declaration.
4508
4509    The value returned may be a previous declaration if we guessed wrong
4510    about what language DECL should belong to (C or C++).  Otherwise,
4511    it's always DECL (and never something that's not a _DECL).  */
4512
4513 tree
4514 push_overloaded_decl (decl, flags)
4515      tree decl;
4516      int flags;
4517 {
4518   tree name = DECL_NAME (decl);
4519   tree old;
4520   tree new_binding;
4521   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4522
4523   if (doing_global)
4524     old = namespace_binding (name, DECL_CONTEXT (decl));
4525   else
4526     old = lookup_name_current_level (name);
4527
4528   if (old)
4529     {
4530       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4531         {
4532           tree t = TREE_TYPE (old);
4533           if (IS_AGGR_TYPE (t) && warn_shadow
4534               && (! DECL_IN_SYSTEM_HEADER (decl)
4535                   || ! DECL_IN_SYSTEM_HEADER (old)))
4536             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4537           old = NULL_TREE;
4538         }
4539       else if (is_overloaded_fn (old))
4540         {
4541           tree tmp;
4542
4543           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4544             {
4545               tree fn = OVL_CURRENT (tmp);
4546
4547               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4548                   && !(flags & PUSH_USING)
4549                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4550                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4551                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4552                           decl, fn);
4553
4554               if (duplicate_decls (decl, fn))
4555                 return fn;
4556             }
4557         }
4558       else if (old == error_mark_node)
4559         /* Ignore the undefined symbol marker.  */
4560         old = NULL_TREE;
4561       else
4562         {
4563           cp_error_at ("previous non-function declaration `%#D'", old);
4564           cp_error ("conflicts with function declaration `%#D'", decl);
4565           return decl;
4566         }
4567     }
4568
4569   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4570     {
4571       if (old && TREE_CODE (old) != OVERLOAD)
4572         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4573       else
4574         new_binding = ovl_cons (decl, old);
4575       if (flags & PUSH_USING)
4576         OVL_USED (new_binding) = 1;
4577     }
4578   else
4579     /* NAME is not ambiguous.  */
4580     new_binding = decl;
4581
4582   if (doing_global)
4583     set_namespace_binding (name, current_namespace, new_binding);
4584   else
4585     {
4586       /* We only create an OVERLOAD if there was a previous binding at
4587          this level, or if decl is a template. In the former case, we
4588          need to remove the old binding and replace it with the new
4589          binding.  We must also run through the NAMES on the binding
4590          level where the name was bound to update the chain.  */
4591
4592       if (TREE_CODE (new_binding) == OVERLOAD && old)
4593         {
4594           tree *d;
4595
4596           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4597                *d;
4598                d = &TREE_CHAIN (*d))
4599             if (*d == old
4600                 || (TREE_CODE (*d) == TREE_LIST
4601                     && TREE_VALUE (*d) == old))
4602               {
4603                 if (TREE_CODE (*d) == TREE_LIST)
4604                   /* Just replace the old binding with the new.  */
4605                   TREE_VALUE (*d) = new_binding;
4606                 else
4607                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4608                   *d = tree_cons (NULL_TREE, new_binding,
4609                                   TREE_CHAIN (*d));
4610
4611                 /* And update the CPLUS_BINDING node.  */
4612                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4613                   = new_binding;
4614                 return decl;
4615               }
4616
4617           /* We should always find a previous binding in this case.  */
4618           my_friendly_abort (0);
4619         }
4620
4621       /* Install the new binding.  */
4622       push_local_binding (name, new_binding, flags);
4623     }
4624
4625   return decl;
4626 }
4627 \f
4628 /* Generate an implicit declaration for identifier FUNCTIONID
4629    as a function of type int ().  Print a warning if appropriate.  */
4630
4631 tree
4632 implicitly_declare (functionid)
4633      tree functionid;
4634 {
4635   register tree decl;
4636
4637   /* We used to reuse an old implicit decl here,
4638      but this loses with inline functions because it can clobber
4639      the saved decl chains.  */
4640   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4641
4642   DECL_EXTERNAL (decl) = 1;
4643   TREE_PUBLIC (decl) = 1;
4644
4645   /* ISO standard says implicit declarations are in the innermost block.
4646      So we record the decl in the standard fashion.  */
4647   pushdecl (decl);
4648   rest_of_decl_compilation (decl, NULL, 0, 0);
4649
4650   if (warn_implicit
4651       /* Only one warning per identifier.  */
4652       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4653     {
4654       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4655     }
4656
4657   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4658
4659   return decl;
4660 }
4661
4662 /* Return zero if the declaration NEWDECL is valid
4663    when the declaration OLDDECL (assumed to be for the same name)
4664    has already been seen.
4665    Otherwise return an error message format string with a %s
4666    where the identifier should go.  */
4667
4668 static const char *
4669 redeclaration_error_message (newdecl, olddecl)
4670      tree newdecl, olddecl;
4671 {
4672   if (TREE_CODE (newdecl) == TYPE_DECL)
4673     {
4674       /* Because C++ can put things into name space for free,
4675          constructs like "typedef struct foo { ... } foo"
4676          would look like an erroneous redeclaration.  */
4677       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4678         return 0;
4679       else
4680         return "redefinition of `%#D'";
4681     }
4682   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4683     {
4684       /* If this is a pure function, its olddecl will actually be
4685          the original initialization to `0' (which we force to call
4686          abort()).  Don't complain about redefinition in this case.  */
4687       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4688         return 0;
4689
4690       /* If both functions come from different namespaces, this is not
4691          a redeclaration - this is a conflict with a used function. */
4692       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4693           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4694         return "`%D' conflicts with used function";
4695
4696       /* We'll complain about linkage mismatches in
4697          warn_extern_redeclared_static.  */
4698
4699       /* Defining the same name twice is no good.  */
4700       if (DECL_INITIAL (olddecl) != NULL_TREE
4701           && DECL_INITIAL (newdecl) != NULL_TREE)
4702         {
4703           if (DECL_NAME (olddecl) == NULL_TREE)
4704             return "`%#D' not declared in class";
4705           else
4706             return "redefinition of `%#D'";
4707         }
4708       return 0;
4709     }
4710   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4711     {
4712       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4713            && (DECL_TEMPLATE_RESULT (newdecl)
4714                != DECL_TEMPLATE_RESULT (olddecl))
4715            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4716            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4717           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4718               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4719               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4720         return "redefinition of `%#D'";
4721       return 0;
4722     }
4723   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4724     {
4725       /* Objects declared at top level:  */
4726       /* If at least one is a reference, it's ok.  */
4727       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4728         return 0;
4729       /* Reject two definitions.  */
4730       return "redefinition of `%#D'";
4731     }
4732   else
4733     {
4734       /* Objects declared with block scope:  */
4735       /* Reject two definitions, and reject a definition
4736          together with an external reference.  */
4737       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4738         return "redeclaration of `%#D'";
4739       return 0;
4740     }
4741 }
4742 \f
4743 /* Create a new label, named ID.  */
4744
4745 static tree
4746 make_label_decl (id, local_p)
4747      tree id;
4748      int local_p;
4749 {
4750   tree decl;
4751
4752   decl = build_decl (LABEL_DECL, id, void_type_node);
4753   if (expanding_p)
4754     /* Make sure every label has an rtx.  */
4755     label_rtx (decl);
4756
4757   DECL_CONTEXT (decl) = current_function_decl;
4758   DECL_MODE (decl) = VOIDmode;
4759   C_DECLARED_LABEL_FLAG (decl) = local_p;
4760
4761   /* Say where one reference is to the label, for the sake of the
4762      error if it is not defined.  */
4763   DECL_SOURCE_LINE (decl) = lineno;
4764   DECL_SOURCE_FILE (decl) = input_filename;
4765
4766   /* Record the fact that this identifier is bound to this label.  */
4767   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4768
4769   return decl;
4770 }
4771
4772 /* Record this label on the list of used labels so that we can check
4773    at the end of the function to see whether or not the label was
4774    actually defined, and so we can check when the label is defined whether
4775    this use is valid.  */
4776
4777 static void
4778 use_label (decl)
4779      tree decl;
4780 {
4781   if (named_label_uses == NULL
4782       || named_label_uses->names_in_scope != current_binding_level->names
4783       || named_label_uses->label_decl != decl)
4784     {
4785       struct named_label_use_list *new_ent;
4786       new_ent = ((struct named_label_use_list *)
4787                  ggc_alloc (sizeof (struct named_label_use_list)));
4788       new_ent->label_decl = decl;
4789       new_ent->names_in_scope = current_binding_level->names;
4790       new_ent->binding_level = current_binding_level;
4791       new_ent->lineno_o_goto = lineno;
4792       new_ent->filename_o_goto = input_filename;
4793       new_ent->next = named_label_uses;
4794       named_label_uses = new_ent;
4795     }
4796 }
4797
4798 /* Look for a label named ID in the current function.  If one cannot
4799    be found, create one.  (We keep track of used, but undefined,
4800    labels, and complain about them at the end of a function.)  */
4801
4802 tree
4803 lookup_label (id)
4804      tree id;
4805 {
4806   tree decl;
4807   struct named_label_list *ent;
4808
4809   /* You can't use labels at global scope.  */
4810   if (current_function_decl == NULL_TREE)
4811     {
4812       error ("label `%s' referenced outside of any function",
4813              IDENTIFIER_POINTER (id));
4814       return NULL_TREE;
4815     }
4816
4817   /* See if we've already got this label.  */
4818   decl = IDENTIFIER_LABEL_VALUE (id);
4819   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4820     return decl;
4821
4822   /* Record this label on the list of labels used in this function.
4823      We do this before calling make_label_decl so that we get the
4824      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4825   ent = ((struct named_label_list *)
4826          ggc_alloc_cleared (sizeof (struct named_label_list)));
4827   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4828   ent->next = named_labels;
4829   named_labels = ent;
4830
4831   /* We need a new label.  */
4832   decl = make_label_decl (id, /*local_p=*/0);
4833
4834   /* Now fill in the information we didn't have before.  */
4835   ent->label_decl = decl;
4836
4837   return decl;
4838 }
4839
4840 /* Declare a local label named ID.  */
4841
4842 tree
4843 declare_local_label (id)
4844      tree id;
4845 {
4846   tree decl;
4847
4848   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4849      this scope we can restore the old value of
4850      IDENTIFIER_TYPE_VALUE.  */
4851   current_binding_level->shadowed_labels
4852     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4853                  current_binding_level->shadowed_labels);
4854   /* Look for the label.  */
4855   decl = make_label_decl (id, /*local_p=*/1);
4856   /* Now fill in the information we didn't have before.  */
4857   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4858
4859   return decl;
4860 }
4861
4862 /* Returns nonzero if it is ill-formed to jump past the declaration of
4863    DECL.  Returns 2 if it's also a real problem.  */
4864
4865 static int
4866 decl_jump_unsafe (decl)
4867      tree decl;
4868 {
4869   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4870     return 0;
4871
4872   if (DECL_INITIAL (decl) == NULL_TREE
4873       && pod_type_p (TREE_TYPE (decl)))
4874     return 0;
4875
4876   /* This is really only important if we're crossing an initialization.
4877      The POD stuff is just pedantry; why should it matter if the class
4878      contains a field of pointer to member type?  */
4879   if (DECL_INITIAL (decl)
4880       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4881     return 2;
4882   return 1;
4883 }
4884
4885 /* Check that a single previously seen jump to a newly defined label
4886    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4887    the jump context; NAMES are the names in scope in LEVEL at the jump
4888    context; FILE and LINE are the source position of the jump or 0.  */
4889
4890 static void
4891 check_previous_goto_1 (decl, level, names, file, line)
4892      tree decl;
4893      struct binding_level *level;
4894      tree names;
4895      const char *file;
4896      int line;
4897 {
4898   int identified = 0;
4899   int saw_eh = 0;
4900   struct binding_level *b = current_binding_level;
4901   for (; b; b = b->level_chain)
4902     {
4903       tree new_decls = b->names;
4904       tree old_decls = (b == level ? names : NULL_TREE);
4905       for (; new_decls != old_decls;
4906            new_decls = TREE_CHAIN (new_decls))
4907         {
4908           int problem = decl_jump_unsafe (new_decls);
4909           if (! problem)
4910             continue;
4911
4912           if (! identified)
4913             {
4914               if (decl)
4915                 cp_pedwarn ("jump to label `%D'", decl);
4916               else
4917                 pedwarn ("jump to case label");
4918
4919               if (file)
4920                 pedwarn_with_file_and_line (file, line, "  from here");
4921               identified = 1;
4922             }
4923
4924           if (problem > 1)
4925             cp_error_at ("  crosses initialization of `%#D'",
4926                          new_decls);
4927           else
4928             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4929                            new_decls);
4930         }
4931
4932       if (b == level)
4933         break;
4934       if ((b->is_try_scope || b->is_catch_scope) && ! saw_eh)
4935         {
4936           if (! identified)
4937             {
4938               if (decl)
4939                 cp_pedwarn ("jump to label `%D'", decl);
4940               else
4941                 pedwarn ("jump to case label");
4942
4943               if (file)
4944                 pedwarn_with_file_and_line (file, line, "  from here");
4945               identified = 1;
4946             }
4947           if (b->is_try_scope)
4948             error ("  enters try block");
4949           else
4950             error ("  enters catch block");
4951           saw_eh = 1;
4952         }
4953     }
4954 }
4955
4956 static void
4957 check_previous_goto (use)
4958      struct named_label_use_list *use;
4959 {
4960   check_previous_goto_1 (use->label_decl, use->binding_level,
4961                          use->names_in_scope, use->filename_o_goto,
4962                          use->lineno_o_goto);
4963 }
4964
4965 static void
4966 check_switch_goto (level)
4967      struct binding_level *level;
4968 {
4969   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
4970 }
4971
4972 /* Check that any previously seen jumps to a newly defined label DECL
4973    are OK.  Called by define_label.  */
4974
4975 static void
4976 check_previous_gotos (decl)
4977      tree decl;
4978 {
4979   struct named_label_use_list **usep;
4980
4981   if (! TREE_USED (decl))
4982     return;
4983
4984   for (usep = &named_label_uses; *usep; )
4985     {
4986       struct named_label_use_list *use = *usep;
4987       if (use->label_decl == decl)
4988         {
4989           check_previous_goto (use);
4990           *usep = use->next;
4991         }
4992       else
4993         usep = &(use->next);
4994     }
4995 }
4996
4997 /* Check that a new jump to a label DECL is OK.  Called by
4998    finish_goto_stmt.  */
4999
5000 void
5001 check_goto (decl)
5002      tree decl;
5003 {
5004   int identified = 0;
5005   tree bad;
5006   struct named_label_list *lab;
5007
5008   /* We can't know where a computed goto is jumping.  So we assume
5009      that it's OK.  */
5010   if (! DECL_P (decl))
5011     return;
5012
5013   /* If the label hasn't been defined yet, defer checking.  */
5014   if (! DECL_INITIAL (decl))
5015     {
5016       use_label (decl);
5017       return;
5018     }
5019
5020   for (lab = named_labels; lab; lab = lab->next)
5021     if (decl == lab->label_decl)
5022       break;
5023
5024   /* If the label is not on named_labels it's a gcc local label, so
5025      it must be in an outer scope, so jumping to it is always OK.  */
5026   if (lab == 0)
5027     return;
5028
5029   if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
5030       && !identified)
5031     {
5032       cp_pedwarn_at ("jump to label `%D'", decl);
5033       pedwarn ("  from here");
5034       identified = 1;
5035     }
5036
5037   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5038     {
5039       tree b = TREE_VALUE (bad);
5040       int u = decl_jump_unsafe (b);
5041
5042       if (u > 1 && DECL_ARTIFICIAL (b))
5043         /* Can't skip init of __exception_info.  */
5044         cp_error_at ("  enters catch block", b);
5045       else if (u > 1)
5046         cp_error_at ("  skips initialization of `%#D'", b);
5047       else
5048         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5049     }
5050
5051   if (lab->in_try_scope)
5052     error ("  enters try block");
5053   else if (lab->in_catch_scope)
5054     error ("  enters catch block");
5055 }
5056
5057 /* Define a label, specifying the location in the source file.
5058    Return the LABEL_DECL node for the label, if the definition is valid.
5059    Otherwise return 0.  */
5060
5061 tree
5062 define_label (filename, line, name)
5063      const char *filename;
5064      int line;
5065      tree name;
5066 {
5067   tree decl = lookup_label (name);
5068   struct named_label_list *ent;
5069   register struct binding_level *p;
5070
5071   for (ent = named_labels; ent; ent = ent->next)
5072     if (ent->label_decl == decl)
5073       break;
5074
5075   /* After labels, make any new cleanups in the function go into their
5076      own new (temporary) binding contour.  */
5077   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5078     p->more_cleanups_ok = 0;
5079
5080   if (name == get_identifier ("wchar_t"))
5081     cp_pedwarn ("label named wchar_t");
5082
5083   if (DECL_INITIAL (decl) != NULL_TREE)
5084     {
5085       cp_error ("duplicate label `%D'", decl);
5086       return 0;
5087     }
5088   else
5089     {
5090       /* Mark label as having been defined.  */
5091       DECL_INITIAL (decl) = error_mark_node;
5092       /* Say where in the source.  */
5093       DECL_SOURCE_FILE (decl) = filename;
5094       DECL_SOURCE_LINE (decl) = line;
5095       if (ent)
5096         {
5097           ent->names_in_scope = current_binding_level->names;
5098           ent->binding_level = current_binding_level;
5099         }
5100       check_previous_gotos (decl);
5101       return decl;
5102     }
5103 }
5104
5105 struct cp_switch
5106 {
5107   struct binding_level *level;
5108   struct cp_switch *next;
5109   /* The SWITCH_STMT being built.  */
5110   tree switch_stmt;
5111   /* A splay-tree mapping the low element of a case range to the high
5112      element, or NULL_TREE if there is no high element.  Used to
5113      determine whether or not a new case label duplicates an old case
5114      label.  We need a tree, rather than simply a hash table, because
5115      of the GNU case range extension.  */
5116   splay_tree cases;
5117 };
5118
5119 /* A stack of the currently active switch statements.  The innermost
5120    switch statement is on the top of the stack.  There is no need to
5121    mark the stack for garbage collection because it is only active
5122    during the processing of the body of a function, and we never
5123    collect at that point.  */
5124
5125 static struct cp_switch *switch_stack;
5126
5127 /* Called right after a switch-statement condition is parsed.
5128    SWITCH_STMT is the switch statement being parsed.  */
5129
5130 void
5131 push_switch (switch_stmt)
5132      tree switch_stmt;
5133 {
5134   struct cp_switch *p
5135     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5136   p->level = current_binding_level;
5137   p->next = switch_stack;
5138   p->switch_stmt = switch_stmt;
5139   p->cases = splay_tree_new (case_compare, NULL, NULL);
5140   switch_stack = p;
5141 }
5142
5143 void
5144 pop_switch ()
5145 {
5146   struct cp_switch *cs;
5147
5148   cs = switch_stack;
5149   splay_tree_delete (cs->cases);
5150   switch_stack = switch_stack->next;
5151   free (cs);
5152 }
5153
5154 /* Note that we've seen a definition of a case label, and complain if this
5155    is a bad place for one.  */
5156
5157 tree
5158 finish_case_label (low_value, high_value)
5159      tree low_value;
5160      tree high_value;
5161 {
5162   tree cond, r;
5163   register struct binding_level *p;
5164
5165   if (! switch_stack)
5166     {
5167       if (high_value)
5168         error ("case label not within a switch statement");
5169       else if (low_value)
5170         cp_error ("case label `%E' not within a switch statement",
5171                   low_value);
5172       else
5173         error ("`default' label not within a switch statement");
5174       return NULL_TREE;
5175     }
5176
5177   if (processing_template_decl)
5178     {
5179       tree label;
5180
5181       /* For templates, just add the case label; we'll do semantic
5182          analysis at instantiation-time.  */
5183       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5184       return add_stmt (build_case_label (low_value, high_value, label));
5185     }
5186
5187   /* Find the condition on which this switch statement depends.  */
5188   cond = SWITCH_COND (switch_stack->switch_stmt);
5189   if (cond && TREE_CODE (cond) == TREE_LIST)
5190     cond = TREE_VALUE (cond);
5191
5192   r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5193   if (r == error_mark_node)
5194     r = NULL_TREE;
5195
5196   check_switch_goto (switch_stack->level);
5197
5198   /* After labels, make any new cleanups in the function go into their
5199      own new (temporary) binding contour.  */
5200   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5201     p->more_cleanups_ok = 0;
5202
5203   return r;
5204 }
5205 \f
5206 /* Return the list of declarations of the current level.
5207    Note that this list is in reverse order unless/until
5208    you nreverse it; and when you do nreverse it, you must
5209    store the result back using `storedecls' or you will lose.  */
5210
5211 tree
5212 getdecls ()
5213 {
5214   return current_binding_level->names;
5215 }
5216
5217 /* Return the list of type-tags (for structs, etc) of the current level.  */
5218
5219 tree
5220 gettags ()
5221 {
5222   return current_binding_level->tags;
5223 }
5224
5225 /* Store the list of declarations of the current level.
5226    This is done for the parameter declarations of a function being defined,
5227    after they are modified in the light of any missing parameters.  */
5228
5229 static void
5230 storedecls (decls)
5231      tree decls;
5232 {
5233   current_binding_level->names = decls;
5234 }
5235
5236 /* Similarly, store the list of tags of the current level.  */
5237
5238 void
5239 storetags (tags)
5240      tree tags;
5241 {
5242   current_binding_level->tags = tags;
5243 }
5244 \f
5245 /* Given NAME, an IDENTIFIER_NODE,
5246    return the structure (or union or enum) definition for that name.
5247    Searches binding levels from BINDING_LEVEL up to the global level.
5248    If THISLEVEL_ONLY is nonzero, searches only the specified context
5249    (but skips any tag-transparent contexts to find one that is
5250    meaningful for tags).
5251    FORM says which kind of type the caller wants;
5252    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5253    If the wrong kind of type is found, and it's not a template, an error is
5254    reported.  */
5255
5256 static tree
5257 lookup_tag (form, name, binding_level, thislevel_only)
5258      enum tree_code form;
5259      tree name;
5260      struct binding_level *binding_level;
5261      int thislevel_only;
5262 {
5263   register struct binding_level *level;
5264   /* Non-zero if, we should look past a template parameter level, even
5265      if THISLEVEL_ONLY.  */
5266   int allow_template_parms_p = 1;
5267
5268   for (level = binding_level; level; level = level->level_chain)
5269     {
5270       register tree tail;
5271       if (ANON_AGGRNAME_P (name))
5272         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5273           {
5274             /* There's no need for error checking here, because
5275                anon names are unique throughout the compilation.  */
5276             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5277               return TREE_VALUE (tail);
5278           }
5279       else if (level->namespace_p)
5280         /* Do namespace lookup. */
5281         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5282           {
5283             tree old = binding_for_name (name, tail);
5284
5285             /* If we just skipped past a template parameter level,
5286                even though THISLEVEL_ONLY, and we find a template
5287                class declaration, then we use the _TYPE node for the
5288                template.  See the example below.  */
5289             if (thislevel_only && !allow_template_parms_p
5290                 && old && BINDING_VALUE (old)
5291                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5292               old = TREE_TYPE (BINDING_VALUE (old));
5293             else
5294               old = BINDING_TYPE (old);
5295
5296             /* If it has an original type, it is a typedef, and we
5297                should not return it.  */
5298             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5299               old = NULL_TREE;
5300             if (old && TREE_CODE (old) != form
5301                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5302               {
5303                 cp_error ("`%#D' redeclared as %C", old, form);
5304                 return NULL_TREE;
5305               }
5306             if (old)
5307               return old;
5308             if (thislevel_only || tail == global_namespace)
5309               return NULL_TREE;
5310           }
5311       else
5312         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5313           {
5314             if (TREE_PURPOSE (tail) == name)
5315               {
5316                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5317                 /* Should tighten this up; it'll probably permit
5318                    UNION_TYPE and a struct template, for example.  */
5319                 if (code != form
5320                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5321                   {
5322                     /* Definition isn't the kind we were looking for.  */
5323                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5324                               form);
5325                     return NULL_TREE;
5326                   }
5327                 return TREE_VALUE (tail);
5328               }
5329           }
5330       if (thislevel_only && ! level->tag_transparent)
5331         {
5332           if (level->template_parms_p && allow_template_parms_p)
5333             {
5334               /* We must deal with cases like this:
5335
5336                    template <class T> struct S;
5337                    template <class T> struct S {};
5338
5339                  When looking up `S', for the second declaration, we
5340                  would like to find the first declaration.  But, we
5341                  are in the pseudo-global level created for the
5342                  template parameters, rather than the (surrounding)
5343                  namespace level.  Thus, we keep going one more level,
5344                  even though THISLEVEL_ONLY is non-zero.  */
5345               allow_template_parms_p = 0;
5346               continue;
5347             }
5348           else
5349             return NULL_TREE;
5350         }
5351     }
5352   return NULL_TREE;
5353 }
5354
5355 #if 0
5356 void
5357 set_current_level_tags_transparency (tags_transparent)
5358      int tags_transparent;
5359 {
5360   current_binding_level->tag_transparent = tags_transparent;
5361 }
5362 #endif
5363
5364 /* Given a type, find the tag that was defined for it and return the tag name.
5365    Otherwise return 0.  However, the value can never be 0
5366    in the cases in which this is used.
5367
5368    C++: If NAME is non-zero, this is the new name to install.  This is
5369    done when replacing anonymous tags with real tag names.  */
5370
5371 static tree
5372 lookup_tag_reverse (type, name)
5373      tree type;
5374      tree name;
5375 {
5376   register struct binding_level *level;
5377
5378   for (level = current_binding_level; level; level = level->level_chain)
5379     {
5380       register tree tail;
5381       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5382         {
5383           if (TREE_VALUE (tail) == type)
5384             {
5385               if (name)
5386                 TREE_PURPOSE (tail) = name;
5387               return TREE_PURPOSE (tail);
5388             }
5389         }
5390     }
5391   return NULL_TREE;
5392 }
5393 \f
5394 /* Look up NAME in the NAMESPACE.  */
5395
5396 tree
5397 lookup_namespace_name (namespace, name)
5398      tree namespace, name;
5399 {
5400   tree val;
5401   tree template_id = NULL_TREE;
5402
5403   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5404
5405   if (TREE_CODE (name) == NAMESPACE_DECL)
5406     /* This happens for A::B<int> when B is a namespace. */
5407     return name;
5408   else if (TREE_CODE (name) == TEMPLATE_DECL)
5409     {
5410       /* This happens for A::B where B is a template, and there are no
5411          template arguments.  */
5412       cp_error ("invalid use of `%D'", name);
5413       return error_mark_node;
5414     }
5415
5416   namespace = ORIGINAL_NAMESPACE (namespace);
5417
5418   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5419     {
5420       template_id = name;
5421       name = TREE_OPERAND (name, 0);
5422       if (TREE_CODE (name) == OVERLOAD)
5423         name = DECL_NAME (OVL_CURRENT (name));
5424       else if (DECL_P (name))
5425         name = DECL_NAME (name);
5426     }
5427
5428   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5429
5430   val = make_node (CPLUS_BINDING);
5431   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5432     return error_mark_node;
5433
5434   if (BINDING_VALUE (val))
5435     {
5436       val = BINDING_VALUE (val);
5437
5438       if (template_id)
5439         {
5440           if (DECL_CLASS_TEMPLATE_P (val))
5441             val = lookup_template_class (val,
5442                                          TREE_OPERAND (template_id, 1),
5443                                          /*in_decl=*/NULL_TREE,
5444                                          /*context=*/NULL_TREE,
5445                                          /*entering_scope=*/0,
5446                                          /*complain=*/1);
5447           else if (DECL_FUNCTION_TEMPLATE_P (val)
5448                    || TREE_CODE (val) == OVERLOAD)
5449             val = lookup_template_function (val,
5450                                             TREE_OPERAND (template_id, 1));
5451           else
5452             {
5453               cp_error ("`%D::%D' is not a template",
5454                         namespace, name);
5455               return error_mark_node;
5456             }
5457         }
5458
5459       /* If we have a single function from a using decl, pull it out.  */
5460       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5461         val = OVL_FUNCTION (val);
5462       return val;
5463     }
5464
5465   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5466   return error_mark_node;
5467 }
5468
5469 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5470
5471 static unsigned long
5472 typename_hash (k)
5473      hash_table_key k;
5474 {
5475   unsigned long hash;
5476   tree t;
5477
5478   t = (tree) k;
5479   hash = (((unsigned long) TYPE_CONTEXT (t))
5480           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5481
5482   return hash;
5483 }
5484
5485 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5486
5487 static bool
5488 typename_compare (k1, k2)
5489      hash_table_key k1;
5490      hash_table_key k2;
5491 {
5492   tree t1;
5493   tree t2;
5494   tree d1;
5495   tree d2;
5496
5497   t1 = (tree) k1;
5498   t2 = (tree) k2;
5499   d1 = TYPE_NAME (t1);
5500   d2 = TYPE_NAME (t2);
5501
5502   return (DECL_NAME (d1) == DECL_NAME (d2)
5503           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5504           && ((TREE_TYPE (t1) != NULL_TREE)
5505               == (TREE_TYPE (t2) != NULL_TREE))
5506           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5507           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5508 }
5509
5510 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5511    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5512    is non-NULL, this type is being created by the implicit typename
5513    extension, and BASE_TYPE is a type named `t' in some base class of
5514    `T' which depends on template parameters.
5515
5516    Returns the new TYPENAME_TYPE.  */
5517
5518 tree
5519 build_typename_type (context, name, fullname, base_type)
5520      tree context;
5521      tree name;
5522      tree fullname;
5523      tree base_type;
5524 {
5525   tree t;
5526   tree d;
5527   struct hash_entry *e;
5528
5529   static struct hash_table ht;
5530
5531   if (!ht.table)
5532     {
5533       static struct hash_table *h = &ht;
5534
5535       hash_table_init (&ht, &hash_newfunc, &typename_hash, &typename_compare);
5536       ggc_add_tree_hash_table_root (&h, 1);
5537     }
5538
5539   /* Build the TYPENAME_TYPE.  */
5540   t = make_aggr_type (TYPENAME_TYPE);
5541   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5542   TYPENAME_TYPE_FULLNAME (t) = fullname;
5543   TREE_TYPE (t) = base_type;
5544
5545   /* Build the corresponding TYPE_DECL.  */
5546   d = build_decl (TYPE_DECL, name, t);
5547   TYPE_NAME (TREE_TYPE (d)) = d;
5548   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5549   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5550   DECL_ARTIFICIAL (d) = 1;
5551
5552   /* See if we already have this type.  */
5553   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5554   if (e)
5555     t = (tree) e->key;
5556   else
5557     /* Insert the type into the table.  */
5558     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5559
5560   return t;
5561 }
5562
5563 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5564    unless an error occurs, in which case error_mark_node is returned.
5565    If COMPLAIN zero, don't complain about any errors that occur.  */
5566
5567 tree
5568 make_typename_type (context, name, complain)
5569      tree context, name;
5570      int complain;
5571 {
5572   tree fullname;
5573
5574   if (TYPE_P (name))
5575     {
5576       if (!(TYPE_LANG_SPECIFIC (name)
5577             && (CLASSTYPE_IS_TEMPLATE (name)
5578                 || CLASSTYPE_USE_TEMPLATE (name))))
5579         name = TYPE_IDENTIFIER (name);
5580       else
5581         /* Create a TEMPLATE_ID_EXPR for the type.  */
5582         name = build_nt (TEMPLATE_ID_EXPR,
5583                          CLASSTYPE_TI_TEMPLATE (name),
5584                          CLASSTYPE_TI_ARGS (name));
5585     }
5586   else if (TREE_CODE (name) == TYPE_DECL)
5587     name = DECL_NAME (name);
5588
5589   fullname = name;
5590
5591   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5592     {
5593       name = TREE_OPERAND (name, 0);
5594       if (TREE_CODE (name) == TEMPLATE_DECL)
5595         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5596     }
5597   if (TREE_CODE (name) != IDENTIFIER_NODE)
5598     my_friendly_abort (2000);
5599
5600   if (TREE_CODE (context) == NAMESPACE_DECL)
5601     {
5602       /* We can get here from typename_sub0 in the explicit_template_type
5603          expansion.  Just fail.  */
5604       if (complain)
5605         cp_error ("no class template named `%#T' in `%#T'",
5606                   name, context);
5607       return error_mark_node;
5608     }
5609
5610   if (! uses_template_parms (context)
5611       || currently_open_class (context))
5612     {
5613       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5614         {
5615           tree tmpl = NULL_TREE;
5616           if (IS_AGGR_TYPE (context))
5617             tmpl = lookup_field (context, name, 0, 0);
5618           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5619             {
5620               if (complain)
5621                 cp_error ("no class template named `%#T' in `%#T'",
5622                           name, context);
5623               return error_mark_node;
5624             }
5625
5626           return lookup_template_class (tmpl,
5627                                         TREE_OPERAND (fullname, 1),
5628                                         NULL_TREE, context,
5629                                         /*entering_scope=*/0,
5630                                         /*complain=*/1);
5631         }
5632       else
5633         {
5634           tree t;
5635
5636           if (!IS_AGGR_TYPE (context))
5637             {
5638               if (complain)
5639                 cp_error ("no type named `%#T' in `%#T'", name, context);
5640               return error_mark_node;
5641             }
5642
5643           t = lookup_field (context, name, 0, 1);
5644           if (t)
5645             return TREE_TYPE (t);
5646         }
5647     }
5648
5649   /* If the CONTEXT is not a template type, then either the field is
5650      there now or its never going to be.  */
5651   if (!uses_template_parms (context))
5652     {
5653       if (complain)
5654         cp_error ("no type named `%#T' in `%#T'", name, context);
5655       return error_mark_node;
5656     }
5657
5658
5659   return build_typename_type (context, name, fullname,  NULL_TREE);
5660 }
5661
5662 /* Select the right _DECL from multiple choices. */
5663
5664 static tree
5665 select_decl (binding, flags)
5666      tree binding;
5667      int flags;
5668 {
5669   tree val;
5670   val = BINDING_VALUE (binding);
5671
5672   /* When we implicitly declare some builtin entity, we mark it
5673      DECL_ANTICIPATED, so that we know to ignore it until it is
5674      really declared.  */
5675   if (val && DECL_P (val)
5676       && DECL_LANG_SPECIFIC (val)
5677       && DECL_ANTICIPATED (val))
5678     return NULL_TREE;
5679
5680   if (LOOKUP_NAMESPACES_ONLY (flags))
5681     {
5682       /* We are not interested in types. */
5683       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5684         return val;
5685       return NULL_TREE;
5686     }
5687
5688   /* If we could have a type and
5689      we have nothing or we need a type and have none.  */
5690   if (BINDING_TYPE (binding)
5691       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5692                    && TREE_CODE (val) != TYPE_DECL)))
5693     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5694   /* Don't return non-types if we really prefer types. */
5695   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5696            && (TREE_CODE (val) != TEMPLATE_DECL
5697                || !DECL_CLASS_TEMPLATE_P (val)))
5698     val = NULL_TREE;
5699
5700   return val;
5701 }
5702
5703 /* Unscoped lookup of a global: iterate over current namespaces,
5704    considering using-directives.  If SPACESP is non-NULL, store a list
5705    of the namespaces we've considered in it.  */
5706
5707 tree
5708 unqualified_namespace_lookup (name, flags, spacesp)
5709      tree name;
5710      int flags;
5711      tree *spacesp;
5712 {
5713   tree b = make_node (CPLUS_BINDING);
5714   tree initial = current_decl_namespace ();
5715   tree scope = initial;
5716   tree siter;
5717   struct binding_level *level;
5718   tree val = NULL_TREE;
5719
5720   if (spacesp)
5721     *spacesp = NULL_TREE;
5722
5723   for (; !val; scope = CP_DECL_CONTEXT (scope))
5724     {
5725       if (spacesp)
5726         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5727       val = binding_for_name (name, scope);
5728
5729       /* Initialize binding for this context. */
5730       BINDING_VALUE (b) = BINDING_VALUE (val);
5731       BINDING_TYPE (b) = BINDING_TYPE (val);
5732
5733       /* Add all _DECLs seen through local using-directives. */
5734       for (level = current_binding_level;
5735            !level->namespace_p;
5736            level = level->level_chain)
5737         if (!lookup_using_namespace (name, b, level->using_directives,
5738                                      scope, flags, spacesp))
5739           /* Give up because of error. */
5740           return error_mark_node;
5741
5742       /* Add all _DECLs seen through global using-directives. */
5743       /* XXX local and global using lists should work equally. */
5744       siter = initial;
5745       while (1)
5746         {
5747           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5748                                        scope, flags, spacesp))
5749             /* Give up because of error. */
5750             return error_mark_node;
5751           if (siter == scope) break;
5752           siter = CP_DECL_CONTEXT (siter);
5753         }
5754
5755       val = select_decl (b, flags);
5756       if (scope == global_namespace)
5757         break;
5758     }
5759   return val;
5760 }
5761
5762 /* Combine prefer_type and namespaces_only into flags.  */
5763
5764 static int
5765 lookup_flags (prefer_type, namespaces_only)
5766   int prefer_type, namespaces_only;
5767 {
5768   if (namespaces_only)
5769     return LOOKUP_PREFER_NAMESPACES;
5770   if (prefer_type > 1)
5771     return LOOKUP_PREFER_TYPES;
5772   if (prefer_type > 0)
5773     return LOOKUP_PREFER_BOTH;
5774   return 0;
5775 }
5776
5777 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5778    ignore it or not.  Subroutine of lookup_name_real.  */
5779
5780 static tree
5781 qualify_lookup (val, flags)
5782      tree val;
5783      int flags;
5784 {
5785   if (val == NULL_TREE)
5786     return val;
5787   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5788     return val;
5789   if ((flags & LOOKUP_PREFER_TYPES)
5790       && (TREE_CODE (val) == TYPE_DECL
5791           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5792               && DECL_CLASS_TEMPLATE_P (val))))
5793     return val;
5794   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5795     return NULL_TREE;
5796   return val;
5797 }
5798
5799 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5800    that.  */
5801
5802 static void
5803 warn_about_implicit_typename_lookup (typename, binding)
5804      tree typename;
5805      tree binding;
5806 {
5807   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5808   tree name = DECL_NAME (typename);
5809
5810   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5811          && CLASSTYPE_TEMPLATE_INFO (subtype)
5812          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5813       && ! (TREE_CODE (binding) == TYPE_DECL
5814             && same_type_p (TREE_TYPE (binding), subtype)))
5815     {
5816       cp_warning ("lookup of `%D' finds `%#D'",
5817                   name, binding);
5818       cp_warning ("  instead of `%D' from dependent base class",
5819                   typename);
5820       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5821                   constructor_name (current_class_type), name);
5822     }
5823 }
5824
5825 /* Look up NAME in the current binding level and its superiors in the
5826    namespace of variables, functions and typedefs.  Return a ..._DECL
5827    node of some kind representing its definition if there is only one
5828    such declaration, or return a TREE_LIST with all the overloaded
5829    definitions if there are many, or return 0 if it is undefined.
5830
5831    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5832    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5833    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5834    Otherwise we prefer non-TYPE_DECLs.
5835
5836    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5837    using IDENTIFIER_CLASS_VALUE.  */
5838
5839 static tree
5840 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5841      tree name;
5842      int prefer_type, nonclass, namespaces_only;
5843 {
5844   tree t;
5845   tree val = NULL_TREE;
5846   int yylex = 0;
5847   tree from_obj = NULL_TREE;
5848   int flags;
5849   int val_is_implicit_typename = 0;
5850
5851   /* Hack: copy flag set by parser, if set. */
5852   if (only_namespace_names)
5853     namespaces_only = 1;
5854
5855   if (prefer_type == -2)
5856     {
5857       extern int looking_for_typename;
5858       tree type = NULL_TREE;
5859
5860       yylex = 1;
5861       prefer_type = looking_for_typename;
5862
5863       flags = lookup_flags (prefer_type, namespaces_only);
5864       /* If the next thing is '<', class templates are types. */
5865       if (looking_for_template)
5866         flags |= LOOKUP_TEMPLATES_EXPECTED;
5867
5868       if (got_scope)
5869         type = got_scope;
5870       else if (got_object != error_mark_node)
5871         type = got_object;
5872
5873       if (type)
5874         {
5875           if (type == error_mark_node)
5876             return error_mark_node;
5877           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5878             type = TREE_TYPE (type);
5879
5880           if (TYPE_P (type))
5881             type = complete_type (type);
5882
5883           if (TREE_CODE (type) == VOID_TYPE)
5884             type = global_namespace;
5885           if (TREE_CODE (type) == NAMESPACE_DECL)
5886             {
5887               val = make_node (CPLUS_BINDING);
5888               flags |= LOOKUP_COMPLAIN;
5889               if (!qualified_lookup_using_namespace (name, type, val, flags))
5890                 return NULL_TREE;
5891               val = select_decl (val, flags);
5892             }
5893           else if (! IS_AGGR_TYPE (type)
5894                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5895                    || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
5896                    || TREE_CODE (type) == TYPENAME_TYPE)
5897             /* Someone else will give an error about this if needed.  */
5898             val = NULL_TREE;
5899           else if (type == current_class_type)
5900             val = IDENTIFIER_CLASS_VALUE (name);
5901           else
5902             {
5903               val = lookup_member (type, name, 0, prefer_type);
5904               type_access_control (type, val);
5905
5906               /* Restore the containing TYPENAME_TYPE if we looked
5907                  through it before.  */
5908               if (got_scope && got_scope != type
5909                   && val && TREE_CODE (val) == TYPE_DECL
5910                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
5911                 TYPE_CONTEXT (TREE_TYPE (val)) = got_scope;
5912             }
5913         }
5914       else
5915         val = NULL_TREE;
5916
5917       if (got_scope)
5918         goto done;
5919       else if (got_object && val)
5920         {
5921           from_obj = val;
5922           val = NULL_TREE;
5923         }
5924     }
5925   else
5926     {
5927       flags = lookup_flags (prefer_type, namespaces_only);
5928       /* If we're not parsing, we need to complain. */
5929       flags |= LOOKUP_COMPLAIN;
5930     }
5931
5932   /* First, look in non-namespace scopes.  */
5933
5934   if (current_class_type == NULL_TREE)
5935     nonclass = 1;
5936
5937   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5938     {
5939       tree binding;
5940
5941       if (!LOCAL_BINDING_P (t) && nonclass)
5942         /* We're not looking for class-scoped bindings, so keep going.  */
5943         continue;
5944
5945       /* If this is the kind of thing we're looking for, we're done.  */
5946       if (qualify_lookup (BINDING_VALUE (t), flags))
5947         binding = BINDING_VALUE (t);
5948       else if ((flags & LOOKUP_PREFER_TYPES)
5949                && qualify_lookup (BINDING_TYPE (t), flags))
5950         binding = BINDING_TYPE (t);
5951       else
5952         binding = NULL_TREE;
5953
5954       /* Handle access control on types from enclosing or base classes.  */
5955       if (binding && ! yylex
5956           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5957         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5958
5959       if (binding
5960           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5961         {
5962           if (val_is_implicit_typename && !yylex)
5963             warn_about_implicit_typename_lookup (val, binding);
5964           val = binding;
5965           val_is_implicit_typename
5966             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5967           if (!val_is_implicit_typename)
5968             break;
5969         }
5970     }
5971
5972   /* Now lookup in namespace scopes.  */
5973   if (!val || val_is_implicit_typename)
5974     {
5975       t = unqualified_namespace_lookup (name, flags, 0);
5976       if (t)
5977         {
5978           if (val_is_implicit_typename && !yylex)
5979             warn_about_implicit_typename_lookup (val, t);
5980           val = t;
5981         }
5982     }
5983
5984  done:
5985   if (val)
5986     {
5987       /* This should only warn about types used in qualified-ids.  */
5988       if (from_obj && from_obj != val)
5989         {
5990           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5991               && TREE_CODE (val) == TYPE_DECL
5992               && ! same_type_p (TREE_TYPE (from_obj), TREE_TYPE (val)))
5993             cp_pedwarn ("\
5994 lookup of `%D' in the scope of `%#T' (`%#D') \
5995 does not match lookup in the current scope (`%#D')",
5996                         name, got_object, from_obj, val);
5997
5998           /* We don't change val to from_obj if got_object depends on
5999              template parms because that breaks implicit typename for
6000              destructor calls.  */
6001           if (! uses_template_parms (got_object))
6002             val = from_obj;
6003         }
6004
6005       /* If we have a single function from a using decl, pull it out.  */
6006       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6007         val = OVL_FUNCTION (val);
6008     }
6009   else if (from_obj)
6010     val = from_obj;
6011
6012   return val;
6013 }
6014
6015 tree
6016 lookup_name_nonclass (name)
6017      tree name;
6018 {
6019   return lookup_name_real (name, 0, 1, 0);
6020 }
6021
6022 tree
6023 lookup_function_nonclass (name, args)
6024      tree name;
6025      tree args;
6026 {
6027   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6028 }
6029
6030 tree
6031 lookup_name_namespace_only (name)
6032      tree name;
6033 {
6034   /* type-or-namespace, nonclass, namespace_only */
6035   return lookup_name_real (name, 1, 1, 1);
6036 }
6037
6038 tree
6039 lookup_name (name, prefer_type)
6040      tree name;
6041      int prefer_type;
6042 {
6043   return lookup_name_real (name, prefer_type, 0, 0);
6044 }
6045
6046 /* Similar to `lookup_name' but look only in the innermost non-class
6047    binding level.  */
6048
6049 tree
6050 lookup_name_current_level (name)
6051      tree name;
6052 {
6053   struct binding_level *b;
6054   tree t = NULL_TREE;
6055
6056   b = current_binding_level;
6057   while (b->parm_flag == 2)
6058     b = b->level_chain;
6059
6060   if (b->namespace_p)
6061     {
6062       t = IDENTIFIER_NAMESPACE_VALUE (name);
6063
6064       /* extern "C" function() */
6065       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6066         t = TREE_VALUE (t);
6067     }
6068   else if (IDENTIFIER_BINDING (name)
6069            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6070     {
6071       while (1)
6072         {
6073           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6074             return IDENTIFIER_VALUE (name);
6075
6076           if (b->keep == 2)
6077             b = b->level_chain;
6078           else
6079             break;
6080         }
6081     }
6082
6083   return t;
6084 }
6085
6086 /* Like lookup_name_current_level, but for types.  */
6087
6088 tree
6089 lookup_type_current_level (name)
6090      tree name;
6091 {
6092   register tree t = NULL_TREE;
6093
6094   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6095
6096   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6097       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6098     {
6099       struct binding_level *b = current_binding_level;
6100       while (1)
6101         {
6102           if (purpose_member (name, b->type_shadowed))
6103             return REAL_IDENTIFIER_TYPE_VALUE (name);
6104           if (b->keep == 2)
6105             b = b->level_chain;
6106           else
6107             break;
6108         }
6109     }
6110
6111   return t;
6112 }
6113
6114 void
6115 begin_only_namespace_names ()
6116 {
6117   only_namespace_names = 1;
6118 }
6119
6120 void
6121 end_only_namespace_names ()
6122 {
6123   only_namespace_names = 0;
6124 }
6125 \f
6126 /* Push the declarations of builtin types into the namespace.
6127    RID_INDEX is the index of the builtin type
6128    in the array RID_POINTERS.  NAME is the name used when looking
6129    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6130
6131 void
6132 record_builtin_type (rid_index, name, type)
6133      enum rid rid_index;
6134      const char *name;
6135      tree type;
6136 {
6137   tree rname = NULL_TREE, tname = NULL_TREE;
6138   tree tdecl = NULL_TREE;
6139
6140   if ((int) rid_index < (int) RID_MAX)
6141     rname = ridpointers[(int) rid_index];
6142   if (name)
6143     tname = get_identifier (name);
6144
6145   TYPE_BUILT_IN (type) = 1;
6146
6147   if (tname)
6148     {
6149       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6150       set_identifier_type_value (tname, NULL_TREE);
6151       if ((int) rid_index < (int) RID_MAX)
6152         /* Built-in types live in the global namespace. */
6153         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6154     }
6155   if (rname != NULL_TREE)
6156     {
6157       if (tname != NULL_TREE)
6158         {
6159           set_identifier_type_value (rname, NULL_TREE);
6160           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6161         }
6162       else
6163         {
6164           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6165           set_identifier_type_value (rname, NULL_TREE);
6166         }
6167     }
6168 }
6169
6170 /* Record one of the standard Java types.
6171  * Declare it as having the given NAME.
6172  * If SIZE > 0, it is the size of one of the integral types;
6173  * otherwise it is the negative of the size of one of the other types.  */
6174
6175 static tree
6176 record_builtin_java_type (name, size)
6177      const char *name;
6178      int size;
6179 {
6180   tree type, decl;
6181   if (size > 0)
6182     type = make_signed_type (size);
6183   else if (size > -32)
6184     { /* "__java_char" or ""__java_boolean". */
6185       type = make_unsigned_type (-size);
6186       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6187     }
6188   else
6189     { /* "__java_float" or ""__java_double". */
6190       type = make_node (REAL_TYPE);
6191       TYPE_PRECISION (type) = - size;
6192       layout_type (type);
6193     }
6194   record_builtin_type (RID_MAX, name, type);
6195   decl = TYPE_NAME (type);
6196
6197   /* Suppress generate debug symbol entries for these types,
6198      since for normal C++ they are just clutter.
6199      However, push_lang_context undoes this if extern "Java" is seen. */
6200   DECL_IGNORED_P (decl) = 1;
6201
6202   TYPE_FOR_JAVA (type) = 1;
6203   return type;
6204 }
6205
6206 /* Push a type into the namespace so that the back-ends ignore it. */
6207
6208 static void
6209 record_unknown_type (type, name)
6210      tree type;
6211      const char *name;
6212 {
6213   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6214   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6215   DECL_IGNORED_P (decl) = 1;
6216   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6217   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6218   TYPE_ALIGN (type) = 1;
6219   TYPE_USER_ALIGN (type) = 0;
6220   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6221 }
6222
6223 /* An string for which we should create an IDENTIFIER_NODE at
6224    startup.  */
6225
6226 typedef struct predefined_identifier
6227 {
6228   /* The name of the identifier.  */
6229   const char *name;
6230   /* The place where the IDENTIFIER_NODE should be stored.  */
6231   tree *node;
6232   /* Non-zero if this is the name of a constructor or destructor.  */
6233   int ctor_or_dtor_p;
6234 } predefined_identifier;
6235
6236 /* Create all the predefined identifiers.  */
6237
6238 static void
6239 initialize_predefined_identifiers ()
6240 {
6241   struct predefined_identifier *pid;
6242
6243   /* A table of identifiers to create at startup.  */
6244   static predefined_identifier predefined_identifiers[] = {
6245     { "C++", &lang_name_cplusplus, 0 },
6246     { "C", &lang_name_c, 0 },
6247     { "Java", &lang_name_java, 0 },
6248     { CTOR_NAME, &ctor_identifier, 1 },
6249     { "__base_ctor", &base_ctor_identifier, 1 },
6250     { "__comp_ctor", &complete_ctor_identifier, 1 },
6251     { DTOR_NAME, &dtor_identifier, 1 },
6252     { "__comp_dtor", &complete_dtor_identifier, 1 },
6253     { "__base_dtor", &base_dtor_identifier, 1 },
6254     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6255     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6256     { "nelts", &nelts_identifier, 0 },
6257     { THIS_NAME, &this_identifier, 0 },
6258     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6259     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6260     { "_vptr", &vptr_identifier, 0 },
6261     { "__vtt_parm", &vtt_parm_identifier, 0 },
6262     { "std", &std_identifier, 0 },
6263     { NULL, NULL, 0 }
6264   };
6265
6266   for (pid = predefined_identifiers; pid->name; ++pid)
6267     {
6268       *pid->node = get_identifier (pid->name);
6269       if (pid->ctor_or_dtor_p)
6270         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6271     }
6272 }
6273
6274 /* Create the predefined scalar types of C,
6275    and some nodes representing standard constants (0, 1, (void *)0).
6276    Initialize the global binding level.
6277    Make definitions for built-in primitive functions.  */
6278
6279 void
6280 init_decl_processing ()
6281 {
6282   tree void_ftype;
6283   tree void_ftype_ptr;
6284
6285   /* Create all the identifiers we need.  */
6286   initialize_predefined_identifiers ();
6287
6288   /* Fill in back-end hooks.  */
6289   init_lang_status = &push_cp_function_context;
6290   free_lang_status = &pop_cp_function_context;
6291   mark_lang_status = &mark_cp_function_context;
6292   lang_safe_from_p = &c_safe_from_p;
6293   lang_dump_tree = &cp_dump_tree;
6294   lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
6295
6296   cp_parse_init ();
6297   init_decl2 ();
6298   init_pt ();
6299
6300   /* Create the global variables.  */
6301   push_to_top_level ();
6302
6303   /* Enter the global namespace. */
6304   my_friendly_assert (global_namespace == NULL_TREE, 375);
6305   push_namespace (get_identifier ("::"));
6306   global_namespace = current_namespace;
6307   current_lang_name = NULL_TREE;
6308
6309   /* Adjust various flags based on command-line settings.  */
6310   if (! flag_permissive && ! pedantic)
6311     flag_pedantic_errors = 1;
6312   if (!flag_no_inline)
6313     {
6314       flag_inline_trees = 1;
6315       flag_no_inline = 1;
6316     }
6317   if (flag_inline_functions)
6318     {
6319       flag_inline_trees = 2;
6320       flag_inline_functions = 0;
6321     }
6322
6323   /* In C++, we never create builtin functions whose name does not
6324      begin with `__'.  Users should be using headers to get prototypes
6325      in C++.  It would be nice if we could warn when `-fbuiltin' is
6326      used explicitly, but we do not have that information.  */
6327   flag_no_builtin = 1;
6328
6329   /* Initially, C.  */
6330   current_lang_name = lang_name_c;
6331
6332   current_function_decl = NULL_TREE;
6333   current_binding_level = NULL_BINDING_LEVEL;
6334   free_binding_level = NULL_BINDING_LEVEL;
6335
6336   build_common_tree_nodes (flag_signed_char);
6337
6338   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6339   TREE_TYPE (error_mark_list) = error_mark_node;
6340
6341   /* Make the binding_level structure for global names.  */
6342   pushlevel (0);
6343   global_binding_level = current_binding_level;
6344   /* The global level is the namespace level of ::.  */
6345   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6346   declare_namespace_level ();
6347
6348   /* Create the `std' namespace.  */
6349   push_namespace (std_identifier);
6350   std_node = current_namespace;
6351   pop_namespace ();
6352
6353   c_common_nodes_and_builtins ();
6354
6355   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6356   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6357   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6358   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6359   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6360   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6361   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6362   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6363
6364   integer_two_node = build_int_2 (2, 0);
6365   TREE_TYPE (integer_two_node) = integer_type_node;
6366   integer_three_node = build_int_2 (3, 0);
6367   TREE_TYPE (integer_three_node) = integer_type_node;
6368
6369   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6370   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6371   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6372   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6373   TYPE_PRECISION (boolean_type_node) = 1;
6374   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6375   boolean_false_node = build_int_2 (0, 0);
6376   TREE_TYPE (boolean_false_node) = boolean_type_node;
6377   boolean_true_node = build_int_2 (1, 0);
6378   TREE_TYPE (boolean_true_node) = boolean_type_node;
6379
6380   signed_size_zero_node = build_int_2 (0, 0);
6381   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6382
6383   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6384
6385 #if 0
6386   record_builtin_type (RID_MAX, NULL, string_type_node);
6387 #endif
6388
6389   delta_type_node = ptrdiff_type_node;
6390   vtable_index_type = ptrdiff_type_node;
6391
6392   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6393   lang_type_promotes_to = convert_type_from_ellipsis;
6394
6395   void_ftype = build_function_type (void_type_node, void_list_node);
6396   void_ftype_ptr = build_function_type (void_type_node,
6397                                         tree_cons (NULL_TREE,
6398                                                    ptr_type_node,
6399                                                    void_list_node));
6400   void_ftype_ptr
6401     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6402
6403   /* C++ extensions */
6404
6405   unknown_type_node = make_node (UNKNOWN_TYPE);
6406   record_unknown_type (unknown_type_node, "unknown type");
6407
6408   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6409   TREE_TYPE (unknown_type_node) = unknown_type_node;
6410
6411   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6412
6413   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6414      result.  */
6415   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6416   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6417
6418   {
6419     /* Make sure we get a unique function type, so we can give
6420        its pointer type a name.  (This wins for gdb.) */
6421     tree vfunc_type = make_node (FUNCTION_TYPE);
6422     TREE_TYPE (vfunc_type) = integer_type_node;
6423     TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6424     layout_type (vfunc_type);
6425
6426     vtable_entry_type = build_pointer_type (vfunc_type);
6427   }
6428   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6429
6430   vtbl_type_node
6431     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6432   layout_type (vtbl_type_node);
6433   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6434   record_builtin_type (RID_MAX, NULL, vtbl_type_node);
6435   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6436   layout_type (vtbl_ptr_type_node);
6437   record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
6438
6439   push_namespace (get_identifier ("__cxxabiv1"));
6440   abi_node = current_namespace;
6441   pop_namespace ();
6442
6443   global_type_node = make_node (LANG_TYPE);
6444   record_unknown_type (global_type_node, "global type");
6445
6446   /* Now, C++.  */
6447   current_lang_name = lang_name_cplusplus;
6448
6449   {
6450     tree bad_alloc_type_node, newtype, deltype;
6451     tree ptr_ftype_sizetype;
6452
6453     push_namespace (std_identifier);
6454     bad_alloc_type_node = xref_tag
6455       (class_type_node, get_identifier ("bad_alloc"), 1);
6456     pop_namespace ();
6457     ptr_ftype_sizetype
6458       = build_function_type (ptr_type_node,
6459                              tree_cons (NULL_TREE,
6460                                         c_size_type_node,
6461                                         void_list_node));
6462     newtype = build_exception_variant
6463       (ptr_ftype_sizetype, add_exception_specifier
6464        (NULL_TREE, bad_alloc_type_node, -1));
6465     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6466     push_cp_library_fn (NEW_EXPR, newtype);
6467     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6468     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6469     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6470   }
6471
6472   abort_fndecl
6473     = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
6474
6475   /* Perform other language dependent initializations.  */
6476   init_class_processing ();
6477   init_init_processing ();
6478   init_search_processing ();
6479   init_rtti_processing ();
6480
6481   if (flag_exceptions)
6482     init_exception_processing ();
6483
6484   if (! supports_one_only ())
6485     flag_weak = 0;
6486
6487   make_fname_decl = cp_make_fname_decl;
6488   start_fname_decls ();
6489
6490   /* Prepare to check format strings against argument lists.  */
6491   init_function_format_info ();
6492
6493   /* Show we use EH for cleanups.  */
6494   using_eh_for_cleanups ();
6495
6496   valid_lang_attribute = cp_valid_lang_attribute;
6497
6498   /* Maintain consistency.  Perhaps we should just complain if they
6499      say -fwritable-strings?  */
6500   if (flag_writable_strings)
6501     flag_const_strings = 0;
6502
6503   /* Add GC roots for all of our global variables.  */
6504   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6505   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6506   ggc_add_tree_root (&integer_three_node, 1);
6507   ggc_add_tree_root (&integer_two_node, 1);
6508   ggc_add_tree_root (&signed_size_zero_node, 1);
6509   ggc_add_tree_root (&size_one_node, 1);
6510   ggc_add_tree_root (&size_zero_node, 1);
6511   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6512                 mark_binding_level);
6513   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6514   ggc_add_tree_root (&static_ctors, 1);
6515   ggc_add_tree_root (&static_dtors, 1);
6516   ggc_add_tree_root (&lastiddecl, 1);
6517
6518   ggc_add_tree_root (&last_function_parms, 1);
6519   ggc_add_tree_root (&error_mark_list, 1);
6520
6521   ggc_add_tree_root (&global_namespace, 1);
6522   ggc_add_tree_root (&global_type_node, 1);
6523   ggc_add_tree_root (&anonymous_namespace_name, 1);
6524
6525   ggc_add_tree_root (&got_object, 1);
6526   ggc_add_tree_root (&got_scope, 1);
6527
6528   ggc_add_tree_root (&current_lang_name, 1);
6529   ggc_add_tree_root (&static_aggregates, 1);
6530   ggc_add_tree_root (&free_bindings, 1);
6531 }
6532
6533 /* Generate an initializer for a function naming variable from
6534    NAME. NAME may be NULL, in which case we generate a special
6535    ERROR_MARK node which should be replaced later. */
6536
6537 tree
6538 cp_fname_init (name)
6539      const char *name;
6540 {
6541   tree domain = NULL_TREE;
6542   tree type;
6543   tree init = NULL_TREE;
6544   size_t length = 0;
6545
6546   if (name)
6547     {
6548       length = strlen (name);
6549       domain = build_index_type (size_int (length));
6550       init = build_string (length + 1, name);
6551     }
6552
6553   type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
6554   type = build_cplus_array_type (type, domain);
6555
6556   if (init)
6557     TREE_TYPE (init) = type;
6558   else
6559     /* We don't know the value until instantiation time. Make
6560        something which will be digested now, but replaced later. */
6561     init = build (ERROR_MARK, type);
6562
6563   return init;
6564 }
6565
6566 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6567    decl, NAME is the initialization string and TYPE_DEP indicates whether
6568    NAME depended on the type of the function. We make use of that to detect
6569    __PRETTY_FUNCTION__ inside a template fn. This is being done
6570    lazily at the point of first use, so we musn't push the decl now.  */
6571
6572 static tree
6573 cp_make_fname_decl (id, type_dep)
6574      tree id;
6575      int type_dep;
6576 {
6577   const char *const name = (type_dep && processing_template_decl
6578                       ? NULL : fname_as_string (type_dep));
6579   tree init = cp_fname_init (name);
6580   tree decl = build_decl (VAR_DECL, id, TREE_TYPE (init));
6581
6582   /* As we don't push the decl here, we must set the context. */
6583   DECL_CONTEXT (decl) = current_function_decl;
6584   DECL_PRETTY_FUNCTION_P (decl) = type_dep;
6585
6586   TREE_STATIC (decl) = 1;
6587   TREE_READONLY (decl) = 1;
6588   DECL_ARTIFICIAL (decl) = 1;
6589   DECL_INITIAL (decl) = init;
6590
6591   TREE_USED (decl) = 1;
6592
6593   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6594
6595   return decl;
6596 }
6597
6598 /* Entry point for the benefit of c_common_nodes_and_builtins.
6599
6600    Make a definition for a builtin function named NAME and whose data type
6601    is TYPE.  TYPE should be a function type with argument types.
6602
6603    CLASS and CODE tell later passes how to compile calls to this function.
6604    See tree.h for possible values.
6605
6606    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6607    the name to be called if we can't opencode the function.  */
6608
6609 tree
6610 builtin_function (name, type, code, class, libname)
6611      const char *name;
6612      tree type;
6613      int code;
6614      enum built_in_class class;
6615      const char *libname;
6616 {
6617   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6618   DECL_BUILT_IN_CLASS (decl) = class;
6619   DECL_FUNCTION_CODE (decl) = code;
6620
6621   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6622
6623   /* All builtins that don't begin with an `_' should go in the `std'
6624      namespace.  */
6625   if (name[0] != '_')
6626     {
6627       push_namespace (std_identifier);
6628       DECL_CONTEXT (decl) = std_node;
6629     }
6630   pushdecl (decl);
6631   if (name[0] != '_')
6632     pop_namespace ();
6633
6634   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6635      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6636      function in the namespace.  */
6637   if (libname)
6638     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
6639   make_decl_rtl (decl, NULL);
6640
6641   /* Warn if a function in the namespace for users
6642      is used without an occasion to consider it declared.  */
6643   if (name[0] != '_' || name[1] != '_')
6644     DECL_ANTICIPATED (decl) = 1;
6645
6646   return decl;
6647 }
6648
6649 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6650    function.  Not called directly.  */
6651
6652 static tree
6653 build_library_fn_1 (name, operator_code, type)
6654      tree name;
6655      enum tree_code operator_code;
6656      tree type;
6657 {
6658   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6659   DECL_EXTERNAL (fn) = 1;
6660   TREE_PUBLIC (fn) = 1;
6661   DECL_ARTIFICIAL (fn) = 1;
6662   TREE_NOTHROW (fn) = 1;
6663   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6664   SET_DECL_LANGUAGE (fn, lang_c);
6665   return fn;
6666 }
6667
6668 /* Returns the _DECL for a library function with C linkage.
6669    We assume that such functions never throw; if this is incorrect,
6670    callers should unset TREE_NOTHROW.  */
6671
6672 tree
6673 build_library_fn (name, type)
6674      tree name;
6675      tree type;
6676 {
6677   return build_library_fn_1 (name, ERROR_MARK, type);
6678 }
6679
6680 /* Returns the _DECL for a library function with C++ linkage.  */
6681
6682 static tree
6683 build_cp_library_fn (name, operator_code, type)
6684      tree name;
6685      enum tree_code operator_code;
6686      tree type;
6687 {
6688   tree fn = build_library_fn_1 (name, operator_code, type);
6689   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6690   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6691   SET_DECL_LANGUAGE (fn, lang_cplusplus);
6692   set_mangled_name_for_decl (fn);
6693   return fn;
6694 }
6695
6696 /* Like build_library_fn, but takes a C string instead of an
6697    IDENTIFIER_NODE.  */
6698
6699 tree
6700 build_library_fn_ptr (name, type)
6701      const char *name;
6702      tree type;
6703 {
6704   return build_library_fn (get_identifier (name), type);
6705 }
6706
6707 /* Like build_cp_library_fn, but takes a C string instead of an
6708    IDENTIFIER_NODE.  */
6709
6710 tree
6711 build_cp_library_fn_ptr (name, type)
6712      const char *name;
6713      tree type;
6714 {
6715   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6716 }
6717
6718 /* Like build_library_fn, but also pushes the function so that we will
6719    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6720
6721 tree
6722 push_library_fn (name, type)
6723      tree name, type;
6724 {
6725   tree fn = build_library_fn (name, type);
6726   pushdecl_top_level (fn);
6727   return fn;
6728 }
6729
6730 /* Like build_cp_library_fn, but also pushes the function so that it
6731    will be found by normal lookup.  */
6732
6733 static tree
6734 push_cp_library_fn (operator_code, type)
6735      enum tree_code operator_code;
6736      tree type;
6737 {
6738   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6739                                  operator_code,
6740                                  type);
6741   pushdecl (fn);
6742   return fn;
6743 }
6744
6745 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6746    a FUNCTION_TYPE.  */
6747
6748 tree
6749 push_void_library_fn (name, parmtypes)
6750      tree name, parmtypes;
6751 {
6752   tree type = build_function_type (void_type_node, parmtypes);
6753   return push_library_fn (name, type);
6754 }
6755
6756 /* Like push_library_fn, but also note that this function throws
6757    and does not return.  Used for __throw_foo and the like.  */
6758
6759 tree
6760 push_throw_library_fn (name, type)
6761      tree name, type;
6762 {
6763   tree fn = push_library_fn (name, type);
6764   TREE_THIS_VOLATILE (fn) = 1;
6765   TREE_NOTHROW (fn) = 0;
6766   return fn;
6767 }
6768 \f
6769 /* When we call finish_struct for an anonymous union, we create
6770    default copy constructors and such.  But, an anonymous union
6771    shouldn't have such things; this function undoes the damage to the
6772    anonymous union type T.
6773
6774    (The reason that we create the synthesized methods is that we don't
6775    distinguish `union { int i; }' from `typedef union { int i; } U'.
6776    The first is an anonymous union; the second is just an ordinary
6777    union type.)  */
6778
6779 void
6780 fixup_anonymous_aggr (t)
6781      tree t;
6782 {
6783   tree *q;
6784
6785   /* Wipe out memory of synthesized methods */
6786   TYPE_HAS_CONSTRUCTOR (t) = 0;
6787   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6788   TYPE_HAS_INIT_REF (t) = 0;
6789   TYPE_HAS_CONST_INIT_REF (t) = 0;
6790   TYPE_HAS_ASSIGN_REF (t) = 0;
6791   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6792
6793   /* Splice the implicitly generated functions out of the TYPE_METHODS
6794      list.  */
6795   q = &TYPE_METHODS (t);
6796   while (*q)
6797     {
6798       if (DECL_ARTIFICIAL (*q))
6799         *q = TREE_CHAIN (*q);
6800       else
6801         q = &TREE_CHAIN (*q);
6802     }
6803
6804   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6805   if (TYPE_METHODS (t))
6806     cp_error_at ("an anonymous union cannot have function members", t);
6807
6808   /* Anonymous aggregates cannot have fields with ctors, dtors or complex
6809      assignment operators (because they cannot have these methods themselves).
6810      For anonymous unions this is already checked because they are not allowed
6811      in any union, otherwise we have to check it.  */
6812   if (TREE_CODE (t) != UNION_TYPE)
6813     {
6814       tree field, type;
6815
6816       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
6817         if (TREE_CODE (field) == FIELD_DECL)
6818           {
6819             type = TREE_TYPE (field);
6820             if (CLASS_TYPE_P (type))
6821               {
6822                 if (TYPE_NEEDS_CONSTRUCTING (type))
6823                   cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
6824                                field);
6825                 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6826                   cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
6827                                field);
6828                 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
6829                   cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
6830                                field);
6831               }
6832           }
6833     }
6834 }
6835
6836 /* Make sure that a declaration with no declarator is well-formed, i.e.
6837    just defines a tagged type or anonymous union.
6838
6839    Returns the type defined, if any.  */
6840
6841 tree
6842 check_tag_decl (declspecs)
6843      tree declspecs;
6844 {
6845   int found_type = 0;
6846   int saw_friend = 0;
6847   int saw_typedef = 0;
6848   tree ob_modifier = NULL_TREE;
6849   register tree link;
6850   register tree t = NULL_TREE;
6851
6852   for (link = declspecs; link; link = TREE_CHAIN (link))
6853     {
6854       register tree value = TREE_VALUE (link);
6855
6856       if (TYPE_P (value)
6857           || TREE_CODE (value) == TYPE_DECL
6858           || (TREE_CODE (value) == IDENTIFIER_NODE
6859               && IDENTIFIER_GLOBAL_VALUE (value)
6860               && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value)) == TYPE_DECL))
6861         {
6862           ++found_type;
6863
6864           if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
6865             {
6866               if (! in_system_header)
6867                 cp_pedwarn ("redeclaration of C++ built-in type `%T'", value);
6868               return NULL_TREE;
6869             }
6870
6871           if (TYPE_P (value)
6872               && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
6873                   || TREE_CODE (value) == ENUMERAL_TYPE))
6874             {
6875               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6876               t = value;
6877             }
6878         }
6879       else if (value == ridpointers[(int) RID_TYPEDEF])
6880         saw_typedef = 1;
6881       else if (value == ridpointers[(int) RID_FRIEND])
6882         {
6883           if (current_class_type == NULL_TREE
6884               || current_scope () != current_class_type)
6885             ob_modifier = value;
6886           else
6887             saw_friend = 1;
6888         }
6889       else if (value == ridpointers[(int) RID_STATIC]
6890                || value == ridpointers[(int) RID_EXTERN]
6891                || value == ridpointers[(int) RID_AUTO]
6892                || value == ridpointers[(int) RID_REGISTER]
6893                || value == ridpointers[(int) RID_INLINE]
6894                || value == ridpointers[(int) RID_VIRTUAL]
6895                || value == ridpointers[(int) RID_CONST]
6896                || value == ridpointers[(int) RID_VOLATILE]
6897                || value == ridpointers[(int) RID_EXPLICIT])
6898         ob_modifier = value;
6899     }
6900
6901   if (found_type > 1)
6902     error ("multiple types in one declaration");
6903
6904   if (t == NULL_TREE && ! saw_friend)
6905     pedwarn ("declaration does not declare anything");
6906
6907   /* Check for an anonymous union.  */
6908   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
6909            && TYPE_ANONYMOUS_P (t))
6910     {
6911       /* 7/3 In a simple-declaration, the optional init-declarator-list
6912          can be omitted only when declaring a class (clause 9) or
6913          enumeration (7.2), that is, when the decl-specifier-seq contains
6914          either a class-specifier, an elaborated-type-specifier with
6915          a class-key (9.1), or an enum-specifier.  In these cases and
6916          whenever a class-specifier or enum-specifier is present in the
6917          decl-specifier-seq, the identifiers in these specifiers are among
6918          the names being declared by the declaration (as class-name,
6919          enum-names, or enumerators, depending on the syntax).  In such
6920          cases, and except for the declaration of an unnamed bit-field (9.6),
6921          the decl-specifier-seq shall introduce one or more names into the
6922          program, or shall redeclare a name introduced by a previous
6923          declaration.  [Example:
6924              enum { };            // ill-formed
6925              typedef class { };   // ill-formed
6926          --end example]  */
6927       if (saw_typedef)
6928         {
6929           error ("Missing type-name in typedef-declaration.");
6930           return NULL_TREE;
6931         }
6932       /* Anonymous unions are objects, so they can have specifiers.  */;
6933       SET_ANON_AGGR_TYPE_P (t);
6934
6935       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
6936         pedwarn ("ISO C++ prohibits anonymous structs");
6937     }
6938
6939   else if (ob_modifier)
6940     {
6941       if (ob_modifier == ridpointers[(int) RID_INLINE]
6942           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6943         cp_error ("`%D' can only be specified for functions", ob_modifier);
6944       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
6945         cp_error ("`%D' can only be specified inside a class", ob_modifier);
6946       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6947         cp_error ("`%D' can only be specified for constructors",
6948                   ob_modifier);
6949       else
6950         cp_error ("`%D' can only be specified for objects and functions",
6951                   ob_modifier);
6952     }
6953
6954   return t;
6955 }
6956
6957 /* Called when a declaration is seen that contains no names to declare.
6958    If its type is a reference to a structure, union or enum inherited
6959    from a containing scope, shadow that tag name for the current scope
6960    with a forward reference.
6961    If its type defines a new named structure or union
6962    or defines an enum, it is valid but we need not do anything here.
6963    Otherwise, it is an error.
6964
6965    C++: may have to grok the declspecs to learn about static,
6966    complain for anonymous unions.  */
6967
6968 void
6969 shadow_tag (declspecs)
6970      tree declspecs;
6971 {
6972   tree t = check_tag_decl (declspecs);
6973
6974   if (t)
6975     maybe_process_partial_specialization (t);
6976
6977   /* This is where the variables in an anonymous union are
6978      declared.  An anonymous union declaration looks like:
6979      union { ... } ;
6980      because there is no declarator after the union, the parser
6981      sends that declaration here.  */
6982   if (t && ANON_AGGR_TYPE_P (t))
6983     {
6984       fixup_anonymous_aggr (t);
6985
6986       if (TYPE_FIELDS (t))
6987         {
6988           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
6989                                       NULL_TREE);
6990           finish_anon_union (decl);
6991         }
6992     }
6993 }
6994 \f
6995 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
6996
6997 tree
6998 groktypename (typename)
6999      tree typename;
7000 {
7001   if (TREE_CODE (typename) != TREE_LIST)
7002     return typename;
7003   return grokdeclarator (TREE_VALUE (typename),
7004                          TREE_PURPOSE (typename),
7005                          TYPENAME, 0, NULL_TREE);
7006 }
7007
7008 /* Decode a declarator in an ordinary declaration or data definition.
7009    This is called as soon as the type information and variable name
7010    have been parsed, before parsing the initializer if any.
7011    Here we create the ..._DECL node, fill in its type,
7012    and put it on the list of decls for the current context.
7013    The ..._DECL node is returned as the value.
7014
7015    Exception: for arrays where the length is not specified,
7016    the type is left null, to be filled in by `cp_finish_decl'.
7017
7018    Function definitions do not come here; they go to start_function
7019    instead.  However, external and forward declarations of functions
7020    do go through here.  Structure field declarations are done by
7021    grokfield and not through here.  */
7022
7023 tree
7024 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7025      tree declarator, declspecs;
7026      int initialized;
7027      tree attributes, prefix_attributes;
7028 {
7029   tree decl;
7030   register tree type, tem;
7031   tree context;
7032   extern int have_extern_spec;
7033   extern int used_extern_spec;
7034   tree attrlist;
7035
7036 #if 0
7037   /* See code below that used this.  */
7038   int init_written = initialized;
7039 #endif
7040
7041   /* This should only be done once on the top most decl.  */
7042   if (have_extern_spec && !used_extern_spec)
7043     {
7044       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7045                              declspecs);
7046       used_extern_spec = 1;
7047     }
7048
7049   if (attributes || prefix_attributes)
7050     attrlist = build_tree_list (attributes, prefix_attributes);
7051   else
7052     attrlist = NULL_TREE;
7053
7054   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7055                          attrlist);
7056
7057   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7058     return NULL_TREE;
7059
7060   type = TREE_TYPE (decl);
7061
7062   if (type == error_mark_node)
7063     return NULL_TREE;
7064
7065   context = DECL_CONTEXT (decl);
7066
7067   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7068       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7069     {
7070       /* When parsing the initializer, lookup should use the object's
7071          namespace. */
7072       push_decl_namespace (context);
7073     }
7074
7075   /* We are only interested in class contexts, later. */
7076   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7077     context = NULL_TREE;
7078
7079   if (initialized)
7080     /* Is it valid for this decl to have an initializer at all?
7081        If not, set INITIALIZED to zero, which will indirectly
7082        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7083     switch (TREE_CODE (decl))
7084       {
7085       case TYPE_DECL:
7086         /* typedef foo = bar  means give foo the same type as bar.
7087            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7088            Any other case of an initialization in a TYPE_DECL is an error.  */
7089         if (pedantic || list_length (declspecs) > 1)
7090           {
7091             cp_error ("typedef `%D' is initialized", decl);
7092             initialized = 0;
7093           }
7094         break;
7095
7096       case FUNCTION_DECL:
7097         cp_error ("function `%#D' is initialized like a variable", decl);
7098         initialized = 0;
7099         break;
7100
7101       default:
7102         break;
7103       }
7104
7105   if (initialized)
7106     {
7107       if (! toplevel_bindings_p ()
7108           && DECL_EXTERNAL (decl))
7109         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7110                     decl);
7111       DECL_EXTERNAL (decl) = 0;
7112       if (toplevel_bindings_p ())
7113         TREE_STATIC (decl) = 1;
7114
7115       /* Tell `pushdecl' this is an initialized decl
7116          even though we don't yet have the initializer expression.
7117          Also tell `cp_finish_decl' it may store the real initializer.  */
7118       DECL_INITIAL (decl) = error_mark_node;
7119     }
7120
7121   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7122   cplus_decl_attributes (&decl, attributes, prefix_attributes, 0);
7123
7124   if (context && COMPLETE_TYPE_P (complete_type (context)))
7125     {
7126       push_nested_class (context, 2);
7127
7128       if (TREE_CODE (decl) == VAR_DECL)
7129         {
7130           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7131           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7132             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7133           else
7134             {
7135               if (DECL_CONTEXT (field) != context)
7136                 {
7137                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7138                               DECL_CONTEXT (field), DECL_NAME (decl),
7139                               context, DECL_NAME (decl));
7140                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7141                 }
7142               /* Static data member are tricky; an in-class initialization
7143                  still doesn't provide a definition, so the in-class
7144                  declaration will have DECL_EXTERNAL set, but will have an
7145                  initialization.  Thus, duplicate_decls won't warn
7146                  about this situation, and so we check here.  */
7147               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7148                 cp_error ("duplicate initialization of %D", decl);
7149               if (duplicate_decls (decl, field))
7150                 decl = field;
7151             }
7152         }
7153       else
7154         {
7155           tree field = check_classfn (context, decl);
7156           if (field && duplicate_decls (decl, field))
7157             decl = field;
7158         }
7159
7160       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7161       DECL_IN_AGGR_P (decl) = 0;
7162       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7163           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7164         {
7165           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7166           /* [temp.expl.spec] An explicit specialization of a static data
7167              member of a template is a definition if the declaration
7168              includes an initializer; otherwise, it is a declaration.
7169
7170              We check for processing_specialization so this only applies
7171              to the new specialization syntax.  */
7172           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7173             DECL_EXTERNAL (decl) = 1;
7174         }
7175
7176       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7177         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7178                     decl);
7179     }
7180
7181   /* Enter this declaration into the symbol table.  */
7182   tem = maybe_push_decl (decl);
7183
7184   if (processing_template_decl)
7185     tem = push_template_decl (tem);
7186
7187 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7188   /* Tell the back-end to use or not use .common as appropriate.  If we say
7189      -fconserve-space, we want this to save .data space, at the expense of
7190      wrong semantics.  If we say -fno-conserve-space, we want this to
7191      produce errors about redefs; to do this we force variables into the
7192      data segment.  */
7193   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7194 #endif
7195
7196   if (! processing_template_decl)
7197     start_decl_1 (tem);
7198
7199   return tem;
7200 }
7201
7202 void
7203 start_decl_1 (decl)
7204      tree decl;
7205 {
7206   tree type = TREE_TYPE (decl);
7207   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7208
7209   if (type == error_mark_node)
7210     return;
7211
7212   maybe_push_cleanup_level (type);
7213
7214   if (initialized)
7215     /* Is it valid for this decl to have an initializer at all?
7216        If not, set INITIALIZED to zero, which will indirectly
7217        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7218     {
7219       /* Don't allow initializations for incomplete types except for
7220          arrays which might be completed by the initialization.  */
7221       if (COMPLETE_TYPE_P (complete_type (type)))
7222         ;                       /* A complete type is ok.  */
7223       else if (TREE_CODE (type) != ARRAY_TYPE)
7224         {
7225           cp_error ("variable `%#D' has initializer but incomplete type",
7226                     decl);
7227           initialized = 0;
7228           type = TREE_TYPE (decl) = error_mark_node;
7229         }
7230       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7231         {
7232           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7233             cp_error ("elements of array `%#D' have incomplete type", decl);
7234           /* else we already gave an error in start_decl.  */
7235           initialized = 0;
7236         }
7237     }
7238
7239   if (!initialized
7240       && TREE_CODE (decl) != TYPE_DECL
7241       && TREE_CODE (decl) != TEMPLATE_DECL
7242       && type != error_mark_node
7243       && IS_AGGR_TYPE (type)
7244       && ! DECL_EXTERNAL (decl))
7245     {
7246       if ((! processing_template_decl || ! uses_template_parms (type))
7247           && !COMPLETE_TYPE_P (complete_type (type)))
7248         {
7249           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7250                  decl);
7251           /* Change the type so that assemble_variable will give
7252              DECL an rtl we can live with: (mem (const_int 0)).  */
7253           type = TREE_TYPE (decl) = error_mark_node;
7254         }
7255       else
7256         {
7257           /* If any base type in the hierarchy of TYPE needs a constructor,
7258              then we set initialized to 1.  This way any nodes which are
7259              created for the purposes of initializing this aggregate
7260              will live as long as it does.  This is necessary for global
7261              aggregates which do not have their initializers processed until
7262              the end of the file.  */
7263           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7264         }
7265     }
7266
7267   if (! initialized)
7268     DECL_INITIAL (decl) = NULL_TREE;
7269 }
7270
7271 /* Handle initialization of references.
7272    These three arguments are from `cp_finish_decl', and have the
7273    same meaning here that they do there.
7274
7275    Quotes on semantics can be found in ARM 8.4.3.  */
7276
7277 static tree
7278 grok_reference_init (decl, type, init)
7279      tree decl, type, init;
7280 {
7281   tree tmp;
7282
7283   if (init == NULL_TREE)
7284     {
7285       if ((DECL_LANG_SPECIFIC (decl) == 0
7286            || DECL_IN_AGGR_P (decl) == 0)
7287           && ! DECL_THIS_EXTERN (decl))
7288         cp_error ("`%D' declared as reference but not initialized", decl);
7289       return NULL_TREE;
7290     }
7291
7292   if (init == error_mark_node)
7293     return NULL_TREE;
7294
7295   if (TREE_CODE (init) == CONSTRUCTOR)
7296     {
7297       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7298       return NULL_TREE;
7299     }
7300
7301   if (TREE_CODE (init) == TREE_LIST)
7302     init = build_compound_expr (init);
7303
7304   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7305     init = convert_from_reference (init);
7306
7307   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7308       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7309     {
7310       /* Note: default conversion is only called in very special cases.  */
7311       init = default_conversion (init);
7312     }
7313
7314   /* Convert INIT to the reference type TYPE.  This may involve the
7315      creation of a temporary, whose lifetime must be the same as that
7316      of the reference.  If so, a DECL_STMT for the temporary will be
7317      added just after the DECL_STMT for DECL.  That's why we don't set
7318      DECL_INITIAL for local references (instead assigning to them
7319      explicitly); we need to allow the temporary to be initialized
7320      first.  */
7321   tmp = convert_to_reference
7322     (type, init, CONV_IMPLICIT,
7323      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7324      decl);
7325
7326   if (tmp == error_mark_node)
7327     return NULL_TREE;
7328   else if (tmp == NULL_TREE)
7329     {
7330       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7331       return NULL_TREE;
7332     }
7333
7334   if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
7335     return tmp;
7336
7337   DECL_INITIAL (decl) = tmp;
7338
7339   return NULL_TREE;
7340 }
7341
7342 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7343    mucking with forces it does not comprehend (i.e. initialization with a
7344    constructor).  If we are at global scope and won't go into COMMON, fill
7345    it in with a dummy CONSTRUCTOR to force the variable into .data;
7346    otherwise we can use error_mark_node.  */
7347
7348 static tree
7349 obscure_complex_init (decl, init)
7350      tree decl, init;
7351 {
7352   if (! flag_no_inline && TREE_STATIC (decl))
7353     {
7354       if (extract_init (decl, init))
7355         return NULL_TREE;
7356     }
7357
7358 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7359   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7360     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7361                                  NULL_TREE);
7362   else
7363 #endif
7364     DECL_INITIAL (decl) = error_mark_node;
7365
7366   return init;
7367 }
7368
7369 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7370    array until we finish parsing the initializer.  If that's the
7371    situation we're in, update DECL accordingly.  */
7372
7373 static void
7374 maybe_deduce_size_from_array_init (decl, init)
7375      tree decl;
7376      tree init;
7377 {
7378   tree type = TREE_TYPE (decl);
7379
7380   if (TREE_CODE (type) == ARRAY_TYPE
7381       && TYPE_DOMAIN (type) == NULL_TREE
7382       && TREE_CODE (decl) != TYPE_DECL)
7383     {
7384       /* do_default is really a C-ism to deal with tentative definitions.
7385          But let's leave it here to ease the eventual merge.  */
7386       int do_default = !DECL_EXTERNAL (decl);
7387       tree initializer = init ? init : DECL_INITIAL (decl);
7388       int failure = complete_array_type (type, initializer, do_default);
7389
7390       if (failure == 1)
7391         cp_error ("initializer fails to determine size of `%D'", decl);
7392
7393       if (failure == 2)
7394         {
7395           if (do_default)
7396             cp_error ("array size missing in `%D'", decl);
7397           /* If a `static' var's size isn't known, make it extern as
7398              well as static, so it does not get allocated.  If it's not
7399              `static', then don't mark it extern; finish_incomplete_decl
7400              will give it a default size and it will get allocated.  */
7401           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7402             DECL_EXTERNAL (decl) = 1;
7403         }
7404
7405       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7406           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7407                               integer_zero_node))
7408         cp_error ("zero-size array `%D'", decl);
7409
7410       layout_decl (decl, 0);
7411     }
7412 }
7413
7414 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7415    any appropriate error messages regarding the layout.  */
7416
7417 static void
7418 layout_var_decl (decl)
7419      tree decl;
7420 {
7421   tree type = TREE_TYPE (decl);
7422 #if 0
7423   tree ttype = target_type (type);
7424 #endif
7425
7426   /* If we haven't already layed out this declaration, do so now.
7427      Note that we must not call complete type for an external object
7428      because it's type might involve templates that we are not
7429      supposed to isntantiate yet.  (And it's perfectly legal to say
7430      `extern X x' for some incomplete type `X'.)  */
7431   if (!DECL_EXTERNAL (decl))
7432     complete_type (type);
7433   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7434     layout_decl (decl, 0);
7435
7436   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7437     {
7438       /* An automatic variable with an incomplete type: that is an error.
7439          Don't talk about array types here, since we took care of that
7440          message in grokdeclarator.  */
7441       cp_error ("storage size of `%D' isn't known", decl);
7442       TREE_TYPE (decl) = error_mark_node;
7443     }
7444 #if 0
7445   /* Keep this code around in case we later want to control debug info
7446      based on whether a type is "used".  (jason 1999-11-11) */
7447
7448   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7449     /* Let debugger know it should output info for this type.  */
7450     note_debug_info_needed (ttype);
7451
7452   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7453     note_debug_info_needed (DECL_CONTEXT (decl));
7454 #endif
7455
7456   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7457       && DECL_SIZE (decl) != NULL_TREE
7458       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7459     {
7460       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7461         constant_expression_warning (DECL_SIZE (decl));
7462       else
7463         cp_error ("storage size of `%D' isn't constant", decl);
7464     }
7465
7466   if (TREE_STATIC (decl)
7467       && !DECL_ARTIFICIAL (decl)
7468       && current_function_decl
7469       && DECL_CONTEXT (decl) == current_function_decl)
7470     push_local_name (decl);
7471 }
7472
7473 /* If a local static variable is declared in an inline function, or if
7474    we have a weak definition, we must endeavor to create only one
7475    instance of the variable at link-time.  */
7476
7477 static void
7478 maybe_commonize_var (decl)
7479      tree decl;
7480 {
7481   /* Static data in a function with comdat linkage also has comdat
7482      linkage.  */
7483   if (TREE_STATIC (decl)
7484       /* Don't mess with __FUNCTION__.  */
7485       && ! DECL_ARTIFICIAL (decl)
7486       && current_function_decl
7487       && DECL_CONTEXT (decl) == current_function_decl
7488       && (DECL_DECLARED_INLINE_P (current_function_decl)
7489           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7490       && TREE_PUBLIC (current_function_decl))
7491     {
7492       /* If flag_weak, we don't need to mess with this, as we can just
7493          make the function weak, and let it refer to its unique local
7494          copy.  This works because we don't allow the function to be
7495          inlined.  */
7496       if (! flag_weak)
7497         {
7498           if (DECL_INTERFACE_KNOWN (current_function_decl))
7499             {
7500               TREE_PUBLIC (decl) = 1;
7501               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7502             }
7503           else if (DECL_INITIAL (decl) == NULL_TREE
7504                    || DECL_INITIAL (decl) == error_mark_node)
7505             {
7506               TREE_PUBLIC (decl) = 1;
7507               DECL_COMMON (decl) = 1;
7508             }
7509           /* else we lose. We can only do this if we can use common,
7510              which we can't if it has been initialized.  */
7511
7512           if (!TREE_PUBLIC (decl))
7513             {
7514               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7515               cp_warning_at ("  you can work around this by removing the initializer", decl);
7516             }
7517         }
7518       else
7519         comdat_linkage (decl);
7520     }
7521   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7522     /* Set it up again; we might have set DECL_INITIAL since the last
7523        time.  */
7524     comdat_linkage (decl);
7525 }
7526
7527 /* Issue an error message if DECL is an uninitialized const variable.  */
7528
7529 static void
7530 check_for_uninitialized_const_var (decl)
7531      tree decl;
7532 {
7533   tree type = TREE_TYPE (decl);
7534
7535   /* ``Unless explicitly declared extern, a const object does not have
7536      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7537      7.1.6 */
7538   if (TREE_CODE (decl) == VAR_DECL
7539       && TREE_CODE (type) != REFERENCE_TYPE
7540       && CP_TYPE_CONST_P (type)
7541       && !TYPE_NEEDS_CONSTRUCTING (type)
7542       && !DECL_INITIAL (decl))
7543     cp_error ("uninitialized const `%D'", decl);
7544 }
7545
7546 /* Verify INIT (the initializer for DECL), and record the
7547    initialization in DECL_INITIAL, if appropriate.  Returns a new
7548    value for INIT.  */
7549
7550 static tree
7551 check_initializer (decl, init)
7552      tree decl;
7553      tree init;
7554 {
7555   tree type;
7556
7557   if (TREE_CODE (decl) == FIELD_DECL)
7558     return init;
7559
7560   type = TREE_TYPE (decl);
7561
7562   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7563   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7564     init = NULL_TREE;
7565
7566   /* Check the initializer.  */
7567   if (init)
7568     {
7569       /* Things that are going to be initialized need to have complete
7570          type.  */
7571       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7572
7573       if (type == error_mark_node)
7574         /* We will have already complained.  */
7575         init = NULL_TREE;
7576       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7577         {
7578           cp_error ("variable-sized object `%D' may not be initialized", decl);
7579           init = NULL_TREE;
7580         }
7581       else if (TREE_CODE (type) == ARRAY_TYPE
7582                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7583         {
7584           cp_error ("elements of array `%#D' have incomplete type", decl);
7585           init = NULL_TREE;
7586         }
7587       else if (!COMPLETE_TYPE_P (type))
7588         {
7589           cp_error ("`%D' has incomplete type", decl);
7590           TREE_TYPE (decl) = error_mark_node;
7591           init = NULL_TREE;
7592         }
7593     }
7594
7595   if (TREE_CODE (decl) == CONST_DECL)
7596     {
7597       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7598
7599       DECL_INITIAL (decl) = init;
7600
7601       my_friendly_assert (init != NULL_TREE, 149);
7602       init = NULL_TREE;
7603     }
7604   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7605     {
7606       init = grok_reference_init (decl, type, init);
7607       if (init)
7608         init = obscure_complex_init (decl, init);
7609     }
7610   else if (init)
7611     {
7612       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7613         {
7614           if (TREE_CODE (type) == ARRAY_TYPE)
7615             init = digest_init (type, init, (tree *) 0);
7616           else if (TREE_CODE (init) == CONSTRUCTOR
7617                    && TREE_HAS_CONSTRUCTOR (init))
7618             {
7619               if (TYPE_NON_AGGREGATE_CLASS (type))
7620                 {
7621                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7622                             decl);
7623                   init = error_mark_node;
7624                 }
7625               else
7626                 goto dont_use_constructor;
7627             }
7628         }
7629       else
7630         {
7631         dont_use_constructor:
7632           if (TREE_CODE (init) != TREE_VEC)
7633             init = store_init_value (decl, init);
7634         }
7635
7636       if (init)
7637         /* We must hide the initializer so that expand_decl
7638            won't try to do something it does not understand.  */
7639         init = obscure_complex_init (decl, init);
7640     }
7641   else if (DECL_EXTERNAL (decl))
7642     ;
7643   else if (TYPE_P (type)
7644            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7645     {
7646       tree core_type = strip_array_types (type);
7647
7648       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7649         {
7650           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7651             cp_error ("structure `%D' with uninitialized const members", decl);
7652           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7653             cp_error ("structure `%D' with uninitialized reference members",
7654                       decl);
7655         }
7656
7657       check_for_uninitialized_const_var (decl);
7658
7659       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7660         init = obscure_complex_init (decl, NULL_TREE);
7661
7662     }
7663   else
7664     check_for_uninitialized_const_var (decl);
7665
7666   return init;
7667 }
7668
7669 /* If DECL is not a local variable, give it RTL.  */
7670
7671 static void
7672 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7673      tree decl;
7674      tree init;
7675      const char *asmspec;
7676 {
7677   int toplev = toplevel_bindings_p ();
7678   int defer_p;
7679
7680   /* Handle non-variables up front.  */
7681   if (TREE_CODE (decl) != VAR_DECL)
7682     {
7683       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7684       return;
7685     }
7686
7687   /* If we see a class member here, it should be a static data
7688      member.  */
7689   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7690     {
7691       my_friendly_assert (TREE_STATIC (decl), 19990828);
7692       /* An in-class declaration of a static data member should be
7693          external; it is only a declaration, and not a definition.  */
7694       if (init == NULL_TREE)
7695         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7696     }
7697
7698   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7699   if (asmspec)
7700     {
7701       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
7702       /* The `register' keyword, when used together with an
7703          asm-specification, indicates that the variable should be
7704          placed in a particular register.  */
7705       if (DECL_REGISTER (decl))
7706         DECL_C_HARD_REGISTER (decl) = 1;
7707     }
7708
7709   /* We don't create any RTL for local variables.  */
7710   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7711     return;
7712
7713   /* We defer emission of local statics until the corresponding
7714      DECL_STMT is expanded.  */
7715   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7716
7717   /* We try to defer namespace-scope static constants so that they are
7718      not emitted into the object file unncessarily.  */
7719   if (!DECL_VIRTUAL_P (decl)
7720       && TREE_READONLY (decl)
7721       && DECL_INITIAL (decl) != NULL_TREE
7722       && DECL_INITIAL (decl) != error_mark_node
7723       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7724       && toplev
7725       && !TREE_PUBLIC (decl))
7726     {
7727       /* Fool with the linkage according to #pragma interface.  */
7728       if (!interface_unknown)
7729         {
7730           TREE_PUBLIC (decl) = 1;
7731           DECL_EXTERNAL (decl) = interface_only;
7732         }
7733
7734       defer_p = 1;
7735     }
7736
7737   /* If we're deferring the variable, we only need to make RTL if
7738      there's an ASMSPEC.  Otherwise, we'll lazily create it later when
7739      we need it.  (There's no way to lazily create RTL for things that
7740      have assembly specs because the information about the specifier
7741      isn't stored in the tree, yet)  */
7742   if (defer_p && asmspec)
7743     make_decl_rtl (decl, asmspec);
7744   /* If we're not deferring, go ahead and assemble the variable.  */
7745   else if (!defer_p)
7746     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7747 }
7748
7749 /* The old ARM scoping rules injected variables declared in the
7750    initialization statement of a for-statement into the surrounding
7751    scope.  We support this usage, in order to be backward-compatible.
7752    DECL is a just-declared VAR_DECL; if necessary inject its
7753    declaration into the surrounding scope.  */
7754
7755 void
7756 maybe_inject_for_scope_var (decl)
7757      tree decl;
7758 {
7759   if (!DECL_NAME (decl))
7760     return;
7761
7762   if (current_binding_level->is_for_scope)
7763     {
7764       struct binding_level *outer
7765         = current_binding_level->level_chain;
7766
7767       /* Check to see if the same name is already bound at the outer
7768          level, either because it was directly declared, or because a
7769          dead for-decl got preserved.  In either case, the code would
7770          not have been valid under the ARM scope rules, so clear
7771          is_for_scope for the current_binding_level.
7772
7773          Otherwise, we need to preserve the temp slot for decl to last
7774          into the outer binding level.  */
7775
7776       tree outer_binding
7777         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7778
7779       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7780           && (TREE_CODE (BINDING_VALUE (outer_binding))
7781               == VAR_DECL)
7782           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7783         {
7784           BINDING_VALUE (outer_binding)
7785             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7786           current_binding_level->is_for_scope = 0;
7787         }
7788       else if (DECL_IN_MEMORY_P (decl))
7789         preserve_temp_slots (DECL_RTL (decl));
7790     }
7791 }
7792
7793 /* Generate code to initialize DECL (a local variable).  */
7794
7795 void
7796 initialize_local_var (decl, init, flags)
7797      tree decl;
7798      tree init;
7799      int flags;
7800 {
7801   tree type = TREE_TYPE (decl);
7802
7803   /* If the type is bogus, don't bother initializing the variable.  */
7804   if (type == error_mark_node)
7805     return;
7806
7807   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7808     {
7809       /* If we used it already as memory, it must stay in memory.  */
7810       DECL_INITIAL (decl) = NULL_TREE;
7811       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7812     }
7813
7814   /* Local statics are handled differently from ordinary automatic
7815      variables.  */
7816   if (TREE_STATIC (decl))
7817     {
7818       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7819           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7820         expand_static_init (decl, init);
7821       return;
7822     }
7823
7824   if (DECL_SIZE (decl) && type != error_mark_node)
7825     {
7826       int already_used;
7827
7828       /* Compute and store the initial value.  */
7829       already_used = TREE_USED (decl) || TREE_USED (type);
7830
7831       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7832         {
7833           int saved_stmts_are_full_exprs_p;
7834
7835           my_friendly_assert (building_stmt_tree (), 20000906);
7836           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7837           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
7838           finish_expr_stmt (build_aggr_init (decl, init, flags));
7839           current_stmt_tree ()->stmts_are_full_exprs_p =
7840             saved_stmts_are_full_exprs_p;
7841         }
7842
7843       /* Set this to 0 so we can tell whether an aggregate which was
7844          initialized was ever used.  Don't do this if it has a
7845          destructor, so we don't complain about the 'resource
7846          allocation is initialization' idiom.  Now set
7847          attribute((unused)) on types so decls of that type will be
7848          marked used. (see TREE_USED, above.)  */
7849       if (TYPE_NEEDS_CONSTRUCTING (type)
7850           && ! already_used
7851           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7852           && DECL_NAME (decl))
7853         TREE_USED (decl) = 0;
7854       else if (already_used)
7855         TREE_USED (decl) = 1;
7856     }
7857 }
7858
7859 /* Generate code to destroy DECL (a local variable).  */
7860
7861 static void
7862 destroy_local_var (decl)
7863      tree decl;
7864 {
7865   tree type = TREE_TYPE (decl);
7866   tree cleanup;
7867
7868   /* Only variables get cleaned up.  */
7869   if (TREE_CODE (decl) != VAR_DECL)
7870     return;
7871
7872   /* And only things with destructors need cleaning up.  */
7873   if (type == error_mark_node
7874       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7875     return;
7876
7877   if (TREE_CODE (decl) == VAR_DECL &&
7878       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7879     /* We don't clean up things that aren't defined in this
7880        translation unit, or that need a static cleanup.  The latter
7881        are handled by finish_file.  */
7882     return;
7883
7884   /* Compute the cleanup.  */
7885   cleanup = maybe_build_cleanup (decl);
7886
7887   /* Record the cleanup required for this declaration.  */
7888   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7889       && cleanup)
7890     finish_decl_cleanup (decl, cleanup);
7891 }
7892
7893 /* Finish processing of a declaration;
7894    install its line number and initial value.
7895    If the length of an array type is not known before,
7896    it must be determined now, from the initial value, or it is an error.
7897
7898    INIT holds the value of an initializer that should be allowed to escape
7899    the normal rules.
7900
7901    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
7902    if the (init) syntax was used.  */
7903
7904 void
7905 cp_finish_decl (decl, init, asmspec_tree, flags)
7906      tree decl, init;
7907      tree asmspec_tree;
7908      int flags;
7909 {
7910   register tree type;
7911   tree ttype = NULL_TREE;
7912   const char *asmspec = NULL;
7913   int was_readonly = 0;
7914
7915   if (! decl)
7916     {
7917       if (init)
7918         error ("assignment (not initialization) in declaration");
7919       return;
7920     }
7921
7922   /* If a name was specified, get the string.  */
7923   if (asmspec_tree)
7924       asmspec = TREE_STRING_POINTER (asmspec_tree);
7925
7926   if (init && TREE_CODE (init) == NAMESPACE_DECL)
7927     {
7928       cp_error ("cannot initialize `%D' to namespace `%D'",
7929                 decl, init);
7930       init = NULL_TREE;
7931     }
7932
7933   if (current_class_type
7934       && CP_DECL_CONTEXT (decl) == current_class_type
7935       && TYPE_BEING_DEFINED (current_class_type)
7936       && (DECL_INITIAL (decl) || init))
7937     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
7938
7939   if (TREE_CODE (decl) == VAR_DECL
7940       && DECL_CONTEXT (decl)
7941       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
7942       && DECL_CONTEXT (decl) != current_namespace
7943       && init)
7944     {
7945       /* Leave the namespace of the object. */
7946       pop_decl_namespace ();
7947     }
7948
7949   type = TREE_TYPE (decl);
7950
7951   if (type == error_mark_node)
7952     return;
7953
7954   if (TYPE_HAS_MUTABLE_P (type))
7955     TREE_READONLY (decl) = 0;
7956
7957   if (processing_template_decl)
7958     {
7959       /* Add this declaration to the statement-tree.  */
7960       if (at_function_scope_p ()
7961           && TREE_CODE (decl) != RESULT_DECL)
7962         add_decl_stmt (decl);
7963
7964       if (init && DECL_INITIAL (decl))
7965         DECL_INITIAL (decl) = init;
7966       goto finish_end0;
7967     }
7968
7969   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
7970   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
7971
7972   /* Take care of TYPE_DECLs up front.  */
7973   if (TREE_CODE (decl) == TYPE_DECL)
7974     {
7975       if (init && DECL_INITIAL (decl))
7976         {
7977           /* typedef foo = bar; store the type of bar as the type of foo.  */
7978           TREE_TYPE (decl) = type = TREE_TYPE (init);
7979           DECL_INITIAL (decl) = init = NULL_TREE;
7980         }
7981       if (type != error_mark_node
7982           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
7983         {
7984           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
7985             cp_warning ("shadowing previous type declaration of `%#D'", decl);
7986           set_identifier_type_value (DECL_NAME (decl), type);
7987           CLASSTYPE_GOT_SEMICOLON (type) = 1;
7988         }
7989       GNU_xref_decl (current_function_decl, decl);
7990
7991       /* If we have installed this as the canonical typedef for this
7992          type, and that type has not been defined yet, delay emitting
7993          the debug information for it, as we will emit it later.  */
7994       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
7995           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
7996         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
7997
7998       rest_of_decl_compilation (decl, NULL,
7999                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8000       goto finish_end;
8001     }
8002
8003   if (TREE_CODE (decl) != FUNCTION_DECL)
8004     ttype = target_type (type);
8005
8006   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8007       && TYPE_NEEDS_CONSTRUCTING (type))
8008     {
8009       /* Currently, GNU C++ puts constants in text space, making them
8010          impossible to initialize.  In the future, one would hope for
8011          an operating system which understood the difference between
8012          initialization and the running of a program.  */
8013       was_readonly = 1;
8014       TREE_READONLY (decl) = 0;
8015     }
8016
8017   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8018     {
8019       /* This must override the asm specifier which was placed by
8020          grokclassfn.  Lay this out fresh.  */
8021       SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
8022       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8023       make_decl_rtl (decl, asmspec);
8024     }
8025
8026   /* Deduce size of array from initialization, if not already known.  */
8027   maybe_deduce_size_from_array_init (decl, init);
8028   init = check_initializer (decl, init);
8029
8030   GNU_xref_decl (current_function_decl, decl);
8031
8032   /* Add this declaration to the statement-tree.  This needs to happen
8033      after the call to check_initializer so that the DECL_STMT for a
8034      reference temp is added before the DECL_STMT for the reference itself.  */
8035   if (building_stmt_tree ()
8036       && at_function_scope_p ()
8037       && TREE_CODE (decl) != RESULT_DECL)
8038     add_decl_stmt (decl);
8039
8040   if (TREE_CODE (decl) == VAR_DECL)
8041     layout_var_decl (decl);
8042
8043   /* Output the assembler code and/or RTL code for variables and functions,
8044      unless the type is an undefined structure or union.
8045      If not, it will get done when the type is completed.  */
8046   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8047       || TREE_CODE (decl) == RESULT_DECL)
8048     {
8049       if (TREE_CODE (decl) == VAR_DECL)
8050         maybe_commonize_var (decl);
8051
8052       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8053
8054       if (TREE_CODE (type) == FUNCTION_TYPE
8055           || TREE_CODE (type) == METHOD_TYPE)
8056         abstract_virtuals_error (decl,
8057                                  strip_array_types (TREE_TYPE (type)));
8058       else
8059         abstract_virtuals_error (decl, strip_array_types (type));
8060
8061       if (TREE_CODE (decl) == FUNCTION_DECL)
8062         ;
8063       else if (DECL_EXTERNAL (decl)
8064                && ! (DECL_LANG_SPECIFIC (decl)
8065                      && DECL_NOT_REALLY_EXTERN (decl)))
8066         {
8067           if (init)
8068             DECL_INITIAL (decl) = init;
8069         }
8070       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8071         {
8072           /* This is a local declaration.  */
8073           if (doing_semantic_analysis_p ())
8074             maybe_inject_for_scope_var (decl);
8075           /* Initialize the local variable.  But, if we're building a
8076              statement-tree, we'll do the initialization when we
8077              expand the tree.  */
8078           if (processing_template_decl)
8079             {
8080               if (init || DECL_INITIAL (decl) == error_mark_node)
8081                 DECL_INITIAL (decl) = init;
8082             }
8083           else
8084             {
8085               /* If we're not building RTL, then we need to do so
8086                  now.  */
8087               my_friendly_assert (building_stmt_tree (), 20000906);
8088               /* Initialize the variable.  */
8089               initialize_local_var (decl, init, flags);
8090               /* Clean up the variable.  */
8091               destroy_local_var (decl);
8092             }
8093         }
8094       else if (TREE_STATIC (decl) && type != error_mark_node)
8095         {
8096           /* Cleanups for static variables are handled by `finish_file'.  */
8097           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8098               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8099             expand_static_init (decl, init);
8100         }
8101     finish_end0:
8102
8103       /* Undo call to `pushclass' that was done in `start_decl'
8104          due to initialization of qualified member variable.
8105          I.e., Foo::x = 10;  */
8106       {
8107         tree context = CP_DECL_CONTEXT (decl);
8108         if (context
8109             && TYPE_P (context)
8110             && (TREE_CODE (decl) == VAR_DECL
8111                 /* We also have a pushclass done that we need to undo here
8112                    if we're at top level and declare a method.  */
8113                 || TREE_CODE (decl) == FUNCTION_DECL)
8114             /* If size hasn't been set, we're still defining it,
8115                and therefore inside the class body; don't pop
8116                the binding level..  */
8117             && COMPLETE_TYPE_P (context)
8118             && context == current_class_type)
8119           pop_nested_class ();
8120       }
8121     }
8122
8123  finish_end:
8124
8125   if (was_readonly)
8126     TREE_READONLY (decl) = 1;
8127 }
8128
8129 /* This is here for a midend callback from c-common.c */
8130
8131 void
8132 finish_decl (decl, init, asmspec_tree)
8133      tree decl, init;
8134      tree asmspec_tree;
8135 {
8136   cp_finish_decl (decl, init, asmspec_tree, 0);
8137 }
8138
8139 /* Returns a declaration for a VAR_DECL as if:
8140
8141      extern "C" TYPE NAME;
8142
8143    had been seen.  Used to create compiler-generated global
8144    variables.  */
8145
8146 tree
8147 declare_global_var (name, type)
8148      tree name;
8149      tree type;
8150 {
8151   tree decl;
8152
8153   push_to_top_level ();
8154   decl = build_decl (VAR_DECL, name, type);
8155   TREE_PUBLIC (decl) = 1;
8156   DECL_EXTERNAL (decl) = 1;
8157   DECL_ARTIFICIAL (decl) = 1;
8158   pushdecl (decl);
8159   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8160   pop_from_top_level ();
8161
8162   return decl;
8163 }
8164
8165 /* Returns a pointer to the `atexit' function.  Note that if
8166    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8167    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8168
8169 static tree
8170 get_atexit_node ()
8171 {
8172   tree atexit_fndecl;
8173   tree arg_types;
8174   tree fn_type;
8175   tree fn_ptr_type;
8176   const char *name;
8177
8178   if (atexit_node)
8179     return atexit_node;
8180
8181   if (flag_use_cxa_atexit)
8182     {
8183       /* The declaration for `__cxa_atexit' is:
8184
8185            int __cxa_atexit (void (*)(void *), void *, void *)
8186
8187          We build up the argument types and then then function type
8188          itself.  */
8189
8190       /* First, build the pointer-to-function type for the first
8191          argument.  */
8192       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8193       fn_type = build_function_type (void_type_node, arg_types);
8194       fn_ptr_type = build_pointer_type (fn_type);
8195       /* Then, build the rest of the argument types.  */
8196       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8197       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8198       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8199       /* And the final __cxa_atexit type.  */
8200       fn_type = build_function_type (integer_type_node, arg_types);
8201       fn_ptr_type = build_pointer_type (fn_type);
8202       name = "__cxa_atexit";
8203     }
8204   else
8205     {
8206       /* The declaration for `atexit' is:
8207
8208            int atexit (void (*)());
8209
8210          We build up the argument types and then then function type
8211          itself.  */
8212       fn_type = build_function_type (void_type_node, void_list_node);
8213       fn_ptr_type = build_pointer_type (fn_type);
8214       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8215       /* Build the final atexit type.  */
8216       fn_type = build_function_type (integer_type_node, arg_types);
8217       name = "atexit";
8218     }
8219
8220   /* Now, build the function declaration.  */
8221   push_lang_context (lang_name_c);
8222   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8223   mark_used (atexit_fndecl);
8224   pop_lang_context ();
8225   atexit_node = default_conversion (atexit_fndecl);
8226
8227   return atexit_node;
8228 }
8229
8230 /* Returns the __dso_handle VAR_DECL.  */
8231
8232 static tree
8233 get_dso_handle_node ()
8234 {
8235   if (dso_handle_node)
8236     return dso_handle_node;
8237
8238   /* Declare the variable.  */
8239   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8240                                         ptr_type_node);
8241
8242   return dso_handle_node;
8243 }
8244
8245 /* Begin a new function with internal linkage whose job will be simply
8246    to destroy some particular variable.  */
8247
8248 static tree
8249 start_cleanup_fn ()
8250 {
8251   static int counter = 0;
8252   int old_interface_unknown = interface_unknown;
8253   char name[32];
8254   tree parmtypes;
8255   tree fntype;
8256   tree fndecl;
8257
8258   push_to_top_level ();
8259
8260   /* No need to mangle this.  */
8261   push_lang_context (lang_name_c);
8262
8263   interface_unknown = 1;
8264
8265   /* Build the parameter-types.  */
8266   parmtypes = void_list_node;
8267   /* Functions passed to __cxa_atexit take an additional parameter.
8268      We'll just ignore it.  After we implement the new calling
8269      convention for destructors, we can eliminate the use of
8270      additional cleanup functions entirely in the -fnew-abi case.  */
8271   if (flag_use_cxa_atexit)
8272     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8273   /* Build the function type itself.  */
8274   fntype = build_function_type (void_type_node, parmtypes);
8275   /* Build the name of the function.  */
8276   sprintf (name, "__tcf_%d", counter++);
8277   /* Build the function declaration.  */
8278   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8279   /* It's a function with internal linkage, generated by the
8280      compiler.  */
8281   TREE_PUBLIC (fndecl) = 0;
8282   DECL_ARTIFICIAL (fndecl) = 1;
8283   /* Make the function `inline' so that it is only emitted if it is
8284      actually needed.  It is unlikely that it will be inlined, since
8285      it is only called via a function pointer, but we avoid unncessary
8286      emissions this way.  */
8287   DECL_INLINE (fndecl) = 1;
8288   /* Build the parameter.  */
8289   if (flag_use_cxa_atexit)
8290     {
8291       tree parmdecl;
8292
8293       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8294       DECL_CONTEXT (parmdecl) = fndecl;
8295       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8296       TREE_USED (parmdecl) = 1;
8297       DECL_ARGUMENTS (fndecl) = parmdecl;
8298     }
8299
8300   pushdecl (fndecl);
8301   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8302   do_pushlevel ();
8303
8304   interface_unknown = old_interface_unknown;
8305
8306   pop_lang_context ();
8307
8308   return current_function_decl;
8309 }
8310
8311 /* Finish the cleanup function begun by start_cleanup_fn.  */
8312
8313 static void
8314 end_cleanup_fn ()
8315 {
8316   do_poplevel ();
8317
8318   expand_body (finish_function (0));
8319
8320   pop_from_top_level ();
8321 }
8322
8323 /* Generate code to handle the destruction of DECL, an object with
8324    static storage duration.  */
8325
8326 void
8327 register_dtor_fn (decl)
8328      tree decl;
8329 {
8330   tree cleanup;
8331   tree compound_stmt;
8332   tree args;
8333   tree fcall;
8334
8335   int saved_flag_access_control;
8336
8337   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8338     return;
8339
8340   /* Call build_cleanup before we enter the anonymous function so that
8341      any access checks will be done relative to the current scope,
8342      rather than the scope of the anonymous function.  */
8343   build_cleanup (decl);
8344
8345   /* Now start the function.  */
8346   cleanup = start_cleanup_fn ();
8347
8348   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8349      to the original function, rather than the anonymous one.  That
8350      will make the back-end think that nested functions are in use,
8351      which causes confusion.  */
8352   saved_flag_access_control = flag_access_control;
8353   flag_access_control = 0;
8354   fcall = build_cleanup (decl);
8355   flag_access_control = saved_flag_access_control;
8356
8357   /* Create the body of the anonymous function.  */
8358   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8359   finish_expr_stmt (fcall);
8360   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8361   end_cleanup_fn ();
8362
8363   /* Call atexit with the cleanup function.  */
8364   mark_addressable (cleanup);
8365   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8366   if (flag_use_cxa_atexit)
8367     {
8368       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8369       args = tree_cons (NULL_TREE, null_pointer_node, args);
8370       args = tree_cons (NULL_TREE, cleanup, args);
8371     }
8372   else
8373     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8374   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8375 }
8376
8377 void
8378 expand_static_init (decl, init)
8379      tree decl;
8380      tree init;
8381 {
8382   tree oldstatic = value_member (decl, static_aggregates);
8383
8384   if (oldstatic)
8385     {
8386       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8387         cp_error ("multiple initializations given for `%D'", decl);
8388     }
8389   else if (! toplevel_bindings_p ())
8390     {
8391       /* Emit code to perform this initialization but once.  */
8392       tree if_stmt;
8393       tree then_clause;
8394       tree assignment;
8395       tree guard;
8396       tree guard_init;
8397
8398       /* Emit code to perform this initialization but once.  This code
8399          looks like:
8400
8401            static int guard = 0;
8402            if (!guard) {
8403              // Do initialization.
8404              guard = 1;
8405              // Register variable for destruction at end of program.
8406            }
8407
8408          Note that the `temp' variable is only set to 1 *after* the
8409          initialization is complete.  This ensures that an exception,
8410          thrown during the construction, will cause the variable to
8411          reinitialized when we pass through this code again, as per:
8412
8413            [stmt.dcl]
8414
8415            If the initialization exits by throwing an exception, the
8416            initialization is not complete, so it will be tried again
8417            the next time control enters the declaration.
8418
8419          In theory, this process should be thread-safe, too; multiple
8420          threads should not be able to initialize the variable more
8421          than once.  We don't yet attempt to ensure thread-safety.  */
8422
8423       /* Create the guard variable.  */
8424       guard = get_guard (decl);
8425
8426       /* Begin the conditional initialization.  */
8427       if_stmt = begin_if_stmt ();
8428       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8429       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8430
8431       /* Do the initialization itself.  */
8432       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8433           || (init && TREE_CODE (init) == TREE_LIST))
8434         assignment = build_aggr_init (decl, init, 0);
8435       else if (init)
8436         /* The initialization we're doing here is just a bitwise
8437            copy.  */
8438         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8439       else
8440         assignment = NULL_TREE;
8441
8442       /* Once the assignment is complete, set TEMP to 1.  Since the
8443          construction of the static object is complete at this point,
8444          we want to make sure TEMP is set to 1 even if a temporary
8445          constructed during the initialization throws an exception
8446          when it is destroyed.  So, we combine the initialization and
8447          the assignment to TEMP into a single expression, ensuring
8448          that when we call finish_expr_stmt the cleanups will not be
8449          run until after TEMP is set to 1.  */
8450       guard_init = set_guard (guard);
8451       if (assignment)
8452         {
8453           assignment = tree_cons (NULL_TREE, assignment,
8454                                   build_tree_list (NULL_TREE,
8455                                                    guard_init));
8456           assignment = build_compound_expr (assignment);
8457         }
8458       else
8459         assignment = guard_init;
8460       finish_expr_stmt (assignment);
8461
8462       /* Use atexit to register a function for destroying this static
8463          variable.  */
8464       register_dtor_fn (decl);
8465
8466       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8467       finish_then_clause (if_stmt);
8468       finish_if_stmt ();
8469     }
8470   else
8471     static_aggregates = tree_cons (init, decl, static_aggregates);
8472 }
8473
8474 /* Finish the declaration of a catch-parameter.  */
8475
8476 tree
8477 start_handler_parms (declspecs, declarator)
8478      tree declspecs;
8479      tree declarator;
8480 {
8481   tree decl;
8482   if (declspecs)
8483     {
8484       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8485                              1, NULL_TREE);
8486       if (decl == NULL_TREE)
8487         error ("invalid catch parameter");
8488     }
8489   else
8490     decl = NULL_TREE;
8491
8492   return decl;
8493 }
8494
8495 \f
8496 /* Make TYPE a complete type based on INITIAL_VALUE.
8497    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8498    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8499
8500 int
8501 complete_array_type (type, initial_value, do_default)
8502      tree type, initial_value;
8503      int do_default;
8504 {
8505   register tree maxindex = NULL_TREE;
8506   int value = 0;
8507
8508   if (initial_value)
8509     {
8510       /* An array of character type can be initialized from a
8511          brace-enclosed string constant.  */
8512       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8513           && TREE_CODE (initial_value) == CONSTRUCTOR
8514           && CONSTRUCTOR_ELTS (initial_value)
8515           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8516               == STRING_CST)
8517           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8518         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8519
8520       /* Note MAXINDEX is really the maximum index, one less than the
8521          size.  */
8522       if (TREE_CODE (initial_value) == STRING_CST)
8523         {
8524           int eltsize
8525             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8526           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8527                                    / eltsize) - 1, 0);
8528         }
8529       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8530         {
8531           tree elts = CONSTRUCTOR_ELTS (initial_value);
8532
8533           maxindex = ssize_int (-1);
8534           for (; elts; elts = TREE_CHAIN (elts))
8535             {
8536               if (TREE_PURPOSE (elts))
8537                 maxindex = TREE_PURPOSE (elts);
8538               else
8539                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8540             }
8541           maxindex = copy_node (maxindex);
8542         }
8543       else
8544         {
8545           /* Make an error message unless that happened already.  */
8546           if (initial_value != error_mark_node)
8547             value = 1;
8548           else
8549             initial_value = NULL_TREE;
8550
8551           /* Prevent further error messages.  */
8552           maxindex = build_int_2 (0, 0);
8553         }
8554     }
8555
8556   if (!maxindex)
8557     {
8558       if (do_default)
8559         maxindex = build_int_2 (0, 0);
8560       value = 2;
8561     }
8562
8563   if (maxindex)
8564     {
8565       tree itype;
8566       tree domain;
8567
8568       domain = build_index_type (maxindex);
8569       TYPE_DOMAIN (type) = domain;
8570
8571       if (! TREE_TYPE (maxindex))
8572         TREE_TYPE (maxindex) = domain;
8573       if (initial_value)
8574         itype = TREE_TYPE (initial_value);
8575       else
8576         itype = NULL;
8577       if (itype && !TYPE_DOMAIN (itype))
8578         TYPE_DOMAIN (itype) = domain;
8579       /* The type of the main variant should never be used for arrays
8580          of different sizes.  It should only ever be completed with the
8581          size of the array.  */
8582       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8583         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8584     }
8585
8586   /* Lay out the type now that we can get the real answer.  */
8587
8588   layout_type (type);
8589
8590   return value;
8591 }
8592 \f
8593 /* Return zero if something is declared to be a member of type
8594    CTYPE when in the context of CUR_TYPE.  STRING is the error
8595    message to print in that case.  Otherwise, quietly return 1.  */
8596
8597 static int
8598 member_function_or_else (ctype, cur_type, flags)
8599      tree ctype, cur_type;
8600      enum overload_flags flags;
8601 {
8602   if (ctype && ctype != cur_type)
8603     {
8604       if (flags == DTOR_FLAG)
8605         cp_error ("destructor for alien class `%T' cannot be a member",
8606                   ctype);
8607       else
8608         cp_error ("constructor for alien class `%T' cannot be a member",
8609                   ctype);
8610       return 0;
8611     }
8612   return 1;
8613 }
8614 \f
8615 /* Subroutine of `grokdeclarator'.  */
8616
8617 /* Generate errors possibly applicable for a given set of specifiers.
8618    This is for ARM $7.1.2.  */
8619
8620 static void
8621 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8622      tree object;
8623      const char *type;
8624      int virtualp, quals, friendp, raises, inlinep;
8625 {
8626   if (virtualp)
8627     cp_error ("`%D' declared as a `virtual' %s", object, type);
8628   if (inlinep)
8629     cp_error ("`%D' declared as an `inline' %s", object, type);
8630   if (quals)
8631     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8632               object, type);
8633   if (friendp)
8634     cp_error_at ("`%D' declared as a friend", object);
8635   if (raises && !TYPE_PTRFN_P (TREE_TYPE (object))
8636       && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))
8637     cp_error_at ("`%D' declared with an exception specification", object);
8638 }
8639
8640 /* CTYPE is class type, or null if non-class.
8641    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8642    or METHOD_TYPE.
8643    DECLARATOR is the function's name.
8644    VIRTUALP is truthvalue of whether the function is virtual or not.
8645    FLAGS are to be passed through to `grokclassfn'.
8646    QUALS are qualifiers indicating whether the function is `const'
8647    or `volatile'.
8648    RAISES is a list of exceptions that this function can raise.
8649    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8650    not look, and -1 if we should not call `grokclassfn' at all.
8651
8652    Returns `NULL_TREE' if something goes wrong, after issuing
8653    applicable error messages.  */
8654
8655 static tree
8656 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8657             raises, check, friendp, publicp, inlinep, funcdef_flag,
8658             template_count, in_namespace)
8659      tree ctype, type;
8660      tree declarator;
8661      tree orig_declarator;
8662      int virtualp;
8663      enum overload_flags flags;
8664      tree quals, raises;
8665      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8666      tree in_namespace;
8667 {
8668   tree decl;
8669   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8670   int has_default_arg = 0;
8671   tree t;
8672
8673   if (raises)
8674     {
8675       type = build_exception_variant (type, raises);
8676     }
8677
8678   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8679   /* Propagate volatile out from type to decl. */
8680   if (TYPE_VOLATILE (type))
8681     TREE_THIS_VOLATILE (decl) = 1;
8682
8683   /* If this decl has namespace scope, set that up.  */
8684   if (in_namespace)
8685     set_decl_namespace (decl, in_namespace, friendp);
8686   else if (!ctype)
8687     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8688
8689   /* `main' and builtins have implicit 'C' linkage.  */
8690   if ((MAIN_NAME_P (declarator)
8691        || (IDENTIFIER_LENGTH (declarator) > 10
8692            && IDENTIFIER_POINTER (declarator)[0] == '_'
8693            && IDENTIFIER_POINTER (declarator)[1] == '_'
8694            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8695       && current_lang_name == lang_name_cplusplus
8696       && ctype == NULL_TREE
8697       /* NULL_TREE means global namespace.  */
8698       && DECL_CONTEXT (decl) == NULL_TREE)
8699     SET_DECL_LANGUAGE (decl, lang_c);
8700
8701   /* Should probably propagate const out from type to decl I bet (mrs).  */
8702   if (staticp)
8703     {
8704       DECL_STATIC_FUNCTION_P (decl) = 1;
8705       DECL_CONTEXT (decl) = ctype;
8706     }
8707
8708   if (ctype)
8709     DECL_CONTEXT (decl) = ctype;
8710
8711   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8712     {
8713       if (processing_template_decl)
8714         error ("cannot declare `::main' to be a template");
8715       if (inlinep)
8716         error ("cannot declare `::main' to be inline");
8717       if (!publicp)
8718         error ("cannot declare `::main' to be static");
8719       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8720                         integer_type_node))
8721         error ("`main' must return `int'");
8722       inlinep = 0;
8723       publicp = 1;
8724     }
8725
8726   /* Members of anonymous types and local classes have no linkage; make
8727      them internal.  */
8728   /* FIXME what if it gets a name from typedef?  */
8729   if (ctype && (TYPE_ANONYMOUS_P (ctype)
8730                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8731     publicp = 0;
8732
8733   if (publicp)
8734     {
8735       /* [basic.link]: A name with no linkage (notably, the name of a class
8736          or enumeration declared in a local scope) shall not be used to
8737          declare an entity with linkage.
8738
8739          Only check this for public decls for now.  */
8740       t = no_linkage_check (TREE_TYPE (decl));
8741       if (t)
8742         {
8743           if (TYPE_ANONYMOUS_P (t))
8744             {
8745               if (DECL_EXTERN_C_P (decl))
8746                 /* Allow this; it's pretty common in C.  */;
8747               else
8748                 {
8749                   cp_pedwarn ("non-local function `%#D' uses anonymous type",
8750                               decl);
8751                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
8752                     cp_pedwarn_at ("\
8753 `%#D' does not refer to the unqualified type, so it is not used for linkage",
8754                                 TYPE_NAME (t));
8755                 }
8756             }
8757           else
8758             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8759                         decl, t);
8760         }
8761     }
8762
8763   TREE_PUBLIC (decl) = publicp;
8764   if (! publicp)
8765     {
8766       DECL_INTERFACE_KNOWN (decl) = 1;
8767       DECL_NOT_REALLY_EXTERN (decl) = 1;
8768     }
8769
8770   /* If the declaration was declared inline, mark it as such.  */
8771   if (inlinep)
8772     DECL_DECLARED_INLINE_P (decl) = 1;
8773   /* We inline functions that are explicitly declared inline, or, when
8774      the user explicitly asks us to, all functions.  */
8775   if (DECL_DECLARED_INLINE_P (decl) || flag_inline_trees == 2)
8776     DECL_INLINE (decl) = 1;
8777
8778   DECL_EXTERNAL (decl) = 1;
8779   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8780     {
8781       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8782                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8783       quals = NULL_TREE;
8784     }
8785
8786   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8787     grok_op_properties (decl, virtualp, check < 0);
8788
8789   if (ctype && decl_function_context (decl))
8790     DECL_NO_STATIC_CHAIN (decl) = 1;
8791
8792   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8793     if (TREE_PURPOSE (t)
8794         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8795       {
8796         has_default_arg = 1;
8797         break;
8798       }
8799
8800   if (friendp
8801       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8802     {
8803       if (funcdef_flag)
8804         cp_error
8805           ("defining explicit specialization `%D' in friend declaration",
8806            orig_declarator);
8807       else
8808         {
8809           tree fns = TREE_OPERAND (orig_declarator, 0);
8810           tree args = TREE_OPERAND (orig_declarator, 1);
8811
8812           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8813             {
8814               /* Something like `template <class T> friend void f<T>()'.  */
8815               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8816                         orig_declarator);
8817               return NULL_TREE;
8818             }
8819
8820
8821           /* A friend declaration of the form friend void f<>().  Record
8822              the information in the TEMPLATE_ID_EXPR.  */
8823           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8824
8825           if (TREE_CODE (fns) == COMPONENT_REF)
8826             {
8827               /* Due to bison parser ickiness, we will have already looked
8828                  up an operator_name or PFUNCNAME within the current class
8829                  (see template_id in parse.y). If the current class contains
8830                  such a name, we'll get a COMPONENT_REF here. Undo that. */
8831
8832               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
8833                                   == current_class_type, 20001120);
8834               fns = TREE_OPERAND (fns, 1);
8835             }
8836           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
8837                               || TREE_CODE (fns) == LOOKUP_EXPR
8838                               || TREE_CODE (fns) == OVERLOAD, 20001120);
8839           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
8840
8841           if (has_default_arg)
8842             {
8843               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8844                         decl);
8845               return NULL_TREE;
8846             }
8847
8848           if (inlinep)
8849             {
8850               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8851                         decl);
8852               return NULL_TREE;
8853             }
8854         }
8855     }
8856
8857   if (has_default_arg)
8858     add_defarg_fn (decl);
8859
8860   if (funcdef_flag)
8861     /* Make the init_value nonzero so pushdecl knows this is not
8862        tentative.  error_mark_node is replaced later with the BLOCK.  */
8863     DECL_INITIAL (decl) = error_mark_node;
8864
8865   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8866     TREE_NOTHROW (decl) = 1;
8867
8868   /* Caller will do the rest of this.  */
8869   if (check < 0)
8870     return decl;
8871
8872   if (flags == NO_SPECIAL && ctype && constructor_name (ctype) == declarator)
8873     DECL_CONSTRUCTOR_P (decl) = 1;
8874
8875   /* Function gets the ugly name, field gets the nice one.  This call
8876      may change the type of the function (because of default
8877      parameters)!  */
8878   if (ctype != NULL_TREE)
8879     grokclassfn (ctype, decl, flags, quals);
8880
8881   decl = check_explicit_specialization (orig_declarator, decl,
8882                                         template_count,
8883                                         2 * (funcdef_flag != 0) +
8884                                         4 * (friendp != 0));
8885   if (decl == error_mark_node)
8886     return NULL_TREE;
8887
8888   if (ctype != NULL_TREE
8889       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8890       && check)
8891     {
8892       tree old_decl;
8893
8894       old_decl = check_classfn (ctype, decl);
8895
8896       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
8897         /* Because grokfndecl is always supposed to return a
8898            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8899            here.  We depend on our callers to figure out that its
8900            really a template that's being returned.  */
8901         old_decl = DECL_TEMPLATE_RESULT (old_decl);
8902
8903       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
8904           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8905         {
8906           /* Remove the `this' parm added by grokclassfn.
8907              XXX Isn't this done in start_function, too?  */
8908           revert_static_member_fn (decl);
8909           last_function_parms = TREE_CHAIN (last_function_parms);
8910         }
8911       if (old_decl && DECL_ARTIFICIAL (old_decl))
8912         cp_error ("definition of implicitly-declared `%D'", old_decl);
8913
8914       if (old_decl)
8915         {
8916           /* Since we've smashed OLD_DECL to its
8917              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
8918           if (TREE_CODE (decl) == TEMPLATE_DECL)
8919             decl = DECL_TEMPLATE_RESULT (decl);
8920
8921           /* Attempt to merge the declarations.  This can fail, in
8922              the case of some illegal specialization declarations.  */
8923           if (!duplicate_decls (decl, old_decl))
8924             cp_error ("no `%#D' member function declared in class `%T'",
8925                       decl, ctype);
8926           return old_decl;
8927         }
8928     }
8929
8930   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
8931     return NULL_TREE;
8932
8933   if (ctype == NULL_TREE || check)
8934     return decl;
8935
8936   if (virtualp)
8937     DECL_VIRTUAL_P (decl) = 1;
8938
8939   return decl;
8940 }
8941
8942 static tree
8943 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
8944      tree type;
8945      tree declarator;
8946      RID_BIT_TYPE *specbits_in;
8947      int initialized;
8948      int constp;
8949      tree in_namespace;
8950 {
8951   tree decl;
8952   RID_BIT_TYPE specbits;
8953
8954   specbits = *specbits_in;
8955
8956   if (TREE_CODE (type) == OFFSET_TYPE)
8957     {
8958       /* If you declare a static member so that it
8959          can be initialized, the code will reach here.  */
8960       tree basetype = TYPE_OFFSET_BASETYPE (type);
8961       type = TREE_TYPE (type);
8962       decl = build_lang_decl (VAR_DECL, declarator, type);
8963       DECL_CONTEXT (decl) = basetype;
8964     }
8965   else
8966     {
8967       tree context;
8968
8969       if (in_namespace)
8970         context = in_namespace;
8971       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
8972         context = current_namespace;
8973       else
8974         context = NULL_TREE;
8975
8976       /* For namespace-scope variables, declared in a template, we
8977          need the full lang_decl.  The same is true for
8978          namespace-scope variables that do not have C++ language
8979          linkage.  */
8980       if (context
8981           && (processing_template_decl
8982               || current_lang_name != lang_name_cplusplus))
8983         decl = build_lang_decl (VAR_DECL, declarator, type);
8984       else
8985         decl = build_decl (VAR_DECL, declarator, type);
8986
8987       if (context)
8988         set_decl_namespace (decl, context, 0);
8989
8990       context = DECL_CONTEXT (decl);
8991       if (declarator && context && current_lang_name != lang_name_c)
8992         /* We can't mangle lazily here because we don't have any
8993            way to recover whether or not a variable was `extern
8994            "C"' later.  */
8995         mangle_decl (decl);
8996     }
8997
8998   if (in_namespace)
8999     set_decl_namespace (decl, in_namespace, 0);
9000
9001   if (RIDBIT_SETP (RID_EXTERN, specbits))
9002     {
9003       DECL_THIS_EXTERN (decl) = 1;
9004       DECL_EXTERNAL (decl) = !initialized;
9005     }
9006
9007   /* In class context, static means one per class,
9008      public access, and static storage.  */
9009   if (DECL_CLASS_SCOPE_P (decl))
9010     {
9011       TREE_PUBLIC (decl) = 1;
9012       TREE_STATIC (decl) = 1;
9013       DECL_EXTERNAL (decl) = 0;
9014     }
9015   /* At top level, either `static' or no s.c. makes a definition
9016      (perhaps tentative), and absence of `static' makes it public.  */
9017   else if (toplevel_bindings_p ())
9018     {
9019       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9020                             && (DECL_THIS_EXTERN (decl) || ! constp));
9021       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9022     }
9023   /* Not at top level, only `static' makes a static definition.  */
9024   else
9025     {
9026       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9027       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9028     }
9029
9030   if (TREE_PUBLIC (decl))
9031     {
9032       /* [basic.link]: A name with no linkage (notably, the name of a class
9033          or enumeration declared in a local scope) shall not be used to
9034          declare an entity with linkage.
9035
9036          Only check this for public decls for now.  */
9037       tree t = no_linkage_check (TREE_TYPE (decl));
9038       if (t)
9039         {
9040           if (TYPE_ANONYMOUS_P (t))
9041             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9042           else
9043             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9044                         decl, t);
9045         }
9046     }
9047
9048   return decl;
9049 }
9050
9051 /* Create and return a canonical pointer to member function type, for
9052    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9053
9054 tree
9055 build_ptrmemfunc_type (type)
9056      tree type;
9057 {
9058   tree fields[4];
9059   tree t;
9060   tree unqualified_variant = NULL_TREE;
9061
9062   if (type == error_mark_node)
9063     return type;
9064
9065   /* If a canonical type already exists for this type, use it.  We use
9066      this method instead of type_hash_canon, because it only does a
9067      simple equality check on the list of field members.  */
9068
9069   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9070     return t;
9071
9072   /* Make sure that we always have the unqualified pointer-to-member
9073      type first.  */
9074   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9075     unqualified_variant
9076       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9077
9078   t = make_aggr_type (RECORD_TYPE);
9079   /* Let the front-end know this is a pointer to member function...  */
9080   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9081   /* ... and not really an aggregate.  */
9082   SET_IS_AGGR_TYPE (t, 0);
9083
9084   fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9085   fields[1] = build_decl (FIELD_DECL, delta_identifier,
9086                           delta_type_node);
9087   finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9088
9089   /* Zap out the name so that the back-end will give us the debugging
9090      information for this anonymous RECORD_TYPE.  */
9091   TYPE_NAME (t) = NULL_TREE;
9092
9093   /* If this is not the unqualified form of this pointer-to-member
9094      type, set the TYPE_MAIN_VARIANT for this type to be the
9095      unqualified type.  Since they are actually RECORD_TYPEs that are
9096      not variants of each other, we must do this manually.  */
9097   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9098     {
9099       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9100       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9101       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9102       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9103     }
9104
9105   /* Cache this pointer-to-member type so that we can find it again
9106      later.  */
9107   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9108
9109   /* Seems to be wanted.  */
9110   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9111
9112   return t;
9113 }
9114
9115 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9116    Check to see that the definition is valid.  Issue appropriate error
9117    messages.  Return 1 if the definition is particularly bad, or 0
9118    otherwise.  */
9119
9120 int
9121 check_static_variable_definition (decl, type)
9122      tree decl;
9123      tree type;
9124 {
9125   /* Motion 10 at San Diego: If a static const integral data member is
9126      initialized with an integral constant expression, the initializer
9127      may appear either in the declaration (within the class), or in
9128      the definition, but not both.  If it appears in the class, the
9129      member is a member constant.  The file-scope definition is always
9130      required.  */
9131   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9132     {
9133       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9134                 type);
9135       /* If we just return the declaration, crashes will sometimes
9136          occur.  We therefore return void_type_node, as if this was a
9137          friend declaration, to cause callers to completely ignore
9138          this declaration.  */
9139       return 1;
9140     }
9141   else if (!CP_TYPE_CONST_P (type))
9142     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9143               decl);
9144   else if (pedantic && !INTEGRAL_TYPE_P (type))
9145     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9146
9147   return 0;
9148 }
9149
9150 /* Given the SIZE (i.e., number of elements) in an array, compute an
9151    appropriate index type for the array.  If non-NULL, NAME is the
9152    name of the thing being declared.  */
9153
9154 tree
9155 compute_array_index_type (name, size)
9156      tree name;
9157      tree size;
9158 {
9159   tree itype;
9160
9161   /* If this involves a template parameter, it will be a constant at
9162      instantiation time, but we don't know what the value is yet.
9163      Even if no template parameters are involved, we may an expression
9164      that is not a constant; we don't even simplify `1 + 2' when
9165      processing a template.  */
9166   if (processing_template_decl)
9167     {
9168       /* Resolve a qualified reference to an enumerator or static
9169          const data member of ours.  */
9170       if (TREE_CODE (size) == SCOPE_REF
9171           && TREE_OPERAND (size, 0) == current_class_type)
9172         {
9173           tree t = lookup_field (current_class_type,
9174                                  TREE_OPERAND (size, 1), 0, 0);
9175           if (t)
9176             size = t;
9177         }
9178
9179       return build_index_type (build_min (MINUS_EXPR, sizetype,
9180                                           size, integer_one_node));
9181     }
9182
9183   /* The size might be the result of a cast. */
9184   STRIP_TYPE_NOPS (size);
9185
9186   /* It might be a const variable or enumeration constant.  */
9187   size = decl_constant_value (size);
9188
9189   /* The array bound must be an integer type.  */
9190   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9191       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9192       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9193     {
9194       if (name)
9195         cp_error ("size of array `%D' has non-integer type", name);
9196       else
9197         cp_error ("size of array has non-integer type");
9198       size = integer_one_node;
9199     }
9200
9201   /* Normally, the array-bound will be a constant.  */
9202   if (TREE_CODE (size) == INTEGER_CST)
9203     {
9204       /* Check to see if the array bound overflowed.  Make that an
9205          error, no matter how generous we're being.  */
9206       int old_flag_pedantic_errors = flag_pedantic_errors;
9207       int old_pedantic = pedantic;
9208       pedantic = flag_pedantic_errors = 1;
9209       constant_expression_warning (size);
9210       pedantic = old_pedantic;
9211       flag_pedantic_errors = old_flag_pedantic_errors;
9212
9213       /* An array must have a positive number of elements.  */
9214       if (INT_CST_LT (size, integer_zero_node))
9215         {
9216           if (name)
9217             cp_error ("size of array `%D' is negative", name);
9218           else
9219             cp_error ("size of array is negative");
9220           size = integer_one_node;
9221         }
9222       /* Except that an extension we allow zero-sized arrays.  We
9223          always allow them in system headers because glibc uses
9224          them.  */
9225       else if (integer_zerop (size) && pedantic && !in_system_header)
9226         {
9227           if (name)
9228             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9229           else
9230             cp_pedwarn ("ISO C++ forbids zero-size array");
9231         }
9232     }
9233   else if (TREE_CONSTANT (size))
9234     {
9235       /* `(int) &fn' is not a valid array bound.  */
9236       if (name)
9237         cp_error ("size of array `%D' is not an integral constant-expression",
9238                   name);
9239       else
9240         cp_error ("size of array is not an integral constant-expression");
9241     }
9242
9243   /* Compute the index of the largest element in the array.  It is
9244      one less than the number of elements in the array.  */
9245   itype
9246     = fold (cp_build_binary_op (MINUS_EXPR,
9247                                 cp_convert (ssizetype, size),
9248                                 cp_convert (ssizetype,
9249                                             integer_one_node)));
9250
9251   /* Check for variable-sized arrays.  We allow such things as an
9252      extension, even though they are not allowed in ANSI/ISO C++.  */
9253   if (!TREE_CONSTANT (itype))
9254     {
9255       if (pedantic)
9256         {
9257           if (name)
9258             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9259                         name);
9260           else
9261             cp_pedwarn ("ISO C++ forbids variable-size array");
9262         }
9263
9264       /* Create a variable-sized array index type.  */
9265       itype = variable_size (itype);
9266     }
9267   /* Make sure that there was no overflow when creating to a signed
9268      index type.  (For example, on a 32-bit machine, an array with
9269      size 2^32 - 1 is too big.)  */
9270   else if (TREE_OVERFLOW (itype))
9271     {
9272       error ("overflow in array dimension");
9273       TREE_OVERFLOW (itype) = 0;
9274     }
9275
9276   /* Create and return the appropriate index type.  */
9277   return build_index_type (itype);
9278 }
9279
9280 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9281    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9282    with this type.  */
9283
9284 static tree
9285 create_array_type_for_decl (name, type, size)
9286      tree name;
9287      tree type;
9288      tree size;
9289 {
9290   tree itype = NULL_TREE;
9291   const char* error_msg;
9292
9293   /* If things have already gone awry, bail now.  */
9294   if (type == error_mark_node || size == error_mark_node)
9295     return error_mark_node;
9296
9297   /* Assume that everything will go OK.  */
9298   error_msg = NULL;
9299
9300   /* There are some types which cannot be array elements.  */
9301   switch (TREE_CODE (type))
9302     {
9303     case VOID_TYPE:
9304       error_msg = "array of void";
9305       break;
9306
9307     case FUNCTION_TYPE:
9308       error_msg = "array of functions";
9309       break;
9310
9311     case REFERENCE_TYPE:
9312       error_msg = "array of references";
9313       break;
9314
9315     case OFFSET_TYPE:
9316       error_msg = "array of data members";
9317       break;
9318
9319     case METHOD_TYPE:
9320       error_msg = "array of function members";
9321       break;
9322
9323     default:
9324       break;
9325     }
9326
9327   /* If something went wrong, issue an error-message and return.  */
9328   if (error_msg)
9329     {
9330       if (name)
9331         cp_error ("declaration of `%D' as %s", name, error_msg);
9332       else
9333         cp_error ("creating %s", error_msg);
9334
9335       return error_mark_node;
9336     }
9337
9338   /* [dcl.array]
9339
9340      The constant expressions that specify the bounds of the arrays
9341      can be omitted only for the first member of the sequence.  */
9342   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9343     {
9344       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9345                 name);
9346
9347       return error_mark_node;
9348     }
9349
9350   /* Figure out the index type for the array.  */
9351   if (size)
9352     itype = compute_array_index_type (name, size);
9353
9354   return build_cplus_array_type (type, itype);
9355 }
9356
9357 /* Check that it's OK to declare a function with the indicated TYPE.
9358    SFK indicates the kind of special function (if any) that this
9359    function is.  OPTYPE is the type given in a conversion operator
9360    declaration.  Returns the actual return type of the function; that
9361    may be different than TYPE if an error occurs, or for certain
9362    special functions.  */
9363
9364 static tree
9365 check_special_function_return_type (sfk, type, optype)
9366      special_function_kind sfk;
9367      tree type;
9368      tree optype;
9369 {
9370   switch (sfk)
9371     {
9372     case sfk_constructor:
9373       if (type)
9374         cp_error ("return type specification for constructor invalid");
9375
9376       type = void_type_node;
9377       break;
9378
9379     case sfk_destructor:
9380       if (type)
9381         cp_error ("return type specification for destructor invalid");
9382       type = void_type_node;
9383       break;
9384
9385     case sfk_conversion:
9386       if (type && !same_type_p (type, optype))
9387         cp_error ("operator `%T' declared to return `%T'", optype, type);
9388       else if (type)
9389         cp_pedwarn ("return type specified for `operator %T'",  optype);
9390       type = optype;
9391       break;
9392
9393     default:
9394       my_friendly_abort (20000408);
9395       break;
9396     }
9397
9398   return type;
9399 }
9400
9401 /* Given declspecs and a declarator,
9402    determine the name and type of the object declared
9403    and construct a ..._DECL node for it.
9404    (In one case we can return a ..._TYPE node instead.
9405     For invalid input we sometimes return 0.)
9406
9407    DECLSPECS is a chain of tree_list nodes whose value fields
9408     are the storage classes and type specifiers.
9409
9410    DECL_CONTEXT says which syntactic context this declaration is in:
9411      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9412      FUNCDEF for a function definition.  Like NORMAL but a few different
9413       error messages in each case.  Return value may be zero meaning
9414       this definition is too screwy to try to parse.
9415      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9416       handle member functions (which have FIELD context).
9417       Return value may be zero meaning this definition is too screwy to
9418       try to parse.
9419      PARM for a parameter declaration (either within a function prototype
9420       or before a function body).  Make a PARM_DECL, or return void_type_node.
9421      CATCHPARM for a parameter declaration before a catch clause.
9422      TYPENAME if for a typename (in a cast or sizeof).
9423       Don't make a DECL node; just return the ..._TYPE node.
9424      FIELD for a struct or union field; make a FIELD_DECL.
9425      BITFIELD for a field with specified width.
9426    INITIALIZED is 1 if the decl has an initializer.
9427
9428    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9429    normal attributes in TREE_PURPOSE, or NULL_TREE.
9430
9431    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9432    It may also be so in the PARM case, for a prototype where the
9433    argument type is specified but not the name.
9434
9435    This function is where the complicated C meanings of `static'
9436    and `extern' are interpreted.
9437
9438    For C++, if there is any monkey business to do, the function which
9439    calls this one must do it, i.e., prepending instance variables,
9440    renaming overloaded function names, etc.
9441
9442    Note that for this C++, it is an error to define a method within a class
9443    which does not belong to that class.
9444
9445    Except in the case where SCOPE_REFs are implicitly known (such as
9446    methods within a class being redundantly qualified),
9447    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9448    (class_name::decl_name).  The caller must also deal with this.
9449
9450    If a constructor or destructor is seen, and the context is FIELD,
9451    then the type gains the attribute TREE_HAS_x.  If such a declaration
9452    is erroneous, NULL_TREE is returned.
9453
9454    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9455    function, these are the qualifiers to give to the `this' pointer. We
9456    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9457
9458    May return void_type_node if the declarator turned out to be a friend.
9459    See grokfield for details.  */
9460
9461 tree
9462 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9463      tree declspecs;
9464      tree declarator;
9465      enum decl_context decl_context;
9466      int initialized;
9467      tree attrlist;
9468 {
9469   RID_BIT_TYPE specbits;
9470   int nclasses = 0;
9471   tree spec;
9472   tree type = NULL_TREE;
9473   int longlong = 0;
9474   int constp;
9475   int restrictp;
9476   int volatilep;
9477   int type_quals;
9478   int virtualp, explicitp, friendp, inlinep, staticp;
9479   int explicit_int = 0;
9480   int explicit_char = 0;
9481   int defaulted_int = 0;
9482   tree typedef_decl = NULL_TREE;
9483   const char *name;
9484   tree typedef_type = NULL_TREE;
9485   int funcdef_flag = 0;
9486   enum tree_code innermost_code = ERROR_MARK;
9487   int bitfield = 0;
9488 #if 0
9489   /* See the code below that used this.  */
9490   tree decl_machine_attr = NULL_TREE;
9491 #endif
9492   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9493      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9494   tree init = NULL_TREE;
9495
9496   /* Keep track of what sort of function is being processed
9497      so that we can warn about default return values, or explicit
9498      return values which do not match prescribed defaults.  */
9499   special_function_kind sfk = sfk_none;
9500
9501   tree dname = NULL_TREE;
9502   tree ctype = current_class_type;
9503   tree ctor_return_type = NULL_TREE;
9504   enum overload_flags flags = NO_SPECIAL;
9505   tree quals = NULL_TREE;
9506   tree raises = NULL_TREE;
9507   int template_count = 0;
9508   tree in_namespace = NULL_TREE;
9509   tree inner_attrs;
9510   int ignore_attrs;
9511
9512   RIDBIT_RESET_ALL (specbits);
9513   if (decl_context == FUNCDEF)
9514     funcdef_flag = 1, decl_context = NORMAL;
9515   else if (decl_context == MEMFUNCDEF)
9516     funcdef_flag = -1, decl_context = FIELD;
9517   else if (decl_context == BITFIELD)
9518     bitfield = 1, decl_context = FIELD;
9519
9520   /* Look inside a declarator for the name being declared
9521      and get it as a string, for an error message.  */
9522   {
9523     tree *next = &declarator;
9524     register tree decl;
9525     name = NULL;
9526
9527     while (next && *next)
9528       {
9529         decl = *next;
9530         switch (TREE_CODE (decl))
9531           {
9532           case TREE_LIST:
9533             /* For attributes.  */
9534             next = &TREE_VALUE (decl);
9535             break;
9536
9537           case COND_EXPR:
9538             ctype = NULL_TREE;
9539             next = &TREE_OPERAND (decl, 0);
9540             break;
9541
9542           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9543             {
9544               tree name = TREE_OPERAND (decl, 0);
9545               tree rename = NULL_TREE;
9546
9547               my_friendly_assert (flags == NO_SPECIAL, 152);
9548               flags = DTOR_FLAG;
9549               sfk = sfk_destructor;
9550               if (TREE_CODE (name) == TYPE_DECL)
9551                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9552               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9553               if (ctype == NULL_TREE)
9554                 {
9555                   if (current_class_type == NULL_TREE)
9556                     {
9557                       error ("destructors must be member functions");
9558                       flags = NO_SPECIAL;
9559                     }
9560                   else
9561                     {
9562                       tree t = constructor_name (current_class_name);
9563                       if (t != name)
9564                         rename = t;
9565                     }
9566                 }
9567               else
9568                 {
9569                   tree t = constructor_name (ctype);
9570                   if (t != name)
9571                     rename = t;
9572                 }
9573
9574               if (rename)
9575                 {
9576                   cp_error ("destructor `%T' must match class name `%T'",
9577                             name, rename);
9578                   TREE_OPERAND (decl, 0) = rename;
9579                 }
9580               next = &name;
9581             }
9582             break;
9583
9584           case ADDR_EXPR:       /* C++ reference declaration */
9585             /* Fall through. */
9586           case ARRAY_REF:
9587           case INDIRECT_REF:
9588             ctype = NULL_TREE;
9589             innermost_code = TREE_CODE (decl);
9590             next = &TREE_OPERAND (decl, 0);
9591             break;
9592
9593           case CALL_EXPR:
9594             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9595               {
9596                 /* This is actually a variable declaration using
9597                    constructor syntax.  We need to call start_decl and
9598                    cp_finish_decl so we can get the variable
9599                    initialized...  */
9600
9601                 tree attributes, prefix_attributes;
9602
9603                 *next = TREE_OPERAND (decl, 0);
9604                 init = CALL_DECLARATOR_PARMS (decl);
9605
9606                 if (attrlist)
9607                   {
9608                     attributes = TREE_PURPOSE (attrlist);
9609                     prefix_attributes = TREE_VALUE (attrlist);
9610                   }
9611                 else
9612                   {
9613                     attributes = NULL_TREE;
9614                     prefix_attributes = NULL_TREE;
9615                   }
9616
9617                 decl = start_decl (declarator, declspecs, 1,
9618                                    attributes, prefix_attributes);
9619                 decl_type_access_control (decl);
9620                 if (decl)
9621                   {
9622                     /* Look for __unused__ attribute */
9623                     if (TREE_USED (TREE_TYPE (decl)))
9624                       TREE_USED (decl) = 1;
9625                     finish_decl (decl, init, NULL_TREE);
9626                   }
9627                 else
9628                   cp_error ("invalid declarator");
9629                 return 0;
9630               }
9631             innermost_code = TREE_CODE (decl);
9632             if (decl_context == FIELD && ctype == NULL_TREE)
9633               ctype = current_class_type;
9634             if (ctype
9635                 && TREE_OPERAND (decl, 0)
9636                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9637                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9638                          == constructor_name_full (ctype))
9639                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9640                             == constructor_name (ctype)))))
9641               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9642             next = &TREE_OPERAND (decl, 0);
9643             decl = *next;
9644             if (ctype != NULL_TREE
9645                 && decl != NULL_TREE && flags != DTOR_FLAG
9646                 && decl == constructor_name (ctype))
9647               {
9648                 sfk = sfk_constructor;
9649                 ctor_return_type = ctype;
9650               }
9651             ctype = NULL_TREE;
9652             break;
9653
9654           case TEMPLATE_ID_EXPR:
9655               {
9656                 tree fns = TREE_OPERAND (decl, 0);
9657
9658                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9659                   fns = TREE_OPERAND (fns, 0);
9660
9661                 dname = fns;
9662                 if (TREE_CODE (dname) == COMPONENT_REF)
9663                   dname = TREE_OPERAND (dname, 1);
9664                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9665                   {
9666                     my_friendly_assert (is_overloaded_fn (dname),
9667                                         19990331);
9668                     dname = DECL_NAME (get_first_fn (dname));
9669                   }
9670               }
9671           /* Fall through. */
9672
9673           case IDENTIFIER_NODE:
9674             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9675               dname = decl;
9676
9677             next = 0;
9678
9679             if (C_IS_RESERVED_WORD (dname))
9680               {
9681                 cp_error ("declarator-id missing; using reserved word `%D'",
9682                           dname);
9683                 name = IDENTIFIER_POINTER (dname);
9684               }
9685             else if (!IDENTIFIER_TYPENAME_P (dname))
9686               name = IDENTIFIER_POINTER (dname);
9687             else
9688               {
9689                 my_friendly_assert (flags == NO_SPECIAL, 154);
9690                 flags = TYPENAME_FLAG;
9691                 ctor_return_type = TREE_TYPE (dname);
9692                 sfk = sfk_conversion;
9693                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9694                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9695                         == TYPE_DECL))
9696                   name = IDENTIFIER_POINTER (dname);
9697                 else
9698                   name = "<invalid operator>";
9699               }
9700             break;
9701
9702             /* C++ extension */
9703           case SCOPE_REF:
9704             {
9705               /* Perform error checking, and decide on a ctype.  */
9706               tree cname = TREE_OPERAND (decl, 0);
9707               if (cname == NULL_TREE)
9708                 ctype = NULL_TREE;
9709               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9710                 {
9711                   ctype = NULL_TREE;
9712                   in_namespace = TREE_OPERAND (decl, 0);
9713                   TREE_OPERAND (decl, 0) = NULL_TREE;
9714                 }
9715               else if (! is_aggr_type (cname, 1))
9716                 TREE_OPERAND (decl, 0) = NULL_TREE;
9717               /* Must test TREE_OPERAND (decl, 1), in case user gives
9718                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9719               else if (TREE_OPERAND (decl, 1)
9720                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9721                 ctype = cname;
9722               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9723                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9724                 {
9725                   cp_error ("`%T::%D' is not a valid declarator", cname,
9726                             TREE_OPERAND (decl, 1));
9727                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9728                             cname, TREE_OPERAND (decl, 1));
9729                   return void_type_node;
9730                 }
9731               else if (ctype == NULL_TREE)
9732                 ctype = cname;
9733               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9734                 TREE_OPERAND (decl, 0) = ctype;
9735               else
9736                 {
9737                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9738                     {
9739                       cp_error ("type `%T' is not derived from type `%T'",
9740                                 cname, ctype);
9741                       TREE_OPERAND (decl, 0) = NULL_TREE;
9742                     }
9743                   else
9744                     ctype = cname;
9745                 }
9746
9747               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9748                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9749                        == constructor_name_full (ctype))
9750                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9751                           == constructor_name (ctype))))
9752                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9753               next = &TREE_OPERAND (decl, 1);
9754               decl = *next;
9755               if (ctype)
9756                 {
9757                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9758                       && constructor_name (ctype) == decl)
9759                     {
9760                       sfk = sfk_constructor;
9761                       ctor_return_type = ctype;
9762                     }
9763                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9764                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9765                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9766                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9767                     {
9768                       sfk = sfk_destructor;
9769                       ctor_return_type = ctype;
9770                       flags = DTOR_FLAG;
9771                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9772                       next = &TREE_OPERAND (decl, 0);
9773                     }
9774                 }
9775             }
9776             break;
9777
9778           case ERROR_MARK:
9779             next = 0;
9780             break;
9781
9782           case TYPE_DECL:
9783             /* Parse error puts this typespec where
9784                a declarator should go.  */
9785             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9786             if (TREE_TYPE (decl) == current_class_type)
9787               cp_error ("  perhaps you want `%T' for a constructor",
9788                         current_class_name);
9789             dname = DECL_NAME (decl);
9790             name = IDENTIFIER_POINTER (dname);
9791
9792             /* Avoid giving two errors for this.  */
9793             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9794
9795             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9796             *next = dname;
9797             next = 0;
9798             break;
9799
9800           default:
9801             cp_compiler_error ("`%D' as declarator", decl);
9802             return 0; /* We used to do a 155 abort here.  */
9803           }
9804       }
9805   }
9806
9807   /* A function definition's declarator must have the form of
9808      a function declarator.  */
9809
9810   if (funcdef_flag && innermost_code != CALL_EXPR)
9811     return 0;
9812
9813   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9814       && innermost_code != CALL_EXPR
9815       && ! (ctype && declspecs == NULL_TREE))
9816     {
9817       cp_error ("declaration of `%D' as non-function", dname);
9818       return void_type_node;
9819     }
9820
9821   /* Anything declared one level down from the top level
9822      must be one of the parameters of a function
9823      (because the body is at least two levels down).  */
9824
9825   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9826      by not allowing C++ class definitions to specify their parameters
9827      with xdecls (must be spec.d in the parmlist).
9828
9829      Since we now wait to push a class scope until we are sure that
9830      we are in a legitimate method context, we must set oldcname
9831      explicitly (since current_class_name is not yet alive).
9832
9833      We also want to avoid calling this a PARM if it is in a namespace.  */
9834
9835   if (decl_context == NORMAL && !toplevel_bindings_p ())
9836     {
9837       struct binding_level *b = current_binding_level;
9838       current_binding_level = b->level_chain;
9839       if (current_binding_level != 0 && toplevel_bindings_p ())
9840         decl_context = PARM;
9841       current_binding_level = b;
9842     }
9843
9844   if (name == NULL)
9845     name = decl_context == PARM ? "parameter" : "type name";
9846
9847   /* Look through the decl specs and record which ones appear.
9848      Some typespecs are defined as built-in typenames.
9849      Others, the ones that are modifiers of other types,
9850      are represented by bits in SPECBITS: set the bits for
9851      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9852
9853      If there is a typedef name or a type, store the type in TYPE.
9854      This includes builtin typedefs such as `int'.
9855
9856      Set EXPLICIT_INT if the type is `int' or `char' and did not
9857      come from a user typedef.
9858
9859      Set LONGLONG if `long' is mentioned twice.
9860
9861      For C++, constructors and destructors have their own fast treatment.  */
9862
9863   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9864     {
9865       register int i;
9866       register tree id;
9867
9868       /* Certain parse errors slip through.  For example,
9869          `int class;' is not caught by the parser. Try
9870          weakly to recover here.  */
9871       if (TREE_CODE (spec) != TREE_LIST)
9872         return 0;
9873
9874       id = TREE_VALUE (spec);
9875
9876       if (TREE_CODE (id) == IDENTIFIER_NODE)
9877         {
9878           if (id == ridpointers[(int) RID_INT]
9879               || id == ridpointers[(int) RID_CHAR]
9880               || id == ridpointers[(int) RID_BOOL]
9881               || id == ridpointers[(int) RID_WCHAR])
9882             {
9883               if (type)
9884                 {
9885                   if (id == ridpointers[(int) RID_BOOL])
9886                     error ("`bool' is now a keyword");
9887                   else
9888                     cp_error ("extraneous `%T' ignored", id);
9889                 }
9890               else
9891                 {
9892                   if (id == ridpointers[(int) RID_INT])
9893                     explicit_int = 1;
9894                   else if (id == ridpointers[(int) RID_CHAR])
9895                     explicit_char = 1;
9896                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9897                 }
9898               goto found;
9899             }
9900           /* C++ aggregate types.  */
9901           if (IDENTIFIER_HAS_TYPE_VALUE (id))
9902             {
9903               if (type)
9904                 cp_error ("multiple declarations `%T' and `%T'", type, id);
9905               else
9906                 type = IDENTIFIER_TYPE_VALUE (id);
9907               goto found;
9908             }
9909
9910           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
9911             {
9912               if (ridpointers[i] == id)
9913                 {
9914                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
9915                     {
9916                       if (pedantic && ! in_system_header && warn_long_long)
9917                         pedwarn ("ISO C++ does not support `long long'");
9918                       if (longlong)
9919                         error ("`long long long' is too long for GCC");
9920                       else
9921                         longlong = 1;
9922                     }
9923                   else if (RIDBIT_SETP (i, specbits))
9924                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
9925                   RIDBIT_SET (i, specbits);
9926                   goto found;
9927                 }
9928             }
9929         }
9930       /* C++ aggregate types.  */
9931       else if (TREE_CODE (id) == TYPE_DECL)
9932         {
9933           if (type)
9934             cp_error ("multiple declarations `%T' and `%T'", type,
9935                       TREE_TYPE (id));
9936           else
9937             {
9938               type = TREE_TYPE (id);
9939               TREE_VALUE (spec) = type;
9940             }
9941           goto found;
9942         }
9943       if (type)
9944         error ("two or more data types in declaration of `%s'", name);
9945       else if (TREE_CODE (id) == IDENTIFIER_NODE)
9946         {
9947           register tree t = lookup_name (id, 1);
9948           if (!t || TREE_CODE (t) != TYPE_DECL)
9949             error ("`%s' fails to be a typedef or built in type",
9950                    IDENTIFIER_POINTER (id));
9951           else
9952             {
9953               type = TREE_TYPE (t);
9954 #if 0
9955               /* See the code below that used this.  */
9956               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
9957 #endif
9958               typedef_decl = t;
9959             }
9960         }
9961       else if (id != error_mark_node)
9962         /* Can't change CLASS nodes into RECORD nodes here!  */
9963         type = id;
9964
9965     found: ;
9966     }
9967
9968   typedef_type = type;
9969
9970   /* No type at all: default to `int', and set DEFAULTED_INT
9971      because it was not a user-defined typedef.  */
9972
9973   if (type == NULL_TREE
9974       && (RIDBIT_SETP (RID_SIGNED, specbits)
9975           || RIDBIT_SETP (RID_UNSIGNED, specbits)
9976           || RIDBIT_SETP (RID_LONG, specbits)
9977           || RIDBIT_SETP (RID_SHORT, specbits)))
9978     {
9979       /* These imply 'int'.  */
9980       type = integer_type_node;
9981       defaulted_int = 1;
9982     }
9983
9984   if (sfk != sfk_none)
9985     type = check_special_function_return_type (sfk, type,
9986                                                ctor_return_type);
9987   else if (type == NULL_TREE)
9988     {
9989       int is_main;
9990
9991       explicit_int = -1;
9992
9993       /* We handle `main' specially here, because 'main () { }' is so
9994          common.  With no options, it is allowed.  With -Wreturn-type,
9995          it is a warning.  It is only an error with -pedantic-errors.  */
9996       is_main = (funcdef_flag
9997                  && MAIN_NAME_P (dname)
9998                  && ctype == NULL_TREE
9999                  && in_namespace == NULL_TREE
10000                  && current_namespace == global_namespace);
10001
10002       if (in_system_header || flag_ms_extensions)
10003         /* Allow it, sigh.  */;
10004       else if (pedantic || ! is_main)
10005         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10006                     name);
10007       else if (warn_return_type)
10008         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10009                     name);
10010
10011       type = integer_type_node;
10012     }
10013
10014   ctype = NULL_TREE;
10015
10016   /* Now process the modifiers that were specified
10017      and check for invalid combinations.  */
10018
10019   /* Long double is a special combination.  */
10020
10021   if (RIDBIT_SETP (RID_LONG, specbits)
10022       && TYPE_MAIN_VARIANT (type) == double_type_node)
10023     {
10024       RIDBIT_RESET (RID_LONG, specbits);
10025       type = build_qualified_type (long_double_type_node,
10026                                    CP_TYPE_QUALS (type));
10027     }
10028
10029   /* Check all other uses of type modifiers.  */
10030
10031   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10032       || RIDBIT_SETP (RID_SIGNED, specbits)
10033       || RIDBIT_SETP (RID_LONG, specbits)
10034       || RIDBIT_SETP (RID_SHORT, specbits))
10035     {
10036       int ok = 0;
10037
10038       if (TREE_CODE (type) == REAL_TYPE)
10039         error ("short, signed or unsigned invalid for `%s'", name);
10040       else if (TREE_CODE (type) != INTEGER_TYPE)
10041         error ("long, short, signed or unsigned invalid for `%s'", name);
10042       else if (RIDBIT_SETP (RID_LONG, specbits)
10043                && RIDBIT_SETP (RID_SHORT, specbits))
10044         error ("long and short specified together for `%s'", name);
10045       else if ((RIDBIT_SETP (RID_LONG, specbits)
10046                 || RIDBIT_SETP (RID_SHORT, specbits))
10047                && explicit_char)
10048         error ("long or short specified with char for `%s'", name);
10049       else if ((RIDBIT_SETP (RID_LONG, specbits)
10050                 || RIDBIT_SETP (RID_SHORT, specbits))
10051                && TREE_CODE (type) == REAL_TYPE)
10052         error ("long or short specified with floating type for `%s'", name);
10053       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10054                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10055         error ("signed and unsigned given together for `%s'", name);
10056       else
10057         {
10058           ok = 1;
10059           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10060             {
10061               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10062                        name);
10063               if (flag_pedantic_errors)
10064                 ok = 0;
10065             }
10066         }
10067
10068       /* Discard the type modifiers if they are invalid.  */
10069       if (! ok)
10070         {
10071           RIDBIT_RESET (RID_UNSIGNED, specbits);
10072           RIDBIT_RESET (RID_SIGNED, specbits);
10073           RIDBIT_RESET (RID_LONG, specbits);
10074           RIDBIT_RESET (RID_SHORT, specbits);
10075           longlong = 0;
10076         }
10077     }
10078
10079   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10080       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10081     {
10082       error ("complex invalid for `%s'", name);
10083       RIDBIT_RESET (RID_COMPLEX, specbits);
10084     }
10085
10086   /* Decide whether an integer type is signed or not.
10087      Optionally treat bitfields as signed by default.  */
10088   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10089       /* [class.bit]
10090
10091          It is implementation-defined whether a plain (neither
10092          explicitly signed or unsigned) char, short, int, or long
10093          bit-field is signed or unsigned.
10094
10095          Naturally, we extend this to long long as well.  Note that
10096          this does not include wchar_t.  */
10097       || (bitfield && !flag_signed_bitfields
10098           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10099           /* A typedef for plain `int' without `signed' can be
10100              controlled just like plain `int', but a typedef for
10101              `signed int' cannot be so controlled.  */
10102           && !(typedef_decl
10103                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10104           && (TREE_CODE (type) == INTEGER_TYPE
10105               || TREE_CODE (type) == CHAR_TYPE)
10106           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10107     {
10108       if (longlong)
10109         type = long_long_unsigned_type_node;
10110       else if (RIDBIT_SETP (RID_LONG, specbits))
10111         type = long_unsigned_type_node;
10112       else if (RIDBIT_SETP (RID_SHORT, specbits))
10113         type = short_unsigned_type_node;
10114       else if (type == char_type_node)
10115         type = unsigned_char_type_node;
10116       else if (typedef_decl)
10117         type = unsigned_type (type);
10118       else
10119         type = unsigned_type_node;
10120     }
10121   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10122            && type == char_type_node)
10123     type = signed_char_type_node;
10124   else if (longlong)
10125     type = long_long_integer_type_node;
10126   else if (RIDBIT_SETP (RID_LONG, specbits))
10127     type = long_integer_type_node;
10128   else if (RIDBIT_SETP (RID_SHORT, specbits))
10129     type = short_integer_type_node;
10130
10131   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10132     {
10133       /* If we just have "complex", it is equivalent to
10134          "complex double", but if any modifiers at all are specified it is
10135          the complex form of TYPE.  E.g, "complex short" is
10136          "complex short int".  */
10137
10138       if (defaulted_int && ! longlong
10139           && ! (RIDBIT_SETP (RID_LONG, specbits)
10140                 || RIDBIT_SETP (RID_SHORT, specbits)
10141                 || RIDBIT_SETP (RID_SIGNED, specbits)
10142                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10143         type = complex_double_type_node;
10144       else if (type == integer_type_node)
10145         type = complex_integer_type_node;
10146       else if (type == float_type_node)
10147         type = complex_float_type_node;
10148       else if (type == double_type_node)
10149         type = complex_double_type_node;
10150       else if (type == long_double_type_node)
10151         type = complex_long_double_type_node;
10152       else
10153         type = build_complex_type (type);
10154     }
10155
10156   if (sfk == sfk_conversion
10157       && (RIDBIT_SETP (RID_CONST, specbits)
10158           || RIDBIT_SETP (RID_VOLATILE, specbits)
10159           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10160     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10161               ctor_return_type);
10162
10163   /* Set CONSTP if this declaration is `const', whether by
10164      explicit specification or via a typedef.
10165      Likewise for VOLATILEP.  */
10166
10167   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10168   restrictp =
10169     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10170   volatilep =
10171     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10172   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10173                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10174                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10175   type = cp_build_qualified_type (type, type_quals);
10176   staticp = 0;
10177   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10178   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10179   RIDBIT_RESET (RID_VIRTUAL, specbits);
10180   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10181   RIDBIT_RESET (RID_EXPLICIT, specbits);
10182
10183   if (RIDBIT_SETP (RID_STATIC, specbits))
10184     staticp = 1 + (decl_context == FIELD);
10185
10186   if (virtualp && staticp == 2)
10187     {
10188       cp_error ("member `%D' cannot be declared both virtual and static",
10189                 dname);
10190       staticp = 0;
10191     }
10192   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10193   RIDBIT_RESET (RID_FRIEND, specbits);
10194
10195   /* Warn if two storage classes are given. Default to `auto'.  */
10196
10197   if (RIDBIT_ANY_SET (specbits))
10198     {
10199       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10200       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10201       if (decl_context == PARM && nclasses > 0)
10202         error ("storage class specifiers invalid in parameter declarations");
10203       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10204         {
10205           if (decl_context == PARM)
10206             error ("typedef declaration invalid in parameter declaration");
10207           nclasses++;
10208         }
10209       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10210       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10211     }
10212
10213   /* Give error if `virtual' is used outside of class declaration.  */
10214   if (virtualp
10215       && (current_class_name == NULL_TREE || decl_context != FIELD))
10216     {
10217       error ("virtual outside class declaration");
10218       virtualp = 0;
10219     }
10220
10221   /* Static anonymous unions are dealt with here.  */
10222   if (staticp && decl_context == TYPENAME
10223       && TREE_CODE (declspecs) == TREE_LIST
10224       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10225     decl_context = FIELD;
10226
10227   /* Warn about storage classes that are invalid for certain
10228      kinds of declarations (parameters, typenames, etc.).  */
10229
10230   if (nclasses > 1)
10231     error ("multiple storage classes in declaration of `%s'", name);
10232   else if (decl_context != NORMAL && nclasses > 0)
10233     {
10234       if ((decl_context == PARM || decl_context == CATCHPARM)
10235           && (RIDBIT_SETP (RID_REGISTER, specbits)
10236               || RIDBIT_SETP (RID_AUTO, specbits)))
10237         ;
10238       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10239         ;
10240       else if (decl_context == FIELD
10241                /* C++ allows static class elements  */
10242                && RIDBIT_SETP (RID_STATIC, specbits))
10243         /* C++ also allows inlines and signed and unsigned elements,
10244            but in those cases we don't come in here.  */
10245         ;
10246       else
10247         {
10248           if (decl_context == FIELD)
10249             {
10250               tree tmp = NULL_TREE;
10251               register int op = 0;
10252
10253               if (declarator)
10254                 {
10255                   /* Avoid trying to get an operand off an identifier node.  */
10256                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10257                     tmp = declarator;
10258                   else
10259                     tmp = TREE_OPERAND (declarator, 0);
10260                   op = IDENTIFIER_OPNAME_P (tmp);
10261                   if (IDENTIFIER_TYPENAME_P (tmp))
10262                     {
10263                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10264                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10265                               == TYPE_DECL))
10266                         name = IDENTIFIER_POINTER (tmp);
10267                       else
10268                         name = "<invalid operator>";
10269                     }
10270                 }
10271               error ("storage class specified for %s `%s'",
10272                      op ? "member operator" : "field",
10273                      name);
10274             }
10275           else
10276             {
10277               if (decl_context == PARM || decl_context == CATCHPARM)
10278                 error ("storage class specified for parameter `%s'", name);
10279               else
10280                 error ("storage class specified for typename");
10281             }
10282           RIDBIT_RESET (RID_REGISTER, specbits);
10283           RIDBIT_RESET (RID_AUTO, specbits);
10284           RIDBIT_RESET (RID_EXTERN, specbits);
10285         }
10286     }
10287   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10288     {
10289       if (toplevel_bindings_p ())
10290         {
10291           /* It's common practice (and completely valid) to have a const
10292              be initialized and declared extern.  */
10293           if (!(type_quals & TYPE_QUAL_CONST))
10294             warning ("`%s' initialized and declared `extern'", name);
10295         }
10296       else
10297         error ("`%s' has both `extern' and initializer", name);
10298     }
10299   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10300            && ! toplevel_bindings_p ())
10301     error ("nested function `%s' declared `extern'", name);
10302   else if (toplevel_bindings_p ())
10303     {
10304       if (RIDBIT_SETP (RID_AUTO, specbits))
10305         error ("top-level declaration of `%s' specifies `auto'", name);
10306     }
10307
10308   if (nclasses > 0 && friendp)
10309     error ("storage class specifiers invalid in friend function declarations");
10310
10311   /* Now figure out the structure of the declarator proper.
10312      Descend through it, creating more complex types, until we reach
10313      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10314
10315   inner_attrs = NULL_TREE;
10316   ignore_attrs = 0;
10317
10318   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10319          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10320     {
10321       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10322          an INDIRECT_REF (for *...),
10323          a CALL_EXPR (for ...(...)),
10324          an identifier (for the name being declared)
10325          or a null pointer (for the place in an absolute declarator
10326          where the name was omitted).
10327          For the last two cases, we have just exited the loop.
10328
10329          For C++ it could also be
10330          a SCOPE_REF (for class :: ...).  In this case, we have converted
10331          sensible names to types, and those are the values we use to
10332          qualify the member name.
10333          an ADDR_EXPR (for &...),
10334          a BIT_NOT_EXPR (for destructors)
10335
10336          At this point, TYPE is the type of elements of an array,
10337          or for a function to return, or for a pointer to point to.
10338          After this sequence of ifs, TYPE is the type of the
10339          array or function or pointer, and DECLARATOR has had its
10340          outermost layer removed.  */
10341
10342       if (type == error_mark_node)
10343         {
10344           if (TREE_CODE (declarator) == SCOPE_REF)
10345             declarator = TREE_OPERAND (declarator, 1);
10346           else
10347             declarator = TREE_OPERAND (declarator, 0);
10348           continue;
10349         }
10350       if (quals != NULL_TREE
10351           && (declarator == NULL_TREE
10352               || TREE_CODE (declarator) != SCOPE_REF))
10353         {
10354           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10355             ctype = TYPE_METHOD_BASETYPE (type);
10356           if (ctype != NULL_TREE)
10357             {
10358               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10359               grok_method_quals (ctype, dummy, quals);
10360               type = TREE_TYPE (dummy);
10361               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10362               quals = NULL_TREE;
10363             }
10364         }
10365
10366       /* See the comment for the TREE_LIST case, below.  */
10367       if (ignore_attrs)
10368         ignore_attrs = 0;
10369       else if (inner_attrs)
10370         {
10371           decl_attributes (&type, inner_attrs, 0);
10372           inner_attrs = NULL_TREE;
10373         }
10374
10375       switch (TREE_CODE (declarator))
10376         {
10377         case TREE_LIST:
10378           {
10379             /* We encode a declarator with embedded attributes using
10380                a TREE_LIST.  The attributes apply to the declarator
10381                directly inside them, so we have to skip an iteration
10382                before applying them to the type.  If the declarator just
10383                inside is the declarator-id, we apply the attrs to the
10384                decl itself.  */
10385             inner_attrs = TREE_PURPOSE (declarator);
10386             ignore_attrs = 1;
10387             declarator = TREE_VALUE (declarator);
10388           }
10389           break;
10390
10391         case ARRAY_REF:
10392           {
10393             register tree size;
10394
10395             size = TREE_OPERAND (declarator, 1);
10396
10397             /* VC++ spells a zero-sized array with [].  */
10398             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10399                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10400               size = integer_zero_node;
10401
10402             declarator = TREE_OPERAND (declarator, 0);
10403
10404             type = create_array_type_for_decl (dname, type, size);
10405
10406             /* VLAs never work as fields. */
10407             if (decl_context == FIELD && !processing_template_decl
10408                 && TREE_CODE (type) == ARRAY_TYPE
10409                 && TYPE_DOMAIN (type) != NULL_TREE
10410                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10411               {
10412                 cp_error ("size of member `%D' is not constant", dname);
10413                 /* Proceed with arbitrary constant size, so that offset
10414                    computations don't get confused. */
10415                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10416                                                    integer_one_node);
10417               }
10418
10419             ctype = NULL_TREE;
10420           }
10421           break;
10422
10423         case CALL_EXPR:
10424           {
10425             tree arg_types;
10426             int funcdecl_p;
10427             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10428             tree inner_decl = TREE_OPERAND (declarator, 0);
10429
10430             /* Declaring a function type.
10431                Make sure we have a valid type for the function to return.  */
10432
10433             /* We now know that the TYPE_QUALS don't apply to the
10434                decl, but to its return type.  */
10435             type_quals = TYPE_UNQUALIFIED;
10436
10437             /* Warn about some types functions can't return.  */
10438
10439             if (TREE_CODE (type) == FUNCTION_TYPE)
10440               {
10441                 error ("`%s' declared as function returning a function", name);
10442                 type = integer_type_node;
10443               }
10444             if (TREE_CODE (type) == ARRAY_TYPE)
10445               {
10446                 error ("`%s' declared as function returning an array", name);
10447                 type = integer_type_node;
10448               }
10449
10450             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10451               inner_decl = TREE_OPERAND (inner_decl, 1);
10452
10453             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10454               inner_decl = dname;
10455
10456             /* Pick up type qualifiers which should be applied to `this'.  */
10457             quals = CALL_DECLARATOR_QUALS (declarator);
10458
10459             /* Pick up the exception specifications.  */
10460             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10461
10462             /* Say it's a definition only for the CALL_EXPR
10463                closest to the identifier.  */
10464             funcdecl_p
10465               = inner_decl
10466               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10467                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10468                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10469
10470             if (ctype == NULL_TREE
10471                 && decl_context == FIELD
10472                 && funcdecl_p
10473                 && (friendp == 0 || dname == current_class_name))
10474               ctype = current_class_type;
10475
10476             if (ctype && sfk == sfk_conversion)
10477               TYPE_HAS_CONVERSION (ctype) = 1;
10478             if (ctype && constructor_name (ctype) == dname)
10479               {
10480                 /* We are within a class's scope. If our declarator name
10481                    is the same as the class name, and we are defining
10482                    a function, then it is a constructor/destructor, and
10483                    therefore returns a void type.  */
10484
10485                 if (flags == DTOR_FLAG)
10486                   {
10487                     /* ISO C++ 12.4/2.  A destructor may not be
10488                        declared const or volatile.  A destructor may
10489                        not be static.  */
10490                     if (staticp == 2)
10491                       error ("destructor cannot be static member function");
10492                     if (quals)
10493                       {
10494                         cp_error ("destructors may not be `%s'",
10495                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10496                         quals = NULL_TREE;
10497                       }
10498                     if (decl_context == FIELD)
10499                       {
10500                         if (! member_function_or_else (ctype,
10501                                                        current_class_type,
10502                                                        flags))
10503                           return void_type_node;
10504                       }
10505                   }
10506                 else            /* It's a constructor.  */
10507                   {
10508                     if (explicitp == 1)
10509                       explicitp = 2;
10510                     /* ISO C++ 12.1.  A constructor may not be
10511                        declared const or volatile.  A constructor may
10512                        not be virtual.  A constructor may not be
10513                        static.  */
10514                     if (staticp == 2)
10515                       error ("constructor cannot be static member function");
10516                     if (virtualp)
10517                       {
10518                         pedwarn ("constructors cannot be declared virtual");
10519                         virtualp = 0;
10520                       }
10521                     if (quals)
10522                       {
10523                         cp_error ("constructors may not be `%s'",
10524                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10525                         quals = NULL_TREE;
10526                       }
10527                     {
10528                       RID_BIT_TYPE tmp_bits;
10529                       memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
10530                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10531                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10532                       if (RIDBIT_ANY_SET (tmp_bits))
10533                         error ("return value type specifier for constructor ignored");
10534                     }
10535                     if (decl_context == FIELD)
10536                       {
10537                         if (! member_function_or_else (ctype,
10538                                                        current_class_type,
10539                                                        flags))
10540                           return void_type_node;
10541                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10542                         if (sfk != sfk_constructor)
10543                           return NULL_TREE;
10544                       }
10545                   }
10546                 if (decl_context == FIELD)
10547                   staticp = 0;
10548               }
10549             else if (friendp)
10550               {
10551                 if (initialized)
10552                   error ("can't initialize friend function `%s'", name);
10553                 if (virtualp)
10554                   {
10555                     /* Cannot be both friend and virtual.  */
10556                     error ("virtual functions cannot be friends");
10557                     RIDBIT_RESET (RID_FRIEND, specbits);
10558                     friendp = 0;
10559                   }
10560                 if (decl_context == NORMAL)
10561                   error ("friend declaration not in class definition");
10562                 if (current_function_decl && funcdef_flag)
10563                   cp_error ("can't define friend function `%s' in a local class definition",
10564                             name);
10565               }
10566
10567             /* Construct the function type and go to the next
10568                inner layer of declarator.  */
10569
10570             declarator = TREE_OPERAND (declarator, 0);
10571
10572             /* FIXME: This is where default args should be fully
10573                processed.  */
10574
10575             arg_types = grokparms (inner_parms);
10576
10577             if (declarator && flags == DTOR_FLAG)
10578               {
10579                 /* A destructor declared in the body of a class will
10580                    be represented as a BIT_NOT_EXPR.  But, we just
10581                    want the underlying IDENTIFIER.  */
10582                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10583                   declarator = TREE_OPERAND (declarator, 0);
10584
10585                 if (arg_types != void_list_node)
10586                   {
10587                     cp_error ("destructors may not have parameters");
10588                     arg_types = void_list_node;
10589                     last_function_parms = NULL_TREE;
10590                   }
10591               }
10592
10593             /* ANSI says that `const int foo ();'
10594                does not make the function foo const.  */
10595             type = build_function_type (type, arg_types);
10596
10597             {
10598               tree t;
10599               for (t = arg_types; t; t = TREE_CHAIN (t))
10600                 if (TREE_PURPOSE (t)
10601                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10602                   {
10603                     add_defarg_fn (type);
10604                     break;
10605                   }
10606             }
10607           }
10608           break;
10609
10610         case ADDR_EXPR:
10611         case INDIRECT_REF:
10612           /* Filter out pointers-to-references and references-to-references.
10613              We can get these if a TYPE_DECL is used.  */
10614
10615           if (TREE_CODE (type) == REFERENCE_TYPE)
10616             {
10617               error ("cannot declare %s to references",
10618                      TREE_CODE (declarator) == ADDR_EXPR
10619                      ? "references" : "pointers");
10620               declarator = TREE_OPERAND (declarator, 0);
10621               continue;
10622             }
10623
10624           if (TREE_CODE (type) == OFFSET_TYPE
10625               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10626                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10627             {
10628               cp_error ("cannot declare pointer to `%#T' member",
10629                         TREE_TYPE (type));
10630               type = TREE_TYPE (type);
10631             }
10632
10633           /* Merge any constancy or volatility into the target type
10634              for the pointer.  */
10635
10636           /* We now know that the TYPE_QUALS don't apply to the decl,
10637              but to the target of the pointer.  */
10638           type_quals = TYPE_UNQUALIFIED;
10639
10640           if (TREE_CODE (declarator) == ADDR_EXPR)
10641             {
10642               if (TREE_CODE (type) == VOID_TYPE)
10643                 error ("invalid type: `void &'");
10644               else
10645                 type = build_reference_type (type);
10646             }
10647           else if (TREE_CODE (type) == METHOD_TYPE)
10648             type = build_ptrmemfunc_type (build_pointer_type (type));
10649           else
10650             type = build_pointer_type (type);
10651
10652           /* Process a list of type modifier keywords (such as
10653              const or volatile) that were given inside the `*' or `&'.  */
10654
10655           if (TREE_TYPE (declarator))
10656             {
10657               register tree typemodlist;
10658               int erred = 0;
10659
10660               constp = 0;
10661               volatilep = 0;
10662               restrictp = 0;
10663               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10664                    typemodlist = TREE_CHAIN (typemodlist))
10665                 {
10666                   tree qualifier = TREE_VALUE (typemodlist);
10667
10668                   if (qualifier == ridpointers[(int) RID_CONST])
10669                     constp++;
10670                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10671                     volatilep++;
10672                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10673                     restrictp++;
10674                   else if (!erred)
10675                     {
10676                       erred = 1;
10677                       error ("invalid type modifier within pointer declarator");
10678                     }
10679                 }
10680               if (constp > 1)
10681                 pedwarn ("duplicate `const'");
10682               if (volatilep > 1)
10683                 pedwarn ("duplicate `volatile'");
10684               if (restrictp > 1)
10685                 pedwarn ("duplicate `restrict'");
10686
10687               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10688                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10689                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10690               if (TREE_CODE (declarator) == ADDR_EXPR
10691                   && (constp || volatilep))
10692                 {
10693                   if (constp)
10694                     pedwarn ("discarding `const' applied to a reference");
10695                   if (volatilep)
10696                     pedwarn ("discarding `volatile' applied to a reference");
10697                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10698                 }
10699               type = cp_build_qualified_type (type, type_quals);
10700             }
10701           declarator = TREE_OPERAND (declarator, 0);
10702           ctype = NULL_TREE;
10703           break;
10704
10705         case SCOPE_REF:
10706           {
10707             /* We have converted type names to NULL_TREE if the
10708                name was bogus, or to a _TYPE node, if not.
10709
10710                The variable CTYPE holds the type we will ultimately
10711                resolve to.  The code here just needs to build
10712                up appropriate member types.  */
10713             tree sname = TREE_OPERAND (declarator, 1);
10714             tree t;
10715
10716             /* Destructors can have their visibilities changed as well.  */
10717             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10718               sname = TREE_OPERAND (sname, 0);
10719
10720             if (TREE_COMPLEXITY (declarator) == 0)
10721               /* This needs to be here, in case we are called
10722                  multiple times.  */ ;
10723             else if (TREE_COMPLEXITY (declarator) == -1)
10724               /* Namespace member. */
10725               pop_decl_namespace ();
10726             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10727               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10728             else if (! IS_AGGR_TYPE_CODE
10729                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10730               ;
10731             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10732               {
10733                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10734                    that refer to ctype.  They couldn't be resolved earlier
10735                    because we hadn't pushed into the class yet.
10736                    Example: resolve 'B<T>::type' in
10737                    'B<typename B<T>::type> B<T>::f () { }'.  */
10738                 if (current_template_parms
10739                     && uses_template_parms (type)
10740                     && uses_template_parms (current_class_type))
10741                   {
10742                     tree args = current_template_args ();
10743                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10744                   }
10745
10746                 /* This pop_nested_class corresponds to the
10747                    push_nested_class used to push into class scope for
10748                    parsing the argument list of a function decl, in
10749                    qualified_id.  */
10750                 pop_nested_class ();
10751                 TREE_COMPLEXITY (declarator) = current_class_depth;
10752               }
10753             else
10754               my_friendly_abort (16);
10755
10756             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10757               {
10758                 /* We had a reference to a global decl, or
10759                    perhaps we were given a non-aggregate typedef,
10760                    in which case we cleared this out, and should just
10761                    keep going as though it wasn't there.  */
10762                 declarator = sname;
10763                 continue;
10764               }
10765             ctype = TREE_OPERAND (declarator, 0);
10766
10767             t = ctype;
10768             while (t != NULL_TREE && CLASS_TYPE_P (t))
10769               {
10770                 /* You're supposed to have one `template <...>'
10771                    for every template class, but you don't need one
10772                    for a full specialization.  For example:
10773
10774                      template <class T> struct S{};
10775                      template <> struct S<int> { void f(); };
10776                      void S<int>::f () {}
10777
10778                    is correct; there shouldn't be a `template <>' for
10779                    the definition of `S<int>::f'.  */
10780                 if (CLASSTYPE_TEMPLATE_INFO (t)
10781                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10782                         || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
10783                     && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
10784                   template_count += 1;
10785
10786                 t = TYPE_MAIN_DECL (t);
10787                 t = DECL_CONTEXT (t);
10788               }
10789
10790             if (sname == NULL_TREE)
10791               goto done_scoping;
10792
10793             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10794               {
10795                 /* This is the `standard' use of the scoping operator:
10796                    basetype :: member .  */
10797
10798                 if (ctype == current_class_type)
10799                   {
10800                     /* class A {
10801                          void A::f ();
10802                        };
10803
10804                        Is this ill-formed?  */
10805
10806                     if (pedantic)
10807                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10808                                   ctype, name);
10809                   }
10810                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10811                   {
10812                     if (current_class_type == NULL_TREE || friendp)
10813                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10814                                                       TYPE_ARG_TYPES (type));
10815                     else
10816                       {
10817                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10818                                   ctype, name, current_class_type);
10819                         return void_type_node;
10820                       }
10821                   }
10822                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10823                          || COMPLETE_TYPE_P (complete_type (ctype)))
10824                   {
10825                     /* Have to move this code elsewhere in this function.
10826                        this code is used for i.e., typedef int A::M; M *pm;
10827
10828                        It is?  How? jason 10/2/94 */
10829
10830                     if (current_class_type)
10831                       {
10832                         cp_error ("cannot declare member `%T::%s' within `%T'",
10833                                   ctype, name, current_class_type);
10834                         return void_type_node;
10835                       }
10836                     type = build_offset_type (ctype, type);
10837                   }
10838                 else
10839                   {
10840                     incomplete_type_error (NULL_TREE, ctype);
10841                     return error_mark_node;
10842                   }
10843
10844                 declarator = sname;
10845               }
10846             else if (TREE_CODE (sname) == SCOPE_REF)
10847               my_friendly_abort (17);
10848             else
10849               {
10850               done_scoping:
10851                 declarator = TREE_OPERAND (declarator, 1);
10852                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10853                   /* In this case, we will deal with it later.  */
10854                   ;
10855                 else
10856                   {
10857                     if (TREE_CODE (type) == FUNCTION_TYPE)
10858                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10859                                                       TYPE_ARG_TYPES (type));
10860                     else
10861                       type = build_offset_type (ctype, type);
10862                   }
10863               }
10864           }
10865           break;
10866
10867         case BIT_NOT_EXPR:
10868           declarator = TREE_OPERAND (declarator, 0);
10869           break;
10870
10871         case RECORD_TYPE:
10872         case UNION_TYPE:
10873         case ENUMERAL_TYPE:
10874           declarator = NULL_TREE;
10875           break;
10876
10877         case ERROR_MARK:
10878           declarator = NULL_TREE;
10879           break;
10880
10881         default:
10882           my_friendly_abort (158);
10883         }
10884     }
10885
10886   /* See the comment for the TREE_LIST case, above.  */
10887   if (inner_attrs)
10888     {
10889       if (! ignore_attrs)
10890         decl_attributes (&type, inner_attrs, 0);
10891       else if (attrlist)
10892         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10893       else
10894         attrlist = build_tree_list (NULL_TREE, inner_attrs);
10895     }
10896
10897   /* Now TYPE has the actual type.  */
10898
10899   if (explicitp == 1 || (explicitp && friendp))
10900     {
10901       /* [dcl.fct.spec] The explicit specifier shall only be used in
10902          declarations of constructors within a class definition.  */
10903       error ("only declarations of constructors can be `explicit'");
10904       explicitp = 0;
10905     }
10906
10907   if (RIDBIT_SETP (RID_MUTABLE, specbits))
10908     {
10909       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
10910         {
10911           error ("non-member `%s' cannot be declared `mutable'", name);
10912           RIDBIT_RESET (RID_MUTABLE, specbits);
10913         }
10914       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
10915         {
10916           error ("non-object member `%s' cannot be declared `mutable'", name);
10917           RIDBIT_RESET (RID_MUTABLE, specbits);
10918         }
10919       else if (TREE_CODE (type) == FUNCTION_TYPE
10920                || TREE_CODE (type) == METHOD_TYPE)
10921         {
10922           error ("function `%s' cannot be declared `mutable'", name);
10923           RIDBIT_RESET (RID_MUTABLE, specbits);
10924         }
10925       else if (staticp)
10926         {
10927           error ("static `%s' cannot be declared `mutable'", name);
10928           RIDBIT_RESET (RID_MUTABLE, specbits);
10929         }
10930       else if (type_quals & TYPE_QUAL_CONST)
10931         {
10932           error ("const `%s' cannot be declared `mutable'", name);
10933           RIDBIT_RESET (RID_MUTABLE, specbits);
10934         }
10935     }
10936
10937   if (declarator == NULL_TREE
10938       || TREE_CODE (declarator) == IDENTIFIER_NODE
10939       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
10940           && (TREE_CODE (type) == FUNCTION_TYPE
10941               || TREE_CODE (type) == METHOD_TYPE)))
10942     /* OK */;
10943   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10944     {
10945       cp_error ("template-id `%D' used as a declarator", declarator);
10946       declarator = dname;
10947     }
10948   else
10949     /* Unexpected declarator format.  */
10950     my_friendly_abort (990210);
10951
10952   /* If this is declaring a typedef name, return a TYPE_DECL.  */
10953
10954   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
10955     {
10956       tree decl;
10957
10958       /* Note that the grammar rejects storage classes
10959          in typenames, fields or parameters.  */
10960       if (current_lang_name == lang_name_java)
10961         TYPE_FOR_JAVA (type) = 1;
10962
10963       if (decl_context == FIELD)
10964         {
10965           if (declarator == constructor_name (current_class_type))
10966             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
10967                         declarator);
10968           decl = build_lang_decl (TYPE_DECL, declarator, type);
10969         }
10970       else
10971         {
10972           decl = build_decl (TYPE_DECL, declarator, type);
10973           if (!current_function_decl)
10974             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
10975         }
10976
10977       /* If the user declares "typedef struct {...} foo" then the
10978          struct will have an anonymous name.  Fill that name in now.
10979          Nothing can refer to it, so nothing needs know about the name
10980          change.  */
10981       if (type != error_mark_node
10982           && declarator
10983           && TYPE_NAME (type)
10984           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10985           && TYPE_ANONYMOUS_P (type)
10986           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
10987         {
10988           tree oldname = TYPE_NAME (type);
10989           tree t;
10990
10991           /* Replace the anonymous name with the real name everywhere.  */
10992           lookup_tag_reverse (type, declarator);
10993           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10994             if (TYPE_NAME (t) == oldname)
10995               TYPE_NAME (t) = decl;
10996
10997           if (TYPE_LANG_SPECIFIC (type))
10998             TYPE_WAS_ANONYMOUS (type) = 1;
10999
11000           /* If this is a typedef within a template class, the nested
11001              type is a (non-primary) template.  The name for the
11002              template needs updating as well.  */
11003           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11004             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11005               = TYPE_IDENTIFIER (type);
11006
11007           /* FIXME remangle member functions; member functions of a
11008              type with external linkage have external linkage.  */
11009         }
11010
11011       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11012         {
11013           cp_error_at ("typedef name may not be class-qualified", decl);
11014           return NULL_TREE;
11015         }
11016       else if (quals)
11017         {
11018           if (ctype == NULL_TREE)
11019             {
11020               if (TREE_CODE (type) != METHOD_TYPE)
11021                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11022               else
11023                 ctype = TYPE_METHOD_BASETYPE (type);
11024             }
11025           if (ctype != NULL_TREE)
11026             grok_method_quals (ctype, decl, quals);
11027         }
11028
11029       if (RIDBIT_SETP (RID_SIGNED, specbits)
11030           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11031         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11032
11033       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11034                       inlinep, friendp, raises != NULL_TREE);
11035
11036       if (initialized)
11037         error ("typedef declaration includes an initializer");
11038
11039       return decl;
11040     }
11041
11042   /* Detect the case of an array type of unspecified size
11043      which came, as such, direct from a typedef name.
11044      We must copy the type, so that each identifier gets
11045      a distinct type, so that each identifier's size can be
11046      controlled separately by its own initializer.  */
11047
11048   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11049       && TYPE_DOMAIN (type) == NULL_TREE)
11050     {
11051       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11052     }
11053
11054   /* Detect where we're using a typedef of function type to declare a
11055      function. last_function_parms will not be set, so we must create
11056      it now.  */
11057
11058   if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
11059     {
11060       tree decls = NULL_TREE;
11061       tree args;
11062
11063       for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
11064         {
11065           tree decl = build_decl (PARM_DECL, NULL_TREE, TREE_VALUE (args));
11066
11067           TREE_CHAIN (decl) = decls;
11068           decls = decl;
11069         }
11070
11071       last_function_parms = nreverse (decls);
11072     }
11073
11074   /* If this is a type name (such as, in a cast or sizeof),
11075      compute the type and return it now.  */
11076
11077   if (decl_context == TYPENAME)
11078     {
11079       /* Note that the grammar rejects storage classes
11080          in typenames, fields or parameters.  */
11081       if (type_quals != TYPE_UNQUALIFIED)
11082         type_quals = TYPE_UNQUALIFIED;
11083
11084       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11085       if (friendp)
11086         {
11087           if (type_quals != TYPE_UNQUALIFIED)
11088             {
11089               cp_error ("type qualifiers specified for friend class declaration");
11090               type_quals = TYPE_UNQUALIFIED;
11091             }
11092           if (inlinep)
11093             {
11094               cp_error ("`inline' specified for friend class declaration");
11095               inlinep = 0;
11096             }
11097
11098           /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11099              But don't allow implicit typenames except with a class-key.  */
11100           if (!current_aggr && (TREE_CODE (type) != TYPENAME_TYPE
11101                                 || IMPLICIT_TYPENAME_P (type)))
11102             {
11103               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11104                 cp_pedwarn ("template parameters cannot be friends");
11105               else if (TREE_CODE (type) == TYPENAME_TYPE)
11106                 cp_pedwarn ("\
11107 friend declaration requires class-key, i.e. `friend class %T::%T'",
11108                             constructor_name (current_class_type),
11109                             TYPE_IDENTIFIER (type));
11110               else
11111                 cp_pedwarn ("\
11112 friend declaration requires class-key, i.e. `friend %#T'",
11113                             type);
11114             }
11115
11116           /* Only try to do this stuff if we didn't already give up.  */
11117           if (type != integer_type_node)
11118             {
11119               /* DR 209. The friendly class does not need to be accessible
11120                  in the scope of the class granting friendship. */
11121               skip_type_access_control ();
11122
11123               /* A friendly class?  */
11124               if (current_class_type)
11125                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11126               else
11127                 cp_error ("trying to make class `%T' a friend of global scope",
11128                           type);
11129
11130               type = void_type_node;
11131             }
11132         }
11133       else if (quals)
11134         {
11135           if (ctype == NULL_TREE)
11136             {
11137               if (TREE_CODE (type) != METHOD_TYPE)
11138                 cp_error ("invalid qualifiers on non-member function type");
11139               else
11140                 ctype = TYPE_METHOD_BASETYPE (type);
11141             }
11142           if (ctype)
11143             {
11144               tree dummy = build_decl (TYPE_DECL, declarator, type);
11145               grok_method_quals (ctype, dummy, quals);
11146               type = TREE_TYPE (dummy);
11147             }
11148         }
11149
11150       return type;
11151     }
11152   else if (declarator == NULL_TREE && decl_context != PARM
11153            && decl_context != CATCHPARM
11154            && TREE_CODE (type) != UNION_TYPE
11155            && ! bitfield)
11156     {
11157       cp_error ("abstract declarator `%T' used as declaration", type);
11158       declarator = make_anon_name ();
11159     }
11160
11161   /* `void' at top level (not within pointer)
11162      is allowed only in typedefs or type names.
11163      We don't complain about parms either, but that is because
11164      a better error message can be made later.  */
11165
11166   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11167     {
11168       if (! declarator)
11169         error ("unnamed variable or field declared void");
11170       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11171         {
11172           if (IDENTIFIER_OPNAME_P (declarator))
11173             my_friendly_abort (356);
11174           else
11175             error ("variable or field `%s' declared void", name);
11176         }
11177       else
11178         error ("variable or field declared void");
11179       type = integer_type_node;
11180     }
11181
11182   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11183      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11184
11185   if (decl_context == PARM || decl_context == CATCHPARM)
11186     {
11187       if (ctype || in_namespace)
11188         error ("cannot use `::' in parameter declaration");
11189
11190       /* A parameter declared as an array of T is really a pointer to T.
11191          One declared as a function is really a pointer to a function.
11192          One declared as a member is really a pointer to member.  */
11193
11194       if (TREE_CODE (type) == ARRAY_TYPE)
11195         {
11196           /* Transfer const-ness of array into that of type pointed to.  */
11197           type = build_pointer_type (TREE_TYPE (type));
11198           type_quals = TYPE_UNQUALIFIED;
11199         }
11200       else if (TREE_CODE (type) == FUNCTION_TYPE)
11201         type = build_pointer_type (type);
11202       else if (TREE_CODE (type) == OFFSET_TYPE)
11203         type = build_pointer_type (type);
11204     }
11205
11206   {
11207     register tree decl;
11208
11209     if (decl_context == PARM)
11210       {
11211         decl = build_decl (PARM_DECL, declarator, type);
11212
11213         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11214                         inlinep, friendp, raises != NULL_TREE);
11215
11216         /* Compute the type actually passed in the parmlist,
11217            for the case where there is no prototype.
11218            (For example, shorts and chars are passed as ints.)
11219            When there is a prototype, this is overridden later.  */
11220
11221         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11222       }
11223     else if (decl_context == FIELD)
11224       {
11225         if (type == error_mark_node)
11226           {
11227             /* Happens when declaring arrays of sizes which
11228                are error_mark_node, for example.  */
11229             decl = NULL_TREE;
11230           }
11231         else if (in_namespace && !friendp)
11232           {
11233             /* Something like struct S { int N::j; };  */
11234             cp_error ("invalid use of `::'");
11235             decl = NULL_TREE;
11236           }
11237         else if (TREE_CODE (type) == FUNCTION_TYPE)
11238           {
11239             int publicp = 0;
11240             tree function_context;
11241
11242             /* We catch the others as conflicts with the builtin
11243                typedefs.  */
11244             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11245               {
11246                 cp_error ("function `%D' cannot be declared friend",
11247                           declarator);
11248                 friendp = 0;
11249               }
11250
11251             if (friendp == 0)
11252               {
11253                 if (ctype == NULL_TREE)
11254                   ctype = current_class_type;
11255
11256                 if (ctype == NULL_TREE)
11257                   {
11258                     cp_error ("can't make `%D' into a method -- not in a class",
11259                               declarator);
11260                     return void_type_node;
11261                   }
11262
11263                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11264                    ARM 9.5 */
11265                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11266                   {
11267                     cp_error ("function `%D' declared virtual inside a union",
11268                               declarator);
11269                     return void_type_node;
11270                   }
11271
11272                 if (declarator == ansi_opname (NEW_EXPR)
11273                     || declarator == ansi_opname (VEC_NEW_EXPR)
11274                     || declarator == ansi_opname (DELETE_EXPR)
11275                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11276                   {
11277                     if (virtualp)
11278                       {
11279                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11280                                   declarator);
11281                         virtualp = 0;
11282                       }
11283                   }
11284                 else if (staticp < 2)
11285                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11286                                                   TYPE_ARG_TYPES (type));
11287               }
11288
11289             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11290             function_context = (ctype != NULL_TREE) ?
11291               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11292             publicp = (! friendp || ! staticp)
11293               && function_context == NULL_TREE;
11294             decl = grokfndecl (ctype, type,
11295                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11296                                ? declarator : dname,
11297                                declarator,
11298                                virtualp, flags, quals, raises,
11299                                friendp ? -1 : 0, friendp, publicp, inlinep,
11300                                funcdef_flag, template_count, in_namespace);
11301             if (decl == NULL_TREE)
11302               return decl;
11303 #if 0
11304             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11305             /* The decl and setting of decl_machine_attr is also turned off.  */
11306             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11307 #endif
11308
11309             /* [class.conv.ctor]
11310
11311                A constructor declared without the function-specifier
11312                explicit that can be called with a single parameter
11313                specifies a conversion from the type of its first
11314                parameter to the type of its class.  Such a constructor
11315                is called a converting constructor.  */
11316             if (explicitp == 2)
11317               DECL_NONCONVERTING_P (decl) = 1;
11318             else if (DECL_CONSTRUCTOR_P (decl))
11319               {
11320                 /* The constructor can be called with exactly one
11321                    parameter if there is at least one parameter, and
11322                    any subsequent parameters have default arguments.
11323                    Ignore any compiler-added parms.  */
11324                 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
11325
11326                 if (arg_types == void_list_node
11327                     || (arg_types
11328                         && TREE_CHAIN (arg_types)
11329                         && TREE_CHAIN (arg_types) != void_list_node
11330                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11331                   DECL_NONCONVERTING_P (decl) = 1;
11332               }
11333           }
11334         else if (TREE_CODE (type) == METHOD_TYPE)
11335           {
11336             /* We only get here for friend declarations of
11337                members of other classes.  */
11338             /* All method decls are public, so tell grokfndecl to set
11339                TREE_PUBLIC, also.  */
11340             decl = grokfndecl (ctype, type, declarator, declarator,
11341                                virtualp, flags, quals, raises,
11342                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11343                                template_count, in_namespace);
11344             if (decl == NULL_TREE)
11345               return NULL_TREE;
11346           }
11347         else if (!staticp && ! processing_template_decl
11348                  && !COMPLETE_TYPE_P (complete_type (type))
11349                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11350           {
11351             if (declarator)
11352               cp_error ("field `%D' has incomplete type", declarator);
11353             else
11354               cp_error ("name `%T' has incomplete type", type);
11355
11356             /* If we're instantiating a template, tell them which
11357                instantiation made the field's type be incomplete.  */
11358             if (current_class_type
11359                 && TYPE_NAME (current_class_type)
11360                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11361                 && declspecs && TREE_VALUE (declspecs)
11362                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11363               cp_error ("  in instantiation of template `%T'",
11364                         current_class_type);
11365
11366             type = error_mark_node;
11367             decl = NULL_TREE;
11368           }
11369         else
11370           {
11371             if (friendp)
11372               {
11373                 error ("`%s' is neither function nor member function; cannot be declared friend",
11374                        IDENTIFIER_POINTER (declarator));
11375                 friendp = 0;
11376               }
11377             decl = NULL_TREE;
11378           }
11379
11380         if (friendp)
11381           {
11382             /* Friends are treated specially.  */
11383             tree t = NULL_TREE;
11384
11385             /* DR 209. The friend does not need to be accessible at this
11386                point. */
11387             skip_type_access_control ();
11388
11389             if (ctype == current_class_type)
11390               warning ("member functions are implicitly friends of their class");
11391
11392             if (decl && DECL_NAME (decl))
11393               {
11394                 if (template_class_depth (current_class_type) == 0)
11395                   {
11396                     decl = check_explicit_specialization
11397                             (declarator, decl,
11398                              template_count, 2 * (funcdef_flag != 0) + 4);
11399                     if (decl == error_mark_node)
11400                       return error_mark_node;
11401                   }
11402
11403                 t = do_friend (ctype, declarator, decl,
11404                                last_function_parms, attrlist, flags, quals,
11405                                funcdef_flag);
11406               }
11407             if (t && funcdef_flag)
11408               return t;
11409             return void_type_node;
11410           }
11411
11412         /* Structure field.  It may not be a function, except for C++ */
11413
11414         if (decl == NULL_TREE)
11415           {
11416             if (initialized)
11417               {
11418                 if (!staticp)
11419                   {
11420                     /* An attempt is being made to initialize a non-static
11421                        member.  But, from [class.mem]:
11422
11423                        4 A member-declarator can contain a
11424                        constant-initializer only if it declares a static
11425                        member (_class.static_) of integral or enumeration
11426                        type, see _class.static.data_.
11427
11428                        This used to be relatively common practice, but
11429                        the rest of the compiler does not correctly
11430                        handle the initialization unless the member is
11431                        static so we make it static below.  */
11432                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11433                                 declarator);
11434                     cp_pedwarn ("making `%D' static", declarator);
11435                     staticp = 1;
11436                   }
11437
11438                 if (uses_template_parms (type))
11439                   /* We'll check at instantiation time.  */
11440                   ;
11441                 else if (check_static_variable_definition (declarator,
11442                                                            type))
11443                   /* If we just return the declaration, crashes
11444                      will sometimes occur.  We therefore return
11445                      void_type_node, as if this was a friend
11446                      declaration, to cause callers to completely
11447                      ignore this declaration.  */
11448                   return void_type_node;
11449               }
11450
11451             /* 9.2p13 [class.mem] */
11452             if (declarator == constructor_name (current_class_type)
11453                 /* The standard does not allow non-static data members
11454                    here either, but we agreed at the 10/99 meeting
11455                    to change that in TC 1 so that they are allowed in
11456                    classes with no user-defined constructors.  */
11457                 && staticp)
11458               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11459                           declarator);
11460
11461             if (staticp)
11462               {
11463                 /* C++ allows static class members.  All other work
11464                    for this is done by grokfield.  */
11465                 decl = build_lang_decl (VAR_DECL, declarator, type);
11466                 TREE_STATIC (decl) = 1;
11467                 /* In class context, 'static' means public access.  */
11468                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11469               }
11470             else
11471               {
11472                 decl = build_decl (FIELD_DECL, declarator, type);
11473                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11474                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11475                   {
11476                     DECL_MUTABLE_P (decl) = 1;
11477                     RIDBIT_RESET (RID_MUTABLE, specbits);
11478                   }
11479               }
11480
11481             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11482                             inlinep, friendp, raises != NULL_TREE);
11483           }
11484       }
11485     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11486       {
11487         tree original_name;
11488         int publicp = 0;
11489
11490         if (! declarator)
11491           return NULL_TREE;
11492
11493         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11494           original_name = dname;
11495         else
11496           original_name = declarator;
11497
11498         if (RIDBIT_SETP (RID_AUTO, specbits))
11499           error ("storage class `auto' invalid for function `%s'", name);
11500         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11501           error ("storage class `register' invalid for function `%s'", name);
11502
11503         /* Function declaration not at top level.
11504            Storage classes other than `extern' are not allowed
11505            and `extern' makes no difference.  */
11506         if (! toplevel_bindings_p ()
11507             && (RIDBIT_SETP (RID_STATIC, specbits)
11508                 || RIDBIT_SETP (RID_INLINE, specbits))
11509             && pedantic)
11510           {
11511             if (RIDBIT_SETP (RID_STATIC, specbits))
11512               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11513             else
11514               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11515           }
11516
11517         if (ctype == NULL_TREE)
11518           {
11519             if (virtualp)
11520               {
11521                 error ("virtual non-class function `%s'", name);
11522                 virtualp = 0;
11523               }
11524           }
11525         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11526           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11527                                           TYPE_ARG_TYPES (type));
11528
11529         /* Record presence of `static'.  */
11530         publicp = (ctype != NULL_TREE
11531                    || RIDBIT_SETP (RID_EXTERN, specbits)
11532                    || !RIDBIT_SETP (RID_STATIC, specbits));
11533
11534         decl = grokfndecl (ctype, type, original_name, declarator,
11535                            virtualp, flags, quals, raises,
11536                            1, friendp,
11537                            publicp, inlinep, funcdef_flag,
11538                            template_count, in_namespace);
11539         if (decl == NULL_TREE)
11540           return NULL_TREE;
11541
11542         if (staticp == 1)
11543           {
11544             int illegal_static = 0;
11545
11546             /* Don't allow a static member function in a class, and forbid
11547                declaring main to be static.  */
11548             if (TREE_CODE (type) == METHOD_TYPE)
11549               {
11550                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11551                 illegal_static = 1;
11552               }
11553             else if (current_function_decl)
11554               {
11555                 /* FIXME need arm citation */
11556                 error ("cannot declare static function inside another function");
11557                 illegal_static = 1;
11558               }
11559
11560             if (illegal_static)
11561               {
11562                 staticp = 0;
11563                 RIDBIT_RESET (RID_STATIC, specbits);
11564               }
11565           }
11566       }
11567     else
11568       {
11569         /* It's a variable.  */
11570
11571         /* An uninitialized decl with `extern' is a reference.  */
11572         decl = grokvardecl (type, declarator, &specbits,
11573                             initialized,
11574                             (type_quals & TYPE_QUAL_CONST) != 0,
11575                             in_namespace);
11576         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11577                         inlinep, friendp, raises != NULL_TREE);
11578
11579         if (ctype)
11580           {
11581             DECL_CONTEXT (decl) = ctype;
11582             if (staticp == 1)
11583               {
11584                 cp_pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
11585                 staticp = 0;
11586                 RIDBIT_RESET (RID_STATIC, specbits);
11587               }
11588             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11589               {
11590                 cp_error ("static member `%D' declared `register'", decl);
11591                 RIDBIT_RESET (RID_REGISTER, specbits);
11592               }
11593             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11594               {
11595                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11596                             decl);
11597                 RIDBIT_RESET (RID_EXTERN, specbits);
11598               }
11599           }
11600       }
11601
11602     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11603
11604     /* Record `register' declaration for warnings on &
11605        and in case doing stupid register allocation.  */
11606
11607     if (RIDBIT_SETP (RID_REGISTER, specbits))
11608       DECL_REGISTER (decl) = 1;
11609
11610     if (RIDBIT_SETP (RID_EXTERN, specbits))
11611       DECL_THIS_EXTERN (decl) = 1;
11612
11613     if (RIDBIT_SETP (RID_STATIC, specbits))
11614       DECL_THIS_STATIC (decl) = 1;
11615
11616     /* Record constancy and volatility.  There's no need to do this
11617        when processing a template; we'll do this for the instantiated
11618        declaration based on the type of DECL.  */
11619     if (!processing_template_decl)
11620       c_apply_type_quals_to_decl (type_quals, decl);
11621
11622     return decl;
11623   }
11624 }
11625 \f
11626 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11627    An empty exprlist is a parmlist.  An exprlist which
11628    contains only identifiers at the global level
11629    is a parmlist.  Otherwise, it is an exprlist.  */
11630
11631 int
11632 parmlist_is_exprlist (exprs)
11633      tree exprs;
11634 {
11635   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11636     return 0;
11637
11638   if (toplevel_bindings_p ())
11639     {
11640       /* At the global level, if these are all identifiers,
11641          then it is a parmlist.  */
11642       while (exprs)
11643         {
11644           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11645             return 1;
11646           exprs = TREE_CHAIN (exprs);
11647         }
11648       return 0;
11649     }
11650   return 1;
11651 }
11652
11653 /* Subroutine of start_function.  Ensure that each of the parameter
11654    types (as listed in PARMS) is complete, as is required for a
11655    function definition.  */
11656
11657 static void
11658 require_complete_types_for_parms (parms)
11659      tree parms;
11660 {
11661   for (; parms; parms = TREE_CHAIN (parms))
11662     {
11663       if (VOID_TYPE_P (TREE_TYPE (parms)))
11664         /* grokparms will have already issued an error */
11665         TREE_TYPE (parms) = error_mark_node;
11666       else if (complete_type_or_else (TREE_TYPE (parms), parms))
11667         layout_decl (parms, 0);
11668       else
11669         TREE_TYPE (parms) = error_mark_node;
11670     }
11671 }
11672
11673 /* Returns non-zero if T is a local variable.  */
11674
11675 int
11676 local_variable_p (t)
11677      tree t;
11678 {
11679   if ((TREE_CODE (t) == VAR_DECL
11680        /* A VAR_DECL with a context that is a _TYPE is a static data
11681           member.  */
11682        && !TYPE_P (CP_DECL_CONTEXT (t))
11683        /* Any other non-local variable must be at namespace scope.  */
11684        && !DECL_NAMESPACE_SCOPE_P (t))
11685       || (TREE_CODE (t) == PARM_DECL))
11686     return 1;
11687
11688   return 0;
11689 }
11690
11691 /* Returns non-zero if T is an automatic local variable or a label.
11692    (These are the declarations that need to be remapped when the code
11693    containing them is duplicated.)  */
11694
11695 int
11696 nonstatic_local_decl_p (t)
11697      tree t;
11698 {
11699   return ((local_variable_p (t) && !TREE_STATIC (t))
11700           || TREE_CODE (t) == LABEL_DECL
11701           || TREE_CODE (t) == RESULT_DECL);
11702 }
11703
11704 /* Like local_variable_p, but suitable for use as a tree-walking
11705    function.  */
11706
11707 static tree
11708 local_variable_p_walkfn (tp, walk_subtrees, data)
11709      tree *tp;
11710      int *walk_subtrees ATTRIBUTE_UNUSED;
11711      void *data ATTRIBUTE_UNUSED;
11712 {
11713   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11714           ? *tp : NULL_TREE);
11715 }
11716
11717 /* Check that ARG, which is a default-argument expression for a
11718    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11719    something goes wrong.  DECL may also be a _TYPE node, rather than a
11720    DECL, if there is no DECL available.  */
11721
11722 tree
11723 check_default_argument (decl, arg)
11724      tree decl;
11725      tree arg;
11726 {
11727   tree var;
11728   tree decl_type;
11729
11730   if (TREE_CODE (arg) == DEFAULT_ARG)
11731     /* We get a DEFAULT_ARG when looking at an in-class declaration
11732        with a default argument.  Ignore the argument for now; we'll
11733        deal with it after the class is complete.  */
11734     return arg;
11735
11736   if (processing_template_decl || uses_template_parms (arg))
11737     /* We don't do anything checking until instantiation-time.  Note
11738        that there may be uninstantiated arguments even for an
11739        instantiated function, since default arguments are not
11740        instantiated until they are needed.  */
11741     return arg;
11742
11743   if (TYPE_P (decl))
11744     {
11745       decl_type = decl;
11746       decl = NULL_TREE;
11747     }
11748   else
11749     decl_type = TREE_TYPE (decl);
11750
11751   if (arg == error_mark_node
11752       || decl == error_mark_node
11753       || TREE_TYPE (arg) == error_mark_node
11754       || decl_type == error_mark_node)
11755     /* Something already went wrong.  There's no need to check
11756        further.  */
11757     return error_mark_node;
11758
11759   /* [dcl.fct.default]
11760
11761      A default argument expression is implicitly converted to the
11762      parameter type.  */
11763   if (!TREE_TYPE (arg)
11764       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11765     {
11766       if (decl)
11767         cp_error ("default argument for `%#D' has type `%T'",
11768                   decl, TREE_TYPE (arg));
11769       else
11770         cp_error ("default argument for parameter of type `%T' has type `%T'",
11771                   decl_type, TREE_TYPE (arg));
11772
11773       return error_mark_node;
11774     }
11775
11776   /* [dcl.fct.default]
11777
11778      Local variables shall not be used in default argument
11779      expressions.
11780
11781      The keyword `this' shall not be used in a default argument of a
11782      member function.  */
11783   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
11784                                       NULL);
11785   if (var)
11786     {
11787       cp_error ("default argument `%E' uses local variable `%D'",
11788                 arg, var);
11789       return error_mark_node;
11790     }
11791
11792   /* All is well.  */
11793   return arg;
11794 }
11795
11796 /* Decode the list of parameter types for a function type.
11797    Given the list of things declared inside the parens,
11798    return a list of types.
11799
11800    We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
11801    flag. If unset, we append void_list_node. A parmlist declared
11802    as `(void)' is accepted as the empty parmlist.
11803
11804    Also set last_function_parms to the chain of PARM_DECLs.  */
11805
11806 static tree
11807 grokparms (first_parm)
11808      tree first_parm;
11809 {
11810   tree result = NULL_TREE;
11811   tree decls = NULL_TREE;
11812   int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
11813   tree parm, chain;
11814   int any_error = 0;
11815
11816   my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
11817
11818   for (parm = first_parm; parm != NULL_TREE; parm = chain)
11819     {
11820       tree type = NULL_TREE;
11821       register tree decl = TREE_VALUE (parm);
11822       tree init = TREE_PURPOSE (parm);
11823
11824       chain = TREE_CHAIN (parm);
11825       /* @@ weak defense against parse errors.  */
11826       if (TREE_CODE (decl) != VOID_TYPE
11827           && TREE_CODE (decl) != TREE_LIST)
11828         {
11829           /* Give various messages as the need arises.  */
11830           if (TREE_CODE (decl) == STRING_CST)
11831             cp_error ("invalid string constant `%E'", decl);
11832           else if (TREE_CODE (decl) == INTEGER_CST)
11833             error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11834           continue;
11835         }
11836
11837       if (parm == void_list_node)
11838         break;
11839
11840       decl = grokdeclarator (TREE_VALUE (decl), TREE_PURPOSE (decl),
11841                      PARM, init != NULL_TREE, NULL_TREE);
11842       if (! decl || TREE_TYPE (decl) == error_mark_node)
11843         continue;
11844
11845       type = TREE_TYPE (decl);
11846       if (VOID_TYPE_P (type))
11847         {
11848           if (same_type_p (type, void_type_node)
11849               && !DECL_NAME (decl) && !result && !chain && !ellipsis)
11850             /* this is a parmlist of `(void)', which is ok.  */
11851             break;
11852           incomplete_type_error (decl, type);
11853           /* It's not a good idea to actually create parameters of
11854              type `void'; other parts of the compiler assume that a
11855              void type terminates the parameter list.  */
11856           type = error_mark_node;
11857           TREE_TYPE (decl) = error_mark_node;
11858         }
11859
11860       if (type != error_mark_node)
11861         {
11862           /* Top-level qualifiers on the parameters are
11863              ignored for function types.  */
11864           type = TYPE_MAIN_VARIANT (type);
11865           if (TREE_CODE (type) == METHOD_TYPE)
11866             {
11867               cp_error ("parameter `%D' invalidly declared method type", decl);
11868               type = build_pointer_type (type);
11869               TREE_TYPE (decl) = type;
11870             }
11871           else if (TREE_CODE (type) == OFFSET_TYPE)
11872             {
11873               cp_error ("parameter `%D' invalidly declared offset type", decl);
11874               type = build_pointer_type (type);
11875               TREE_TYPE (decl) = type;
11876             }
11877           else if (abstract_virtuals_error (decl, type))
11878             any_error = 1;  /* Seems like a good idea. */
11879           else if (POINTER_TYPE_P (type))
11880             {
11881               /* [dcl.fct]/6, parameter types cannot contain pointers
11882                  (references) to arrays of unknown bound.  */
11883               tree t = TREE_TYPE (type);
11884               int ptr = TYPE_PTR_P (type);
11885
11886               while (1)
11887                 {
11888                   if (TYPE_PTR_P (t))
11889                     ptr = 1;
11890                   else if (TREE_CODE (t) != ARRAY_TYPE)
11891                     break;
11892                   else if (!TYPE_DOMAIN (t))
11893                     break;
11894                   t = TREE_TYPE (t);
11895                 }
11896               if (TREE_CODE (t) == ARRAY_TYPE)
11897                 cp_error ("parameter `%D' includes %s to array of unknown bound `%T'",
11898                           decl, ptr ? "pointer" : "reference", t);
11899             }
11900
11901           DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11902           if (PROMOTE_PROTOTYPES
11903               && INTEGRAL_TYPE_P (type)
11904               && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11905             DECL_ARG_TYPE (decl) = integer_type_node;
11906           if (!any_error && init)
11907             init = check_default_argument (decl, init);
11908           else
11909             init = NULL_TREE;
11910         }
11911
11912       TREE_CHAIN (decl) = decls;
11913       decls = decl;
11914       result = tree_cons (init, type, result);
11915     }
11916   decls = nreverse (decls);
11917   result = nreverse (result);
11918   if (!ellipsis)
11919     result = chainon (result, void_list_node);
11920   last_function_parms = decls;
11921
11922   return result;
11923 }
11924
11925 \f
11926 /* D is a constructor or overloaded `operator='.  Returns non-zero if
11927    D's arguments allow it to be a copy constructor, or copy assignment
11928    operator.  */
11929
11930 int
11931 copy_args_p (d)
11932      tree d;
11933 {
11934   tree t;
11935
11936   if (!DECL_FUNCTION_MEMBER_P (d))
11937     return 0;
11938
11939   t = FUNCTION_FIRST_USER_PARMTYPE (d);
11940   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
11941       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
11942           == DECL_CONTEXT (d))
11943       && (TREE_CHAIN (t) == NULL_TREE
11944           || TREE_CHAIN (t) == void_list_node
11945           || TREE_PURPOSE (TREE_CHAIN (t))))
11946     return 1;
11947   return 0;
11948 }
11949
11950 /* These memoizing functions keep track of special properties which
11951    a class may have.  `grok_ctor_properties' notices whether a class
11952    has a constructor of the form X(X&), and also complains
11953    if the class has a constructor of the form X(X).
11954    `grok_op_properties' takes notice of the various forms of
11955    operator= which are defined, as well as what sorts of type conversion
11956    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
11957
11958 int
11959 grok_ctor_properties (ctype, decl)
11960      tree ctype, decl;
11961 {
11962   tree parmtypes = FUNCTION_FIRST_USER_PARMTYPE (decl);
11963   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
11964
11965   /* [class.copy]
11966
11967      A non-template constructor for class X is a copy constructor if
11968      its first parameter is of type X&, const X&, volatile X& or const
11969      volatile X&, and either there are no other parameters or else all
11970      other parameters have default arguments.  */
11971   if (TREE_CODE (parmtype) == REFERENCE_TYPE
11972       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
11973       && sufficient_parms_p (TREE_CHAIN (parmtypes))
11974       && !(DECL_TEMPLATE_INSTANTIATION (decl)
11975            && is_member_template (DECL_TI_TEMPLATE (decl))))
11976     {
11977       TYPE_HAS_INIT_REF (ctype) = 1;
11978       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
11979         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
11980     }
11981   /* [class.copy]
11982
11983      A declaration of a constructor for a class X is ill-formed if its
11984      first parameter is of type (optionally cv-qualified) X and either
11985      there are no other parameters or else all other parameters have
11986      default arguments.
11987
11988      We *don't* complain about member template instantiations that
11989      have this form, though; they can occur as we try to decide what
11990      constructor to use during overload resolution.  Since overload
11991      resolution will never prefer such a constructor to the
11992      non-template copy constructor (which is either explicitly or
11993      implicitly defined), there's no need to worry about their
11994      existence.  Theoretically, they should never even be
11995      instantiated, but that's hard to forestall.  */
11996   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
11997            && sufficient_parms_p (TREE_CHAIN (parmtypes))
11998            && !(DECL_TEMPLATE_INSTANTIATION (decl)
11999                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12000     {
12001       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12002                 ctype, ctype);
12003       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12004       return 0;
12005     }
12006   else if (TREE_CODE (parmtype) == VOID_TYPE
12007            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12008     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12009
12010   return 1;
12011 }
12012
12013 /* An operator with this code is unary, but can also be binary.  */
12014
12015 static int
12016 ambi_op_p (code)
12017      enum tree_code code;
12018 {
12019   return (code == INDIRECT_REF
12020           || code == ADDR_EXPR
12021           || code == CONVERT_EXPR
12022           || code == NEGATE_EXPR
12023           || code == PREINCREMENT_EXPR
12024           || code == PREDECREMENT_EXPR);
12025 }
12026
12027 /* An operator with this name can only be unary.  */
12028
12029 static int
12030 unary_op_p (code)
12031      enum tree_code code;
12032 {
12033   return (code == TRUTH_NOT_EXPR
12034           || code == BIT_NOT_EXPR
12035           || code == COMPONENT_REF
12036           || code == TYPE_EXPR);
12037 }
12038
12039 /* Do a little sanity-checking on how they declared their operator.  */
12040
12041 void
12042 grok_op_properties (decl, virtualp, friendp)
12043      tree decl;
12044      int virtualp, friendp;
12045 {
12046   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12047   tree argtype;
12048   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12049   tree name = DECL_NAME (decl);
12050   enum tree_code operator_code;
12051   int arity;
12052
12053   /* Count the number of arguments.  */
12054   for (argtype = argtypes, arity = 0;
12055        argtype && argtype != void_list_node;
12056        argtype = TREE_CHAIN (argtype))
12057     ++arity;
12058
12059   if (current_class_type == NULL_TREE)
12060     friendp = 1;
12061
12062   if (DECL_CONV_FN_P (decl))
12063     operator_code = TYPE_EXPR;
12064   else
12065     do
12066       {
12067 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)       \
12068         if (ansi_opname (CODE) == name)                         \
12069           {                                                     \
12070             operator_code = CODE;                               \
12071             break;                                              \
12072           }                                                     \
12073         else if (ansi_assopname (CODE) == name)                 \
12074           {                                                     \
12075             operator_code = CODE;                               \
12076             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;              \
12077             break;                                              \
12078           }
12079
12080 #include "operators.def"
12081 #undef DEF_OPERATOR
12082
12083         my_friendly_abort (20000527);
12084       }
12085     while (0);
12086   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12087   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12088
12089   if (! friendp)
12090     {
12091       switch (operator_code)
12092         {
12093         case CALL_EXPR:
12094           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12095           break;
12096
12097         case ARRAY_REF:
12098           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12099           break;
12100
12101         case COMPONENT_REF:
12102         case MEMBER_REF:
12103           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12104           break;
12105
12106         case NEW_EXPR:
12107           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12108           break;
12109
12110         case DELETE_EXPR:
12111           TYPE_GETS_DELETE (current_class_type) |= 1;
12112           break;
12113
12114         case VEC_NEW_EXPR:
12115           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12116           break;
12117
12118         case VEC_DELETE_EXPR:
12119           TYPE_GETS_DELETE (current_class_type) |= 2;
12120           break;
12121
12122         default:
12123           break;
12124         }
12125     }
12126
12127   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12128     {
12129       /* When the compiler encounters the definition of A::operator new, it
12130          doesn't look at the class declaration to find out if it's static.  */
12131       if (methodp)
12132         revert_static_member_fn (decl);
12133
12134       TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12135     }
12136   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12137     {
12138       if (methodp)
12139         revert_static_member_fn (decl);
12140
12141       TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12142     }
12143   else
12144     {
12145       /* An operator function must either be a non-static member function
12146          or have at least one parameter of a class, a reference to a class,
12147          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12148       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12149         {
12150           if (operator_code == TYPE_EXPR
12151               || operator_code == CALL_EXPR
12152               || operator_code == COMPONENT_REF
12153               || operator_code == ARRAY_REF
12154               || operator_code == NOP_EXPR)
12155             cp_error ("`%D' must be a nonstatic member function", decl);
12156           else
12157             {
12158               tree p = argtypes;
12159
12160               if (DECL_STATIC_FUNCTION_P (decl))
12161                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12162
12163               if (p)
12164                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12165                   {
12166                     tree arg = TREE_VALUE (p);
12167                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12168                       arg = TREE_TYPE (arg);
12169
12170                     /* This lets bad template code slip through.  */
12171                     if (IS_AGGR_TYPE (arg)
12172                         || TREE_CODE (arg) == ENUMERAL_TYPE
12173                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12174                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12175                       goto foundaggr;
12176                   }
12177               cp_error
12178                 ("`%D' must have an argument of class or enumerated type",
12179                  decl);
12180             foundaggr:
12181               ;
12182             }
12183         }
12184
12185       if (operator_code == CALL_EXPR)
12186         return;                 /* No restrictions on args. */
12187
12188       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12189         {
12190           tree t = TREE_TYPE (name);
12191           if (! friendp)
12192             {
12193               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12194               const char *what = 0;
12195
12196               if (ref)
12197                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12198
12199               if (TREE_CODE (t) == VOID_TYPE)
12200                 what = "void";
12201               else if (t == current_class_type)
12202                 what = "the same type";
12203               /* Don't force t to be complete here.  */
12204               else if (IS_AGGR_TYPE (t)
12205                        && COMPLETE_TYPE_P (t)
12206                        && DERIVED_FROM_P (t, current_class_type))
12207                 what = "a base class";
12208
12209               if (what)
12210                 warning ("conversion to %s%s will never use a type conversion operator",
12211                          ref ? "a reference to " : "", what);
12212             }
12213         }
12214
12215       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12216           && operator_code == NOP_EXPR)
12217         {
12218           tree parmtype;
12219
12220           if (arity != 2 && methodp)
12221             {
12222               cp_error ("`%D' must take exactly one argument", decl);
12223               return;
12224             }
12225           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12226
12227           /* [class.copy]
12228
12229              A user-declared copy assignment operator X::operator= is
12230              a non-static non-template member function of class X with
12231              exactly one parameter of type X, X&, const X&, volatile
12232              X& or const volatile X&.  */
12233           if (copy_assignment_arg_p (parmtype, virtualp)
12234               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12235                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12236               && ! friendp)
12237             {
12238               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12239               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12240                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12241                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12242             }
12243         }
12244       else if (operator_code == COND_EXPR)
12245         {
12246           /* 13.4.0.3 */
12247           cp_error ("ISO C++ prohibits overloading operator ?:");
12248         }
12249       else if (ambi_op_p (operator_code))
12250         {
12251           if (arity == 1)
12252             /* We pick the one-argument operator codes by default, so
12253                we don't have to change anything.  */
12254             ;
12255           else if (arity == 2)
12256             {
12257               /* If we thought this was a unary operator, we now know
12258                  it to be a binary operator.  */
12259               switch (operator_code)
12260                 {
12261                 case INDIRECT_REF:
12262                   operator_code = MULT_EXPR;
12263                   break;
12264
12265                 case ADDR_EXPR:
12266                   operator_code = BIT_AND_EXPR;
12267                   break;
12268
12269                 case CONVERT_EXPR:
12270                   operator_code = PLUS_EXPR;
12271                   break;
12272
12273                 case NEGATE_EXPR:
12274                   operator_code = MINUS_EXPR;
12275                   break;
12276
12277                 case PREINCREMENT_EXPR:
12278                   operator_code = POSTINCREMENT_EXPR;
12279                   break;
12280
12281                 case PREDECREMENT_EXPR:
12282                   operator_code = POSTDECREMENT_EXPR;
12283                   break;
12284
12285                 default:
12286                   my_friendly_abort (20000527);
12287                 }
12288
12289               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12290
12291               if ((operator_code == POSTINCREMENT_EXPR
12292                    || operator_code == POSTDECREMENT_EXPR)
12293                   && ! processing_template_decl
12294                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12295                 {
12296                   if (methodp)
12297                     cp_error ("postfix `%D' must take `int' as its argument",
12298                               decl);
12299                   else
12300                     cp_error
12301                       ("postfix `%D' must take `int' as its second argument",
12302                        decl);
12303                 }
12304             }
12305           else
12306             {
12307               if (methodp)
12308                 cp_error ("`%D' must take either zero or one argument", decl);
12309               else
12310                 cp_error ("`%D' must take either one or two arguments", decl);
12311             }
12312
12313           /* More Effective C++ rule 6.  */
12314           if (warn_ecpp
12315               && (operator_code == POSTINCREMENT_EXPR
12316                   || operator_code == POSTDECREMENT_EXPR
12317                   || operator_code == PREINCREMENT_EXPR
12318                   || operator_code == PREDECREMENT_EXPR))
12319             {
12320               tree arg = TREE_VALUE (argtypes);
12321               tree ret = TREE_TYPE (TREE_TYPE (decl));
12322               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12323                 arg = TREE_TYPE (arg);
12324               arg = TYPE_MAIN_VARIANT (arg);
12325               if (operator_code == PREINCREMENT_EXPR
12326                   || operator_code == PREDECREMENT_EXPR)
12327                 {
12328                   if (TREE_CODE (ret) != REFERENCE_TYPE
12329                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12330                                        arg))
12331                     cp_warning ("prefix `%D' should return `%T'", decl,
12332                                 build_reference_type (arg));
12333                 }
12334               else
12335                 {
12336                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12337                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12338                 }
12339             }
12340         }
12341       else if (unary_op_p (operator_code))
12342         {
12343           if (arity != 1)
12344             {
12345               if (methodp)
12346                 cp_error ("`%D' must take `void'", decl);
12347               else
12348                 cp_error ("`%D' must take exactly one argument", decl);
12349             }
12350         }
12351       else /* if (binary_op_p (operator_code)) */
12352         {
12353           if (arity != 2)
12354             {
12355               if (methodp)
12356                 cp_error ("`%D' must take exactly one argument", decl);
12357               else
12358                 cp_error ("`%D' must take exactly two arguments", decl);
12359             }
12360
12361           /* More Effective C++ rule 7.  */
12362           if (warn_ecpp
12363               && (operator_code == TRUTH_ANDIF_EXPR
12364                   || operator_code == TRUTH_ORIF_EXPR
12365                   || operator_code == COMPOUND_EXPR))
12366             cp_warning ("user-defined `%D' always evaluates both arguments",
12367                         decl);
12368         }
12369
12370       /* Effective C++ rule 23.  */
12371       if (warn_ecpp
12372           && arity == 2
12373           && (operator_code == PLUS_EXPR
12374               || operator_code == MINUS_EXPR
12375               || operator_code == TRUNC_DIV_EXPR
12376               || operator_code == MULT_EXPR)
12377           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12378         cp_warning ("`%D' should return by value", decl);
12379
12380       /* 13.4.0.8 */
12381       for (; argtypes && argtypes != void_list_node;
12382           argtypes = TREE_CHAIN (argtypes))
12383         if (TREE_PURPOSE (argtypes))
12384           {
12385             TREE_PURPOSE (argtypes) = NULL_TREE;
12386             if (operator_code == POSTINCREMENT_EXPR
12387                 || operator_code == POSTDECREMENT_EXPR)
12388               {
12389                 if (pedantic)
12390                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12391               }
12392             else
12393               cp_error ("`%D' cannot have default arguments", decl);
12394           }
12395
12396     }
12397 }
12398 \f
12399 static const char *
12400 tag_name (code)
12401      enum tag_types code;
12402 {
12403   switch (code)
12404     {
12405     case record_type:
12406       return "struct";
12407     case class_type:
12408       return "class";
12409     case union_type:
12410       return "union ";
12411     case enum_type:
12412       return "enum";
12413     default:
12414       my_friendly_abort (981122);
12415     }
12416 }
12417
12418 /* Get the struct, enum or union (CODE says which) with tag NAME.
12419    Define the tag as a forward-reference if it is not defined.
12420
12421    C++: If a class derivation is given, process it here, and report
12422    an error if multiple derivation declarations are not identical.
12423
12424    If this is a definition, come in through xref_tag and only look in
12425    the current frame for the name (since C++ allows new names in any
12426    scope.)  */
12427
12428 tree
12429 xref_tag (code_type_node, name, globalize)
12430      tree code_type_node;
12431      tree name;
12432      int globalize;
12433 {
12434   enum tag_types tag_code;
12435   enum tree_code code;
12436   register tree ref, t;
12437   struct binding_level *b = current_binding_level;
12438   int got_type = 0;
12439   tree attributes = NULL_TREE;
12440   tree context = NULL_TREE;
12441
12442   /* If we are called from the parser, code_type_node will sometimes be a
12443      TREE_LIST.  This indicates that the user wrote
12444      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12445      use them later.  */
12446   if (TREE_CODE (code_type_node) == TREE_LIST)
12447     {
12448       attributes = TREE_PURPOSE (code_type_node);
12449       code_type_node = TREE_VALUE (code_type_node);
12450     }
12451
12452   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12453   switch (tag_code)
12454     {
12455     case record_type:
12456     case class_type:
12457       code = RECORD_TYPE;
12458       break;
12459     case union_type:
12460       code = UNION_TYPE;
12461       break;
12462     case enum_type:
12463       code = ENUMERAL_TYPE;
12464       break;
12465     default:
12466       my_friendly_abort (18);
12467     }
12468
12469   /* If a cross reference is requested, look up the type
12470      already defined for this tag and return it.  */
12471   if (TYPE_P (name))
12472     {
12473       t = name;
12474       name = TYPE_IDENTIFIER (t);
12475       got_type = 1;
12476     }
12477   else
12478     t = IDENTIFIER_TYPE_VALUE (name);
12479
12480   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12481   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12482     {
12483       static int explained;
12484       tree shadowed;
12485
12486       cp_warning ("`%s %T' declares a new type at namespace scope",
12487                   tag_name (tag_code), name);
12488       if (!explained++)
12489         cp_warning ("  names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'",
12490                     tag_name (tag_code),
12491                     constructor_name (current_class_type),
12492                     TYPE_IDENTIFIER (t));
12493
12494       /* We need to remove the class scope binding for the
12495          TYPENAME_TYPE as otherwise poplevel_class gets confused. */
12496       for (shadowed = b->class_shadowed;
12497            shadowed;
12498            shadowed = TREE_CHAIN (shadowed))
12499         if (TREE_TYPE (shadowed) == TYPE_NAME (t))
12500           {
12501             TREE_PURPOSE (shadowed) = NULL_TREE;
12502             break;
12503           }
12504     }
12505
12506   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12507       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12508     t = NULL_TREE;
12509
12510   if (! globalize)
12511     {
12512       /* If we know we are defining this tag, only look it up in
12513          this scope and don't try to find it as a type.  */
12514       ref = lookup_tag (code, name, b, 1);
12515     }
12516   else
12517     {
12518       if (t)
12519         {
12520           /* [dcl.type.elab] If the identifier resolves to a
12521              typedef-name or a template type-parameter, the
12522              elaborated-type-specifier is ill-formed.  */
12523           if (t != TYPE_MAIN_VARIANT (t)
12524               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12525             cp_pedwarn ("using typedef-name `%D' after `%s'",
12526                         TYPE_NAME (t), tag_name (tag_code));
12527           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12528             cp_error ("using template type parameter `%T' after `%s'",
12529                       t, tag_name (tag_code));
12530
12531           ref = t;
12532         }
12533       else
12534         ref = lookup_tag (code, name, b, 0);
12535
12536       if (! ref)
12537         {
12538           /* Try finding it as a type declaration.  If that wins,
12539              use it.  */
12540           ref = lookup_name (name, 1);
12541
12542           if (ref != NULL_TREE
12543               && processing_template_decl
12544               && DECL_CLASS_TEMPLATE_P (ref)
12545               && template_class_depth (current_class_type) == 0)
12546             /* Since GLOBALIZE is true, we're declaring a global
12547                template, so we want this type.  */
12548             ref = DECL_TEMPLATE_RESULT (ref);
12549
12550           if (ref && TREE_CODE (ref) == TYPE_DECL
12551               && TREE_CODE (TREE_TYPE (ref)) == code)
12552             ref = TREE_TYPE (ref);
12553           else
12554             ref = NULL_TREE;
12555         }
12556
12557       if (ref && current_class_type
12558           && template_class_depth (current_class_type)
12559           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12560         {
12561           /* Since GLOBALIZE is non-zero, we are not looking at a
12562              definition of this tag.  Since, in addition, we are currently
12563              processing a (member) template declaration of a template
12564              class, we must be very careful; consider:
12565
12566                template <class X>
12567                struct S1
12568
12569                template <class U>
12570                struct S2
12571                { template <class V>
12572                friend struct S1; };
12573
12574              Here, the S2::S1 declaration should not be confused with the
12575              outer declaration.  In particular, the inner version should
12576              have a template parameter of level 2, not level 1.  This
12577              would be particularly important if the member declaration
12578              were instead:
12579
12580                template <class V = U> friend struct S1;
12581
12582              say, when we should tsubst into `U' when instantiating
12583              S2.  On the other hand, when presented with:
12584
12585                  template <class T>
12586                  struct S1 {
12587                    template <class U>
12588                    struct S2 {};
12589                    template <class U>
12590                    friend struct S2;
12591                  };
12592
12593               we must find the inner binding eventually.  We
12594               accomplish this by making sure that the new type we
12595               create to represent this declaration has the right
12596               TYPE_CONTEXT.  */
12597           context = TYPE_CONTEXT (ref);
12598           ref = NULL_TREE;
12599         }
12600     }
12601
12602   if (! ref)
12603     {
12604       /* If no such tag is yet defined, create a forward-reference node
12605          and record it as the "definition".
12606          When a real declaration of this type is found,
12607          the forward-reference will be altered into a real type.  */
12608       if (code == ENUMERAL_TYPE)
12609         {
12610           cp_error ("use of enum `%#D' without previous declaration", name);
12611
12612           ref = make_node (ENUMERAL_TYPE);
12613
12614           /* Give the type a default layout like unsigned int
12615              to avoid crashing if it does not get defined.  */
12616           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12617           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12618           TYPE_USER_ALIGN (ref) = 0;
12619           TREE_UNSIGNED (ref) = 1;
12620           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12621           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12622           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12623
12624           /* Enable us to recognize when a type is created in class context.
12625              To do nested classes correctly, this should probably be cleared
12626              out when we leave this classes scope.  Currently this in only
12627              done in `start_enum'.  */
12628
12629           pushtag (name, ref, globalize);
12630         }
12631       else
12632         {
12633           struct binding_level *old_b = class_binding_level;
12634
12635           ref = make_aggr_type (code);
12636           TYPE_CONTEXT (ref) = context;
12637
12638 #ifdef NONNESTED_CLASSES
12639           /* Class types don't nest the way enums do.  */
12640           class_binding_level = (struct binding_level *)0;
12641 #endif
12642           pushtag (name, ref, globalize);
12643           class_binding_level = old_b;
12644         }
12645     }
12646   else
12647     {
12648       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12649         redeclare_class_template (ref, current_template_parms);
12650     }
12651
12652   /* Until the type is defined, tentatively accept whatever
12653      structure tag the user hands us.  */
12654   if (!COMPLETE_TYPE_P (ref)
12655       && ref != current_class_type
12656       /* Have to check this, in case we have contradictory tag info.  */
12657       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12658     {
12659       if (tag_code == class_type)
12660         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12661       else if (tag_code == record_type)
12662         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12663     }
12664
12665   TREE_TYPE (ref) = attributes;
12666
12667   return ref;
12668 }
12669
12670 tree
12671 xref_tag_from_type (old, id, globalize)
12672      tree old, id;
12673      int globalize;
12674 {
12675   tree code_type_node;
12676
12677   if (TREE_CODE (old) == RECORD_TYPE)
12678     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12679                       ? class_type_node : record_type_node);
12680   else
12681     code_type_node = union_type_node;
12682
12683   if (id == NULL_TREE)
12684     id = TYPE_IDENTIFIER (old);
12685
12686   return xref_tag (code_type_node, id, globalize);
12687 }
12688
12689 /* REF is a type (named NAME), for which we have just seen some
12690    baseclasses.  BINFO is a list of those baseclasses; the
12691    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12692    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12693    struct, or union.  */
12694
12695 void
12696 xref_basetypes (code_type_node, name, ref, binfo)
12697      tree code_type_node;
12698      tree name, ref;
12699      tree binfo;
12700 {
12701   /* In the declaration `A : X, Y, ... Z' we mark all the types
12702      (A, X, Y, ..., Z) so we can check for duplicates.  */
12703   tree binfos;
12704   tree base;
12705
12706   int i, len;
12707   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12708
12709   if (tag_code == union_type)
12710     {
12711       cp_error ("derived union `%T' invalid", ref);
12712       return;
12713     }
12714
12715   len = list_length (binfo);
12716
12717   /* First, make sure that any templates in base-classes are
12718      instantiated.  This ensures that if we call ourselves recursively
12719      we do not get confused about which classes are marked and which
12720      are not.  */
12721   for (base = binfo; base; base = TREE_CHAIN (base))
12722     complete_type (TREE_VALUE (base));
12723
12724   SET_CLASSTYPE_MARKED (ref);
12725   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12726
12727   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12728     {
12729       /* The base of a derived struct is public by default.  */
12730       int via_public
12731         = (TREE_PURPOSE (binfo) == access_public_node
12732            || TREE_PURPOSE (binfo) == access_public_virtual_node
12733            || (tag_code != class_type
12734                && (TREE_PURPOSE (binfo) == access_default_node
12735                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12736       int via_protected
12737         = (TREE_PURPOSE (binfo) == access_protected_node
12738            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12739       int via_virtual
12740         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12741            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12742            || TREE_PURPOSE (binfo) == access_public_virtual_node
12743            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12744       tree basetype = TREE_VALUE (binfo);
12745       tree base_binfo;
12746
12747       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12748         basetype = TREE_TYPE (basetype);
12749       if (!basetype
12750           || (TREE_CODE (basetype) != RECORD_TYPE
12751               && TREE_CODE (basetype) != TYPENAME_TYPE
12752               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12753               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
12754         {
12755           cp_error ("base type `%T' fails to be a struct or class type",
12756                     TREE_VALUE (binfo));
12757           continue;
12758         }
12759
12760       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12761
12762       /* This code replaces similar code in layout_basetypes.
12763          We put the complete_type first for implicit `typename'.  */
12764       if (!COMPLETE_TYPE_P (basetype)
12765           && ! (current_template_parms && uses_template_parms (basetype)))
12766         {
12767           cp_error ("base class `%T' has incomplete type", basetype);
12768           continue;
12769         }
12770       else
12771         {
12772           if (CLASSTYPE_MARKED (basetype))
12773             {
12774               if (basetype == ref)
12775                 cp_error ("recursive type `%T' undefined", basetype);
12776               else
12777                 cp_error ("duplicate base type `%T' invalid", basetype);
12778               continue;
12779             }
12780
12781           if (TYPE_FOR_JAVA (basetype)
12782               && (current_lang_depth () == 0))
12783             TYPE_FOR_JAVA (ref) = 1;
12784
12785           /* Note that the BINFO records which describe individual
12786              inheritances are *not* shared in the lattice!  They
12787              cannot be shared because a given baseclass may be
12788              inherited with different `accessibility' by different
12789              derived classes.  (Each BINFO record describing an
12790              individual inheritance contains flags which say what
12791              the `accessibility' of that particular inheritance is.)  */
12792
12793           base_binfo
12794             = make_binfo (size_zero_node, basetype,
12795                           CLASS_TYPE_P (basetype)
12796                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12797                           CLASS_TYPE_P (basetype)
12798                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12799
12800           TREE_VEC_ELT (binfos, i) = base_binfo;
12801           TREE_VIA_PUBLIC (base_binfo) = via_public;
12802           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12803           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12804           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12805
12806           /* We need to unshare the binfos now so that lookups during class
12807              definition work.  */
12808           unshare_base_binfos (base_binfo);
12809
12810           SET_CLASSTYPE_MARKED (basetype);
12811
12812           /* We are free to modify these bits because they are meaningless
12813              at top level, and BASETYPE is a top-level type.  */
12814           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12815             {
12816               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12817               /* Converting to a virtual base class requires looking
12818                  up the offset of the virtual base.  */
12819               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12820             }
12821
12822           if (CLASS_TYPE_P (basetype))
12823             {
12824               TYPE_HAS_NEW_OPERATOR (ref)
12825                 |= TYPE_HAS_NEW_OPERATOR (basetype);
12826               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12827                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12828               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12829               /* If the base-class uses multiple inheritance, so do we.  */
12830               TYPE_USES_MULTIPLE_INHERITANCE (ref)
12831                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12832               /* Likewise, if converting to a base of the base may require
12833                  code, then we may need to generate code to convert to a
12834                  base as well.  */
12835               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12836                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12837             }
12838
12839           i += 1;
12840         }
12841     }
12842   if (i)
12843     TREE_VEC_LENGTH (binfos) = i;
12844   else
12845     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12846
12847   if (i > 1)
12848     {
12849       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12850       /* If there is more than one non-empty they cannot be at the same
12851          address.  */
12852       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12853     }
12854
12855   /* Unmark all the types.  */
12856   while (--i >= 0)
12857     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12858   CLEAR_CLASSTYPE_MARKED (ref);
12859
12860   /* Now that we know all the base-classes, set up the list of virtual
12861      bases.  */
12862   get_vbase_types (ref);
12863 }
12864
12865 \f
12866 /* Begin compiling the definition of an enumeration type.
12867    NAME is its name (or null if anonymous).
12868    Returns the type object, as yet incomplete.
12869    Also records info about it so that build_enumerator
12870    may be used to declare the individual values as they are read.  */
12871
12872 tree
12873 start_enum (name)
12874      tree name;
12875 {
12876   register tree enumtype = NULL_TREE;
12877   struct binding_level *b = current_binding_level;
12878
12879   /* If this is the real definition for a previous forward reference,
12880      fill in the contents in the same object that used to be the
12881      forward reference.  */
12882
12883   if (name != NULL_TREE)
12884     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12885
12886   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12887     {
12888       cp_error ("multiple definition of `%#T'", enumtype);
12889       cp_error_at ("previous definition here", enumtype);
12890       /* Clear out TYPE_VALUES, and start again.  */
12891       TYPE_VALUES (enumtype) = NULL_TREE;
12892     }
12893   else
12894     {
12895       enumtype = make_node (ENUMERAL_TYPE);
12896       pushtag (name, enumtype, 0);
12897     }
12898
12899   if (current_class_type)
12900     TREE_ADDRESSABLE (b->tags) = 1;
12901
12902   GNU_xref_decl (current_function_decl, enumtype);
12903   return enumtype;
12904 }
12905
12906 /* After processing and defining all the values of an enumeration type,
12907    install their decls in the enumeration type and finish it off.
12908    ENUMTYPE is the type object and VALUES a list of name-value pairs.  */
12909
12910 void
12911 finish_enum (enumtype)
12912      tree enumtype;
12913 {
12914   tree pair;
12915   tree minnode;
12916   tree maxnode;
12917   tree t;
12918   bool unsignedp;
12919   int lowprec;
12920   int highprec;
12921   int precision;
12922
12923   /* We built up the VALUES in reverse order.  */
12924   TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
12925
12926   /* [dcl.enum]
12927
12928      Following the closing brace of an enum-specifier, each
12929      enumerator has the type of its enumeration.  Prior to the
12930      closing brace, the type of each enumerator is the type of
12931      its initializing value.  */
12932   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
12933     TREE_TYPE (TREE_VALUE (pair)) = enumtype;
12934
12935   /* For a enum defined in a template, all further processing is
12936      postponed until the template is instantiated.  */
12937   if (processing_template_decl)
12938     {
12939       tree scope = current_scope ();
12940       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12941         add_stmt (build_min (TAG_DEFN, enumtype));
12942
12943
12944       return;
12945     }
12946
12947   /* Figure out what the minimum and maximum values of the enumerators
12948      are.  */
12949   if (TYPE_VALUES (enumtype))
12950     {
12951       minnode = maxnode = NULL_TREE;
12952
12953       for (pair = TYPE_VALUES (enumtype);
12954            pair;
12955            pair = TREE_CHAIN (pair))
12956         {
12957           tree value;
12958
12959           value = DECL_INITIAL (TREE_VALUE (pair));
12960
12961           if (!minnode)
12962             minnode = maxnode = value;
12963           else if (tree_int_cst_lt (maxnode, value))
12964             maxnode = value;
12965           else if (tree_int_cst_lt (value, minnode))
12966             minnode = value;
12967         }
12968     }
12969   else
12970     minnode = maxnode = integer_zero_node;
12971
12972   /* Compute the number of bits require to represent all values of the
12973      enumeration.  We must do this before the type of MINNODE and
12974      MAXNODE are transformed, since min_precision relies on the
12975      TREE_TYPE of the value it is passed.  */
12976   unsignedp = tree_int_cst_sgn (minnode) >= 0;
12977   lowprec = min_precision (minnode, unsignedp);
12978   highprec = min_precision (maxnode, unsignedp);
12979   precision = MAX (lowprec, highprec);
12980
12981   /* Set the TREE_TYPE for the values as well.  That's so that when we
12982      call decl_constant_value we get an entity of the right type (but
12983      with the constant value).  In addition, transform the TYPE_VALUES
12984      list to contain the values, rather than the CONST_DECLs for them.  */
12985   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
12986     {
12987       tree value = DECL_INITIAL (TREE_VALUE (pair));
12988
12989       TREE_TYPE (value) = enumtype;
12990       TREE_VALUE (pair) = value;
12991     }
12992
12993   /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
12994   TYPE_SIZE (enumtype) = NULL_TREE;
12995   TYPE_PRECISION (enumtype) = precision;
12996   if (unsignedp)
12997     fixup_unsigned_type (enumtype);
12998   else
12999     fixup_signed_type (enumtype);
13000
13001   if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13002     /* Use the width of the narrowest normal C type which is wide
13003        enough.  */
13004     TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13005                                                 (precision, 1));
13006   else
13007     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13008
13009   TYPE_SIZE (enumtype) = NULL_TREE;
13010   layout_type (enumtype);
13011
13012   /* Fix up all variant types of this enum type.  */
13013   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13014     {
13015       TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13016       TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
13017       TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
13018       TYPE_SIZE (t) = TYPE_SIZE (enumtype);
13019       TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
13020       TYPE_MODE (t) = TYPE_MODE (enumtype);
13021       TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
13022       TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
13023       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
13024       TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype);
13025     }
13026
13027   /* Finish debugging output for this type.  */
13028   rest_of_type_compilation (enumtype, namespace_bindings_p ());
13029 }
13030
13031 /* Build and install a CONST_DECL for an enumeration constant of the
13032    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13033    Assignment of sequential values by default is handled here.  */
13034
13035 void
13036 build_enumerator (name, value, enumtype)
13037      tree name;
13038      tree value;
13039      tree enumtype;
13040 {
13041   tree decl;
13042   tree context;
13043   tree type;
13044   tree values;
13045
13046   /* Remove no-op casts from the value.  */
13047   if (value)
13048     STRIP_TYPE_NOPS (value);
13049
13050   if (! processing_template_decl)
13051     {
13052       /* Validate and default VALUE.  */
13053       if (value != NULL_TREE)
13054         {
13055           value = decl_constant_value (value);
13056
13057           if (TREE_CODE (value) == INTEGER_CST)
13058             {
13059               value = default_conversion (value);
13060               constant_expression_warning (value);
13061             }
13062           else
13063             {
13064               cp_error ("enumerator value for `%D' not integer constant", name);
13065               value = NULL_TREE;
13066             }
13067         }
13068
13069       /* Default based on previous value.  */
13070       if (value == NULL_TREE && ! processing_template_decl)
13071         {
13072           tree prev_value;
13073
13074           if (TYPE_VALUES (enumtype))
13075             {
13076               /* The next value is the previous value ... */
13077               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13078               /* ... plus one.  */
13079               value = cp_build_binary_op (PLUS_EXPR,
13080                                           prev_value,
13081                                           integer_one_node);
13082
13083               if (tree_int_cst_lt (value, prev_value))
13084                 cp_error ("overflow in enumeration values at `%D'", name);
13085             }
13086           else
13087             value = integer_zero_node;
13088         }
13089
13090       /* Remove no-op casts from the value.  */
13091       if (value)
13092         STRIP_TYPE_NOPS (value);
13093 #if 0
13094       /* To fix MAX_VAL enum consts. (bkoz)  */
13095       TREE_TYPE (value) = integer_type_node;
13096 #endif
13097     }
13098
13099   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13100      Even in other cases, we will later (in finish_enum) be setting
13101      the type of VALUE.  But, we don't need to make a copy if this
13102      VALUE is one of the enumeration constants for this same
13103      enumeration type.  */
13104   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13105     if (TREE_VALUE (values) == value)
13106       break;
13107   /* If we didn't break out of the loop, then we do need a copy.  */
13108   if (!values && value)
13109     value = copy_node (value);
13110
13111   /* C++ associates enums with global, function, or class declarations.  */
13112   context = current_scope ();
13113
13114   /* Build the actual enumeration constant.  Note that the enumeration
13115     constants have the type of their initializers until the
13116     enumeration is complete:
13117
13118       [ dcl.enum ]
13119
13120       Following the closing brace of an enum-specifier, each enumer-
13121       ator has the type of its enumeration.  Prior to the closing
13122       brace, the type of each enumerator is the type of its
13123       initializing value.
13124
13125     In finish_enum we will reset the type.  Of course, if we're
13126     processing a template, there may be no value.   */
13127   type = value ? TREE_TYPE (value) : NULL_TREE;
13128
13129   if (context && context == current_class_type)
13130     /* This enum declaration is local to the class.  We need the full
13131        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13132     decl = build_lang_decl (CONST_DECL, name, type);
13133   else
13134     /* It's a global enum, or it's local to a function.  (Note local to
13135       a function could mean local to a class method.  */
13136     decl = build_decl (CONST_DECL, name, type);
13137
13138   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13139   DECL_INITIAL (decl) = value;
13140   TREE_READONLY (decl) = 1;
13141
13142   if (context && context == current_class_type)
13143     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13144       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13145       things like `S::i' later.)  */
13146     finish_member_declaration (decl);
13147   else
13148     {
13149       pushdecl (decl);
13150       GNU_xref_decl (current_function_decl, decl);
13151     }
13152
13153   /* Add this enumeration constant to the list for this type.  */
13154   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13155 }
13156
13157 \f
13158 /* We're defining DECL.  Make sure that it's type is OK.  */
13159
13160 static void
13161 check_function_type (decl, current_function_parms)
13162      tree decl;
13163      tree current_function_parms;
13164 {
13165   tree fntype = TREE_TYPE (decl);
13166   tree return_type = complete_type (TREE_TYPE (fntype));
13167
13168   /* In a function definition, arg types must be complete.  */
13169   require_complete_types_for_parms (current_function_parms);
13170
13171   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13172     {
13173       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13174
13175       /* Make it return void instead, but don't change the
13176          type of the DECL_RESULT, in case we have a named return value.  */
13177       if (TREE_CODE (fntype) == METHOD_TYPE)
13178         {
13179           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13180           TREE_TYPE (decl)
13181             = build_cplus_method_type (ctype,
13182                                        void_type_node,
13183                                        FUNCTION_ARG_CHAIN (decl));
13184         }
13185       else
13186         TREE_TYPE (decl)
13187           = build_function_type (void_type_node,
13188                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13189       TREE_TYPE (decl)
13190         = build_exception_variant (fntype,
13191                                    TYPE_RAISES_EXCEPTIONS (fntype));
13192     }
13193   else
13194     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13195 }
13196
13197 /* Create the FUNCTION_DECL for a function definition.
13198    DECLSPECS and DECLARATOR are the parts of the declaration;
13199    they describe the function's name and the type it returns,
13200    but twisted together in a fashion that parallels the syntax of C.
13201
13202    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13203    DECLARATOR is really the DECL for the function we are about to
13204    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13205    indicating that the function is an inline defined in-class.
13206
13207    This function creates a binding context for the function body
13208    as well as setting up the FUNCTION_DECL in current_function_decl.
13209
13210    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13211    (it defines a datum instead), we return 0, which tells
13212    yyparse to report a parse error.
13213
13214    For C++, we must first check whether that datum makes any sense.
13215    For example, "class A local_a(1,2);" means that variable local_a
13216    is an aggregate of type A, which should have a constructor
13217    applied to it with the argument list [1, 2].  */
13218
13219 int
13220 start_function (declspecs, declarator, attrs, flags)
13221      tree declspecs, declarator, attrs;
13222      int flags;
13223 {
13224   tree decl1;
13225   tree ctype = NULL_TREE;
13226   tree fntype;
13227   tree restype;
13228   extern int have_extern_spec;
13229   extern int used_extern_spec;
13230   int doing_friend = 0;
13231   struct binding_level *bl;
13232   tree current_function_parms;
13233
13234   /* Sanity check.  */
13235   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13236   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13237
13238   /* This should only be done once on the top most decl.  */
13239   if (have_extern_spec && !used_extern_spec)
13240     {
13241       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13242       used_extern_spec = 1;
13243     }
13244
13245   if (flags & SF_PRE_PARSED)
13246     {
13247       decl1 = declarator;
13248
13249       fntype = TREE_TYPE (decl1);
13250       if (TREE_CODE (fntype) == METHOD_TYPE)
13251         ctype = TYPE_METHOD_BASETYPE (fntype);
13252
13253       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13254          the (lexical) scope of the class in which it is defined.  */
13255       if (!ctype && DECL_FRIEND_P (decl1))
13256         {
13257           ctype = DECL_FRIEND_CONTEXT (decl1);
13258
13259           /* CTYPE could be null here if we're dealing with a template;
13260              for example, `inline friend float foo()' inside a template
13261              will have no CTYPE set.  */
13262           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13263             ctype = NULL_TREE;
13264           else
13265             doing_friend = 1;
13266         }
13267
13268       last_function_parms = DECL_ARGUMENTS (decl1);
13269     }
13270   else
13271     {
13272       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13273       /* If the declarator is not suitable for a function definition,
13274          cause a syntax error.  */
13275       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13276
13277       fntype = TREE_TYPE (decl1);
13278
13279       restype = TREE_TYPE (fntype);
13280       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13281         {
13282           cp_error ("semicolon missing after declaration of `%#T'", restype);
13283           shadow_tag (build_tree_list (NULL_TREE, restype));
13284           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13285           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13286             fntype = build_function_type (integer_type_node,
13287                                           TYPE_ARG_TYPES (fntype));
13288           else
13289             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13290                                               integer_type_node,
13291                                               TYPE_ARG_TYPES (fntype));
13292           TREE_TYPE (decl1) = fntype;
13293         }
13294
13295       if (TREE_CODE (fntype) == METHOD_TYPE)
13296         ctype = TYPE_METHOD_BASETYPE (fntype);
13297       else if (DECL_MAIN_P (decl1))
13298         {
13299           /* If this doesn't return integer_type, complain.  */
13300           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13301             {
13302               if (pedantic || warn_return_type)
13303                 pedwarn ("return type for `main' changed to `int'");
13304               TREE_TYPE (decl1) = fntype = default_function_type;
13305             }
13306         }
13307     }
13308
13309   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13310     /* This is a constructor, we must ensure that any default args
13311        introduced by this definition are propagated to the clones
13312        now. The clones are used directly in overload resolution.  */
13313     adjust_clone_args (decl1);
13314
13315   /* Sometimes we don't notice that a function is a static member, and
13316      build a METHOD_TYPE for it.  Fix that up now.  */
13317   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13318       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13319     {
13320       revert_static_member_fn (decl1);
13321       last_function_parms = TREE_CHAIN (last_function_parms);
13322       ctype = NULL_TREE;
13323     }
13324
13325   /* Warn if function was previously implicitly declared
13326      (but not if we warned then).  */
13327   if (! warn_implicit
13328       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13329     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13330
13331   /* Set up current_class_type, and enter the scope of the class, if
13332      appropriate.  */
13333   if (ctype)
13334     push_nested_class (ctype, 1);
13335   else if (DECL_STATIC_FUNCTION_P (decl1))
13336     push_nested_class (DECL_CONTEXT (decl1), 2);
13337
13338   /* Now that we have entered the scope of the class, we must restore
13339      the bindings for any template parameters surrounding DECL1, if it
13340      is an inline member template.  (Order is important; consider the
13341      case where a template parameter has the same name as a field of
13342      the class.)  It is not until after this point that
13343      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13344   if (flags & SF_INCLASS_INLINE)
13345     maybe_begin_member_template_processing (decl1);
13346
13347   /* Effective C++ rule 15.  */
13348   if (warn_ecpp
13349       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13350       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13351     cp_warning ("`operator=' should return a reference to `*this'");
13352
13353   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13354      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13355   if (!DECL_INITIAL (decl1))
13356     DECL_INITIAL (decl1) = error_mark_node;
13357
13358   /* This function exists in static storage.
13359      (This does not mean `static' in the C sense!)  */
13360   TREE_STATIC (decl1) = 1;
13361
13362   /* We must call push_template_decl after current_class_type is set
13363      up.  (If we are processing inline definitions after exiting a
13364      class scope, current_class_type will be NULL_TREE until set above
13365      by push_nested_class.)  */
13366   if (processing_template_decl)
13367     decl1 = push_template_decl (decl1);
13368
13369   /* We are now in the scope of the function being defined.  */
13370   current_function_decl = decl1;
13371
13372   /* Save the parm names or decls from this function's declarator
13373      where store_parm_decls will find them.  */
13374   current_function_parms = last_function_parms;
13375
13376   /* Make sure the parameter and return types are reasonable.  When
13377      you declare a function, these types can be incomplete, but they
13378      must be complete when you define the function.  */
13379   if (! processing_template_decl)
13380     check_function_type (decl1, current_function_parms);
13381
13382   /* Build the return declaration for the function.  */
13383   restype = TREE_TYPE (fntype);
13384   if (!processing_template_decl)
13385     {
13386       if (!DECL_RESULT (decl1))
13387         {
13388           DECL_RESULT (decl1)
13389             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13390           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13391                                       DECL_RESULT (decl1));
13392         }
13393     }
13394   else
13395     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13396     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13397
13398   /* Initialize RTL machinery.  We cannot do this until
13399      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13400      even when processing a template; this is how we get
13401      CFUN set up, and our per-function variables initialized.
13402      FIXME factor out the non-RTL stuff.  */
13403   bl = current_binding_level;
13404   init_function_start (decl1, input_filename, lineno);
13405   current_binding_level = bl;
13406
13407   /* Even though we're inside a function body, we still don't want to
13408      call expand_expr to calculate the size of a variable-sized array.
13409      We haven't necessarily assigned RTL to all variables yet, so it's
13410      not safe to try to expand expressions involving them.  */
13411   immediate_size_expand = 0;
13412   cfun->x_dont_save_pending_sizes_p = 1;
13413
13414   /* Start the statement-tree, start the tree now.  */
13415   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13416
13417   /* Let the user know we're compiling this function.  */
13418   announce_function (decl1);
13419
13420   /* Record the decl so that the function name is defined.
13421      If we already have a decl for this name, and it is a FUNCTION_DECL,
13422      use the old decl.  */
13423   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13424     {
13425       /* A specialization is not used to guide overload resolution.  */
13426       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13427           && ! DECL_FUNCTION_MEMBER_P (decl1))
13428         decl1 = pushdecl (decl1);
13429       else
13430         {
13431           /* We need to set the DECL_CONTEXT. */
13432           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13433             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13434           /* And make sure we have enough default args.  */
13435           check_default_args (decl1);
13436         }
13437       fntype = TREE_TYPE (decl1);
13438     }
13439
13440   /* Reset these in case the call to pushdecl changed them.  */
13441   current_function_decl = decl1;
13442   cfun->decl = decl1;
13443
13444   /* If we are (erroneously) defining a function that we have already
13445      defined before, wipe out what we knew before.  */
13446   if (!DECL_PENDING_INLINE_P (decl1)
13447       && DECL_SAVED_FUNCTION_DATA (decl1))
13448     {
13449       free (DECL_SAVED_FUNCTION_DATA (decl1));
13450       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13451     }
13452
13453   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13454     {
13455       /* We know that this was set up by `grokclassfn'.  We do not
13456          wait until `store_parm_decls', since evil parse errors may
13457          never get us to that point.  Here we keep the consistency
13458          between `current_class_type' and `current_class_ptr'.  */
13459       tree t = DECL_ARGUMENTS (decl1);
13460
13461       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13462                           162);
13463       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13464                           19990811);
13465
13466       cp_function_chain->x_current_class_ref
13467         = build_indirect_ref (t, NULL);
13468       cp_function_chain->x_current_class_ptr = t;
13469
13470       /* Constructors and destructors need to know whether they're "in
13471          charge" of initializing virtual base classes.  */
13472       t = TREE_CHAIN (t);
13473       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13474         {
13475           current_in_charge_parm = t;
13476           t = TREE_CHAIN (t);
13477         }
13478       if (DECL_HAS_VTT_PARM_P (decl1))
13479         {
13480           if (DECL_NAME (t) != vtt_parm_identifier)
13481             abort ();
13482           current_vtt_parm = t;
13483         }
13484     }
13485
13486   if (DECL_INTERFACE_KNOWN (decl1))
13487     {
13488       tree ctx = decl_function_context (decl1);
13489
13490       if (DECL_NOT_REALLY_EXTERN (decl1))
13491         DECL_EXTERNAL (decl1) = 0;
13492
13493       if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
13494           && TREE_PUBLIC (ctx))
13495         /* This is a function in a local class in an extern inline
13496            function.  */
13497         comdat_linkage (decl1);
13498     }
13499   /* If this function belongs to an interface, it is public.
13500      If it belongs to someone else's interface, it is also external.
13501      This only affects inlines and template instantiations.  */
13502   else if (interface_unknown == 0
13503            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13504                || flag_alt_external_templates))
13505     {
13506       if (DECL_DECLARED_INLINE_P (decl1)
13507           || DECL_TEMPLATE_INSTANTIATION (decl1)
13508           || processing_template_decl)
13509         {
13510           DECL_EXTERNAL (decl1)
13511             = (interface_only
13512                || (DECL_DECLARED_INLINE_P (decl1)
13513                    && ! flag_implement_inlines
13514                    && !DECL_VINDEX (decl1)));
13515
13516           /* For WIN32 we also want to put these in linkonce sections.  */
13517           maybe_make_one_only (decl1);
13518         }
13519       else
13520         DECL_EXTERNAL (decl1) = 0;
13521       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13522       DECL_INTERFACE_KNOWN (decl1) = 1;
13523     }
13524   else if (interface_unknown && interface_only
13525            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13526                || flag_alt_external_templates))
13527     {
13528       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13529          interface, we will have interface_only set but not
13530          interface_known.  In that case, we don't want to use the normal
13531          heuristics because someone will supply a #pragma implementation
13532          elsewhere, and deducing it here would produce a conflict.  */
13533       comdat_linkage (decl1);
13534       DECL_EXTERNAL (decl1) = 0;
13535       DECL_INTERFACE_KNOWN (decl1) = 1;
13536       DECL_DEFER_OUTPUT (decl1) = 1;
13537     }
13538   else
13539     {
13540       /* This is a definition, not a reference.
13541          So clear DECL_EXTERNAL.  */
13542       DECL_EXTERNAL (decl1) = 0;
13543
13544       if ((DECL_DECLARED_INLINE_P (decl1)
13545            || DECL_TEMPLATE_INSTANTIATION (decl1))
13546           && ! DECL_INTERFACE_KNOWN (decl1)
13547           /* Don't try to defer nested functions for now.  */
13548           && ! decl_function_context (decl1))
13549         DECL_DEFER_OUTPUT (decl1) = 1;
13550       else
13551         DECL_INTERFACE_KNOWN (decl1) = 1;
13552     }
13553
13554   pushlevel (0);
13555   current_binding_level->parm_flag = 1;
13556
13557   cplus_decl_attributes (&decl1, NULL_TREE, attrs, 0);
13558
13559   /* Promote the value to int before returning it.  */
13560   if (c_promoting_integer_type_p (restype))
13561     restype = type_promotes_to (restype);
13562
13563   if (DECL_RESULT (decl1) == NULL_TREE)
13564     {
13565       DECL_RESULT (decl1)
13566         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13567       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13568       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13569     }
13570
13571   ++function_depth;
13572
13573   if (DECL_DESTRUCTOR_P (decl1))
13574     {
13575       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13576       DECL_CONTEXT (dtor_label) = current_function_decl;
13577     }
13578
13579   start_fname_decls ();
13580
13581   store_parm_decls (current_function_parms);
13582
13583   return 1;
13584 }
13585 \f
13586 /* Store the parameter declarations into the current function declaration.
13587    This is called after parsing the parameter declarations, before
13588    digesting the body of the function.
13589
13590    Also install to binding contour return value identifier, if any.  */
13591
13592 static void
13593 store_parm_decls (current_function_parms)
13594      tree current_function_parms;
13595 {
13596   register tree fndecl = current_function_decl;
13597   register tree parm;
13598   int parms_have_cleanups = 0;
13599   tree cleanups = NULL_TREE;
13600
13601   /* This is a chain of any other decls that came in among the parm
13602      declarations.  If a parm is declared with  enum {foo, bar} x;
13603      then CONST_DECLs for foo and bar are put here.  */
13604   tree nonparms = NULL_TREE;
13605
13606   if (current_function_parms)
13607     {
13608       /* This case is when the function was defined with an ANSI prototype.
13609          The parms already have decls, so we need not do anything here
13610          except record them as in effect
13611          and complain if any redundant old-style parm decls were written.  */
13612
13613       tree specparms = current_function_parms;
13614       tree next;
13615
13616       /* Must clear this because it might contain TYPE_DECLs declared
13617              at class level.  */
13618       storedecls (NULL_TREE);
13619
13620       /* If we're doing semantic analysis, then we'll call pushdecl
13621              for each of these.  We must do them in reverse order so that
13622              they end in the correct forward order.  */
13623       specparms = nreverse (specparms);
13624
13625       for (parm = specparms; parm; parm = next)
13626         {
13627           next = TREE_CHAIN (parm);
13628           if (TREE_CODE (parm) == PARM_DECL)
13629             {
13630               tree cleanup;
13631
13632               if (DECL_NAME (parm) == NULL_TREE
13633                   || TREE_CODE (parm) != VOID_TYPE)
13634                 pushdecl (parm);
13635               else
13636                 cp_error ("parameter `%D' declared void", parm);
13637
13638               cleanup = (processing_template_decl
13639                          ? NULL_TREE
13640                          : maybe_build_cleanup (parm));
13641
13642               if (cleanup)
13643                 cleanups = tree_cons (parm, cleanup, cleanups);
13644             }
13645           else
13646             {
13647               /* If we find an enum constant or a type tag,
13648                  put it aside for the moment.  */
13649               TREE_CHAIN (parm) = NULL_TREE;
13650               nonparms = chainon (nonparms, parm);
13651             }
13652         }
13653
13654       /* Get the decls in their original chain order and record in the
13655          function.  This is all and only the PARM_DECLs that were
13656          pushed into scope by the loop above.  */
13657       DECL_ARGUMENTS (fndecl) = getdecls ();
13658       storetags (gettags ());
13659     }
13660   else
13661     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13662
13663   /* Now store the final chain of decls for the arguments
13664      as the decl-chain of the current lexical scope.
13665      Put the enumerators in as well, at the front so that
13666      DECL_ARGUMENTS is not modified.  */
13667   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13668
13669   /* Now that we have initialized the parms, we can start their
13670      cleanups.  We cannot do this before, since expand_decl_cleanup
13671      should not be called before the parm can be used.  */
13672   while (cleanups)
13673     {
13674       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13675                            TREE_VALUE (cleanups));
13676       cleanups = TREE_CHAIN (cleanups);
13677     }
13678
13679   /* Create a binding contour which can be used to catch
13680      cleanup-generated temporaries.  */
13681   if (parms_have_cleanups)
13682     pushlevel (0);
13683
13684   /* Do the starting of the exception specifications, if we have any.  */
13685   if (flag_exceptions && !processing_template_decl
13686       && flag_enforce_eh_specs
13687       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13688     current_eh_spec_block = begin_eh_spec_block ();
13689 }
13690
13691 \f
13692 /* We have finished doing semantic analysis on DECL, but have not yet
13693    generated RTL for its body.  Save away our current state, so that
13694    when we want to generate RTL later we know what to do.  */
13695
13696 static void
13697 save_function_data (decl)
13698      tree decl;
13699 {
13700   struct cp_language_function *f;
13701
13702   /* Save the language-specific per-function data so that we can
13703      get it back when we really expand this function.  */
13704   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13705                       19990908);
13706
13707   /* Make a copy.  */
13708   f = ((struct cp_language_function *)
13709        xmalloc (sizeof (struct cp_language_function)));
13710   memcpy (f, cp_function_chain, sizeof (struct cp_language_function));
13711   DECL_SAVED_FUNCTION_DATA (decl) = f;
13712
13713   /* Clear out the bits we don't need.  */
13714   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
13715   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
13716   f->x_named_label_uses = NULL;
13717   f->bindings = NULL;
13718   f->x_local_names = NULL;
13719
13720   /* When we get back here again, we will be expanding.  */
13721   f->x_expanding_p = 1;
13722
13723   /* If we've already decided that we cannot inline this function, we
13724      must remember that fact when we actually go to expand the
13725      function.  */
13726   if (current_function_cannot_inline)
13727     {
13728       f->cannot_inline = current_function_cannot_inline;
13729       DECL_INLINE (decl) = 0;
13730     }
13731 }
13732
13733 /* At the end of every constructor we generate to code to return
13734    `this'.  Do that now.  */
13735
13736 static void
13737 finish_constructor_body ()
13738 {
13739   /* Any return from a constructor will end up here.  */
13740   if (ctor_label)
13741     add_stmt (build_stmt (LABEL_STMT, ctor_label));
13742
13743   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13744      generate the return, rather than a goto to CTOR_LABEL.  */
13745   ctor_label = NULL_TREE;
13746   /* In check_return_expr we translate an empty return from a
13747      constructor to a return of `this'.  */
13748   finish_return_stmt (NULL_TREE);
13749   /* Mark the end of the constructor.  */
13750   add_stmt (build_stmt (CTOR_STMT));
13751 }
13752
13753 /* At the end of every destructor we generate code to restore virtual
13754    function tables to the values desired by base classes and to call
13755    to base class destructors.  Do that now.  */
13756
13757 static void
13758 finish_destructor_body ()
13759 {
13760   tree compound_stmt;
13761   tree exprstmt;
13762
13763   /* Create a block to contain all the extra code.  */
13764   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13765
13766   /* Any return from a destructor will end up here.  */
13767   add_stmt (build_stmt (LABEL_STMT, dtor_label));
13768
13769   /* Generate the code to call destructor on base class.  If this
13770      destructor belongs to a class with virtual functions, then set
13771      the virtual function table pointer to represent the type of our
13772      base class.  */
13773
13774   /* This side-effect makes call to `build_delete' generate the code
13775      we have to have at the end of this destructor.  `build_delete'
13776      will set the flag again.  */
13777   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13778
13779   exprstmt = build_delete (current_class_type,
13780                            current_class_ref,
13781                            sfk_base_destructor,
13782                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13783                            0);
13784
13785   if (exprstmt != error_mark_node
13786       && (TREE_CODE (exprstmt) != NOP_EXPR
13787           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13788           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13789     {
13790       if (exprstmt != void_zero_node)
13791         /* Don't call `expand_expr_stmt' if we're not going to do
13792            anything, since -Wall will give a diagnostic.  */
13793         finish_expr_stmt (exprstmt);
13794
13795       /* Run destructors for all virtual baseclasses.  */
13796       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13797         {
13798           tree vbases;
13799           tree if_stmt;
13800
13801           if_stmt = begin_if_stmt ();
13802           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13803                                       current_in_charge_parm,
13804                                       integer_two_node),
13805                                if_stmt);
13806
13807           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
13808           /* The CLASSTYPE_VBASECLASSES list is in initialization
13809              order, so we have to march through it in reverse order.  */
13810           for (vbases = nreverse (copy_list (vbases));
13811                vbases;
13812                vbases = TREE_CHAIN (vbases))
13813             {
13814               tree vbase = TREE_VALUE (vbases);
13815               tree base_type = BINFO_TYPE (vbase);
13816
13817               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (base_type))
13818                 {
13819                   tree base_ptr_type = build_pointer_type (base_type);
13820                   tree expr = current_class_ptr;
13821
13822                   /* Convert to the basetype here, as we know the layout is
13823                      fixed. What is more, if we let build_method_call do it,
13824                      it will use the vtable, which may have been clobbered
13825                      by the deletion of our primary base.  */
13826
13827                   expr = build1 (NOP_EXPR, base_ptr_type, expr);
13828                   expr = build (PLUS_EXPR, base_ptr_type, expr,
13829                                 BINFO_OFFSET (vbase));
13830                   expr = build_indirect_ref (expr, NULL);
13831                   expr = build_method_call (expr, base_dtor_identifier,
13832                                             NULL_TREE, vbase,
13833                                             LOOKUP_NORMAL);
13834                   finish_expr_stmt (expr);
13835                 }
13836             }
13837
13838           finish_then_clause (if_stmt);
13839           finish_if_stmt ();
13840         }
13841     }
13842
13843   /* In a virtual destructor, we must call delete.  */
13844   if (DECL_VIRTUAL_P (current_function_decl))
13845     {
13846       tree if_stmt;
13847       tree virtual_size = c_sizeof (current_class_type);
13848
13849       /* [class.dtor]
13850
13851          At the point of definition of a virtual destructor (including
13852          an implicit definition), non-placement operator delete shall
13853          be looked up in the scope of the destructor's class and if
13854          found shall be accessible and unambiguous.  */
13855       exprstmt = build_op_delete_call
13856         (DELETE_EXPR, current_class_ptr, virtual_size,
13857          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13858
13859       if_stmt = begin_if_stmt ();
13860       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13861                                   current_in_charge_parm,
13862                                   integer_one_node),
13863                            if_stmt);
13864       finish_expr_stmt (exprstmt);
13865       finish_then_clause (if_stmt);
13866       finish_if_stmt ();
13867     }
13868
13869   /* Close the block we started above.  */
13870   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13871 }
13872
13873 /* Finish up a function declaration and compile that function
13874    all the way to assembler language output.  The free the storage
13875    for the function definition.
13876
13877    FLAGS is a bitwise or of the following values:
13878      1 - CALL_POPLEVEL
13879        An extra call to poplevel (and expand_end_bindings) must be
13880        made to take care of the binding contour for the base
13881        initializers.  This is only relevant for constructors.
13882      2 - INCLASS_INLINE
13883        We just finished processing the body of an in-class inline
13884        function definition.  (This processing will have taken place
13885        after the class definition is complete.)  */
13886
13887 tree
13888 finish_function (flags)
13889      int flags;
13890 {
13891   register tree fndecl = current_function_decl;
13892   tree fntype, ctype = NULL_TREE;
13893   int call_poplevel = (flags & 1) != 0;
13894   int inclass_inline = (flags & 2) != 0;
13895   int nested;
13896
13897   /* When we get some parse errors, we can end up without a
13898      current_function_decl, so cope.  */
13899   if (fndecl == NULL_TREE)
13900     return error_mark_node;
13901
13902   nested = function_depth > 1;
13903   fntype = TREE_TYPE (fndecl);
13904
13905   /*  TREE_READONLY (fndecl) = 1;
13906       This caused &foo to be of type ptr-to-const-function
13907       which then got a warning when stored in a ptr-to-function variable.  */
13908
13909   my_friendly_assert (building_stmt_tree (), 20000911);
13910
13911   finish_fname_decls ();
13912
13913   /* For a cloned function, we've already got all the code we need;
13914      there's no need to add any extra bits.  */
13915   if (!DECL_CLONED_FUNCTION_P (fndecl))
13916     {
13917       if (DECL_CONSTRUCTOR_P (fndecl))
13918         {
13919           finish_constructor_body ();
13920           if (call_poplevel)
13921             do_poplevel ();
13922         }
13923       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
13924         finish_destructor_body ();
13925       else if (DECL_MAIN_P (fndecl))
13926         {
13927           /* Make it so that `main' always returns 0 by default.  */
13928 #ifdef VMS
13929           finish_return_stmt (integer_one_node);
13930 #else
13931           finish_return_stmt (integer_zero_node);
13932 #endif
13933         }
13934
13935       /* Finish dealing with exception specifiers.  */
13936       if (flag_exceptions && !processing_template_decl
13937           && flag_enforce_eh_specs
13938           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13939         finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
13940                               (TREE_TYPE (current_function_decl)),
13941                               current_eh_spec_block);
13942     }
13943
13944   /* If we're saving up tree structure, tie off the function now.  */
13945   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
13946
13947   /* This must come after expand_function_end because cleanups might
13948      have declarations (from inline functions) that need to go into
13949      this function's blocks.  */
13950   if (current_binding_level->parm_flag != 1)
13951     my_friendly_abort (122);
13952   poplevel (1, 0, 1);
13953
13954   /* Set up the named return value optimization, if we can.  Here, we
13955      eliminate the copy from the nrv into the RESULT_DECL and any cleanup
13956      for the nrv.  genrtl_start_function and declare_return_variable
13957      handle making the nrv and RESULT_DECL share space.  */
13958   if (current_function_return_value)
13959     {
13960       tree r = current_function_return_value;
13961       /* This is only worth doing for fns that return in memory--and
13962          simpler, since we don't have to worry about promoted modes.  */
13963       if (r != error_mark_node
13964           && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl))))
13965         {
13966           DECL_ALIGN (r) = DECL_ALIGN (DECL_RESULT (fndecl));
13967           walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl),
13968                                         nullify_returns_r, r);
13969         }
13970       else
13971         /* Clear it so genrtl_start_function and declare_return_variable
13972            know we're not optimizing.  */
13973         current_function_return_value = NULL_TREE;
13974     }
13975
13976   /* Remember that we were in class scope.  */
13977   if (current_class_name)
13978     ctype = current_class_type;
13979
13980   /* Must mark the RESULT_DECL as being in this function.  */
13981   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
13982
13983   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13984      to the FUNCTION_DECL node itself.  */
13985   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
13986
13987   /* Save away current state, if appropriate.  */
13988   if (!processing_template_decl)
13989     save_function_data (fndecl);
13990
13991   /* If this function calls `setjmp' it cannot be inlined.  When
13992      `longjmp' is called it is not guaranteed to restore the value of
13993      local variables that have been modified since the call to
13994      `setjmp'.  So, if were to inline this function into some caller
13995      `c', then when we `longjmp', we might not restore all variables
13996      in `c'.  (It might seem, at first blush, that there's no way for
13997      this function to modify local variables in `c', but their
13998      addresses may have been stored somewhere accessible to this
13999      function.)  */
14000   if (!processing_template_decl && calls_setjmp_p (fndecl))
14001     DECL_UNINLINABLE (fndecl) = 1;
14002
14003   /* Clear out memory we no longer need.  */
14004   free_after_parsing (cfun);
14005   /* Since we never call rest_of_compilation, we never clear
14006      CFUN.  Do so explicitly.  */
14007   free_after_compilation (cfun);
14008   cfun = NULL;
14009
14010   /* If this is a in-class inline definition, we may have to pop the
14011      bindings for the template parameters that we added in
14012      maybe_begin_member_template_processing when start_function was
14013      called.  */
14014   if (inclass_inline)
14015     maybe_end_member_template_processing ();
14016
14017   /* Leave the scope of the class.  */
14018   if (ctype)
14019     pop_nested_class ();
14020
14021   --function_depth;
14022
14023   /* Clean up.  */
14024   if (! nested)
14025     /* Let the error reporting routines know that we're outside a
14026        function.  For a nested function, this value is used in
14027        pop_cp_function_context and then reset via pop_function_context.  */
14028     current_function_decl = NULL_TREE;
14029
14030   return fndecl;
14031 }
14032 \f
14033 /* Create the FUNCTION_DECL for a function definition.
14034    DECLSPECS and DECLARATOR are the parts of the declaration;
14035    they describe the return type and the name of the function,
14036    but twisted together in a fashion that parallels the syntax of C.
14037
14038    This function creates a binding context for the function body
14039    as well as setting up the FUNCTION_DECL in current_function_decl.
14040
14041    Returns a FUNCTION_DECL on success.
14042
14043    If the DECLARATOR is not suitable for a function (it defines a datum
14044    instead), we return 0, which tells yyparse to report a parse error.
14045
14046    May return void_type_node indicating that this method is actually
14047    a friend.  See grokfield for more details.
14048
14049    Came here with a `.pushlevel' .
14050
14051    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14052    CHANGES TO CODE IN `grokfield'.  */
14053
14054 tree
14055 start_method (declspecs, declarator, attrlist)
14056      tree declarator, declspecs, attrlist;
14057 {
14058   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14059                                 attrlist);
14060
14061   /* Something too ugly to handle.  */
14062   if (fndecl == NULL_TREE)
14063     return NULL_TREE;
14064
14065   /* Pass friends other than inline friend functions back.  */
14066   if (fndecl == void_type_node)
14067     return fndecl;
14068
14069   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14070     /* Not a function, tell parser to report parse error.  */
14071     return NULL_TREE;
14072
14073   if (DECL_IN_AGGR_P (fndecl))
14074     {
14075       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14076         {
14077           if (DECL_CONTEXT (fndecl)
14078               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14079             cp_error ("`%D' is already defined in class `%T'", fndecl,
14080                       DECL_CONTEXT (fndecl));
14081         }
14082       return void_type_node;
14083     }
14084
14085   check_template_shadow (fndecl);
14086
14087   DECL_DECLARED_INLINE_P (fndecl) = 1;
14088
14089   if (flag_default_inline)
14090     DECL_INLINE (fndecl) = 1;
14091
14092   /* We process method specializations in finish_struct_1.  */
14093   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14094     fndecl = push_template_decl (fndecl);
14095
14096   if (! DECL_FRIEND_P (fndecl))
14097     {
14098       if (TREE_CHAIN (fndecl))
14099         {
14100           fndecl = copy_node (fndecl);
14101           TREE_CHAIN (fndecl) = NULL_TREE;
14102         }
14103
14104       if (DECL_CONSTRUCTOR_P (fndecl))
14105         {
14106           if (! grok_ctor_properties (current_class_type, fndecl))
14107             return void_type_node;
14108         }
14109       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14110         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14111     }
14112
14113   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14114
14115   /* Make a place for the parms */
14116   pushlevel (0);
14117   current_binding_level->parm_flag = 1;
14118
14119   DECL_IN_AGGR_P (fndecl) = 1;
14120   return fndecl;
14121 }
14122
14123 /* Go through the motions of finishing a function definition.
14124    We don't compile this method until after the whole class has
14125    been processed.
14126
14127    FINISH_METHOD must return something that looks as though it
14128    came from GROKFIELD (since we are defining a method, after all).
14129
14130    This is called after parsing the body of the function definition.
14131    STMTS is the chain of statements that makes up the function body.
14132
14133    DECL is the ..._DECL that `start_method' provided.  */
14134
14135 tree
14136 finish_method (decl)
14137      tree decl;
14138 {
14139   register tree fndecl = decl;
14140   tree old_initial;
14141
14142   register tree link;
14143
14144   if (decl == void_type_node)
14145     return decl;
14146
14147   old_initial = DECL_INITIAL (fndecl);
14148
14149   /* Undo the level for the parms (from start_method).
14150      This is like poplevel, but it causes nothing to be
14151      saved.  Saving information here confuses symbol-table
14152      output routines.  Besides, this information will
14153      be correctly output when this method is actually
14154      compiled.  */
14155
14156   /* Clear out the meanings of the local variables of this level;
14157      also record in each decl which block it belongs to.  */
14158
14159   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14160     {
14161       if (DECL_NAME (link) != NULL_TREE)
14162         pop_binding (DECL_NAME (link), link);
14163       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14164       DECL_CONTEXT (link) = NULL_TREE;
14165     }
14166
14167   GNU_xref_end_scope ((size_t) current_binding_level,
14168                       (size_t) current_binding_level->level_chain,
14169                       current_binding_level->parm_flag,
14170                       current_binding_level->keep);
14171
14172   poplevel (0, 0, 0);
14173
14174   DECL_INITIAL (fndecl) = old_initial;
14175
14176   /* We used to check if the context of FNDECL was different from
14177      current_class_type as another way to get inside here.  This didn't work
14178      for String.cc in libg++.  */
14179   if (DECL_FRIEND_P (fndecl))
14180     {
14181       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14182         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14183       decl = void_type_node;
14184     }
14185
14186   return decl;
14187 }
14188 \f
14189 /* Called when a new struct TYPE is defined.
14190    If this structure or union completes the type of any previous
14191    variable declaration, lay it out and output its rtl.  */
14192
14193 void
14194 hack_incomplete_structures (type)
14195      tree type;
14196 {
14197   tree *list;
14198   struct binding_level *level;
14199
14200   if (!type) /* Don't do this for class templates.  */
14201     return;
14202
14203   if (namespace_bindings_p ())
14204     {
14205       level = 0;
14206       list = &namespace_scope_incomplete;
14207     }
14208   else
14209     {
14210       level = innermost_nonclass_level ();
14211       list = &level->incomplete;
14212     }
14213
14214   while (1)
14215     {
14216       while (*list)
14217         {
14218           tree decl = TREE_VALUE (*list);
14219           if ((decl && TREE_TYPE (decl) == type)
14220               || (TREE_TYPE (decl)
14221                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14222                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14223             {
14224               int toplevel = toplevel_bindings_p ();
14225               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14226                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14227                 layout_type (TREE_TYPE (decl));
14228               layout_decl (decl, 0);
14229               rest_of_decl_compilation (decl, NULL, toplevel, 0);
14230               if (! toplevel)
14231                 {
14232                   tree cleanup;
14233                   expand_decl (decl);
14234                   cleanup = maybe_build_cleanup (decl);
14235                   expand_decl_init (decl);
14236                   if (! expand_decl_cleanup (decl, cleanup))
14237                     cp_error ("parser lost in parsing declaration of `%D'",
14238                               decl);
14239                 }
14240               *list = TREE_CHAIN (*list);
14241             }
14242           else
14243             list = &TREE_CHAIN (*list);
14244         }
14245
14246       /* Keep looking through artificial binding levels generated
14247          for local variables.  */
14248       if (level && level->keep == 2)
14249         {
14250           level = level->level_chain;
14251           list = &level->incomplete;
14252         }
14253       else
14254         break;
14255     }
14256 }
14257
14258 /* If DECL is of a type which needs a cleanup, build that cleanup
14259    here.  */
14260
14261 tree
14262 maybe_build_cleanup (decl)
14263      tree decl;
14264 {
14265   tree type = TREE_TYPE (decl);
14266
14267   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14268     {
14269       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14270       tree rval;
14271
14272       if (TREE_CODE (type) == ARRAY_TYPE)
14273         rval = decl;
14274       else
14275         {
14276           mark_addressable (decl);
14277           rval = build_unary_op (ADDR_EXPR, decl, 0);
14278         }
14279
14280       /* Optimize for space over speed here.  */
14281       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14282           || flag_expensive_optimizations)
14283         flags |= LOOKUP_NONVIRTUAL;
14284
14285       rval = build_delete (TREE_TYPE (rval), rval,
14286                            sfk_complete_destructor, flags, 0);
14287
14288       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14289           && ! TYPE_HAS_DESTRUCTOR (type))
14290         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14291                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14292
14293       return rval;
14294     }
14295   return 0;
14296 }
14297 \f
14298 /* When a stmt has been parsed, this function is called.  */
14299
14300 void
14301 finish_stmt ()
14302 {
14303   /* Always assume this statement was not an expression statement.  If
14304      it actually was an expression statement, its our callers
14305      responsibility to fix this up.  */
14306   last_expr_type = NULL_TREE;
14307 }
14308
14309 /* DECL was originally constructed as a non-static member function,
14310    but turned out to be static.  Update it accordingly.  */
14311
14312 void
14313 revert_static_member_fn (decl)
14314      tree decl;
14315 {
14316   tree tmp;
14317   tree function = TREE_TYPE (decl);
14318   tree args = TYPE_ARG_TYPES (function);
14319
14320   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14321       != TYPE_UNQUALIFIED)
14322     cp_error ("static member function `%#D' declared with type qualifiers",
14323               decl);
14324
14325   args = TREE_CHAIN (args);
14326   tmp = build_function_type (TREE_TYPE (function), args);
14327   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14328   tmp = build_exception_variant (tmp,
14329                                  TYPE_RAISES_EXCEPTIONS (function));
14330   TREE_TYPE (decl) = tmp;
14331   if (DECL_ARGUMENTS (decl))
14332     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14333   DECL_STATIC_FUNCTION_P (decl) = 1;
14334 }
14335
14336 /* Initialize the variables used during compilation of a C++
14337    function.  */
14338
14339 static void
14340 push_cp_function_context (f)
14341      struct function *f;
14342 {
14343   struct cp_language_function *p
14344     = ((struct cp_language_function *)
14345        xcalloc (1, sizeof (struct cp_language_function)));
14346   f->language = (struct language_function *) p;
14347
14348   /* It takes an explicit call to expand_body to generate RTL for a
14349      function.  */
14350   expanding_p = 0;
14351
14352   /* Whenever we start a new function, we destroy temporaries in the
14353      usual way.  */
14354   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14355 }
14356
14357 /* Free the language-specific parts of F, now that we've finished
14358    compiling the function.  */
14359
14360 static void
14361 pop_cp_function_context (f)
14362      struct function *f;
14363 {
14364   if (f->language)
14365     {
14366       struct cp_language_function *cp =
14367         (struct cp_language_function *) f->language;
14368       if (cp->x_local_names)
14369         VARRAY_FREE (cp->x_local_names);
14370       free (f->language);
14371     }
14372   f->language = 0;
14373 }
14374
14375 /* Mark P for GC.  */
14376
14377 static void
14378 mark_lang_function (p)
14379      struct cp_language_function *p;
14380 {
14381   if (!p)
14382     return;
14383
14384   mark_c_language_function (&p->base);
14385
14386   ggc_mark_tree (p->x_ctor_label);
14387   ggc_mark_tree (p->x_dtor_label);
14388   ggc_mark_tree (p->x_current_class_ptr);
14389   ggc_mark_tree (p->x_current_class_ref);
14390   ggc_mark_tree (p->x_eh_spec_block);
14391   ggc_mark_tree_varray (p->x_local_names);
14392
14393   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14394   mark_binding_level (&p->bindings);
14395 }
14396
14397 /* Mark the language-specific data in F for GC.  */
14398
14399 static void
14400 mark_cp_function_context (f)
14401      struct function *f;
14402 {
14403   mark_lang_function ((struct cp_language_function *) f->language);
14404 }
14405
14406 void
14407 lang_mark_tree (t)
14408      tree t;
14409 {
14410   enum tree_code code = TREE_CODE (t);
14411   if (code == IDENTIFIER_NODE)
14412     {
14413       struct lang_identifier *li = (struct lang_identifier *) t;
14414       struct lang_id2 *li2 = li->x;
14415       ggc_mark_tree (li->namespace_bindings);
14416       ggc_mark_tree (li->bindings);
14417       ggc_mark_tree (li->class_value);
14418       ggc_mark_tree (li->class_template_info);
14419
14420       if (li2)
14421         {
14422           ggc_mark_tree (li2->label_value);
14423           ggc_mark_tree (li2->implicit_decl);
14424           ggc_mark_tree (li2->error_locus);
14425         }
14426     }
14427   else if (code == CPLUS_BINDING)
14428     {
14429       if (BINDING_HAS_LEVEL_P (t))
14430         mark_binding_level (&BINDING_LEVEL (t));
14431       else
14432         ggc_mark_tree (BINDING_SCOPE (t));
14433       ggc_mark_tree (BINDING_VALUE (t));
14434     }
14435   else if (code == OVERLOAD)
14436     ggc_mark_tree (OVL_FUNCTION (t));
14437   else if (code == TEMPLATE_PARM_INDEX)
14438     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14439   else if (TREE_CODE_CLASS (code) == 'd')
14440     {
14441       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14442
14443       if (ld)
14444         {
14445           ggc_mark (ld);
14446           c_mark_lang_decl (&ld->decl_flags.base);
14447           if (!DECL_GLOBAL_CTOR_P (t)
14448               && !DECL_GLOBAL_DTOR_P (t)
14449               && !DECL_THUNK_P (t)
14450               && !DECL_DISCRIMINATOR_P (t))
14451             ggc_mark_tree (ld->decl_flags.u2.access);
14452           else if (DECL_THUNK_P (t))
14453             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14454           if (TREE_CODE (t) != NAMESPACE_DECL)
14455             ggc_mark_tree (ld->decl_flags.u.template_info);
14456           else
14457             mark_binding_level (&NAMESPACE_LEVEL (t));
14458           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14459             {
14460               ggc_mark_tree (ld->befriending_classes);
14461               ggc_mark_tree (ld->context);
14462               ggc_mark_tree (ld->cloned_function);
14463               ggc_mark_tree (ld->inlined_fns);
14464               if (TREE_CODE (t) == TYPE_DECL)
14465                 ggc_mark_tree (ld->u.sorted_fields);
14466               else if (TREE_CODE (t) == FUNCTION_DECL
14467                        && !DECL_PENDING_INLINE_P (t))
14468                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14469             }
14470         }
14471     }
14472   else if (TREE_CODE_CLASS (code) == 't')
14473     {
14474       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14475
14476       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14477                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14478         {
14479           ggc_mark (lt);
14480           ggc_mark_tree (lt->primary_base);
14481           ggc_mark_tree (lt->vfields);
14482           ggc_mark_tree (lt->vbases);
14483           ggc_mark_tree (lt->tags);
14484           ggc_mark_tree (lt->size);
14485           ggc_mark_tree (lt->pure_virtuals);
14486           ggc_mark_tree (lt->friend_classes);
14487           ggc_mark_tree (lt->rtti);
14488           ggc_mark_tree (lt->methods);
14489           ggc_mark_tree (lt->template_info);
14490           ggc_mark_tree (lt->befriending_classes);
14491         }
14492       else if (lt)
14493         /* In the case of pointer-to-member function types, the
14494            TYPE_LANG_SPECIFIC is really just a tree.  */
14495         ggc_mark_tree ((tree) lt);
14496     }
14497 }
14498
14499 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14500    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
14501
14502 tree
14503 identifier_global_value (t)
14504      tree t;
14505 {
14506   return IDENTIFIER_GLOBAL_VALUE (t);
14507 }
14508
14509 /* Build the void_list_node (void_type_node having been created).  */
14510 tree
14511 build_void_list_node ()
14512 {
14513   tree t = build_tree_list (NULL_TREE, void_type_node);
14514   TREE_PARMLIST (t) = 1;
14515   return t;
14516 }
14517
14518 static int
14519 cp_missing_noreturn_ok_p (decl)
14520      tree decl;
14521 {
14522   /* A missing noreturn is ok for the `main' function.  */
14523   return DECL_MAIN_P (decl);
14524 }