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, 2002  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 "coretypes.h"
  34 #include "tm.h"
  35 #include "tree.h"
  36 #include "rtl.h"
  37 #include "expr.h"
  38 #include "flags.h"
  39 #include "cp-tree.h"
  40 #include "tree-inline.h"
  41 #include "decl.h"
  42 #include "lex.h"
  43 #include "output.h"
  44 #include "except.h"
  45 #include "toplev.h"
  46 #include "hashtab.h"
  47 #include "ggc.h"
  48 #include "tm_p.h"
  49 #include "target.h"
  50 #include "c-common.h"
  51 #include "c-pragma.h"
  52 #include "diagnostic.h"
  53 #include "debug.h"
  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 cp_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 cp_binding_level *));
  63 static struct cp_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 lookup_name_real PARAMS ((tree, int, int, int));
  73 static void push_local_name PARAMS ((tree));
  74 static void warn_extern_redeclared_static PARAMS ((tree, tree));
  75 static tree grok_reference_init PARAMS ((tree, tree, tree));
  76 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
  77                               enum overload_flags, tree,
  78                               tree, int, int, int, int, int, int, tree));
  79 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
  80 static tree follow_tag_typedef PARAMS ((tree));
  81 static tree lookup_tag PARAMS ((enum tree_code, tree,
  82                               struct cp_binding_level *, int));
  83 static void set_identifier_type_value_with_scope
  84         PARAMS ((tree, tree, struct cp_binding_level *));
  85 static void record_unknown_type PARAMS ((tree, const char *));
  86 static tree builtin_function_1 PARAMS ((const char *, tree, tree, int,
  87                                       enum built_in_class, const char *,
  88                                       tree));
  89 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
  90 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
  91 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
  92                                   int));
  93 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct cp_binding_level*));
  94 static void check_for_uninitialized_const_var PARAMS ((tree));
  95 static hashval_t typename_hash PARAMS ((const void *));
  96 static int typename_compare PARAMS ((const void *, const void *));
  97 static void push_binding PARAMS ((tree, tree, struct cp_binding_level*));
  98 static int add_binding PARAMS ((tree, tree));
  99 static void pop_binding PARAMS ((tree, tree));
 100 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 101 static tree find_binding PARAMS ((tree, tree));
 102 static tree select_decl PARAMS ((tree, int));
 103 static int lookup_flags PARAMS ((int, int));
 104 static tree qualify_lookup PARAMS ((tree, int));
 105 static tree record_builtin_java_type PARAMS ((const char *, int));
 106 static const char *tag_name PARAMS ((enum tag_types code));
 107 static void find_class_binding_level PARAMS ((void));
 108 static struct cp_binding_level *innermost_nonclass_level PARAMS ((void));
 109 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 110 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 111 static int walk_globals_r PARAMS ((tree, void *));
 112 static int walk_vtables_r PARAMS ((tree, void*));
 113 static void add_decl_to_level PARAMS ((tree, struct cp_binding_level *));
 114 static tree make_label_decl PARAMS ((tree, int));
 115 static void use_label PARAMS ((tree));
 116 static void check_previous_goto_1 PARAMS ((tree, struct cp_binding_level *, tree,
 117                                            const char *, int));
 118 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 119 static void check_switch_goto PARAMS ((struct cp_binding_level *));
 120 static void check_previous_gotos PARAMS ((tree));
 121 static void pop_label PARAMS ((tree, tree));
 122 static void pop_labels PARAMS ((tree));
 123 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 124 static void layout_var_decl PARAMS ((tree));
 125 static void maybe_commonize_var PARAMS ((tree));
 126 static tree check_initializer (tree, tree, int);
 127 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 128 static void save_function_data PARAMS ((tree));
 129 static void check_function_type PARAMS ((tree, tree));
 130 static void begin_constructor_body PARAMS ((void));
 131 static void finish_constructor_body PARAMS ((void));
 132 static void begin_destructor_body PARAMS ((void));
 133 static void finish_destructor_body PARAMS ((void));
 134 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 135 static tree get_atexit_node PARAMS ((void));
 136 static tree get_dso_handle_node PARAMS ((void));
 137 static tree start_cleanup_fn PARAMS ((void));
 138 static void end_cleanup_fn PARAMS ((void));
 139 static tree cp_make_fname_decl PARAMS ((tree, int));
 140 static void initialize_predefined_identifiers PARAMS ((void));
 141 static tree check_special_function_return_type
 142   PARAMS ((special_function_kind, tree, tree));
 143 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 144 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 145 static void store_parm_decls PARAMS ((tree));
 146 static int cp_missing_noreturn_ok_p PARAMS ((tree));
 147 static void initialize_local_var (tree, tree);
 148 static void expand_static_init (tree, tree);
 149 static tree next_initializable_field (tree);
 150 static tree reshape_init (tree, tree *);
 151
 152 #if defined (DEBUG_BINDING_LEVELS)
 153 static void indent PARAMS ((void));
 154 #endif
 155
 156 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 157 tree error_mark_list;
 158
 159 /* The following symbols are subsumed in the cp_global_trees array, and
 160    listed here individually for documentation purposes.
 161
 162    C++ extensions
 163         tree wchar_decl_node;
 164
 165         tree vtable_entry_type;
 166         tree delta_type_node;
 167         tree __t_desc_type_node;
 168         tree ti_desc_type_node;
 169         tree bltn_desc_type_node, ptr_desc_type_node;
 170         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 171         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 172         tree ptm_desc_type_node;
 173         tree base_desc_type_node;
 174
 175         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 176         tree unknown_type_node;
 177
 178    Array type `vtable_entry_type[]'
 179
 180         tree vtbl_type_node;
 181         tree vtbl_ptr_type_node;
 182
 183    Namespaces,
 184
 185         tree std_node;
 186         tree abi_node;
 187
 188    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 189    one that the user will declare, but sufficient to be called
 190    by routines that want to abort the program.
 191
 192         tree abort_fndecl;
 193
 194    The FUNCTION_DECL for the default `::operator delete'.
 195
 196         tree global_delete_fndecl;
 197
 198    Used by RTTI
 199         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 200         tree tinfo_var_id;
 201
 202 */
 203
 204 tree cp_global_trees[CPTI_MAX];
 205
 206 /* Indicates that there is a type value in some namespace, although
 207    that is not necessarily in scope at the moment.  */
 208
 209 static GTY(()) tree global_type_node;
 210
 211 /* Expect only namespace names now.  */
 212 static int only_namespace_names;
 213
 214 /* Used only for jumps to as-yet undefined labels, since jumps to
 215    defined labels can have their validity checked immediately.  */
 216
 217 struct named_label_use_list GTY(())
 218 {
 219   struct cp_binding_level *binding_level;
 220   tree names_in_scope;
 221   tree label_decl;
 222   const char *filename_o_goto;
 223   int lineno_o_goto;
 224   struct named_label_use_list *next;
 225 };
 226
 227 #define named_label_uses cp_function_chain->x_named_label_uses
 228
 229 #define local_names cp_function_chain->x_local_names
 230
 231 /* A list of objects which have constructors or destructors
 232    which reside in the global scope.  The decl is stored in
 233    the TREE_VALUE slot and the initializer is stored
 234    in the TREE_PURPOSE slot.  */
 235 tree static_aggregates;
 236
 237 /* -- end of C++ */
 238
 239 /* A node for the integer constants 2, and 3.  */
 240
 241 tree integer_two_node, integer_three_node;
 242
 243 /* Similar, for last_function_parm_tags.  */
 244 tree last_function_parms;
 245
 246 /* A list of all LABEL_DECLs in the function that have names.  Here so
 247    we can clear out their names' definitions at the end of the
 248    function, and so we can check the validity of jumps to these labels.  */
 249
 250 struct named_label_list GTY(())
 251 {
 252   struct cp_binding_level *binding_level;
 253   tree names_in_scope;
 254   tree old_value;
 255   tree label_decl;
 256   tree bad_decls;
 257   struct named_label_list *next;
 258   unsigned int in_try_scope : 1;
 259   unsigned int in_catch_scope : 1;
 260 };
 261
 262 #define named_labels cp_function_chain->x_named_labels
 263 \f
 264 /* The name of the anonymous namespace, throughout this translation
 265    unit.  */
 266 tree anonymous_namespace_name;
 267
 268 /* The number of function bodies which we are currently processing.
 269    (Zero if we are at namespace scope, one inside the body of a
 270    function, two inside the body of a function in a local class, etc.)  */
 271 int function_depth;
 272
 273 /* States indicating how grokdeclarator() should handle declspecs marked
 274    with __attribute__((deprecated)).  An object declared as
 275    __attribute__((deprecated)) suppresses warnings of uses of other
 276    deprecated items.  */
 277
 278 enum deprecated_states {
 279   DEPRECATED_NORMAL,
 280   DEPRECATED_SUPPRESS
 281 };
 282
 283 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
 284
 285 /* Set by add_implicitly_declared_members() to keep those members from
 286    being flagged as deprecated or reported as using deprecated
 287    types.  */
 288 int adding_implicit_members = 0;
 289
 290 /* True if a declaration with an `extern' linkage specifier is being
 291    processed.  */
 292 bool have_extern_spec;
 293
 294 \f
 295 /* For each binding contour we allocate a binding_level structure
 296    which records the names defined in that contour.
 297    Contours include:
 298     0) the global one
 299     1) one for each function definition,
 300        where internal declarations of the parameters appear.
 301     2) one for each compound statement,
 302        to record its declarations.
 303
 304    The current meaning of a name can be found by searching the levels
 305    from the current one out to the global one.
 306
 307    Off to the side, may be the class_binding_level.  This exists only
 308    to catch class-local declarations.  It is otherwise nonexistent.
 309
 310    Also there may be binding levels that catch cleanups that must be
 311    run when exceptions occur.  Thus, to see whether a name is bound in
 312    the current scope, it is not enough to look in the
 313    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 314    instead.  */
 315
 316 /* Note that the information in the `names' component of the global contour
 317    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 318
 319 struct cp_binding_level GTY(())
 320   {
 321     /* A chain of _DECL nodes for all variables, constants, functions,
 322        and typedef types.  These are in the reverse of the order
 323        supplied.  There may be OVERLOADs on this list, too, but they
 324        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 325     tree names;
 326
 327     /* Count of elements in names chain.  */
 328     size_t names_size;
 329
 330     /* A chain of NAMESPACE_DECL nodes.  */
 331     tree namespaces;
 332
 333     /* A chain of VTABLE_DECL nodes.  */
 334     tree vtables;
 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 cp_binding_level *level_chain;
 379
 380     /* List of VAR_DECLS saved from a previous for statement.
 381        These would be dead in ISO-conforming code, but might
 382        be referenced in ARM-era code.  These are stored in a
 383        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 384     tree dead_vars_from_for;
 385
 386     /* 1 for the level that holds the parameters of a function.
 387        2 for the level that holds a class declaration.  */
 388     unsigned parm_flag : 2;
 389
 390     /* 1 means make a BLOCK for this level regardless of all else.
 391        2 for temporary binding contours created by the compiler.  */
 392     unsigned keep : 2;
 393
 394     /* Nonzero if this level "doesn't exist" for tags.  */
 395     unsigned tag_transparent : 1;
 396
 397     /* Nonzero if this level can safely have additional
 398        cleanup-needing variables added to it.  */
 399     unsigned more_cleanups_ok : 1;
 400     unsigned have_cleanups : 1;
 401
 402     /* Nonzero if this scope is for storing the decls for template
 403        parameters and generic decls; these decls will be discarded and
 404        replaced with a TEMPLATE_DECL.  */
 405     unsigned template_parms_p : 1;
 406
 407     /* Nonzero if this scope corresponds to the `<>' in a
 408        `template <>' clause.  Whenever this flag is set,
 409        TEMPLATE_PARMS_P will be set as well.  */
 410     unsigned template_spec_p : 1;
 411
 412     /* This is set for a namespace binding level.  */
 413     unsigned namespace_p : 1;
 414
 415     /* True if this level is that of a for-statement where we need to
 416        worry about ambiguous (ARM or ISO) scope rules.  */
 417     unsigned is_for_scope : 1;
 418
 419     /* True if this level corresponds to a TRY block.  Currently this
 420        information is only available while building the tree structure.  */
 421     unsigned is_try_scope : 1;
 422
 423     /* True if this level corresponds to a CATCH block.  Currently this
 424        information is only available while building the tree structure.  */
 425     unsigned is_catch_scope : 1;
 426
 427     /* Three bits left for this word.  */
 428
 429     /* Binding depth at which this level began.  */
 430     unsigned binding_depth;
 431   };
 432
 433 #define NULL_BINDING_LEVEL ((struct cp_binding_level *) NULL)
 434
 435 /* The binding level currently in effect.  */
 436
 437 #define current_binding_level                   \
 438   (cfun && cp_function_chain->bindings          \
 439    ? cp_function_chain->bindings                \
 440    : scope_chain->bindings)
 441
 442 /* The binding level of the current class, if any.  */
 443
 444 #define class_binding_level scope_chain->class_bindings
 445
 446 /* A chain of binding_level structures awaiting reuse.  */
 447
 448 static GTY((deletable (""))) struct cp_binding_level *free_binding_level;
 449
 450 /* The outermost binding level, for names of file scope.
 451    This is created when the compiler is started and exists
 452    through the entire run.  */
 453
 454 static GTY(()) struct cp_binding_level *global_binding_level;
 455
 456 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 457
 458 static int keep_next_level_flag;
 459
 460 /* A TREE_LIST of VAR_DECLs.  The TREE_PURPOSE is a RECORD_TYPE or
 461    UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type.  At the
 462    time the VAR_DECL was declared, the type was incomplete.  */
 463
 464 static GTY(()) tree incomplete_vars;
 465
 466 #if defined(DEBUG_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_BINDING_LEVELS) */
 479
 480 static tree pushdecl_with_scope PARAMS ((tree, struct cp_binding_level *));
 481
 482 static void
 483 push_binding_level (newlevel, tag_transparent, keep)
 484      struct cp_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 cp_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_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_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 cp_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         abort ();
 530     }
 531   /* Pop the current level, and free the structure for reuse.  */
 532 #if defined(DEBUG_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_BINDING_LEVELS) */
 545   {
 546     register struct cp_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_BINDING_LEVELS) */
 550     if (level->binding_depth != binding_depth)
 551       abort ();
 552 #endif /* defined(DEBUG_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         abort ();
 569     }
 570   /* Suspend the current level.  */
 571 #if defined(DEBUG_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_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 cp_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_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_BINDING_LEVELS) */
 606 }
 607 \f
 608 /* Create a new `struct cp_binding_level'.  */
 609
 610 static
 611 struct cp_binding_level *
 612 make_binding_level ()
 613 {
 614   /* NOSTRICT */
 615   return (struct cp_binding_level *) ggc_alloc (sizeof (struct cp_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 cp_binding_level *
 629 innermost_nonclass_level ()
 630 {
 631   struct cp_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 cp_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 cp_binding_level *b = innermost_nonclass_level ();
 662
 663   return b->namespace_p;
 664 }
 665
 666 /* If KEEP is nonzero, 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 nonzero 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 cp_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 invalid 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 invalid; 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 cp_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_BINDING_LEVELS)
 815   if (0)
 816 #else /* !defined(DEBUG_BINDING_LEVELS) */
 817   if (free_binding_level)
 818 #endif /* !defined(DEBUG_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   keep_next_level_flag = 0;
 828 }
 829
 830 /* We're defining an object of type TYPE.  If it needs a cleanup, but
 831    we're not allowed to add any more objects with cleanups to the current
 832    scope, create a new binding level.  */
 833
 834 void
 835 maybe_push_cleanup_level (type)
 836      tree type;
 837 {
 838   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
 839       && current_binding_level->more_cleanups_ok == 0)
 840     {
 841       keep_next_level (2);
 842       pushlevel (1);
 843       clear_last_expr ();
 844       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
 845     }
 846 }
 847
 848 /* Enter a new scope.  The KIND indicates what kind of scope is being
 849    created.  */
 850
 851 void
 852 begin_scope (sk)
 853      scope_kind sk;
 854 {
 855   pushlevel (0);
 856
 857   switch (sk)
 858     {
 859     case sk_template_spec:
 860       current_binding_level->template_spec_p = 1;
 861       /* Fall through.  */
 862
 863     case sk_template_parms:
 864       current_binding_level->template_parms_p = 1;
 865       break;
 866
 867     default:
 868       abort ();
 869     }
 870 }
 871
 872 /* Exit the current scope.  */
 873
 874 void
 875 finish_scope ()
 876 {
 877   poplevel (0, 0, 0);
 878 }
 879
 880 void
 881 note_level_for_for ()
 882 {
 883   current_binding_level->is_for_scope = 1;
 884 }
 885
 886 /* Record that the current binding level represents a try block.  */
 887
 888 void
 889 note_level_for_try ()
 890 {
 891   current_binding_level->is_try_scope = 1;
 892 }
 893
 894 /* Record that the current binding level represents a catch block.  */
 895
 896 void
 897 note_level_for_catch ()
 898 {
 899   current_binding_level->is_catch_scope = 1;
 900 }
 901
 902 /* For a binding between a name and an entity at a block scope,
 903    this is the `struct cp_binding_level' for the block.  */
 904 #define BINDING_LEVEL(NODE) \
 905   (((struct tree_binding*)(NODE))->scope.level)
 906
 907 /* A free list of CPLUS_BINDING nodes, connected by their
 908    TREE_CHAINs.  */
 909
 910 static GTY((deletable (""))) tree free_bindings;
 911
 912 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 913    level at which this declaration is being bound.  */
 914
 915 static void
 916 push_binding (id, decl, level)
 917      tree id;
 918      tree decl;
 919      struct cp_binding_level* level;
 920 {
 921   tree binding;
 922
 923   if (free_bindings)
 924     {
 925       binding = free_bindings;
 926       free_bindings = TREE_CHAIN (binding);
 927     }
 928   else
 929     binding = make_node (CPLUS_BINDING);
 930
 931   /* Now, fill in the binding information.  */
 932   BINDING_VALUE (binding) = decl;
 933   BINDING_TYPE (binding) = NULL_TREE;
 934   BINDING_LEVEL (binding) = level;
 935   INHERITED_VALUE_BINDING_P (binding) = 0;
 936   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 937   BINDING_HAS_LEVEL_P (binding) = 1;
 938
 939   /* And put it on the front of the list of bindings for ID.  */
 940   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 941   IDENTIFIER_BINDING (id) = binding;
 942 }
 943
 944 /* ID is already bound in the current scope.  But, DECL is an
 945    additional binding for ID in the same scope.  This is the `struct
 946    stat' hack whereby a non-typedef class-name or enum-name can be
 947    bound at the same level as some other kind of entity.  It's the
 948    responsibility of the caller to check that inserting this name is
 949    valid here.  Returns nonzero if the new binding was successful.  */
 950 static int
 951 add_binding (id, decl)
 952      tree id;
 953      tree decl;
 954 {
 955   tree binding = IDENTIFIER_BINDING (id);
 956   int ok = 1;
 957
 958   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 959     /* The new name is the type name.  */
 960     BINDING_TYPE (binding) = decl;
 961   else if (!BINDING_VALUE (binding))
 962     /* This situation arises when push_class_level_binding moves an
 963        inherited type-binding out of the way to make room for a new
 964        value binding.  */
 965     BINDING_VALUE (binding) = decl;
 966   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 967            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 968     {
 969       /* The old binding was a type name.  It was placed in
 970          BINDING_VALUE because it was thought, at the point it was
 971          declared, to be the only entity with such a name.  Move the
 972          type name into the type slot; it is now hidden by the new
 973          binding.  */
 974       BINDING_TYPE (binding) = BINDING_VALUE (binding);
 975       BINDING_VALUE (binding) = decl;
 976       INHERITED_VALUE_BINDING_P (binding) = 0;
 977     }
 978   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 979            && TREE_CODE (decl) == TYPE_DECL
 980            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
 981            && (same_type_p (TREE_TYPE (decl),
 982                             TREE_TYPE (BINDING_VALUE (binding)))
 983                /* If either type involves template parameters, we must
 984                   wait until instantiation.  */
 985                || uses_template_parms (TREE_TYPE (decl))
 986                || uses_template_parms (TREE_TYPE (BINDING_VALUE (binding)))))
 987     /* We have two typedef-names, both naming the same type to have
 988        the same name.  This is OK because of:
 989
 990          [dcl.typedef]
 991
 992          In a given scope, a typedef specifier can be used to redefine
 993          the name of any type declared in that scope to refer to the
 994          type to which it already refers.  */
 995     ok = 0;
 996   /* There can be two block-scope declarations of the same variable,
 997      so long as they are `extern' declarations.  */
 998   else if (TREE_CODE (decl) == VAR_DECL
 999            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1000            && DECL_EXTERNAL (decl)
1001            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1002     {
1003       duplicate_decls (decl, BINDING_VALUE (binding));
1004       ok = 0;
1005     }
1006   else
1007     {
1008       error ("declaration of `%#D'", decl);
1009       cp_error_at ("conflicts with previous declaration `%#D'",
1010                    BINDING_VALUE (binding));
1011       ok = 0;
1012     }
1013
1014   return ok;
1015 }
1016
1017 /* Add DECL to the list of things declared in B.  */
1018
1019 static void
1020 add_decl_to_level (decl, b)
1021      tree decl;
1022      struct cp_binding_level *b;
1023 {
1024   if (TREE_CODE (decl) == NAMESPACE_DECL
1025       && !DECL_NAMESPACE_ALIAS (decl))
1026     {
1027       TREE_CHAIN (decl) = b->namespaces;
1028       b->namespaces = decl;
1029     }
1030   else if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
1031     {
1032       TREE_CHAIN (decl) = b->vtables;
1033       b->vtables = decl;
1034     }
1035   else
1036     {
1037       /* We build up the list in reverse order, and reverse it later if
1038          necessary.  */
1039       TREE_CHAIN (decl) = b->names;
1040       b->names = decl;
1041       b->names_size++;
1042     }
1043 }
1044
1045 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1046    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1047    doesn't really belong to this binding level, that it got here
1048    through a using-declaration.  */
1049
1050 void
1051 push_local_binding (id, decl, flags)
1052      tree id;
1053      tree decl;
1054      int flags;
1055 {
1056   struct cp_binding_level *b;
1057
1058   /* Skip over any local classes.  This makes sense if we call
1059      push_local_binding with a friend decl of a local class.  */
1060   b = current_binding_level;
1061   while (b->parm_flag == 2)
1062     b = b->level_chain;
1063
1064   if (lookup_name_current_level (id))
1065     {
1066       /* Supplement the existing binding.  */
1067       if (!add_binding (id, decl))
1068         /* It didn't work.  Something else must be bound at this
1069            level.  Do not add DECL to the list of things to pop
1070            later.  */
1071         return;
1072     }
1073   else
1074     /* Create a new binding.  */
1075     push_binding (id, decl, b);
1076
1077   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1078     /* We must put the OVERLOAD into a TREE_LIST since the
1079        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1080        decls that got here through a using-declaration.  */
1081     decl = build_tree_list (NULL_TREE, decl);
1082
1083   /* And put DECL on the list of things declared by the current
1084      binding level.  */
1085   add_decl_to_level (decl, b);
1086 }
1087
1088 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1089    binding was successful.  */
1090
1091 int
1092 push_class_binding (id, decl)
1093      tree id;
1094      tree decl;
1095 {
1096   int result = 1;
1097   tree binding = IDENTIFIER_BINDING (id);
1098   tree context;
1099
1100   /* Note that we declared this value so that we can issue an error if
1101      this is an invalid redeclaration of a name already used for some
1102      other purpose.  */
1103   note_name_declared_in_class (id, decl);
1104
1105   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1106     /* Supplement the existing binding.  */
1107     result = add_binding (id, decl);
1108   else
1109     /* Create a new binding.  */
1110     push_binding (id, decl, class_binding_level);
1111
1112   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1113      class-level declaration.  Note that we do not use DECL here
1114      because of the possibility of the `struct stat' hack; if DECL is
1115      a class-name or enum-name we might prefer a field-name, or some
1116      such.  */
1117   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1118
1119   /* If this is a binding from a base class, mark it as such.  */
1120   binding = IDENTIFIER_BINDING (id);
1121   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1122     {
1123       /* Any implicit typename must be from a base-class.  The
1124          context for an implicit typename declaration is always
1125          the derived class in which the lookup was done, so the checks
1126          based on the context of DECL below will not trigger.  */
1127       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1128         INHERITED_VALUE_BINDING_P (binding) = 1;
1129       else
1130         {
1131           if (TREE_CODE (decl) == OVERLOAD)
1132             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1133           else
1134             {
1135               my_friendly_assert (DECL_P (decl), 0);
1136               context = context_for_name_lookup (decl);
1137             }
1138
1139           if (is_properly_derived_from (current_class_type, context))
1140             INHERITED_VALUE_BINDING_P (binding) = 1;
1141           else
1142             INHERITED_VALUE_BINDING_P (binding) = 0;
1143         }
1144     }
1145   else if (BINDING_VALUE (binding) == decl)
1146     /* We only encounter a TREE_LIST when push_class_decls detects an
1147        ambiguity.  Such an ambiguity can be overridden by a definition
1148        in this class.  */
1149     INHERITED_VALUE_BINDING_P (binding) = 1;
1150
1151   return result;
1152 }
1153
1154 /* Remove the binding for DECL which should be the innermost binding
1155    for ID.  */
1156
1157 static void
1158 pop_binding (id, decl)
1159      tree id;
1160      tree decl;
1161 {
1162   tree binding;
1163
1164   if (id == NULL_TREE)
1165     /* It's easiest to write the loops that call this function without
1166        checking whether or not the entities involved have names.  We
1167        get here for such an entity.  */
1168     return;
1169
1170   /* Get the innermost binding for ID.  */
1171   binding = IDENTIFIER_BINDING (id);
1172
1173   /* The name should be bound.  */
1174   my_friendly_assert (binding != NULL_TREE, 0);
1175
1176   /* The DECL will be either the ordinary binding or the type
1177      binding for this identifier.  Remove that binding.  */
1178   if (BINDING_VALUE (binding) == decl)
1179     BINDING_VALUE (binding) = NULL_TREE;
1180   else if (BINDING_TYPE (binding) == decl)
1181     BINDING_TYPE (binding) = NULL_TREE;
1182   else
1183     abort ();
1184
1185   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1186     {
1187       /* We're completely done with the innermost binding for this
1188          identifier.  Unhook it from the list of bindings.  */
1189       IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1190
1191       /* Add it to the free list.  */
1192       TREE_CHAIN (binding) = free_bindings;
1193       free_bindings = binding;
1194
1195       /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
1196          it.  */
1197       BINDING_LEVEL (binding) = NULL;
1198     }
1199 }
1200
1201 /* When a label goes out of scope, check to see if that label was used
1202    in a valid manner, and issue any appropriate warnings or errors.  */
1203
1204 static void
1205 pop_label (label, old_value)
1206      tree label;
1207      tree old_value;
1208 {
1209   if (!processing_template_decl && doing_semantic_analysis_p ())
1210     {
1211       if (DECL_INITIAL (label) == NULL_TREE)
1212         {
1213           cp_error_at ("label `%D' used but not defined", label);
1214           /* Avoid crashing later.  */
1215           define_label (input_filename, 1, DECL_NAME (label));
1216         }
1217       else if (warn_unused_label && !TREE_USED (label))
1218         cp_warning_at ("label `%D' defined but not used", label);
1219     }
1220
1221   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1222 }
1223
1224 /* At the end of a function, all labels declared within the function
1225    go out of scope.  BLOCK is the top-level block for the
1226    function.  */
1227
1228 static void
1229 pop_labels (block)
1230      tree block;
1231 {
1232   struct named_label_list *link;
1233
1234   /* Clear out the definitions of all label names, since their scopes
1235      end here.  */
1236   for (link = named_labels; link; link = link->next)
1237     {
1238       pop_label (link->label_decl, link->old_value);
1239       /* Put the labels into the "variables" of the top-level block,
1240          so debugger can see them.  */
1241       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1242       BLOCK_VARS (block) = link->label_decl;
1243     }
1244
1245   named_labels = NULL;
1246 }
1247
1248 /* Exit a binding level.
1249    Pop the level off, and restore the state of the identifier-decl mappings
1250    that were in effect when this level was entered.
1251
1252    If KEEP == 1, this level had explicit declarations, so
1253    and create a "block" (a BLOCK node) for the level
1254    to record its declarations and subblocks for symbol table output.
1255
1256    If FUNCTIONBODY is nonzero, this level is the body of a function,
1257    so create a block as if KEEP were set and also clear out all
1258    label names.
1259
1260    If REVERSE is nonzero, reverse the order of decls before putting
1261    them into the BLOCK.  */
1262
1263 tree
1264 poplevel (keep, reverse, functionbody)
1265      int keep;
1266      int reverse;
1267      int functionbody;
1268 {
1269   register tree link;
1270   /* The chain of decls was accumulated in reverse order.
1271      Put it into forward order, just for cleanliness.  */
1272   tree decls;
1273   int tmp = functionbody;
1274   int real_functionbody;
1275   tree tags;
1276   tree subblocks;
1277   tree block = NULL_TREE;
1278   tree decl;
1279   int leaving_for_scope;
1280
1281   if (cfun && !doing_semantic_analysis_p ())
1282     return NULL_TREE;
1283
1284   my_friendly_assert (current_binding_level->parm_flag != 2,
1285                       19990916);
1286
1287   real_functionbody = (current_binding_level->keep == 2
1288                        ? ((functionbody = 0), tmp) : functionbody);
1289   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1290   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1291
1292   my_friendly_assert (!current_binding_level->class_shadowed,
1293                       19990414);
1294
1295   /* We used to use KEEP == 2 to indicate that the new block should go
1296      at the beginning of the list of blocks at this binding level,
1297      rather than the end.  This hack is no longer used.  */
1298   my_friendly_assert (keep == 0 || keep == 1, 0);
1299
1300   if (current_binding_level->keep == 1)
1301     keep = 1;
1302
1303   /* Any uses of undefined labels, and any defined labels, now operate
1304      under constraints of next binding contour.  */
1305   if (cfun && !functionbody)
1306     {
1307       struct cp_binding_level *level_chain;
1308       level_chain = current_binding_level->level_chain;
1309       if (level_chain)
1310         {
1311           struct named_label_use_list *uses;
1312           struct named_label_list *labels;
1313           for (labels = named_labels; labels; labels = labels->next)
1314             if (labels->binding_level == current_binding_level)
1315               {
1316                 tree decl;
1317                 if (current_binding_level->is_try_scope)
1318                   labels->in_try_scope = 1;
1319                 if (current_binding_level->is_catch_scope)
1320                   labels->in_catch_scope = 1;
1321                 for (decl = labels->names_in_scope; decl;
1322                      decl = TREE_CHAIN (decl))
1323                   if (decl_jump_unsafe (decl))
1324                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1325                                                    labels->bad_decls);
1326                 labels->binding_level = level_chain;
1327                 labels->names_in_scope = level_chain->names;
1328               }
1329
1330           for (uses = named_label_uses; uses; uses = uses->next)
1331             if (uses->binding_level == current_binding_level)
1332               {
1333                 uses->binding_level = level_chain;
1334                 uses->names_in_scope = level_chain->names;
1335               }
1336         }
1337     }
1338
1339   /* Get the decls in the order they were written.
1340      Usually current_binding_level->names is in reverse order.
1341      But parameter decls were previously put in forward order.  */
1342
1343   if (reverse)
1344     current_binding_level->names
1345       = decls = nreverse (current_binding_level->names);
1346   else
1347     decls = current_binding_level->names;
1348
1349   /* Output any nested inline functions within this block
1350      if they weren't already output.  */
1351   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1352     if (TREE_CODE (decl) == FUNCTION_DECL
1353         && ! TREE_ASM_WRITTEN (decl)
1354         && DECL_INITIAL (decl) != NULL_TREE
1355         && TREE_ADDRESSABLE (decl)
1356         && decl_function_context (decl) == current_function_decl)
1357       {
1358         /* If this decl was copied from a file-scope decl
1359            on account of a block-scope extern decl,
1360            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1361         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1362           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1363         else
1364           {
1365             push_function_context ();
1366             output_inline_function (decl);
1367             pop_function_context ();
1368           }
1369       }
1370
1371   /* When not in function-at-a-time mode, expand_end_bindings will
1372      warn about unused variables.  But, in function-at-a-time mode
1373      expand_end_bindings is not passed the list of variables in the
1374      current scope, and therefore no warning is emitted.  So, we
1375      explicitly warn here.  */
1376   if (!processing_template_decl)
1377     warn_about_unused_variables (getdecls ());
1378
1379   /* If there were any declarations or structure tags in that level,
1380      or if this level is a function body,
1381      create a BLOCK to record them for the life of this function.  */
1382   block = NULL_TREE;
1383   if (keep == 1 || functionbody)
1384     block = make_node (BLOCK);
1385   if (block != NULL_TREE)
1386     {
1387       BLOCK_VARS (block) = decls;
1388       BLOCK_SUBBLOCKS (block) = subblocks;
1389     }
1390
1391   /* In each subblock, record that this is its superior.  */
1392   if (keep >= 0)
1393     for (link = subblocks; link; link = TREE_CHAIN (link))
1394       BLOCK_SUPERCONTEXT (link) = block;
1395
1396   /* We still support the old for-scope rules, whereby the variables
1397      in a for-init statement were in scope after the for-statement
1398      ended.  We only use the new rules in flag_new_for_scope is
1399      nonzero.  */
1400   leaving_for_scope
1401     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1402
1403   /* Remove declarations for all the DECLs in this level.  */
1404   for (link = decls; link; link = TREE_CHAIN (link))
1405     {
1406       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1407           && DECL_NAME (link))
1408         {
1409           tree outer_binding
1410             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1411           tree ns_binding;
1412
1413           if (!outer_binding)
1414             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1415           else
1416             ns_binding = NULL_TREE;
1417
1418           if (outer_binding
1419               && (BINDING_LEVEL (outer_binding)
1420                   == current_binding_level->level_chain))
1421             /* We have something like:
1422
1423                  int i;
1424                  for (int i; ;);
1425
1426                and we are leaving the `for' scope.  There's no reason to
1427                keep the binding of the inner `i' in this case.  */
1428             pop_binding (DECL_NAME (link), link);
1429           else if ((outer_binding
1430                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1431                         == TYPE_DECL))
1432                    || (ns_binding
1433                        && TREE_CODE (ns_binding) == TYPE_DECL))
1434             /* Here, we have something like:
1435
1436                  typedef int I;
1437
1438                  void f () {
1439                    for (int I; ;);
1440                  }
1441
1442                We must pop the for-scope binding so we know what's a
1443                type and what isn't.  */
1444             pop_binding (DECL_NAME (link), link);
1445           else
1446             {
1447               /* Mark this VAR_DECL as dead so that we can tell we left it
1448                  there only for backward compatibility.  */
1449               DECL_DEAD_FOR_LOCAL (link) = 1;
1450
1451               /* Keep track of what should of have happenned when we
1452                  popped the binding.  */
1453               if (outer_binding && BINDING_VALUE (outer_binding))
1454                 DECL_SHADOWED_FOR_VAR (link)
1455                   = BINDING_VALUE (outer_binding);
1456
1457               /* Add it to the list of dead variables in the next
1458                  outermost binding to that we can remove these when we
1459                  leave that binding.  */
1460               current_binding_level->level_chain->dead_vars_from_for
1461                 = tree_cons (NULL_TREE, link,
1462                              current_binding_level->level_chain->
1463                              dead_vars_from_for);
1464
1465               /* Although we don't pop the CPLUS_BINDING, we do clear
1466                  its BINDING_LEVEL since the level is going away now.  */
1467               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1468                 = 0;
1469             }
1470         }
1471       else
1472         {
1473           /* Remove the binding.  */
1474           decl = link;
1475           if (TREE_CODE (decl) == TREE_LIST)
1476             decl = TREE_VALUE (decl);
1477           if (DECL_P (decl))
1478             pop_binding (DECL_NAME (decl), decl);
1479           else if (TREE_CODE (decl) == OVERLOAD)
1480             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1481           else
1482             abort ();
1483         }
1484     }
1485
1486   /* Remove declarations for any `for' variables from inner scopes
1487      that we kept around.  */
1488   for (link = current_binding_level->dead_vars_from_for;
1489        link; link = TREE_CHAIN (link))
1490     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1491
1492   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1493   for (link = current_binding_level->type_shadowed;
1494        link; link = TREE_CHAIN (link))
1495     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1496
1497   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1498   for (link = current_binding_level->shadowed_labels;
1499        link;
1500        link = TREE_CHAIN (link))
1501     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1502
1503   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1504      list if a `using' declaration put them there.  The debugging
1505      back-ends won't understand OVERLOAD, so we remove them here.
1506      Because the BLOCK_VARS are (temporarily) shared with
1507      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1508      popped all the bindings.  */
1509   if (block)
1510     {
1511       tree* d;
1512
1513       for (d = &BLOCK_VARS (block); *d; )
1514         {
1515           if (TREE_CODE (*d) == TREE_LIST)
1516             *d = TREE_CHAIN (*d);
1517           else
1518             d = &TREE_CHAIN (*d);
1519         }
1520     }
1521
1522   /* If the level being exited is the top level of a function,
1523      check over all the labels.  */
1524   if (functionbody)
1525     {
1526       /* Since this is the top level block of a function, the vars are
1527          the function's parameters.  Don't leave them in the BLOCK
1528          because they are found in the FUNCTION_DECL instead.  */
1529       BLOCK_VARS (block) = 0;
1530       pop_labels (block);
1531     }
1532
1533   tmp = current_binding_level->keep;
1534
1535   pop_binding_level ();
1536   if (functionbody)
1537     DECL_INITIAL (current_function_decl) = block;
1538   else if (block)
1539     current_binding_level->blocks
1540       = chainon (current_binding_level->blocks, block);
1541
1542   /* If we did not make a block for the level just exited,
1543      any blocks made for inner levels
1544      (since they cannot be recorded as subblocks in that level)
1545      must be carried forward so they will later become subblocks
1546      of something else.  */
1547   else if (subblocks)
1548     current_binding_level->blocks
1549       = chainon (current_binding_level->blocks, subblocks);
1550
1551   /* Each and every BLOCK node created here in `poplevel' is important
1552      (e.g. for proper debugging information) so if we created one
1553      earlier, mark it as "used".  */
1554   if (block)
1555     TREE_USED (block) = 1;
1556
1557   /* Take care of compiler's internal binding structures.  */
1558   if (tmp == 2)
1559     {
1560       tree scope_stmts;
1561
1562       scope_stmts
1563         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1564       if (block)
1565         {
1566           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1567           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1568         }
1569
1570       block = poplevel (keep, reverse, functionbody);
1571     }
1572
1573   return block;
1574 }
1575
1576 /* Delete the node BLOCK from the current binding level.
1577    This is used for the block inside a stmt expr ({...})
1578    so that the block can be reinserted where appropriate.  */
1579
1580 void
1581 delete_block (block)
1582      tree block;
1583 {
1584   tree t;
1585   if (current_binding_level->blocks == block)
1586     current_binding_level->blocks = TREE_CHAIN (block);
1587   for (t = current_binding_level->blocks; t;)
1588     {
1589       if (TREE_CHAIN (t) == block)
1590         TREE_CHAIN (t) = TREE_CHAIN (block);
1591       else
1592         t = TREE_CHAIN (t);
1593     }
1594   TREE_CHAIN (block) = NULL_TREE;
1595   /* Clear TREE_USED which is always set by poplevel.
1596      The flag is set again if insert_block is called.  */
1597   TREE_USED (block) = 0;
1598 }
1599
1600 /* Insert BLOCK at the end of the list of subblocks of the
1601    current binding level.  This is used when a BIND_EXPR is expanded,
1602    to handle the BLOCK node inside the BIND_EXPR.  */
1603
1604 void
1605 insert_block (block)
1606      tree block;
1607 {
1608   TREE_USED (block) = 1;
1609   current_binding_level->blocks
1610     = chainon (current_binding_level->blocks, block);
1611 }
1612
1613 /* Set the BLOCK node for the innermost scope
1614    (the one we are currently in).  */
1615
1616 void
1617 set_block (block)
1618     tree block ATTRIBUTE_UNUSED;
1619 {
1620   /* The RTL expansion machinery requires us to provide this callback,
1621      but it is not applicable in function-at-a-time mode.  */
1622   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1623 }
1624
1625 /* Do a pushlevel for class declarations.  */
1626
1627 void
1628 pushlevel_class ()
1629 {
1630   register struct cp_binding_level *newlevel;
1631
1632   /* Reuse or create a struct for this binding level.  */
1633 #if defined(DEBUG_BINDING_LEVELS)
1634   if (0)
1635 #else /* !defined(DEBUG_BINDING_LEVELS) */
1636   if (free_binding_level)
1637 #endif /* !defined(DEBUG_BINDING_LEVELS) */
1638     {
1639       newlevel = free_binding_level;
1640       free_binding_level = free_binding_level->level_chain;
1641     }
1642   else
1643     newlevel = make_binding_level ();
1644
1645 #if defined(DEBUG_BINDING_LEVELS)
1646   is_class_level = 1;
1647 #endif /* defined(DEBUG_BINDING_LEVELS) */
1648
1649   push_binding_level (newlevel, 0, 0);
1650
1651   class_binding_level = current_binding_level;
1652   class_binding_level->parm_flag = 2;
1653   class_binding_level->this_class = current_class_type;
1654 }
1655
1656 /* ...and a poplevel for class declarations.  */
1657
1658 void
1659 poplevel_class ()
1660 {
1661   register struct cp_binding_level *level = class_binding_level;
1662   tree shadowed;
1663
1664   my_friendly_assert (level != 0, 354);
1665
1666   /* If we're leaving a toplevel class, don't bother to do the setting
1667      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1668      shouldn't even be used when current_class_type isn't set, and second,
1669      if we don't touch it here, we're able to use the cache effect if the
1670      next time we're entering a class scope, it is the same class.  */
1671   if (current_class_depth != 1)
1672     {
1673       struct cp_binding_level* b;
1674
1675       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1676       for (shadowed = level->class_shadowed;
1677            shadowed;
1678            shadowed = TREE_CHAIN (shadowed))
1679         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1680
1681       /* Find the next enclosing class, and recreate
1682          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1683       b = level->level_chain;
1684       while (b && b->parm_flag != 2)
1685         b = b->level_chain;
1686
1687       if (b)
1688         for (shadowed = b->class_shadowed;
1689              shadowed;
1690              shadowed = TREE_CHAIN (shadowed))
1691           {
1692             tree t;
1693
1694             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1695             while (t && BINDING_LEVEL (t) != b)
1696               t = TREE_CHAIN (t);
1697
1698             if (t)
1699               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1700                 = BINDING_VALUE (t);
1701           }
1702     }
1703   else
1704     /* Remember to save what IDENTIFIER's were bound in this scope so we
1705        can recover from cache misses.  */
1706     {
1707       previous_class_type = current_class_type;
1708       previous_class_values = class_binding_level->class_shadowed;
1709     }
1710   for (shadowed = level->type_shadowed;
1711        shadowed;
1712        shadowed = TREE_CHAIN (shadowed))
1713     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1714
1715   /* Remove the bindings for all of the class-level declarations.  */
1716   for (shadowed = level->class_shadowed;
1717        shadowed;
1718        shadowed = TREE_CHAIN (shadowed))
1719     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1720
1721   /* Now, pop out of the binding level which we created up in the
1722      `pushlevel_class' routine.  */
1723 #if defined(DEBUG_BINDING_LEVELS)
1724   is_class_level = 1;
1725 #endif /* defined(DEBUG_BINDING_LEVELS) */
1726
1727   pop_binding_level ();
1728 }
1729
1730 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1731    for any names in enclosing classes.  */
1732
1733 void
1734 clear_identifier_class_values ()
1735 {
1736   tree t;
1737
1738   if (!class_binding_level)
1739     return;
1740
1741   for (t = class_binding_level->class_shadowed;
1742        t;
1743        t = TREE_CHAIN (t))
1744     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1745 }
1746
1747 /* Returns nonzero if T is a virtual function table.  */
1748
1749 int
1750 vtable_decl_p (t, data)
1751      tree t;
1752      void *data ATTRIBUTE_UNUSED;
1753 {
1754   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1755 }
1756
1757 /* Returns nonzero if T is a TYPE_DECL for a type with virtual
1758    functions.  */
1759
1760 int
1761 vtype_decl_p (t, data)
1762      tree t;
1763      void *data ATTRIBUTE_UNUSED;
1764 {
1765   return (TREE_CODE (t) == TYPE_DECL
1766           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1767           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1768 }
1769
1770 /* Return the declarations that are members of the namespace NS.  */
1771
1772 tree
1773 cp_namespace_decls (ns)
1774      tree ns;
1775 {
1776   return NAMESPACE_LEVEL (ns)->names;
1777 }
1778
1779 struct walk_globals_data {
1780   walk_globals_pred p;
1781   walk_globals_fn f;
1782   void *data;
1783 };
1784
1785 /* Walk the vtable declarations in NAMESPACE.  Whenever one is found
1786    for which P returns nonzero, call F with its address.  If any call
1787    to F returns a nonzero value, return a nonzero value.  */
1788
1789 static int
1790 walk_vtables_r (namespace, data)
1791      tree namespace;
1792      void *data;
1793 {
1794   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1795   walk_globals_fn f = wgd->f;
1796   void *d = wgd->data;
1797   tree decl = NAMESPACE_LEVEL (namespace)->vtables;
1798   int result = 0;
1799
1800   for (; decl ; decl = TREE_CHAIN (decl))
1801     result |= (*f) (&decl, d);
1802
1803   return result;
1804 }
1805
1806 /* Walk the vtable declarations.  Whenever one is found for which P
1807    returns nonzero, call F with its address.  If any call to F
1808    returns a nonzero value, return a nonzero value.  */
1809 int
1810 walk_vtables (p, f, data)
1811      walk_globals_pred p;
1812      walk_globals_fn f;
1813      void *data;
1814 {
1815   struct walk_globals_data wgd;
1816   wgd.p = p;
1817   wgd.f = f;
1818   wgd.data = data;
1819
1820   return walk_namespaces (walk_vtables_r, &wgd);
1821 }
1822
1823 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1824    itself, calling F for each.  The DATA is passed to F as well.  */
1825
1826 static int
1827 walk_namespaces_r (namespace, f, data)
1828      tree namespace;
1829      walk_namespaces_fn f;
1830      void *data;
1831 {
1832   int result = 0;
1833   tree current = NAMESPACE_LEVEL (namespace)->namespaces;
1834
1835   result |= (*f) (namespace, data);
1836
1837   for (; current; current = TREE_CHAIN (current))
1838     result |= walk_namespaces_r (current, f, data);
1839
1840   return result;
1841 }
1842
1843 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1844    F as well.  */
1845
1846 int
1847 walk_namespaces (f, data)
1848      walk_namespaces_fn f;
1849      void *data;
1850 {
1851   return walk_namespaces_r (global_namespace, f, data);
1852 }
1853
1854 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1855    for which P returns nonzero, call F with its address.  If any call
1856    to F returns a nonzero value, return a nonzero value.  */
1857
1858 static int
1859 walk_globals_r (namespace, data)
1860      tree namespace;
1861      void *data;
1862 {
1863   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1864   walk_globals_pred p = wgd->p;
1865   walk_globals_fn f = wgd->f;
1866   void *d = wgd->data;
1867   tree *t;
1868   int result = 0;
1869
1870   t = &NAMESPACE_LEVEL (namespace)->names;
1871
1872   while (*t)
1873     {
1874       tree glbl = *t;
1875
1876       if ((*p) (glbl, d))
1877         result |= (*f) (t, d);
1878
1879       /* If F changed *T, then *T still points at the next item to
1880          examine.  */
1881       if (*t == glbl)
1882         t = &TREE_CHAIN (*t);
1883     }
1884
1885   return result;
1886 }
1887
1888 /* Walk the global declarations.  Whenever one is found for which P
1889    returns nonzero, call F with its address.  If any call to F
1890    returns a nonzero value, return a nonzero value.  */
1891
1892 int
1893 walk_globals (p, f, data)
1894      walk_globals_pred p;
1895      walk_globals_fn f;
1896      void *data;
1897 {
1898   struct walk_globals_data wgd;
1899   wgd.p = p;
1900   wgd.f = f;
1901   wgd.data = data;
1902
1903   return walk_namespaces (walk_globals_r, &wgd);
1904 }
1905
1906 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1907    DATA is non-NULL, this is the last time we will call
1908    wrapup_global_declarations for this NAMESPACE.  */
1909
1910 int
1911 wrapup_globals_for_namespace (namespace, data)
1912      tree namespace;
1913      void *data;
1914 {
1915   tree globals = cp_namespace_decls (namespace);
1916   int len = NAMESPACE_LEVEL (namespace)->names_size;
1917   tree *vec = (tree *) alloca (sizeof (tree) * len);
1918   int i;
1919   int result;
1920   tree decl;
1921   int last_time = (data != 0);
1922
1923   if (last_time && namespace == global_namespace)
1924     /* Let compile_file handle the global namespace.  */
1925     return 0;
1926
1927   /* Process the decls in reverse order--earliest first.
1928      Put them into VEC from back to front, then take out from front.  */
1929   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1930     vec[len - i - 1] = decl;
1931
1932   if (last_time)
1933     {
1934       check_global_declarations (vec, len);
1935       return 0;
1936     }
1937
1938   /* Write out any globals that need to be output.  */
1939   result = wrapup_global_declarations (vec, len);
1940
1941   return result;
1942 }
1943
1944 \f
1945 /* For debugging.  */
1946 static int no_print_functions = 0;
1947 static int no_print_builtins = 0;
1948
1949 void
1950 print_binding_level (lvl)
1951      struct cp_binding_level *lvl;
1952 {
1953   tree t;
1954   int i = 0, len;
1955   fprintf (stderr, " blocks=");
1956   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1957   if (lvl->tag_transparent)
1958     fprintf (stderr, " tag-transparent");
1959   if (lvl->more_cleanups_ok)
1960     fprintf (stderr, " more-cleanups-ok");
1961   if (lvl->have_cleanups)
1962     fprintf (stderr, " have-cleanups");
1963   fprintf (stderr, "\n");
1964   if (lvl->names)
1965     {
1966       fprintf (stderr, " names:\t");
1967       /* We can probably fit 3 names to a line?  */
1968       for (t = lvl->names; t; t = TREE_CHAIN (t))
1969         {
1970           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1971             continue;
1972           if (no_print_builtins
1973               && (TREE_CODE (t) == TYPE_DECL)
1974               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
1975             continue;
1976
1977           /* Function decls tend to have longer names.  */
1978           if (TREE_CODE (t) == FUNCTION_DECL)
1979             len = 3;
1980           else
1981             len = 2;
1982           i += len;
1983           if (i > 6)
1984             {
1985               fprintf (stderr, "\n\t");
1986               i = len;
1987             }
1988           print_node_brief (stderr, "", t, 0);
1989           if (t == error_mark_node)
1990             break;
1991         }
1992       if (i)
1993         fprintf (stderr, "\n");
1994     }
1995   if (lvl->tags)
1996     {
1997       fprintf (stderr, " tags:\t");
1998       i = 0;
1999       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2000         {
2001           if (TREE_PURPOSE (t) == NULL_TREE)
2002             len = 3;
2003           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2004             len = 2;
2005           else
2006             len = 4;
2007           i += len;
2008           if (i > 5)
2009             {
2010               fprintf (stderr, "\n\t");
2011               i = len;
2012             }
2013           if (TREE_PURPOSE (t) == NULL_TREE)
2014             {
2015               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2016               fprintf (stderr, ">");
2017             }
2018           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2019             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2020           else
2021             {
2022               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2023               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2024               fprintf (stderr, ">");
2025             }
2026         }
2027       if (i)
2028         fprintf (stderr, "\n");
2029     }
2030   if (lvl->class_shadowed)
2031     {
2032       fprintf (stderr, " class-shadowed:");
2033       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2034         {
2035           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2036         }
2037       fprintf (stderr, "\n");
2038     }
2039   if (lvl->type_shadowed)
2040     {
2041       fprintf (stderr, " type-shadowed:");
2042       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2043         {
2044           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2045         }
2046       fprintf (stderr, "\n");
2047     }
2048 }
2049
2050 void
2051 print_other_binding_stack (stack)
2052      struct cp_binding_level *stack;
2053 {
2054   struct cp_binding_level *level;
2055   for (level = stack; level != global_binding_level; level = level->level_chain)
2056     {
2057       fprintf (stderr, "binding level ");
2058       fprintf (stderr, HOST_PTR_PRINTF, level);
2059       fprintf (stderr, "\n");
2060       print_binding_level (level);
2061     }
2062 }
2063
2064 void
2065 print_binding_stack ()
2066 {
2067   struct cp_binding_level *b;
2068   fprintf (stderr, "current_binding_level=");
2069   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2070   fprintf (stderr, "\nclass_binding_level=");
2071   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2072   fprintf (stderr, "\nglobal_binding_level=");
2073   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2074   fprintf (stderr, "\n");
2075   if (class_binding_level)
2076     {
2077       for (b = class_binding_level; b; b = b->level_chain)
2078         if (b == current_binding_level)
2079           break;
2080       if (b)
2081         b = class_binding_level;
2082       else
2083         b = current_binding_level;
2084     }
2085   else
2086     b = current_binding_level;
2087   print_other_binding_stack (b);
2088   fprintf (stderr, "global:\n");
2089   print_binding_level (global_binding_level);
2090 }
2091
2092 /* Namespace binding access routines: The namespace_bindings field of
2093    the identifier is polymorphic, with three possible values:
2094    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2095    indicating the BINDING_VALUE of global_namespace.  */
2096
2097 /* Check whether the a binding for the name to scope is known.
2098    Assumes that the bindings of the name are already a list
2099    of bindings. Returns the binding found, or NULL_TREE.  */
2100
2101 static tree
2102 find_binding (name, scope)
2103      tree name;
2104      tree scope;
2105 {
2106   tree iter, prev = NULL_TREE;
2107
2108   scope = ORIGINAL_NAMESPACE (scope);
2109
2110   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2111        iter = TREE_CHAIN (iter))
2112     {
2113       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2114       if (BINDING_SCOPE (iter) == scope)
2115         {
2116           /* Move binding found to the front of the list, so
2117              subsequent lookups will find it faster.  */
2118           if (prev)
2119             {
2120               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2121               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2122               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2123             }
2124           return iter;
2125         }
2126       prev = iter;
2127     }
2128   return NULL_TREE;
2129 }
2130
2131 /* Always returns a binding for name in scope. If the
2132    namespace_bindings is not a list, convert it to one first.
2133    If no binding is found, make a new one.  */
2134
2135 tree
2136 binding_for_name (name, scope)
2137      tree name;
2138      tree scope;
2139 {
2140   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2141   tree result;
2142
2143   scope = ORIGINAL_NAMESPACE (scope);
2144
2145   if (b && TREE_CODE (b) != CPLUS_BINDING)
2146     {
2147       /* Get rid of optimization for global scope.  */
2148       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2149       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2150       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2151     }
2152   if (b && (result = find_binding (name, scope)))
2153     return result;
2154   /* Not found, make a new one.  */
2155   result = make_node (CPLUS_BINDING);
2156   TREE_CHAIN (result) = b;
2157   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2158   BINDING_SCOPE (result) = scope;
2159   BINDING_TYPE (result) = NULL_TREE;
2160   BINDING_VALUE (result) = NULL_TREE;
2161   return result;
2162 }
2163
2164 /* Return the binding value for name in scope, considering that
2165    namespace_binding may or may not be a list of CPLUS_BINDINGS.  */
2166
2167 tree
2168 namespace_binding (name, scope)
2169      tree name;
2170      tree scope;
2171 {
2172   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2173   if (b == NULL_TREE)
2174     return NULL_TREE;
2175   if (scope == NULL_TREE)
2176     scope = global_namespace;
2177   if (TREE_CODE (b) != CPLUS_BINDING)
2178     return (scope == global_namespace) ? b : NULL_TREE;
2179   name = find_binding (name,scope);
2180   if (name == NULL_TREE)
2181     return name;
2182   return BINDING_VALUE (name);
2183 }
2184
2185 /* Set the binding value for name in scope. If modifying the binding
2186    of global_namespace is attempted, try to optimize it.  */
2187
2188 void
2189 set_namespace_binding (name, scope, val)
2190      tree name;
2191      tree scope;
2192      tree val;
2193 {
2194   tree b;
2195
2196   if (scope == NULL_TREE)
2197     scope = global_namespace;
2198
2199   if (scope == global_namespace)
2200     {
2201       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2202       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2203         {
2204           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2205           return;
2206         }
2207     }
2208   b = binding_for_name (name, scope);
2209   BINDING_VALUE (b) = val;
2210 }
2211
2212 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2213    select a name that is unique to this compilation unit.  */
2214
2215 void
2216 push_namespace (name)
2217      tree name;
2218 {
2219   tree d = NULL_TREE;
2220   int need_new = 1;
2221   int implicit_use = 0;
2222   int global = 0;
2223   if (!global_namespace)
2224     {
2225       /* This must be ::.  */
2226       my_friendly_assert (name == get_identifier ("::"), 377);
2227       global = 1;
2228     }
2229   else if (!name)
2230     {
2231       /* The name of anonymous namespace is unique for the translation
2232          unit.  */
2233       if (!anonymous_namespace_name)
2234         anonymous_namespace_name = get_file_function_name ('N');
2235       name = anonymous_namespace_name;
2236       d = IDENTIFIER_NAMESPACE_VALUE (name);
2237       if (d)
2238         /* Reopening anonymous namespace.  */
2239         need_new = 0;
2240       implicit_use = 1;
2241     }
2242   else
2243     {
2244       /* Check whether this is an extended namespace definition.  */
2245       d = IDENTIFIER_NAMESPACE_VALUE (name);
2246       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2247         {
2248           need_new = 0;
2249           if (DECL_NAMESPACE_ALIAS (d))
2250             {
2251               error ("namespace alias `%D' not allowed here, assuming `%D'",
2252                         d, DECL_NAMESPACE_ALIAS (d));
2253               d = DECL_NAMESPACE_ALIAS (d);
2254             }
2255         }
2256     }
2257
2258   if (need_new)
2259     {
2260       /* Make a new namespace, binding the name to it.  */
2261       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2262       /* The global namespace is not pushed, and the global binding
2263          level is set elsewhere.  */
2264       if (!global)
2265         {
2266           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2267           d = pushdecl (d);
2268           pushlevel (0);
2269           declare_namespace_level ();
2270           NAMESPACE_LEVEL (d) = current_binding_level;
2271         }
2272     }
2273   else
2274     resume_binding_level (NAMESPACE_LEVEL (d));
2275
2276   if (implicit_use)
2277     do_using_directive (d);
2278   /* Enter the name space.  */
2279   current_namespace = d;
2280 }
2281
2282 /* Pop from the scope of the current namespace.  */
2283
2284 void
2285 pop_namespace ()
2286 {
2287   my_friendly_assert (current_namespace != global_namespace, 20010801);
2288   current_namespace = CP_DECL_CONTEXT (current_namespace);
2289   /* The binding level is not popped, as it might be re-opened later.  */
2290   suspend_binding_level ();
2291 }
2292
2293 /* Push into the scope of the namespace NS, even if it is deeply
2294    nested within another namespace.  */
2295
2296 void
2297 push_nested_namespace (ns)
2298      tree ns;
2299 {
2300   if (ns == global_namespace)
2301     push_to_top_level ();
2302   else
2303     {
2304       push_nested_namespace (CP_DECL_CONTEXT (ns));
2305       push_namespace (DECL_NAME (ns));
2306     }
2307 }
2308
2309 /* Pop back from the scope of the namespace NS, which was previously
2310    entered with push_nested_namespace.  */
2311
2312 void
2313 pop_nested_namespace (ns)
2314      tree ns;
2315 {
2316   while (ns != global_namespace)
2317     {
2318       pop_namespace ();
2319       ns = CP_DECL_CONTEXT (ns);
2320     }
2321
2322   pop_from_top_level ();
2323 }
2324
2325 \f
2326 /* Subroutines for reverting temporarily to top-level for instantiation
2327    of templates and such.  We actually need to clear out the class- and
2328    local-value slots of all identifiers, so that only the global values
2329    are at all visible.  Simply setting current_binding_level to the global
2330    scope isn't enough, because more binding levels may be pushed.  */
2331 struct saved_scope *scope_chain;
2332
2333 static tree
2334 store_bindings (names, old_bindings)
2335      tree names, old_bindings;
2336 {
2337   tree t;
2338   tree search_bindings = old_bindings;
2339
2340   for (t = names; t; t = TREE_CHAIN (t))
2341     {
2342       tree binding, t1, id;
2343
2344       if (TREE_CODE (t) == TREE_LIST)
2345         id = TREE_PURPOSE (t);
2346       else
2347         id = DECL_NAME (t);
2348
2349       if (!id
2350           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2351              we have no IDENTIFIER_BINDING if we have left the class
2352              scope, but cached the class-level declarations.  */
2353           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2354         continue;
2355
2356       for (t1 = search_bindings; t1; t1 = TREE_CHAIN (t1))
2357         if (TREE_VEC_ELT (t1, 0) == id)
2358           goto skip_it;
2359
2360       my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2361       binding = make_tree_vec (4);
2362       TREE_VEC_ELT (binding, 0) = id;
2363       TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2364       TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2365       TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2366       IDENTIFIER_BINDING (id) = NULL_TREE;
2367       IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2368       TREE_CHAIN (binding) = old_bindings;
2369       old_bindings = binding;
2370     skip_it:
2371       ;
2372     }
2373   return old_bindings;
2374 }
2375
2376 void
2377 maybe_push_to_top_level (pseudo)
2378      int pseudo;
2379 {
2380   struct saved_scope *s;
2381   struct cp_binding_level *b;
2382   tree old_bindings;
2383   int need_pop;
2384
2385   s = (struct saved_scope *) ggc_alloc_cleared (sizeof (struct saved_scope));
2386
2387   b = scope_chain ? current_binding_level : 0;
2388
2389   /* If we're in the middle of some function, save our state.  */
2390   if (cfun)
2391     {
2392       need_pop = 1;
2393       push_function_context_to (NULL_TREE);
2394     }
2395   else
2396     need_pop = 0;
2397
2398   old_bindings = NULL_TREE;
2399   if (scope_chain && previous_class_type)
2400     old_bindings = store_bindings (previous_class_values, old_bindings);
2401
2402   /* Have to include global_binding_level, because class-level decls
2403      aren't listed anywhere useful.  */
2404   for (; b; b = b->level_chain)
2405     {
2406       tree t;
2407
2408       /* Template IDs are inserted into the global level. If they were
2409          inserted into namespace level, finish_file wouldn't find them
2410          when doing pending instantiations. Therefore, don't stop at
2411          namespace level, but continue until :: .  */
2412       if (b == global_binding_level || (pseudo && b->template_parms_p))
2413         break;
2414
2415       old_bindings = store_bindings (b->names, old_bindings);
2416       /* We also need to check class_shadowed to save class-level type
2417          bindings, since pushclass doesn't fill in b->names.  */
2418       if (b->parm_flag == 2)
2419         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2420
2421       /* Unwind type-value slots back to top level.  */
2422       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2423         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2424     }
2425   s->prev = scope_chain;
2426   s->old_bindings = old_bindings;
2427   s->bindings = b;
2428   s->need_pop_function_context = need_pop;
2429   s->function_decl = current_function_decl;
2430   s->last_parms = last_function_parms;
2431
2432   scope_chain = s;
2433   current_function_decl = NULL_TREE;
2434   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2435   current_lang_name = lang_name_cplusplus;
2436   current_namespace = global_namespace;
2437 }
2438
2439 void
2440 push_to_top_level ()
2441 {
2442   maybe_push_to_top_level (0);
2443 }
2444
2445 void
2446 pop_from_top_level ()
2447 {
2448   struct saved_scope *s = scope_chain;
2449   tree t;
2450
2451   /* Clear out class-level bindings cache.  */
2452   if (previous_class_type)
2453     invalidate_class_lookup_cache ();
2454
2455   current_lang_base = 0;
2456
2457   scope_chain = s->prev;
2458   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2459     {
2460       tree id = TREE_VEC_ELT (t, 0);
2461
2462       SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2463       IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2464       IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2465     }
2466
2467   /* If we were in the middle of compiling a function, restore our
2468      state.  */
2469   if (s->need_pop_function_context)
2470     pop_function_context_from (NULL_TREE);
2471   current_function_decl = s->function_decl;
2472   last_function_parms = s->last_parms;
2473 }
2474 \f
2475 /* Push a definition of struct, union or enum tag "name".
2476    into binding_level "b".   "type" should be the type node,
2477    We assume that the tag "name" is not already defined.
2478
2479    Note that the definition may really be just a forward reference.
2480    In that case, the TYPE_SIZE will be a NULL_TREE.
2481
2482    C++ gratuitously puts all these tags in the name space.  */
2483
2484 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2485    record the shadowed value for this binding contour.  TYPE is
2486    the type that ID maps to.  */
2487
2488 static void
2489 set_identifier_type_value_with_scope (id, type, b)
2490      tree id;
2491      tree type;
2492      struct cp_binding_level *b;
2493 {
2494   if (!b->namespace_p)
2495     {
2496       /* Shadow the marker, not the real thing, so that the marker
2497          gets restored later.  */
2498       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2499       b->type_shadowed
2500         = tree_cons (id, old_type_value, b->type_shadowed);
2501     }
2502   else
2503     {
2504       tree binding = binding_for_name (id, current_namespace);
2505       BINDING_TYPE (binding) = type;
2506       /* Store marker instead of real type.  */
2507       type = global_type_node;
2508     }
2509   SET_IDENTIFIER_TYPE_VALUE (id, type);
2510 }
2511
2512 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2513
2514 void
2515 set_identifier_type_value (id, type)
2516      tree id;
2517      tree type;
2518 {
2519   set_identifier_type_value_with_scope (id, type, current_binding_level);
2520 }
2521
2522 /* Return the type associated with id.  */
2523
2524 tree
2525 identifier_type_value (id)
2526      tree id;
2527 {
2528   /* There is no type with that name, anywhere.  */
2529   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2530     return NULL_TREE;
2531   /* This is not the type marker, but the real thing.  */
2532   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2533     return REAL_IDENTIFIER_TYPE_VALUE (id);
2534   /* Have to search for it. It must be on the global level, now.
2535      Ask lookup_name not to return non-types.  */
2536   id = lookup_name_real (id, 2, 1, 0);
2537   if (id)
2538     return TREE_TYPE (id);
2539   return NULL_TREE;
2540 }
2541
2542 /* Pop off extraneous binding levels left over due to syntax errors.
2543
2544    We don't pop past namespaces, as they might be valid.  */
2545
2546 void
2547 pop_everything ()
2548 {
2549 #ifdef DEBUG_BINDING_LEVELS
2550   fprintf (stderr, "XXX entering pop_everything ()\n");
2551 #endif
2552   while (!toplevel_bindings_p ())
2553     {
2554       if (current_binding_level->parm_flag == 2)
2555         pop_nested_class ();
2556       else
2557         poplevel (0, 0, 0);
2558     }
2559 #ifdef DEBUG_BINDING_LEVELS
2560   fprintf (stderr, "XXX leaving pop_everything ()\n");
2561 #endif
2562 }
2563
2564 /* The type TYPE is being declared.  If it is a class template, or a
2565    specialization of a class template, do any processing required and
2566    perform error-checking.  If IS_FRIEND is nonzero, this TYPE is
2567    being declared a friend.  B is the binding level at which this TYPE
2568    should be bound.
2569
2570    Returns the TYPE_DECL for TYPE, which may have been altered by this
2571    processing.  */
2572
2573 static tree
2574 maybe_process_template_type_declaration (type, globalize, b)
2575      tree type;
2576      int globalize;
2577      struct cp_binding_level* b;
2578 {
2579   tree decl = TYPE_NAME (type);
2580
2581   if (processing_template_parmlist)
2582     /* You can't declare a new template type in a template parameter
2583        list.  But, you can declare a non-template type:
2584
2585          template <class A*> struct S;
2586
2587        is a forward-declaration of `A'.  */
2588     ;
2589   else
2590     {
2591       maybe_check_template_type (type);
2592
2593       my_friendly_assert (IS_AGGR_TYPE (type)
2594                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2595
2596
2597       if (processing_template_decl)
2598         {
2599           /* This may change after the call to
2600              push_template_decl_real, but we want the original value.  */
2601           tree name = DECL_NAME (decl);
2602
2603           decl = push_template_decl_real (decl, globalize);
2604           /* If the current binding level is the binding level for the
2605              template parameters (see the comment in
2606              begin_template_parm_list) and the enclosing level is a class
2607              scope, and we're not looking at a friend, push the
2608              declaration of the member class into the class scope.  In the
2609              friend case, push_template_decl will already have put the
2610              friend into global scope, if appropriate.  */
2611           if (TREE_CODE (type) != ENUMERAL_TYPE
2612               && !globalize && b->template_parms_p
2613               && b->level_chain->parm_flag == 2)
2614             {
2615               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2616               /* Put this tag on the list of tags for the class, since
2617                  that won't happen below because B is not the class
2618                  binding level, but is instead the pseudo-global level.  */
2619               b->level_chain->tags =
2620                 tree_cons (name, type, b->level_chain->tags);
2621               if (!COMPLETE_TYPE_P (current_class_type))
2622                 {
2623                   maybe_add_class_template_decl_list (current_class_type,
2624                                                       type, /*friend_p=*/0);
2625                   CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2626                 }
2627             }
2628         }
2629     }
2630
2631   return decl;
2632 }
2633
2634 /* In C++, you don't have to write `struct S' to refer to `S'; you
2635    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2636    if the user had written `typedef struct S S'.  Create and return
2637    the TYPE_DECL for TYPE.  */
2638
2639 tree
2640 create_implicit_typedef (name, type)
2641      tree name;
2642      tree type;
2643 {
2644   tree decl;
2645
2646   decl = build_decl (TYPE_DECL, name, type);
2647   DECL_ARTIFICIAL (decl) = 1;
2648   /* There are other implicit type declarations, like the one *within*
2649      a class that allows you to write `S::S'.  We must distinguish
2650      amongst these.  */
2651   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2652   TYPE_NAME (type) = decl;
2653
2654   return decl;
2655 }
2656
2657 /* Remember a local name for name-mangling purposes.  */
2658
2659 static void
2660 push_local_name (decl)
2661      tree decl;
2662 {
2663   size_t i, nelts;
2664   tree t, name;
2665
2666   if (!local_names)
2667     VARRAY_TREE_INIT (local_names, 8, "local_names");
2668
2669   name = DECL_NAME (decl);
2670
2671   nelts = VARRAY_ACTIVE_SIZE (local_names);
2672   for (i = 0; i < nelts; i++)
2673     {
2674       t = VARRAY_TREE (local_names, i);
2675       if (DECL_NAME (t) == name)
2676         {
2677           if (!DECL_LANG_SPECIFIC (decl))
2678             retrofit_lang_decl (decl);
2679           DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
2680           if (DECL_LANG_SPECIFIC (t))
2681             DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
2682           else
2683             DECL_DISCRIMINATOR (decl) = 1;
2684
2685           VARRAY_TREE (local_names, i) = decl;
2686           return;
2687         }
2688     }
2689
2690   VARRAY_PUSH_TREE (local_names, decl);
2691 }
2692
2693 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2694    Normally put it into the inner-most non-tag-transparent scope,
2695    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2696    The latter is needed for implicit declarations.  */
2697
2698 void
2699 pushtag (name, type, globalize)
2700      tree name, type;
2701      int globalize;
2702 {
2703   register struct cp_binding_level *b;
2704
2705   b = current_binding_level;
2706   while (b->tag_transparent
2707          || (b->parm_flag == 2
2708              && (globalize
2709                  /* We may be defining a new type in the initializer
2710                     of a static member variable. We allow this when
2711                     not pedantic, and it is particularly useful for
2712                     type punning via an anonymous union.  */
2713                  || COMPLETE_TYPE_P (b->this_class))))
2714     b = b->level_chain;
2715
2716   b->tags = tree_cons (name, type, b->tags);
2717
2718   if (name)
2719     {
2720       /* Do C++ gratuitous typedefing.  */
2721       if (IDENTIFIER_TYPE_VALUE (name) != type)
2722         {
2723           register tree d = NULL_TREE;
2724           int in_class = 0;
2725           tree context = TYPE_CONTEXT (type);
2726
2727           if (! context)
2728             {
2729               tree cs = current_scope ();
2730
2731               if (! globalize)
2732                 context = cs;
2733               else if (cs != NULL_TREE && TYPE_P (cs))
2734                 /* When declaring a friend class of a local class, we want
2735                    to inject the newly named class into the scope
2736                    containing the local class, not the namespace scope.  */
2737                 context = decl_function_context (get_type_decl (cs));
2738             }
2739           if (!context)
2740             context = current_namespace;
2741
2742           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2743               || b->parm_flag == 2)
2744             in_class = 1;
2745
2746           if (current_lang_name == lang_name_java)
2747             TYPE_FOR_JAVA (type) = 1;
2748
2749           d = create_implicit_typedef (name, type);
2750           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2751           if (! in_class)
2752             set_identifier_type_value_with_scope (name, type, b);
2753
2754           d = maybe_process_template_type_declaration (type,
2755                                                        globalize, b);
2756
2757           if (b->parm_flag == 2)
2758             {
2759               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2760                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2761                    class.  But if it's a member template class, we
2762                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2763                    is done later.  */
2764                 finish_member_declaration (d);
2765               else
2766                 pushdecl_class_level (d);
2767             }
2768           else
2769             d = pushdecl_with_scope (d, b);
2770
2771           /* FIXME what if it gets a name from typedef?  */
2772           if (ANON_AGGRNAME_P (name))
2773             DECL_IGNORED_P (d) = 1;
2774
2775           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2776
2777           /* If this is a local class, keep track of it.  We need this
2778              information for name-mangling, and so that it is possible to find
2779              all function definitions in a translation unit in a convenient
2780              way.  (It's otherwise tricky to find a member function definition
2781              it's only pointed to from within a local class.)  */
2782           if (TYPE_CONTEXT (type)
2783               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2784               && !processing_template_decl)
2785             VARRAY_PUSH_TREE (local_classes, type);
2786         }
2787       if (b->parm_flag == 2)
2788         {
2789           if (!COMPLETE_TYPE_P (current_class_type))
2790             {
2791               maybe_add_class_template_decl_list (current_class_type,
2792                                                   type, /*friend_p=*/0);
2793               CLASSTYPE_TAGS (current_class_type) = b->tags;
2794             }
2795         }
2796     }
2797
2798   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2799     /* Use the canonical TYPE_DECL for this node.  */
2800     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2801   else
2802     {
2803       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2804          will be the tagged type we just added to the current
2805          binding level.  This fake NULL-named TYPE_DECL node helps
2806          dwarfout.c to know when it needs to output a
2807          representation of a tagged type, and it also gives us a
2808          convenient place to record the "scope start" address for
2809          the tagged type.  */
2810
2811       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2812       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2813     }
2814 }
2815
2816 /* Counter used to create anonymous type names.  */
2817
2818 static int anon_cnt = 0;
2819
2820 /* Return an IDENTIFIER which can be used as a name for
2821    anonymous structs and unions.  */
2822
2823 tree
2824 make_anon_name ()
2825 {
2826   char buf[32];
2827
2828   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2829   return get_identifier (buf);
2830 }
2831
2832 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2833    This keeps dbxout from getting confused.  */
2834
2835 void
2836 clear_anon_tags ()
2837 {
2838   register struct cp_binding_level *b;
2839   register tree tags;
2840   static int last_cnt = 0;
2841
2842   /* Fast out if no new anon names were declared.  */
2843   if (last_cnt == anon_cnt)
2844     return;
2845
2846   b = current_binding_level;
2847   while (b->tag_transparent)
2848     b = b->level_chain;
2849   tags = b->tags;
2850   while (tags)
2851     {
2852       /* A NULL purpose means we have already processed all tags
2853          from here to the end of the list.  */
2854       if (TREE_PURPOSE (tags) == NULL_TREE)
2855         break;
2856       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2857         TREE_PURPOSE (tags) = NULL_TREE;
2858       tags = TREE_CHAIN (tags);
2859     }
2860   last_cnt = anon_cnt;
2861 }
2862 \f
2863 /* Subroutine of duplicate_decls: return truthvalue of whether
2864    or not types of these decls match.
2865
2866    For C++, we must compare the parameter list so that `int' can match
2867    `int&' in a parameter position, but `int&' is not confused with
2868    `const int&'.  */
2869
2870 int
2871 decls_match (newdecl, olddecl)
2872      tree newdecl, olddecl;
2873 {
2874   int types_match;
2875
2876   if (newdecl == olddecl)
2877     return 1;
2878
2879   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2880     /* If the two DECLs are not even the same kind of thing, we're not
2881        interested in their types.  */
2882     return 0;
2883
2884   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2885     {
2886       tree f1 = TREE_TYPE (newdecl);
2887       tree f2 = TREE_TYPE (olddecl);
2888       tree p1 = TYPE_ARG_TYPES (f1);
2889       tree p2 = TYPE_ARG_TYPES (f2);
2890
2891       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2892           && ! (DECL_EXTERN_C_P (newdecl)
2893                 && DECL_EXTERN_C_P (olddecl)))
2894         return 0;
2895
2896       if (TREE_CODE (f1) != TREE_CODE (f2))
2897         return 0;
2898
2899       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2900         {
2901           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
2902               && (DECL_BUILT_IN (olddecl)
2903 #ifndef NO_IMPLICIT_EXTERN_C
2904                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
2905                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
2906 #endif
2907               ))
2908             {
2909               types_match = self_promoting_args_p (p1);
2910               if (p1 == void_list_node)
2911                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2912             }
2913 #ifndef NO_IMPLICIT_EXTERN_C
2914           else if (p1 == NULL_TREE
2915                    && (DECL_EXTERN_C_P (olddecl)
2916                        && DECL_IN_SYSTEM_HEADER (olddecl)
2917                        && !DECL_CLASS_SCOPE_P (olddecl))
2918                    && (DECL_EXTERN_C_P (newdecl)
2919                        && DECL_IN_SYSTEM_HEADER (newdecl)
2920                        && !DECL_CLASS_SCOPE_P (newdecl)))
2921             {
2922               types_match = self_promoting_args_p (p2);
2923               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2924             }
2925 #endif
2926           else
2927             types_match = compparms (p1, p2);
2928         }
2929       else
2930         types_match = 0;
2931     }
2932   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2933     {
2934       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2935                                 DECL_TEMPLATE_PARMS (olddecl)))
2936         return 0;
2937
2938       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
2939           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
2940         return 0;
2941
2942       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2943         types_match = 1;
2944       else
2945         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2946                                    DECL_TEMPLATE_RESULT (newdecl));
2947     }
2948   else
2949     {
2950       if (TREE_TYPE (newdecl) == error_mark_node)
2951         types_match = TREE_TYPE (olddecl) == error_mark_node;
2952       else if (TREE_TYPE (olddecl) == NULL_TREE)
2953         types_match = TREE_TYPE (newdecl) == NULL_TREE;
2954       else if (TREE_TYPE (newdecl) == NULL_TREE)
2955         types_match = 0;
2956       else
2957         types_match = comptypes (TREE_TYPE (newdecl),
2958                                  TREE_TYPE (olddecl),
2959                                  COMPARE_REDECLARATION);
2960     }
2961
2962   return types_match;
2963 }
2964
2965 /* If NEWDECL is `static' and an `extern' was seen previously,
2966    warn about it.  OLDDECL is the previous declaration.
2967
2968    Note that this does not apply to the C++ case of declaring
2969    a variable `extern const' and then later `const'.
2970
2971    Don't complain about built-in functions, since they are beyond
2972    the user's control.  */
2973
2974 static void
2975 warn_extern_redeclared_static (newdecl, olddecl)
2976      tree newdecl, olddecl;
2977 {
2978   static const char *const explicit_extern_static_warning
2979     = "`%D' was declared `extern' and later `static'";
2980   static const char *const implicit_extern_static_warning
2981     = "`%D' was declared implicitly `extern' and later `static'";
2982
2983   tree name;
2984
2985   if (TREE_CODE (newdecl) == TYPE_DECL
2986       || TREE_CODE (newdecl) == TEMPLATE_DECL
2987       || TREE_CODE (newdecl) == CONST_DECL)
2988     return;
2989
2990   /* Don't get confused by static member functions; that's a different
2991      use of `static'.  */
2992   if (TREE_CODE (newdecl) == FUNCTION_DECL
2993       && DECL_STATIC_FUNCTION_P (newdecl))
2994     return;
2995
2996   /* If the old declaration was `static', or the new one isn't, then
2997      then everything is OK.  */
2998   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
2999     return;
3000
3001   /* It's OK to declare a builtin function as `static'.  */
3002   if (TREE_CODE (olddecl) == FUNCTION_DECL
3003       && DECL_ARTIFICIAL (olddecl))
3004     return;
3005
3006   name = DECL_ASSEMBLER_NAME (newdecl);
3007   pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3008               ? implicit_extern_static_warning
3009               : explicit_extern_static_warning, newdecl);
3010   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3011 }
3012
3013 /* Handle when a new declaration NEWDECL has the same name as an old
3014    one OLDDECL in the same binding contour.  Prints an error message
3015    if appropriate.
3016
3017    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3018    Otherwise, return 0.  */
3019
3020 int
3021 duplicate_decls (newdecl, olddecl)
3022      tree newdecl, olddecl;
3023 {
3024   unsigned olddecl_uid = DECL_UID (olddecl);
3025   int olddecl_friend = 0, types_match = 0;
3026   int new_defines_function = 0;
3027
3028   if (newdecl == olddecl)
3029     return 1;
3030
3031   types_match = decls_match (newdecl, olddecl);
3032
3033   /* If either the type of the new decl or the type of the old decl is an
3034      error_mark_node, then that implies that we have already issued an
3035      error (earlier) for some bogus type specification, and in that case,
3036      it is rather pointless to harass the user with yet more error message
3037      about the same declaration, so just pretend the types match here.  */
3038   if (TREE_TYPE (newdecl) == error_mark_node
3039       || TREE_TYPE (olddecl) == error_mark_node)
3040     types_match = 1;
3041
3042   if (DECL_P (olddecl)
3043       && TREE_CODE (newdecl) == FUNCTION_DECL
3044       && TREE_CODE (olddecl) == FUNCTION_DECL
3045       && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
3046     {
3047       if (DECL_DECLARED_INLINE_P (newdecl)
3048           && DECL_UNINLINABLE (newdecl)
3049           && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
3050         /* Already warned elsewhere.  */;
3051       else if (DECL_DECLARED_INLINE_P (olddecl)
3052                && DECL_UNINLINABLE (olddecl)
3053                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
3054         /* Already warned.  */;
3055       else if (DECL_DECLARED_INLINE_P (newdecl)
3056                && DECL_UNINLINABLE (olddecl)
3057                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
3058         {
3059           warning_with_decl (newdecl,
3060                              "function `%s' redeclared as inline");
3061           warning_with_decl (olddecl,
3062                              "previous declaration of function `%s' with attribute noinline");
3063         }
3064       else if (DECL_DECLARED_INLINE_P (olddecl)
3065                && DECL_UNINLINABLE (newdecl)
3066                && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
3067         {
3068           warning_with_decl (newdecl,
3069                              "function `%s' redeclared with attribute noinline");
3070           warning_with_decl (olddecl,
3071                              "previous declaration of function `%s' was inline");
3072         }
3073     }
3074
3075   /* Check for redeclaration and other discrepancies.  */
3076   if (TREE_CODE (olddecl) == FUNCTION_DECL
3077       && DECL_ARTIFICIAL (olddecl))
3078     {
3079       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3080         {
3081           /* Avoid warnings redeclaring anticipated built-ins.  */
3082           if (DECL_ANTICIPATED (olddecl))
3083             return 0;
3084
3085           /* If you declare a built-in or predefined function name as static,
3086              the old definition is overridden, but optionally warn this was a
3087              bad choice of name.  */
3088           if (! TREE_PUBLIC (newdecl))
3089             {
3090               if (warn_shadow)
3091                 warning ("shadowing %s function `%#D'",
3092                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3093                             olddecl);
3094               /* Discard the old built-in function.  */
3095               return 0;
3096             }
3097           /* If the built-in is not ansi, then programs can override
3098              it even globally without an error.  */
3099           else if (! DECL_BUILT_IN (olddecl))
3100             warning ("library function `%#D' redeclared as non-function `%#D'",
3101                         olddecl, newdecl);
3102           else
3103             {
3104               error ("declaration of `%#D'", newdecl);
3105               error ("conflicts with built-in declaration `%#D'",
3106                         olddecl);
3107             }
3108           return 0;
3109         }
3110       else if (!types_match)
3111         {
3112           /* Avoid warnings redeclaring anticipated built-ins.  */
3113           if (DECL_ANTICIPATED (olddecl))
3114             ;  /* Do nothing yet.  */
3115           else if ((DECL_EXTERN_C_P (newdecl)
3116                && DECL_EXTERN_C_P (olddecl))
3117               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3118                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3119             {
3120               /* A near match; override the builtin.  */
3121
3122               if (TREE_PUBLIC (newdecl))
3123                 {
3124                   warning ("new declaration `%#D'", newdecl);
3125                   warning ("ambiguates built-in declaration `%#D'",
3126                               olddecl);
3127                 }
3128               else if (warn_shadow)
3129                 warning ("shadowing %s function `%#D'",
3130                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3131                             olddecl);
3132             }
3133           else
3134             /* Discard the old built-in function.  */
3135             return 0;
3136
3137           /* Replace the old RTL to avoid problems with inlining.  */
3138           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3139         }
3140
3141       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3142         {
3143           /* If a builtin function is redeclared as `static', merge
3144              the declarations, but make the original one static.  */
3145           DECL_THIS_STATIC (olddecl) = 1;
3146           TREE_PUBLIC (olddecl) = 0;
3147
3148           /* Make the old declaration consistent with the new one so
3149              that all remnants of the builtin-ness of this function
3150              will be banished.  */
3151           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3152           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3153         }
3154     }
3155   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3156     {
3157       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3158            && TREE_CODE (newdecl) != TYPE_DECL
3159            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3160                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3161           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3162               && TREE_CODE (olddecl) != TYPE_DECL
3163               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3164                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3165                         == TYPE_DECL))))
3166         {
3167           /* We do nothing special here, because C++ does such nasty
3168              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3169              get shadowed, and know that if we need to find a TYPE_DECL
3170              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3171              slot of the identifier.  */
3172           return 0;
3173         }
3174
3175       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3176            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3177           || (TREE_CODE (olddecl) == FUNCTION_DECL
3178               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3179         return 0;
3180
3181       error ("`%#D' redeclared as different kind of symbol", newdecl);
3182       if (TREE_CODE (olddecl) == TREE_LIST)
3183         olddecl = TREE_VALUE (olddecl);
3184       cp_error_at ("previous declaration of `%#D'", olddecl);
3185
3186       /* New decl is completely inconsistent with the old one =>
3187          tell caller to replace the old one.  */
3188
3189       return 0;
3190     }
3191   else if (!types_match)
3192     {
3193       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3194         /* These are certainly not duplicate declarations; they're
3195            from different scopes.  */
3196         return 0;
3197
3198       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3199         {
3200           /* The name of a class template may not be declared to refer to
3201              any other template, class, function, object, namespace, value,
3202              or type in the same scope.  */
3203           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3204               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3205             {
3206               error ("declaration of template `%#D'", newdecl);
3207               cp_error_at ("conflicts with previous declaration `%#D'",
3208                            olddecl);
3209             }
3210           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3211                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3212                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3213                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3214                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3215                                            DECL_TEMPLATE_PARMS (olddecl)))
3216             {
3217               error ("new declaration `%#D'", newdecl);
3218               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3219             }
3220           return 0;
3221         }
3222       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3223         {
3224           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3225             {
3226               error ("declaration of C function `%#D' conflicts with",
3227                         newdecl);
3228               cp_error_at ("previous declaration `%#D' here", olddecl);
3229             }
3230           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3231                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3232             {
3233               error ("new declaration `%#D'", newdecl);
3234               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3235             }
3236           else
3237             return 0;
3238         }
3239
3240       /* Already complained about this, so don't do so again.  */
3241       else if (current_class_type == NULL_TREE
3242           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3243         {
3244           error ("conflicting types for `%#D'", newdecl);
3245           cp_error_at ("previous declaration as `%#D'", olddecl);
3246         }
3247     }
3248   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3249             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3250                  && (!DECL_TEMPLATE_INFO (newdecl)
3251                      || (DECL_TI_TEMPLATE (newdecl)
3252                          != DECL_TI_TEMPLATE (olddecl))))
3253                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3254                     && (!DECL_TEMPLATE_INFO (olddecl)
3255                         || (DECL_TI_TEMPLATE (olddecl)
3256                             != DECL_TI_TEMPLATE (newdecl))))))
3257     /* It's OK to have a template specialization and a non-template
3258        with the same type, or to have specializations of two
3259        different templates with the same type.  Note that if one is a
3260        specialization, and the other is an instantiation of the same
3261        template, that we do not exit at this point.  That situation
3262        can occur if we instantiate a template class, and then
3263        specialize one of its methods.  This situation is valid, but
3264        the declarations must be merged in the usual way.  */
3265     return 0;
3266   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3267            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3268                 && !DECL_USE_TEMPLATE (newdecl))
3269                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3270                    && !DECL_USE_TEMPLATE (olddecl))))
3271     /* One of the declarations is a template instantiation, and the
3272        other is not a template at all.  That's OK.  */
3273     return 0;
3274   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3275            && DECL_NAMESPACE_ALIAS (newdecl)
3276            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3277     /* Redeclaration of namespace alias, ignore it.  */
3278     return 1;
3279   else
3280     {
3281       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3282       if (errmsg)
3283         {
3284           error (errmsg, newdecl);
3285           if (DECL_NAME (olddecl) != NULL_TREE)
3286             cp_error_at ((DECL_INITIAL (olddecl)
3287                           && namespace_bindings_p ())
3288                          ? "`%#D' previously defined here"
3289                          : "`%#D' previously declared here", olddecl);
3290           return 0;
3291         }
3292       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3293                && DECL_INITIAL (olddecl) != NULL_TREE
3294                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3295                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3296         {
3297           /* Prototype decl follows defn w/o prototype.  */
3298           cp_warning_at ("prototype for `%#D'", newdecl);
3299           cp_warning_at ("follows non-prototype definition here", olddecl);
3300         }
3301       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3302                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3303         {
3304           /* extern "C" int foo ();
3305              int foo () { bar (); }
3306              is OK.  */
3307           if (current_lang_depth () == 0)
3308             SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3309           else
3310             {
3311               cp_error_at ("previous declaration of `%#D' with %L linkage",
3312                            olddecl, DECL_LANGUAGE (olddecl));
3313               error ("conflicts with new declaration with %L linkage",
3314                         DECL_LANGUAGE (newdecl));
3315             }
3316         }
3317
3318       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3319         ;
3320       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3321         {
3322           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3323           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3324           int i = 1;
3325
3326           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3327             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3328
3329           for (; t1 && t1 != void_list_node;
3330                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3331             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3332               {
3333                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3334                                            TREE_PURPOSE (t2)))
3335                   {
3336                     pedwarn ("default argument given for parameter %d of `%#D'",
3337                              i, newdecl);
3338                     cp_pedwarn_at ("after previous specification in `%#D'",
3339                                    olddecl);
3340                   }
3341                 else
3342                   {
3343                     error ("default argument given for parameter %d of `%#D'",
3344                               i, newdecl);
3345                     cp_error_at ("after previous specification in `%#D'",
3346                                  olddecl);
3347                   }
3348               }
3349
3350           if (DECL_DECLARED_INLINE_P (newdecl)
3351               && ! DECL_DECLARED_INLINE_P (olddecl)
3352               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3353             {
3354               warning ("`%#D' was used before it was declared inline",
3355                           newdecl);
3356               cp_warning_at ("previous non-inline declaration here",
3357                              olddecl);
3358             }
3359         }
3360     }
3361
3362   /* Do not merge an implicit typedef with an explicit one.  In:
3363
3364        class A;
3365        ...
3366        typedef class A A __attribute__ ((foo));
3367
3368      the attribute should apply only to the typedef.  */
3369   if (TREE_CODE (olddecl) == TYPE_DECL
3370       && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
3371           || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
3372     return 0;
3373
3374   /* If new decl is `static' and an `extern' was seen previously,
3375      warn about it.  */
3376   warn_extern_redeclared_static (newdecl, olddecl);
3377
3378   /* We have committed to returning 1 at this point.  */
3379   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3380     {
3381       /* Now that functions must hold information normally held
3382          by field decls, there is extra work to do so that
3383          declaration information does not get destroyed during
3384          definition.  */
3385       if (DECL_VINDEX (olddecl))
3386         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3387       if (DECL_CONTEXT (olddecl))
3388         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3389       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3390       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3391       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3392       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3393       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3394       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3395       if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
3396         SET_OVERLOADED_OPERATOR_CODE
3397           (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
3398       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3399
3400       /* Optionally warn about more than one declaration for the same
3401          name, but don't warn about a function declaration followed by a
3402          definition.  */
3403       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3404           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3405           /* Don't warn about extern decl followed by definition.  */
3406           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3407           /* Don't warn about friends, let add_friend take care of it.  */
3408           && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
3409         {
3410           warning ("redundant redeclaration of `%D' in same scope", newdecl);
3411           cp_warning_at ("previous declaration of `%D'", olddecl);
3412         }
3413     }
3414
3415   /* Deal with C++: must preserve virtual function table size.  */
3416   if (TREE_CODE (olddecl) == TYPE_DECL)
3417     {
3418       register tree newtype = TREE_TYPE (newdecl);
3419       register tree oldtype = TREE_TYPE (olddecl);
3420
3421       if (newtype != error_mark_node && oldtype != error_mark_node
3422           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3423         CLASSTYPE_FRIEND_CLASSES (newtype)
3424           = CLASSTYPE_FRIEND_CLASSES (oldtype);
3425 \
3426       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3427     }
3428
3429   /* Copy all the DECL_... slots specified in the new decl
3430      except for any that we copy here from the old type.  */
3431   DECL_ATTRIBUTES (newdecl)
3432     = (*targetm.merge_decl_attributes) (olddecl, newdecl);
3433
3434   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3435     {
3436       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3437       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3438         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3439                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3440
3441       /* If the new declaration is a definition, update the file and
3442          line information on the declaration.  */
3443       if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
3444           && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
3445         {
3446           DECL_SOURCE_LOCATION (olddecl)
3447             = DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (olddecl))
3448             = DECL_SOURCE_LOCATION (newdecl);
3449         }
3450
3451       return 1;
3452     }
3453
3454   if (types_match)
3455     {
3456       /* Automatically handles default parameters.  */
3457       tree oldtype = TREE_TYPE (olddecl);
3458       tree newtype;
3459
3460       /* Merge the data types specified in the two decls.  */
3461       newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3462
3463       /* If merge_types produces a non-typedef type, just use the old type.  */
3464       if (TREE_CODE (newdecl) == TYPE_DECL
3465           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3466         newtype = oldtype;
3467
3468       if (TREE_CODE (newdecl) == VAR_DECL)
3469         {
3470           DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3471           DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
3472         }
3473
3474       /* Do this after calling `merge_types' so that default
3475          parameters don't confuse us.  */
3476       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3477           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3478               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3479         {
3480           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3481                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3482           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3483                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3484
3485           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3486               && DECL_SOURCE_LINE (olddecl) != 0
3487               && flag_exceptions
3488               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3489                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3490             {
3491               error ("declaration of `%F' throws different exceptions",
3492                         newdecl);
3493               cp_error_at ("than previous declaration `%F'", olddecl);
3494             }
3495         }
3496       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3497
3498       /* Lay the type out, unless already done.  */
3499       if (! same_type_p (newtype, oldtype)
3500           && TREE_TYPE (newdecl) != error_mark_node
3501           && !(processing_template_decl && uses_template_parms (newdecl)))
3502         layout_type (TREE_TYPE (newdecl));
3503
3504       if ((TREE_CODE (newdecl) == VAR_DECL
3505            || TREE_CODE (newdecl) == PARM_DECL
3506            || TREE_CODE (newdecl) == RESULT_DECL
3507            || TREE_CODE (newdecl) == FIELD_DECL
3508            || TREE_CODE (newdecl) == TYPE_DECL)
3509           && !(processing_template_decl && uses_template_parms (newdecl)))
3510         layout_decl (newdecl, 0);
3511
3512       /* Merge the type qualifiers.  */
3513       if (TREE_READONLY (newdecl))
3514         TREE_READONLY (olddecl) = 1;
3515       if (TREE_THIS_VOLATILE (newdecl))
3516         TREE_THIS_VOLATILE (olddecl) = 1;
3517
3518       /* Merge the initialization information.  */
3519       if (DECL_INITIAL (newdecl) == NULL_TREE
3520           && DECL_INITIAL (olddecl) != NULL_TREE)
3521         {
3522           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3523           DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
3524           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3525               && DECL_LANG_SPECIFIC (newdecl)
3526               && DECL_LANG_SPECIFIC (olddecl))
3527             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3528         }
3529
3530       /* Merge the section attribute.
3531          We want to issue an error if the sections conflict but that must be
3532          done later in decl_attributes since we are called before attributes
3533          are assigned.  */
3534       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3535         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3536
3537       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3538         {
3539           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3540             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3541           DECL_NO_LIMIT_STACK (newdecl)
3542             |= DECL_NO_LIMIT_STACK (olddecl);
3543           /* Keep the old RTL.  */
3544           COPY_DECL_RTL (olddecl, newdecl);
3545         }
3546       else if (TREE_CODE (newdecl) == VAR_DECL
3547                && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
3548         {
3549           /* Keep the old RTL.  We cannot keep the old RTL if the old
3550              declaration was for an incomplete object and the new
3551              declaration is not since many attributes of the RTL will
3552              change.  */
3553           COPY_DECL_RTL (olddecl, newdecl);
3554         }
3555     }
3556   /* If cannot merge, then use the new type and qualifiers,
3557      and don't preserve the old rtl.  */
3558   else
3559     {
3560       /* Clean out any memory we had of the old declaration.  */
3561       tree oldstatic = value_member (olddecl, static_aggregates);
3562       if (oldstatic)
3563         TREE_VALUE (oldstatic) = error_mark_node;
3564
3565       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3566       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3567       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3568       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3569     }
3570
3571   /* Merge the storage class information.  */
3572   merge_weak (newdecl, olddecl);
3573
3574   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3575   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3576   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3577   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3578   if (! DECL_EXTERNAL (olddecl))
3579     DECL_EXTERNAL (newdecl) = 0;
3580
3581   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3582     {
3583       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3584       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3585       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3586       DECL_TEMPLATE_INSTANTIATED (newdecl)
3587         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3588       /* Don't really know how much of the language-specific
3589          values we should copy from old to new.  */
3590       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3591       DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
3592         DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
3593       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3594       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3595       DECL_INITIALIZED_IN_CLASS_P (newdecl)
3596         |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
3597       olddecl_friend = DECL_FRIEND_P (olddecl);
3598
3599       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3600       if (TREE_CODE (newdecl) == FUNCTION_DECL
3601           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3602         {
3603           DECL_BEFRIENDING_CLASSES (newdecl)
3604             = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3605                        DECL_BEFRIENDING_CLASSES (olddecl));
3606           DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
3607         }
3608     }
3609
3610   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3611     {
3612       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3613           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3614         {
3615           /* If newdecl is not a specialization, then it is not a
3616              template-related function at all.  And that means that we
3617              shoud have exited above, returning 0.  */
3618           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3619                               0);
3620
3621           if (TREE_USED (olddecl))
3622             /* From [temp.expl.spec]:
3623
3624                If a template, a member template or the member of a class
3625                template is explicitly specialized then that
3626                specialization shall be declared before the first use of
3627                that specialization that would cause an implicit
3628                instantiation to take place, in every translation unit in
3629                which such a use occurs.  */
3630             error ("explicit specialization of %D after first use",
3631                       olddecl);
3632
3633           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3634
3635           /* [temp.expl.spec/14] We don't inline explicit specialization
3636              just because the primary template says so.  */
3637         }
3638       else
3639         {
3640           if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3641             DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3642
3643           DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
3644
3645           /* If either decl says `inline', this fn is inline, unless
3646              its definition was passed already.  */
3647           if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3648             DECL_INLINE (olddecl) = 1;
3649           DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3650
3651           DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
3652             = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
3653         }
3654
3655       /* Preserve abstractness on cloned [cd]tors.  */
3656       DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
3657
3658       if (! types_match)
3659         {
3660           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3661           COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
3662           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3663         }
3664       if (! types_match || new_defines_function)
3665         {
3666           /* These need to be copied so that the names are available.
3667              Note that if the types do match, we'll preserve inline
3668              info and other bits, but if not, we won't.  */
3669           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3670           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3671         }
3672       if (new_defines_function)
3673         /* If defining a function declared with other language
3674            linkage, use the previously declared language linkage.  */
3675         SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3676       else if (types_match)
3677         {
3678           /* If redeclaring a builtin function, and not a definition,
3679              it stays built in.  */
3680           if (DECL_BUILT_IN (olddecl))
3681             {
3682               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3683               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3684               /* If we're keeping the built-in definition, keep the rtl,
3685                  regardless of declaration matches.  */
3686               SET_DECL_RTL (newdecl, DECL_RTL (olddecl));
3687             }
3688           else
3689             DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
3690
3691           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3692           /* Don't clear out the arguments if we're redefining a function.  */
3693           if (DECL_ARGUMENTS (olddecl))
3694             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3695         }
3696     }
3697   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3698     NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3699
3700   /* Now preserve various other info from the definition.  */
3701   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3702   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3703   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3704   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3705
3706   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3707     {
3708       int function_size;
3709
3710       function_size = sizeof (struct tree_decl);
3711
3712       memcpy ((char *) olddecl + sizeof (struct tree_common),
3713               (char *) newdecl + sizeof (struct tree_common),
3714               function_size - sizeof (struct tree_common));
3715
3716       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3717         {
3718           /* If newdecl is a template instantiation, it is possible that
3719              the following sequence of events has occurred:
3720
3721              o A friend function was declared in a class template.  The
3722              class template was instantiated.
3723
3724              o The instantiation of the friend declaration was
3725              recorded on the instantiation list, and is newdecl.
3726
3727              o Later, however, instantiate_class_template called pushdecl
3728              on the newdecl to perform name injection.  But, pushdecl in
3729              turn called duplicate_decls when it discovered that another
3730              declaration of a global function with the same name already
3731              existed.
3732
3733              o Here, in duplicate_decls, we decided to clobber newdecl.
3734
3735              If we're going to do that, we'd better make sure that
3736              olddecl, and not newdecl, is on the list of
3737              instantiations so that if we try to do the instantiation
3738              again we won't get the clobbered declaration.  */
3739
3740           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3741           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3742
3743           for (; decls; decls = TREE_CHAIN (decls))
3744             if (TREE_VALUE (decls) == newdecl)
3745               TREE_VALUE (decls) = olddecl;
3746         }
3747     }
3748   else
3749     {
3750       memcpy ((char *) olddecl + sizeof (struct tree_common),
3751               (char *) newdecl + sizeof (struct tree_common),
3752               sizeof (struct tree_decl) - sizeof (struct tree_common)
3753               + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
3754     }
3755
3756   DECL_UID (olddecl) = olddecl_uid;
3757   if (olddecl_friend)
3758     DECL_FRIEND_P (olddecl) = 1;
3759
3760   /* NEWDECL contains the merged attribute lists.
3761      Update OLDDECL to be the same.  */
3762   DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
3763
3764   return 1;
3765 }
3766
3767 /* Record a decl-node X as belonging to the current lexical scope.
3768    Check for errors (such as an incompatible declaration for the same
3769    name already seen in the same scope).
3770
3771    Returns either X or an old decl for the same name.
3772    If an old decl is returned, it may have been smashed
3773    to agree with what X says.  */
3774
3775 tree
3776 pushdecl (x)
3777      tree x;
3778 {
3779   register tree t;
3780   register tree name;
3781   int need_new_binding;
3782
3783   /* We shouldn't be calling pushdecl when we're generating RTL for a
3784      function that we already did semantic analysis on previously.  */
3785   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3786                       19990913);
3787
3788   need_new_binding = 1;
3789
3790   if (DECL_TEMPLATE_PARM_P (x))
3791     /* Template parameters have no context; they are not X::T even
3792        when declared within a class or namespace.  */
3793     ;
3794   else
3795     {
3796       if (current_function_decl && x != current_function_decl
3797           /* A local declaration for a function doesn't constitute
3798              nesting.  */
3799           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3800           /* A local declaration for an `extern' variable is in the
3801              scope of the current namespace, not the current
3802              function.  */
3803           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3804           && !DECL_CONTEXT (x))
3805         DECL_CONTEXT (x) = current_function_decl;
3806
3807       /* If this is the declaration for a namespace-scope function,
3808          but the declaration itself is in a local scope, mark the
3809          declaration.  */
3810       if (TREE_CODE (x) == FUNCTION_DECL
3811           && DECL_NAMESPACE_SCOPE_P (x)
3812           && current_function_decl
3813           && x != current_function_decl)
3814         DECL_LOCAL_FUNCTION_P (x) = 1;
3815     }
3816
3817   name = DECL_NAME (x);
3818   if (name)
3819     {
3820       int different_binding_level = 0;
3821
3822       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3823         name = TREE_OPERAND (name, 0);
3824
3825       /* In case this decl was explicitly namespace-qualified, look it
3826          up in its namespace context.  */
3827       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3828           && namespace_bindings_p ())
3829         t = namespace_binding (name, DECL_CONTEXT (x));
3830       else
3831         t = lookup_name_current_level (name);
3832
3833       /* [basic.link] If there is a visible declaration of an entity
3834          with linkage having the same name and type, ignoring entities
3835          declared outside the innermost enclosing namespace scope, the
3836          block scope declaration declares that same entity and
3837          receives the linkage of the previous declaration.  */
3838       if (! t && current_function_decl && x != current_function_decl
3839           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3840           && DECL_EXTERNAL (x))
3841         {
3842           /* Look in block scope.  */
3843           t = IDENTIFIER_VALUE (name);
3844           /* Or in the innermost namespace.  */
3845           if (! t)
3846             t = namespace_binding (name, DECL_CONTEXT (x));
3847           /* Does it have linkage?  Note that if this isn't a DECL, it's an
3848              OVERLOAD, which is OK.  */
3849           if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3850             t = NULL_TREE;
3851           if (t)
3852             different_binding_level = 1;
3853         }
3854
3855       /* If we are declaring a function, and the result of name-lookup
3856          was an OVERLOAD, look for an overloaded instance that is
3857          actually the same as the function we are declaring.  (If
3858          there is one, we have to merge our declaration with the
3859          previous declaration.)  */
3860       if (t && TREE_CODE (t) == OVERLOAD)
3861         {
3862           tree match;
3863
3864           if (TREE_CODE (x) == FUNCTION_DECL)
3865             for (match = t; match; match = OVL_NEXT (match))
3866               {
3867                 if (decls_match (OVL_CURRENT (match), x))
3868                   break;
3869               }
3870           else
3871             /* Just choose one.  */
3872             match = t;
3873
3874           if (match)
3875             t = OVL_CURRENT (match);
3876           else
3877             t = NULL_TREE;
3878         }
3879
3880       if (t == error_mark_node)
3881         {
3882           /* error_mark_node is 0 for a while during initialization!  */
3883           t = NULL_TREE;
3884           cp_error_at ("`%#D' used prior to declaration", x);
3885         }
3886       else if (t != NULL_TREE)
3887         {
3888           if (different_binding_level)
3889             {
3890               if (decls_match (x, t))
3891                 /* The standard only says that the local extern
3892                    inherits linkage from the previous decl; in
3893                    particular, default args are not shared.  It would
3894                    be nice to propagate inlining info, though.  FIXME.  */
3895                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3896             }
3897           else if (TREE_CODE (t) == PARM_DECL)
3898             {
3899               if (DECL_CONTEXT (t) == NULL_TREE)
3900                 /* This is probaby caused by too many errors, but calling
3901                    abort will say that if errors have occurred.  */
3902                 abort ();
3903
3904               /* Check for duplicate params.  */
3905               if (duplicate_decls (x, t))
3906                 return t;
3907             }
3908           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3909                     || DECL_FUNCTION_TEMPLATE_P (x))
3910                    && is_overloaded_fn (t))
3911             /* Don't do anything just yet.  */;
3912           else if (t == wchar_decl_node)
3913             {
3914               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3915                 pedwarn ("redeclaration of `wchar_t' as `%T'",
3916                             TREE_TYPE (x));
3917
3918               /* Throw away the redeclaration.  */
3919               return t;
3920             }
3921           else if (TREE_CODE (t) != TREE_CODE (x))
3922             {
3923               if (duplicate_decls (x, t))
3924                 return t;
3925             }
3926           else if (duplicate_decls (x, t))
3927             {
3928               if (TREE_CODE (t) == TYPE_DECL)
3929                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3930               else if (TREE_CODE (t) == FUNCTION_DECL)
3931                 check_default_args (t);
3932
3933               return t;
3934             }
3935           else if (DECL_MAIN_P (x))
3936             {
3937               /* A redeclaration of main, but not a duplicate of the
3938                  previous one.
3939
3940                  [basic.start.main]
3941
3942                  This function shall not be overloaded.  */
3943               cp_error_at ("invalid redeclaration of `%D'", t);
3944               error ("as `%D'", x);
3945               /* We don't try to push this declaration since that
3946                  causes a crash.  */
3947               return x;
3948             }
3949         }
3950
3951       check_template_shadow (x);
3952
3953       /* If this is a function conjured up by the backend, massage it
3954          so it looks friendly.  */
3955       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3956         {
3957           retrofit_lang_decl (x);
3958           SET_DECL_LANGUAGE (x, lang_c);
3959         }
3960
3961       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3962         {
3963           t = push_overloaded_decl (x, PUSH_LOCAL);
3964           if (t != x)
3965             return t;
3966           if (!namespace_bindings_p ())
3967             /* We do not need to create a binding for this name;
3968                push_overloaded_decl will have already done so if
3969                necessary.  */
3970             need_new_binding = 0;
3971         }
3972       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3973         {
3974           t = push_overloaded_decl (x, PUSH_GLOBAL);
3975           if (t == x)
3976             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3977           return t;
3978         }
3979
3980       /* If declaring a type as a typedef, copy the type (unless we're
3981          at line 0), and install this TYPE_DECL as the new type's typedef
3982          name.  See the extensive comment in ../c-decl.c (pushdecl).  */
3983       if (TREE_CODE (x) == TYPE_DECL)
3984         {
3985           tree type = TREE_TYPE (x);
3986           if (DECL_SOURCE_LINE (x) == 0)
3987             {
3988               if (TYPE_NAME (type) == 0)
3989                 TYPE_NAME (type) = x;
3990             }
3991           else if (type != error_mark_node && TYPE_NAME (type) != x
3992                    /* We don't want to copy the type when all we're
3993                       doing is making a TYPE_DECL for the purposes of
3994                       inlining.  */
3995                    && (!TYPE_NAME (type)
3996                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3997             {
3998               DECL_ORIGINAL_TYPE (x) = type;
3999               type = build_type_copy (type);
4000               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4001               TYPE_NAME (type) = x;
4002               TREE_TYPE (x) = type;
4003             }
4004
4005           if (type != error_mark_node
4006               && TYPE_NAME (type)
4007               && TYPE_IDENTIFIER (type))
4008             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4009                                                   current_binding_level);
4010
4011         }
4012
4013       /* Multiple external decls of the same identifier ought to match.
4014
4015          We get warnings about inline functions where they are defined.
4016          We get warnings about other functions from push_overloaded_decl.
4017
4018          Avoid duplicate warnings where they are used.  */
4019       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4020         {
4021           tree decl;
4022
4023           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4024           if (decl && TREE_CODE (decl) == OVERLOAD)
4025             decl = OVL_FUNCTION (decl);
4026
4027           if (decl && decl != error_mark_node
4028               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4029               /* If different sort of thing, we already gave an error.  */
4030               && TREE_CODE (decl) == TREE_CODE (x)
4031               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4032             {
4033               pedwarn ("type mismatch with previous external decl", x);
4034               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4035             }
4036         }
4037
4038       /* This name is new in its binding level.
4039          Install the new declaration and return it.  */
4040       if (namespace_bindings_p ())
4041         {
4042           /* Install a global value.  */
4043
4044           /* If the first global decl has external linkage,
4045              warn if we later see static one.  */
4046           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4047             TREE_PUBLIC (name) = 1;
4048
4049           /* Bind the name for the entity.  */
4050           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4051                 && t != NULL_TREE)
4052               && (TREE_CODE (x) == TYPE_DECL
4053                   || TREE_CODE (x) == VAR_DECL
4054                   || TREE_CODE (x) == NAMESPACE_DECL
4055                   || TREE_CODE (x) == CONST_DECL
4056                   || TREE_CODE (x) == TEMPLATE_DECL))
4057             SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
4058
4059           /* Don't forget if the function was used via an implicit decl.  */
4060           if (IDENTIFIER_IMPLICIT_DECL (name)
4061               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4062             TREE_USED (x) = 1;
4063
4064           /* Don't forget if its address was taken in that way.  */
4065           if (IDENTIFIER_IMPLICIT_DECL (name)
4066               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4067             TREE_ADDRESSABLE (x) = 1;
4068
4069           /* Warn about mismatches against previous implicit decl.  */
4070           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4071               /* If this real decl matches the implicit, don't complain.  */
4072               && ! (TREE_CODE (x) == FUNCTION_DECL
4073                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4074             warning
4075               ("`%D' was previously implicitly declared to return `int'", x);
4076
4077           /* If new decl is `static' and an `extern' was seen previously,
4078              warn about it.  */
4079           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4080             warn_extern_redeclared_static (x, t);
4081         }
4082       else
4083         {
4084           /* Here to install a non-global value.  */
4085           tree oldlocal = IDENTIFIER_VALUE (name);
4086           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4087
4088           if (need_new_binding)
4089             {
4090               push_local_binding (name, x, 0);
4091               /* Because push_local_binding will hook X on to the
4092                  current_binding_level's name list, we don't want to
4093                  do that again below.  */
4094               need_new_binding = 0;
4095             }
4096
4097           /* If this is a TYPE_DECL, push it into the type value slot.  */
4098           if (TREE_CODE (x) == TYPE_DECL)
4099             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4100                                                   current_binding_level);
4101
4102           /* Clear out any TYPE_DECL shadowed by a namespace so that
4103              we won't think this is a type.  The C struct hack doesn't
4104              go through namespaces.  */
4105           if (TREE_CODE (x) == NAMESPACE_DECL)
4106             set_identifier_type_value_with_scope (name, NULL_TREE,
4107                                                   current_binding_level);
4108
4109           if (oldlocal)
4110             {
4111               tree d = oldlocal;
4112
4113               while (oldlocal
4114                      && TREE_CODE (oldlocal) == VAR_DECL
4115                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4116                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4117
4118               if (oldlocal == NULL_TREE)
4119                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4120             }
4121
4122           /* If this is an extern function declaration, see if we
4123              have a global definition or declaration for the function.  */
4124           if (oldlocal == NULL_TREE
4125               && DECL_EXTERNAL (x)
4126               && oldglobal != NULL_TREE
4127               && TREE_CODE (x) == FUNCTION_DECL
4128               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4129             {
4130               /* We have one.  Their types must agree.  */
4131               if (decls_match (x, oldglobal))
4132                 /* OK */;
4133               else
4134                 {
4135                   warning ("extern declaration of `%#D' doesn't match", x);
4136                   cp_warning_at ("global declaration `%#D'", oldglobal);
4137                 }
4138             }
4139           /* If we have a local external declaration,
4140              and no file-scope declaration has yet been seen,
4141              then if we later have a file-scope decl it must not be static.  */
4142           if (oldlocal == NULL_TREE
4143               && oldglobal == NULL_TREE
4144               && DECL_EXTERNAL (x)
4145               && TREE_PUBLIC (x))
4146             TREE_PUBLIC (name) = 1;
4147
4148           /* Warn if shadowing an argument at the top level of the body.  */
4149           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4150               /* Inline decls shadow nothing.  */
4151               && !DECL_FROM_INLINE (x)
4152               && TREE_CODE (oldlocal) == PARM_DECL)
4153             {
4154               bool err = false;
4155
4156               /* Don't complain if it's from an enclosing function.  */
4157               if (DECL_CONTEXT (oldlocal) == current_function_decl
4158                   && TREE_CODE (x) != PARM_DECL)
4159                 {
4160                   /* Go to where the parms should be and see if we find
4161                      them there.  */
4162                   struct cp_binding_level *b = current_binding_level->level_chain;
4163
4164                   /* Skip the ctor/dtor cleanup level.  */
4165                   b = b->level_chain;
4166
4167                   /* ARM $8.3 */
4168                   if (b->parm_flag == 1)
4169                     {
4170                       error ("declaration of `%#D' shadows a parameter",
4171                                 name);
4172                       err = true;
4173                     }
4174                 }
4175
4176               if (warn_shadow && !err)
4177                 shadow_warning ("a parameter", name, oldlocal);
4178             }
4179
4180           /* Maybe warn if shadowing something else.  */
4181           else if (warn_shadow && !DECL_EXTERNAL (x)
4182               /* No shadow warnings for internally generated vars.  */
4183               && ! DECL_ARTIFICIAL (x)
4184               /* No shadow warnings for vars made for inlining.  */
4185               && ! DECL_FROM_INLINE (x))
4186             {
4187               if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4188                        && current_class_ptr
4189                        && !TREE_STATIC (name))
4190                 warning ("declaration of `%s' shadows a member of `this'",
4191                             IDENTIFIER_POINTER (name));
4192               else if (oldlocal != NULL_TREE
4193                        && TREE_CODE (oldlocal) == VAR_DECL)
4194                 shadow_warning ("a previous local", name, oldlocal);
4195               else if (oldglobal != NULL_TREE
4196                        && TREE_CODE (oldglobal) == VAR_DECL)
4197                 /* XXX shadow warnings in outer-more namespaces */
4198                 shadow_warning ("a global declaration", name, oldglobal);
4199             }
4200         }
4201
4202       if (TREE_CODE (x) == FUNCTION_DECL)
4203         check_default_args (x);
4204
4205       if (TREE_CODE (x) == VAR_DECL)
4206         maybe_register_incomplete_var (x);
4207     }
4208
4209   if (need_new_binding)
4210     add_decl_to_level (x,
4211                        DECL_NAMESPACE_SCOPE_P (x)
4212                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4213                        : current_binding_level);
4214
4215   return x;
4216 }
4217
4218 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4219    caller to set DECL_CONTEXT properly.  */
4220
4221 static tree
4222 pushdecl_with_scope (x, level)
4223      tree x;
4224      struct cp_binding_level *level;
4225 {
4226   register struct cp_binding_level *b;
4227   tree function_decl = current_function_decl;
4228
4229   current_function_decl = NULL_TREE;
4230   if (level->parm_flag == 2)
4231     {
4232       b = class_binding_level;
4233       class_binding_level = level;
4234       pushdecl_class_level (x);
4235       class_binding_level = b;
4236     }
4237   else
4238     {
4239       b = current_binding_level;
4240       current_binding_level = level;
4241       x = pushdecl (x);
4242       current_binding_level = b;
4243     }
4244   current_function_decl = function_decl;
4245   return x;
4246 }
4247
4248 /* Like pushdecl, only it places X in the current namespace,
4249    if appropriate.  */
4250
4251 tree
4252 pushdecl_namespace_level (x)
4253      tree x;
4254 {
4255   register struct cp_binding_level *b = current_binding_level;
4256   register tree t;
4257
4258   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4259
4260   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4261      what we want.  */
4262   if (TREE_CODE (x) == TYPE_DECL)
4263     {
4264       tree name = DECL_NAME (x);
4265       tree newval;
4266       tree *ptr = (tree *)0;
4267       for (; b != global_binding_level; b = b->level_chain)
4268         {
4269           tree shadowed = b->type_shadowed;
4270           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4271             if (TREE_PURPOSE (shadowed) == name)
4272               {
4273                 ptr = &TREE_VALUE (shadowed);
4274                 /* Can't break out of the loop here because sometimes
4275                    a binding level will have duplicate bindings for
4276                    PT names.  It's gross, but I haven't time to fix it.  */
4277               }
4278         }
4279       newval = TREE_TYPE (x);
4280       if (ptr == (tree *)0)
4281         {
4282           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4283              up here if this is changed to an assertion.  --KR  */
4284           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4285         }
4286       else
4287         {
4288           *ptr = newval;
4289         }
4290     }
4291   return t;
4292 }
4293
4294 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4295    if appropriate.  */
4296
4297 tree
4298 pushdecl_top_level (x)
4299      tree x;
4300 {
4301   push_to_top_level ();
4302   x = pushdecl_namespace_level (x);
4303   pop_from_top_level ();
4304   return x;
4305 }
4306
4307 /* Make the declaration of X appear in CLASS scope.  */
4308
4309 void
4310 pushdecl_class_level (x)
4311      tree x;
4312 {
4313   tree name;
4314
4315   /* Get the name of X.  */
4316   if (TREE_CODE (x) == OVERLOAD)
4317     name = DECL_NAME (get_first_fn (x));
4318   else
4319     name = DECL_NAME (x);
4320
4321   if (name)
4322     {
4323       push_class_level_binding (name, x);
4324       if (TREE_CODE (x) == TYPE_DECL)
4325         set_identifier_type_value (name, TREE_TYPE (x));
4326     }
4327   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4328     {
4329       /* If X is an anonymous aggregate, all of its members are
4330          treated as if they were members of the class containing the
4331          aggregate, for naming purposes.  */
4332       tree f;
4333
4334       for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
4335         pushdecl_class_level (f);
4336     }
4337 }
4338
4339 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4340    DECL, or a modified version thereof.  */
4341
4342 tree
4343 maybe_push_decl (decl)
4344      tree decl;
4345 {
4346   tree type = TREE_TYPE (decl);
4347
4348   /* Add this decl to the current binding level, but not if it comes
4349      from another scope, e.g. a static member variable.  TEM may equal
4350      DECL or it may be a previous decl of the same name.  */
4351   if (decl == error_mark_node
4352       || (TREE_CODE (decl) != PARM_DECL
4353           && DECL_CONTEXT (decl) != NULL_TREE
4354           /* Definitions of namespace members outside their namespace are
4355              possible.  */
4356           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4357       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4358       || TREE_CODE (type) == UNKNOWN_TYPE
4359       /* The declaration of a template specialization does not affect
4360          the functions available for overload resolution, so we do not
4361          call pushdecl.  */
4362       || (TREE_CODE (decl) == FUNCTION_DECL
4363           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4364     return decl;
4365   else
4366     return pushdecl (decl);
4367 }
4368
4369 /* Make the declaration(s) of X appear in CLASS scope
4370    under the name NAME.  */
4371
4372 void
4373 push_class_level_binding (name, x)
4374      tree name;
4375      tree x;
4376 {
4377   tree binding;
4378   /* The class_binding_level will be NULL if x is a template
4379      parameter name in a member template.  */
4380   if (!class_binding_level)
4381     return;
4382
4383   /* Make sure that this new member does not have the same name
4384      as a template parameter.  */
4385   if (TYPE_BEING_DEFINED (current_class_type))
4386     check_template_shadow (x);
4387
4388   /* If this declaration shadows a declaration from an enclosing
4389      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4390      we leave this class.  Record the shadowed declaration here.  */
4391   binding = IDENTIFIER_BINDING (name);
4392   if (binding
4393       && ((TREE_CODE (x) == OVERLOAD
4394            && BINDING_VALUE (binding)
4395            && is_overloaded_fn (BINDING_VALUE (binding)))
4396           || INHERITED_VALUE_BINDING_P (binding)))
4397     {
4398       tree shadow;
4399       tree old_decl;
4400
4401       /* If the old binding was from a base class, and was for a tag
4402          name, slide it over to make room for the new binding.  The
4403          old binding is still visible if explicitly qualified with a
4404          class-key.  */
4405       if (INHERITED_VALUE_BINDING_P (binding)
4406           && BINDING_VALUE (binding)
4407           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4408           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4409           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4410         {
4411           old_decl = BINDING_TYPE (binding);
4412           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4413           BINDING_VALUE (binding) = NULL_TREE;
4414           INHERITED_VALUE_BINDING_P (binding) = 0;
4415         }
4416       else
4417         old_decl = BINDING_VALUE (binding);
4418
4419       /* Find the previous binding of name on the class-shadowed
4420          list, and update it.  */
4421       for (shadow = class_binding_level->class_shadowed;
4422            shadow;
4423            shadow = TREE_CHAIN (shadow))
4424         if (TREE_PURPOSE (shadow) == name
4425             && TREE_TYPE (shadow) == old_decl)
4426           {
4427             BINDING_VALUE (binding) = x;
4428             INHERITED_VALUE_BINDING_P (binding) = 0;
4429             TREE_TYPE (shadow) = x;
4430             IDENTIFIER_CLASS_VALUE (name) = x;
4431             return;
4432           }
4433     }
4434
4435   /* If we didn't replace an existing binding, put the binding on the
4436      stack of bindings for the identifier, and update the shadowed list.  */
4437   if (push_class_binding (name, x))
4438     {
4439       class_binding_level->class_shadowed
4440         = tree_cons (name, NULL,
4441                      class_binding_level->class_shadowed);
4442       /* Record the value we are binding NAME to so that we can know
4443          what to pop later.  */
4444       TREE_TYPE (class_binding_level->class_shadowed) = x;
4445     }
4446 }
4447
4448 /* Insert another USING_DECL into the current binding level, returning
4449    this declaration. If this is a redeclaration, do nothing, and
4450    return NULL_TREE if this not in namespace scope (in namespace
4451    scope, a using decl might extend any previous bindings).  */
4452
4453 tree
4454 push_using_decl (scope, name)
4455      tree scope;
4456      tree name;
4457 {
4458   tree decl;
4459
4460   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4461   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4462   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4463     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4464       break;
4465   if (decl)
4466     return namespace_bindings_p () ? decl : NULL_TREE;
4467   decl = build_lang_decl (USING_DECL, name, void_type_node);
4468   DECL_INITIAL (decl) = scope;
4469   TREE_CHAIN (decl) = current_binding_level->usings;
4470   current_binding_level->usings = decl;
4471   return decl;
4472 }
4473
4474 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4475    changed (i.e. there was already a directive), or the fresh
4476    TREE_LIST otherwise.  */
4477
4478 tree
4479 push_using_directive (used)
4480      tree used;
4481 {
4482   tree ud = current_binding_level->using_directives;
4483   tree iter, ancestor;
4484
4485   /* Check if we already have this.  */
4486   if (purpose_member (used, ud) != NULL_TREE)
4487     return NULL_TREE;
4488
4489   /* Recursively add all namespaces used.  */
4490   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4491     push_using_directive (TREE_PURPOSE (iter));
4492
4493   ancestor = namespace_ancestor (current_decl_namespace (), used);
4494   ud = current_binding_level->using_directives;
4495   ud = tree_cons (used, ancestor, ud);
4496   current_binding_level->using_directives = ud;
4497   return ud;
4498 }
4499
4500 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4501    other definitions already in place.  We get around this by making
4502    the value of the identifier point to a list of all the things that
4503    want to be referenced by that name.  It is then up to the users of
4504    that name to decide what to do with that list.
4505
4506    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4507    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4508
4509    FLAGS is a bitwise-or of the following values:
4510      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4511                  namespace scope.
4512      PUSH_USING: DECL is being pushed as the result of a using
4513                  declaration.
4514
4515    The value returned may be a previous declaration if we guessed wrong
4516    about what language DECL should belong to (C or C++).  Otherwise,
4517    it's always DECL (and never something that's not a _DECL).  */
4518
4519 tree
4520 push_overloaded_decl (decl, flags)
4521      tree decl;
4522      int flags;
4523 {
4524   tree name = DECL_NAME (decl);
4525   tree old;
4526   tree new_binding;
4527   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4528
4529   if (doing_global)
4530     old = namespace_binding (name, DECL_CONTEXT (decl));
4531   else
4532     old = lookup_name_current_level (name);
4533
4534   if (old)
4535     {
4536       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4537         {
4538           tree t = TREE_TYPE (old);
4539           if (IS_AGGR_TYPE (t) && warn_shadow
4540               && (! DECL_IN_SYSTEM_HEADER (decl)
4541                   || ! DECL_IN_SYSTEM_HEADER (old)))
4542             warning ("`%#D' hides constructor for `%#T'", decl, t);
4543           old = NULL_TREE;
4544         }
4545       else if (is_overloaded_fn (old))
4546         {
4547           tree tmp;
4548
4549           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4550             {
4551               tree fn = OVL_CURRENT (tmp);
4552
4553               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4554                   && !(flags & PUSH_USING)
4555                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4556                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4557                 error ("`%#D' conflicts with previous using declaration `%#D'",
4558                           decl, fn);
4559
4560               if (duplicate_decls (decl, fn))
4561                 return fn;
4562             }
4563         }
4564       else if (old == error_mark_node)
4565         /* Ignore the undefined symbol marker.  */
4566         old = NULL_TREE;
4567       else
4568         {
4569           cp_error_at ("previous non-function declaration `%#D'", old);
4570           error ("conflicts with function declaration `%#D'", decl);
4571           return decl;
4572         }
4573     }
4574
4575   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4576     {
4577       if (old && TREE_CODE (old) != OVERLOAD)
4578         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4579       else
4580         new_binding = ovl_cons (decl, old);
4581       if (flags & PUSH_USING)
4582         OVL_USED (new_binding) = 1;
4583     }
4584   else
4585     /* NAME is not ambiguous.  */
4586     new_binding = decl;
4587
4588   if (doing_global)
4589     set_namespace_binding (name, current_namespace, new_binding);
4590   else
4591     {
4592       /* We only create an OVERLOAD if there was a previous binding at
4593          this level, or if decl is a template. In the former case, we
4594          need to remove the old binding and replace it with the new
4595          binding.  We must also run through the NAMES on the binding
4596          level where the name was bound to update the chain.  */
4597
4598       if (TREE_CODE (new_binding) == OVERLOAD && old)
4599         {
4600           tree *d;
4601
4602           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4603                *d;
4604                d = &TREE_CHAIN (*d))
4605             if (*d == old
4606                 || (TREE_CODE (*d) == TREE_LIST
4607                     && TREE_VALUE (*d) == old))
4608               {
4609                 if (TREE_CODE (*d) == TREE_LIST)
4610                   /* Just replace the old binding with the new.  */
4611                   TREE_VALUE (*d) = new_binding;
4612                 else
4613                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4614                   *d = tree_cons (NULL_TREE, new_binding,
4615                                   TREE_CHAIN (*d));
4616
4617                 /* And update the CPLUS_BINDING node.  */
4618                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4619                   = new_binding;
4620                 return decl;
4621               }
4622
4623           /* We should always find a previous binding in this case.  */
4624           abort ();
4625         }
4626
4627       /* Install the new binding.  */
4628       push_local_binding (name, new_binding, flags);
4629     }
4630
4631   return decl;
4632 }
4633 \f
4634 /* Generate an implicit declaration for identifier FUNCTIONID
4635    as a function of type int ().  Print a warning if appropriate.  */
4636
4637 tree
4638 implicitly_declare (functionid)
4639      tree functionid;
4640 {
4641   register tree decl;
4642
4643   /* We used to reuse an old implicit decl here,
4644      but this loses with inline functions because it can clobber
4645      the saved decl chains.  */
4646   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4647
4648   DECL_EXTERNAL (decl) = 1;
4649   TREE_PUBLIC (decl) = 1;
4650
4651   /* ISO standard says implicit declarations are in the innermost block.
4652      So we record the decl in the standard fashion.  */
4653   pushdecl (decl);
4654   rest_of_decl_compilation (decl, NULL, 0, 0);
4655
4656   if (warn_implicit
4657       /* Only one warning per identifier.  */
4658       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4659     {
4660       pedwarn ("implicit declaration of function `%#D'", decl);
4661     }
4662
4663   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4664
4665   return decl;
4666 }
4667
4668 /* Return zero if the declaration NEWDECL is valid
4669    when the declaration OLDDECL (assumed to be for the same name)
4670    has already been seen.
4671    Otherwise return an error message format string with a %s
4672    where the identifier should go.  */
4673
4674 static const char *
4675 redeclaration_error_message (newdecl, olddecl)
4676      tree newdecl, olddecl;
4677 {
4678   if (TREE_CODE (newdecl) == TYPE_DECL)
4679     {
4680       /* Because C++ can put things into name space for free,
4681          constructs like "typedef struct foo { ... } foo"
4682          would look like an erroneous redeclaration.  */
4683       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4684         return 0;
4685       else
4686         return "redefinition of `%#D'";
4687     }
4688   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4689     {
4690       /* If this is a pure function, its olddecl will actually be
4691          the original initialization to `0' (which we force to call
4692          abort()).  Don't complain about redefinition in this case.  */
4693       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4694         return 0;
4695
4696       /* If both functions come from different namespaces, this is not
4697          a redeclaration - this is a conflict with a used function.  */
4698       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4699           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4700         return "`%D' conflicts with used function";
4701
4702       /* We'll complain about linkage mismatches in
4703          warn_extern_redeclared_static.  */
4704
4705       /* Defining the same name twice is no good.  */
4706       if (DECL_INITIAL (olddecl) != NULL_TREE
4707           && DECL_INITIAL (newdecl) != NULL_TREE)
4708         {
4709           if (DECL_NAME (olddecl) == NULL_TREE)
4710             return "`%#D' not declared in class";
4711           else
4712             return "redefinition of `%#D'";
4713         }
4714       return 0;
4715     }
4716   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4717     {
4718       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4719            && (DECL_TEMPLATE_RESULT (newdecl)
4720                != DECL_TEMPLATE_RESULT (olddecl))
4721            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4722            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4723           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4724               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4725               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4726         return "redefinition of `%#D'";
4727       return 0;
4728     }
4729   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4730     {
4731       /* Objects declared at top level:  */
4732       /* If at least one is a reference, it's ok.  */
4733       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4734         return 0;
4735       /* Reject two definitions.  */
4736       return "redefinition of `%#D'";
4737     }
4738   else
4739     {
4740       /* Objects declared with block scope:  */
4741       /* Reject two definitions, and reject a definition
4742          together with an external reference.  */
4743       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4744         return "redeclaration of `%#D'";
4745       return 0;
4746     }
4747 }
4748 \f
4749 /* Create a new label, named ID.  */
4750
4751 static tree
4752 make_label_decl (id, local_p)
4753      tree id;
4754      int local_p;
4755 {
4756   tree decl;
4757
4758   decl = build_decl (LABEL_DECL, id, void_type_node);
4759   if (expanding_p)
4760     /* Make sure every label has an rtx.  */
4761     label_rtx (decl);
4762
4763   DECL_CONTEXT (decl) = current_function_decl;
4764   DECL_MODE (decl) = VOIDmode;
4765   C_DECLARED_LABEL_FLAG (decl) = local_p;
4766
4767   /* Say where one reference is to the label, for the sake of the
4768      error if it is not defined.  */
4769   DECL_SOURCE_LINE (decl) = lineno;
4770   DECL_SOURCE_FILE (decl) = input_filename;
4771
4772   /* Record the fact that this identifier is bound to this label.  */
4773   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4774
4775   return decl;
4776 }
4777
4778 /* Record this label on the list of used labels so that we can check
4779    at the end of the function to see whether or not the label was
4780    actually defined, and so we can check when the label is defined whether
4781    this use is valid.  */
4782
4783 static void
4784 use_label (decl)
4785      tree decl;
4786 {
4787   if (named_label_uses == NULL
4788       || named_label_uses->names_in_scope != current_binding_level->names
4789       || named_label_uses->label_decl != decl)
4790     {
4791       struct named_label_use_list *new_ent;
4792       new_ent = ((struct named_label_use_list *)
4793                  ggc_alloc (sizeof (struct named_label_use_list)));
4794       new_ent->label_decl = decl;
4795       new_ent->names_in_scope = current_binding_level->names;
4796       new_ent->binding_level = current_binding_level;
4797       new_ent->lineno_o_goto = lineno;
4798       new_ent->filename_o_goto = input_filename;
4799       new_ent->next = named_label_uses;
4800       named_label_uses = new_ent;
4801     }
4802 }
4803
4804 /* Look for a label named ID in the current function.  If one cannot
4805    be found, create one.  (We keep track of used, but undefined,
4806    labels, and complain about them at the end of a function.)  */
4807
4808 tree
4809 lookup_label (id)
4810      tree id;
4811 {
4812   tree decl;
4813   struct named_label_list *ent;
4814
4815   /* You can't use labels at global scope.  */
4816   if (current_function_decl == NULL_TREE)
4817     {
4818       error ("label `%s' referenced outside of any function",
4819              IDENTIFIER_POINTER (id));
4820       return NULL_TREE;
4821     }
4822
4823   /* See if we've already got this label.  */
4824   decl = IDENTIFIER_LABEL_VALUE (id);
4825   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4826     return decl;
4827
4828   /* Record this label on the list of labels used in this function.
4829      We do this before calling make_label_decl so that we get the
4830      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4831   ent = ((struct named_label_list *)
4832          ggc_alloc_cleared (sizeof (struct named_label_list)));
4833   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4834   ent->next = named_labels;
4835   named_labels = ent;
4836
4837   /* We need a new label.  */
4838   decl = make_label_decl (id, /*local_p=*/0);
4839
4840   /* Now fill in the information we didn't have before.  */
4841   ent->label_decl = decl;
4842
4843   return decl;
4844 }
4845
4846 /* Declare a local label named ID.  */
4847
4848 tree
4849 declare_local_label (id)
4850      tree id;
4851 {
4852   tree decl;
4853
4854   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4855      this scope we can restore the old value of
4856      IDENTIFIER_TYPE_VALUE.  */
4857   current_binding_level->shadowed_labels
4858     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4859                  current_binding_level->shadowed_labels);
4860   /* Look for the label.  */
4861   decl = make_label_decl (id, /*local_p=*/1);
4862   /* Now fill in the information we didn't have before.  */
4863   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4864
4865   return decl;
4866 }
4867
4868 /* Returns nonzero if it is ill-formed to jump past the declaration of
4869    DECL.  Returns 2 if it's also a real problem.  */
4870
4871 static int
4872 decl_jump_unsafe (decl)
4873      tree decl;
4874 {
4875   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4876     return 0;
4877
4878   if (DECL_INITIAL (decl) == NULL_TREE
4879       && pod_type_p (TREE_TYPE (decl)))
4880     return 0;
4881
4882   /* This is really only important if we're crossing an initialization.
4883      The POD stuff is just pedantry; why should it matter if the class
4884      contains a field of pointer to member type?  */
4885   if (DECL_INITIAL (decl)
4886       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4887     return 2;
4888   return 1;
4889 }
4890
4891 /* Check that a single previously seen jump to a newly defined label
4892    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4893    the jump context; NAMES are the names in scope in LEVEL at the jump
4894    context; FILE and LINE are the source position of the jump or 0.  */
4895
4896 static void
4897 check_previous_goto_1 (decl, level, names, file, line)
4898      tree decl;
4899      struct cp_binding_level *level;
4900      tree names;
4901      const char *file;
4902      int line;
4903 {
4904   int identified = 0;
4905   int saw_eh = 0;
4906   struct cp_binding_level *b = current_binding_level;
4907   for (; b; b = b->level_chain)
4908     {
4909       tree new_decls = b->names;
4910       tree old_decls = (b == level ? names : NULL_TREE);
4911       for (; new_decls != old_decls;
4912            new_decls = TREE_CHAIN (new_decls))
4913         {
4914           int problem = decl_jump_unsafe (new_decls);
4915           if (! problem)
4916             continue;
4917
4918           if (! identified)
4919             {
4920               if (decl)
4921                 pedwarn ("jump to label `%D'", decl);
4922               else
4923                 pedwarn ("jump to case label");
4924
4925               if (file)
4926                 pedwarn_with_file_and_line (file, line, "  from here");
4927               identified = 1;
4928             }
4929
4930           if (problem > 1)
4931             cp_error_at ("  crosses initialization of `%#D'",
4932                          new_decls);
4933           else
4934             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4935                            new_decls);
4936         }
4937
4938       if (b == level)
4939         break;
4940       if ((b->is_try_scope || b->is_catch_scope) && ! saw_eh)
4941         {
4942           if (! identified)
4943             {
4944               if (decl)
4945                 pedwarn ("jump to label `%D'", decl);
4946               else
4947                 pedwarn ("jump to case label");
4948
4949               if (file)
4950                 pedwarn_with_file_and_line (file, line, "  from here");
4951               identified = 1;
4952             }
4953           if (b->is_try_scope)
4954             error ("  enters try block");
4955           else
4956             error ("  enters catch block");
4957           saw_eh = 1;
4958         }
4959     }
4960 }
4961
4962 static void
4963 check_previous_goto (use)
4964      struct named_label_use_list *use;
4965 {
4966   check_previous_goto_1 (use->label_decl, use->binding_level,
4967                          use->names_in_scope, use->filename_o_goto,
4968                          use->lineno_o_goto);
4969 }
4970
4971 static void
4972 check_switch_goto (level)
4973      struct cp_binding_level *level;
4974 {
4975   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
4976 }
4977
4978 /* Check that any previously seen jumps to a newly defined label DECL
4979    are OK.  Called by define_label.  */
4980
4981 static void
4982 check_previous_gotos (decl)
4983      tree decl;
4984 {
4985   struct named_label_use_list **usep;
4986
4987   if (! TREE_USED (decl))
4988     return;
4989
4990   for (usep = &named_label_uses; *usep; )
4991     {
4992       struct named_label_use_list *use = *usep;
4993       if (use->label_decl == decl)
4994         {
4995           check_previous_goto (use);
4996           *usep = use->next;
4997         }
4998       else
4999         usep = &(use->next);
5000     }
5001 }
5002
5003 /* Check that a new jump to a label DECL is OK.  Called by
5004    finish_goto_stmt.  */
5005
5006 void
5007 check_goto (decl)
5008      tree decl;
5009 {
5010   int identified = 0;
5011   tree bad;
5012   struct named_label_list *lab;
5013
5014   /* We can't know where a computed goto is jumping.  So we assume
5015      that it's OK.  */
5016   if (! DECL_P (decl))
5017     return;
5018
5019   /* If the label hasn't been defined yet, defer checking.  */
5020   if (! DECL_INITIAL (decl))
5021     {
5022       use_label (decl);
5023       return;
5024     }
5025
5026   for (lab = named_labels; lab; lab = lab->next)
5027     if (decl == lab->label_decl)
5028       break;
5029
5030   /* If the label is not on named_labels it's a gcc local label, so
5031      it must be in an outer scope, so jumping to it is always OK.  */
5032   if (lab == 0)
5033     return;
5034
5035   if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
5036       && !identified)
5037     {
5038       cp_pedwarn_at ("jump to label `%D'", decl);
5039       pedwarn ("  from here");
5040       identified = 1;
5041     }
5042
5043   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5044     {
5045       tree b = TREE_VALUE (bad);
5046       int u = decl_jump_unsafe (b);
5047
5048       if (u > 1 && DECL_ARTIFICIAL (b))
5049         /* Can't skip init of __exception_info.  */
5050         cp_error_at ("  enters catch block", b);
5051       else if (u > 1)
5052         cp_error_at ("  skips initialization of `%#D'", b);
5053       else
5054         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5055     }
5056
5057   if (lab->in_try_scope)
5058     error ("  enters try block");
5059   else if (lab->in_catch_scope)
5060     error ("  enters catch block");
5061 }
5062
5063 /* Define a label, specifying the location in the source file.
5064    Return the LABEL_DECL node for the label, if the definition is valid.
5065    Otherwise return 0.  */
5066
5067 tree
5068 define_label (filename, line, name)
5069      const char *filename;
5070      int line;
5071      tree name;
5072 {
5073   tree decl = lookup_label (name);
5074   struct named_label_list *ent;
5075   register struct cp_binding_level *p;
5076
5077   for (ent = named_labels; ent; ent = ent->next)
5078     if (ent->label_decl == decl)
5079       break;
5080
5081   /* After labels, make any new cleanups in the function go into their
5082      own new (temporary) binding contour.  */
5083   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5084     p->more_cleanups_ok = 0;
5085
5086   if (name == get_identifier ("wchar_t"))
5087     pedwarn ("label named wchar_t");
5088
5089   if (DECL_INITIAL (decl) != NULL_TREE)
5090     {
5091       error ("duplicate label `%D'", decl);
5092       return 0;
5093     }
5094   else
5095     {
5096       /* Mark label as having been defined.  */
5097       DECL_INITIAL (decl) = error_mark_node;
5098       /* Say where in the source.  */
5099       DECL_SOURCE_FILE (decl) = filename;
5100       DECL_SOURCE_LINE (decl) = line;
5101       if (ent)
5102         {
5103           ent->names_in_scope = current_binding_level->names;
5104           ent->binding_level = current_binding_level;
5105         }
5106       check_previous_gotos (decl);
5107       return decl;
5108     }
5109 }
5110
5111 struct cp_switch
5112 {
5113   struct cp_binding_level *level;
5114   struct cp_switch *next;
5115   /* The SWITCH_STMT being built.  */
5116   tree switch_stmt;
5117   /* A splay-tree mapping the low element of a case range to the high
5118      element, or NULL_TREE if there is no high element.  Used to
5119      determine whether or not a new case label duplicates an old case
5120      label.  We need a tree, rather than simply a hash table, because
5121      of the GNU case range extension.  */
5122   splay_tree cases;
5123 };
5124
5125 /* A stack of the currently active switch statements.  The innermost
5126    switch statement is on the top of the stack.  There is no need to
5127    mark the stack for garbage collection because it is only active
5128    during the processing of the body of a function, and we never
5129    collect at that point.  */
5130
5131 static struct cp_switch *switch_stack;
5132
5133 /* Called right after a switch-statement condition is parsed.
5134    SWITCH_STMT is the switch statement being parsed.  */
5135
5136 void
5137 push_switch (switch_stmt)
5138      tree switch_stmt;
5139 {
5140   struct cp_switch *p
5141     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5142   p->level = current_binding_level;
5143   p->next = switch_stack;
5144   p->switch_stmt = switch_stmt;
5145   p->cases = splay_tree_new (case_compare, NULL, NULL);
5146   switch_stack = p;
5147 }
5148
5149 void
5150 pop_switch ()
5151 {
5152   struct cp_switch *cs;
5153
5154   cs = switch_stack;
5155   splay_tree_delete (cs->cases);
5156   switch_stack = switch_stack->next;
5157   free (cs);
5158 }
5159
5160 /* Note that we've seen a definition of a case label, and complain if this
5161    is a bad place for one.  */
5162
5163 tree
5164 finish_case_label (low_value, high_value)
5165      tree low_value;
5166      tree high_value;
5167 {
5168   tree cond, r;
5169   register struct cp_binding_level *p;
5170
5171   if (! switch_stack)
5172     {
5173       if (high_value)
5174         error ("case label not within a switch statement");
5175       else if (low_value)
5176         error ("case label `%E' not within a switch statement",
5177                   low_value);
5178       else
5179         error ("`default' label not within a switch statement");
5180       return NULL_TREE;
5181     }
5182
5183   if (processing_template_decl)
5184     {
5185       tree label;
5186
5187       /* For templates, just add the case label; we'll do semantic
5188          analysis at instantiation-time.  */
5189       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5190       return add_stmt (build_case_label (low_value, high_value, label));
5191     }
5192
5193   /* Find the condition on which this switch statement depends.  */
5194   cond = SWITCH_COND (switch_stack->switch_stmt);
5195   if (cond && TREE_CODE (cond) == TREE_LIST)
5196     cond = TREE_VALUE (cond);
5197
5198   r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5199   if (r == error_mark_node)
5200     r = NULL_TREE;
5201
5202   check_switch_goto (switch_stack->level);
5203
5204   /* After labels, make any new cleanups in the function go into their
5205      own new (temporary) binding contour.  */
5206   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5207     p->more_cleanups_ok = 0;
5208
5209   return r;
5210 }
5211 \f
5212 /* Return the list of declarations of the current level.
5213    Note that this list is in reverse order unless/until
5214    you nreverse it; and when you do nreverse it, you must
5215    store the result back using `storedecls' or you will lose.  */
5216
5217 tree
5218 getdecls ()
5219 {
5220   return current_binding_level->names;
5221 }
5222
5223 /* Return the list of type-tags (for structs, etc) of the current level.  */
5224
5225 tree
5226 gettags ()
5227 {
5228   return current_binding_level->tags;
5229 }
5230
5231 /* Store the list of declarations of the current level.
5232    This is done for the parameter declarations of a function being defined,
5233    after they are modified in the light of any missing parameters.  */
5234
5235 static void
5236 storedecls (decls)
5237      tree decls;
5238 {
5239   current_binding_level->names = decls;
5240 }
5241
5242 /* Similarly, store the list of tags of the current level.  */
5243
5244 void
5245 storetags (tags)
5246      tree tags;
5247 {
5248   current_binding_level->tags = tags;
5249 }
5250 \f
5251 /* Return the type that should be used when TYPE's name is preceded
5252    by a tag such as 'struct' or 'union', or null if the name cannot
5253    be used in this way.
5254
5255    For example, when processing the third line of:
5256
5257         struct A;
5258         typedef struct A A;
5259         struct A;
5260
5261    lookup of A will find the typedef.  Given A's typedef, this function
5262    will return the type associated with "struct A".  For the tag to be
5263    anything other than TYPE, TYPE must be a typedef whose original type
5264    has the same name and context as TYPE itself.
5265
5266    It is not valid for a typedef of an anonymous type to be used with
5267    an explicit tag:
5268
5269        typedef struct { ... } B;
5270        struct B;
5271
5272    Return null for this case.  */
5273
5274 static tree
5275 follow_tag_typedef (type)
5276      tree type;
5277 {
5278   tree original;
5279
5280   original = original_type (type);
5281   if (! TYPE_NAME (original))
5282     return NULL_TREE;
5283   if (TYPE_IDENTIFIER (original) == TYPE_IDENTIFIER (type)
5284       && (CP_DECL_CONTEXT (TYPE_NAME (original))
5285           == CP_DECL_CONTEXT (TYPE_NAME (type)))
5286       && !(CLASS_TYPE_P (original) && TYPE_WAS_ANONYMOUS (original)))
5287     return original;
5288   else
5289     return NULL_TREE;
5290 }
5291
5292 /* Given NAME, an IDENTIFIER_NODE,
5293    return the structure (or union or enum) definition for that name.
5294    Searches binding levels from BINDING_LEVEL up to the global level.
5295    If THISLEVEL_ONLY is nonzero, searches only the specified context
5296    (but skips any tag-transparent contexts to find one that is
5297    meaningful for tags).
5298    FORM says which kind of type the caller wants;
5299    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5300    If the wrong kind of type is found, and it's not a template, an error is
5301    reported.  */
5302
5303 static tree
5304 lookup_tag (form, name, binding_level, thislevel_only)
5305      enum tree_code form;
5306      tree name;
5307      struct cp_binding_level *binding_level;
5308      int thislevel_only;
5309 {
5310   register struct cp_binding_level *level;
5311   /* Nonzero if, we should look past a template parameter level, even
5312      if THISLEVEL_ONLY.  */
5313   int allow_template_parms_p = 1;
5314
5315   for (level = binding_level; level; level = level->level_chain)
5316     {
5317       register tree tail;
5318       if (ANON_AGGRNAME_P (name))
5319         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5320           {
5321             /* There's no need for error checking here, because
5322                anon names are unique throughout the compilation.  */
5323             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5324               return TREE_VALUE (tail);
5325           }
5326       else if (level->namespace_p)
5327         /* Do namespace lookup.  */
5328         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5329           {
5330             tree old = binding_for_name (name, tail);
5331
5332             /* If we just skipped past a template parameter level,
5333                even though THISLEVEL_ONLY, and we find a template
5334                class declaration, then we use the _TYPE node for the
5335                template.  See the example below.  */
5336             if (thislevel_only && !allow_template_parms_p
5337                 && old && BINDING_VALUE (old)
5338                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5339               old = TREE_TYPE (BINDING_VALUE (old));
5340             else
5341               old = BINDING_TYPE (old);
5342
5343             if (old)
5344               {
5345                 /* We've found something at this binding level.  If it is
5346                    a typedef, extract the tag it refers to.  Lookup fails
5347                    if the typedef doesn't refer to a taggable type.  */
5348                 old = follow_tag_typedef (old);
5349                 if (!old)
5350                   return NULL_TREE;
5351                 if (TREE_CODE (old) != form
5352                     && (form == ENUMERAL_TYPE
5353                         || TREE_CODE (old) == ENUMERAL_TYPE))
5354                   {
5355                     error ("`%#D' redeclared as %C", old, form);
5356                     return NULL_TREE;
5357                   }
5358                 return old;
5359               }
5360             if (thislevel_only || tail == global_namespace)
5361               return NULL_TREE;
5362           }
5363       else
5364         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5365           {
5366             if (TREE_PURPOSE (tail) == name)
5367               {
5368                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5369
5370                 if (code != form
5371                     && (form == ENUMERAL_TYPE || code == ENUMERAL_TYPE))
5372                   {
5373                     /* Definition isn't the kind we were looking for.  */
5374                     error ("`%#D' redeclared as %C", TREE_VALUE (tail), form);
5375                     return NULL_TREE;
5376                   }
5377                 return TREE_VALUE (tail);
5378               }
5379           }
5380       if (thislevel_only && ! level->tag_transparent)
5381         {
5382           if (level->template_parms_p && allow_template_parms_p)
5383             {
5384               /* We must deal with cases like this:
5385
5386                    template <class T> struct S;
5387                    template <class T> struct S {};
5388
5389                  When looking up `S', for the second declaration, we
5390                  would like to find the first declaration.  But, we
5391                  are in the pseudo-global level created for the
5392                  template parameters, rather than the (surrounding)
5393                  namespace level.  Thus, we keep going one more level,
5394                  even though THISLEVEL_ONLY is nonzero.  */
5395               allow_template_parms_p = 0;
5396               continue;
5397             }
5398           else
5399             return NULL_TREE;
5400         }
5401     }
5402   return NULL_TREE;
5403 }
5404
5405 #if 0
5406 void
5407 set_current_level_tags_transparency (tags_transparent)
5408      int tags_transparent;
5409 {
5410   current_binding_level->tag_transparent = tags_transparent;
5411 }
5412 #endif
5413
5414 /* Given a type, find the tag that was defined for it and return the tag name.
5415    Otherwise return 0.  However, the value can never be 0
5416    in the cases in which this is used.
5417
5418    C++: If NAME is nonzero, this is the new name to install.  This is
5419    done when replacing anonymous tags with real tag names.  */
5420
5421 static tree
5422 lookup_tag_reverse (type, name)
5423      tree type;
5424      tree name;
5425 {
5426   register struct cp_binding_level *level;
5427
5428   for (level = current_binding_level; level; level = level->level_chain)
5429     {
5430       register tree tail;
5431       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5432         {
5433           if (TREE_VALUE (tail) == type)
5434             {
5435               if (name)
5436                 TREE_PURPOSE (tail) = name;
5437               return TREE_PURPOSE (tail);
5438             }
5439         }
5440     }
5441   return NULL_TREE;
5442 }
5443 \f
5444 /* Look up NAME in the NAMESPACE.  */
5445
5446 tree
5447 lookup_namespace_name (namespace, name)
5448      tree namespace, name;
5449 {
5450   tree val;
5451   tree template_id = NULL_TREE;
5452
5453   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5454
5455   if (TREE_CODE (name) == NAMESPACE_DECL)
5456     /* This happens for A::B<int> when B is a namespace.  */
5457     return name;
5458   else if (TREE_CODE (name) == TEMPLATE_DECL)
5459     {
5460       /* This happens for A::B where B is a template, and there are no
5461          template arguments.  */
5462       error ("invalid use of `%D'", name);
5463       return error_mark_node;
5464     }
5465
5466   namespace = ORIGINAL_NAMESPACE (namespace);
5467
5468   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5469     {
5470       template_id = name;
5471       name = TREE_OPERAND (name, 0);
5472       if (TREE_CODE (name) == OVERLOAD)
5473         name = DECL_NAME (OVL_CURRENT (name));
5474       else if (DECL_P (name))
5475         name = DECL_NAME (name);
5476     }
5477
5478   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5479
5480   val = make_node (CPLUS_BINDING);
5481   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5482     return error_mark_node;
5483
5484   if (BINDING_VALUE (val))
5485     {
5486       val = BINDING_VALUE (val);
5487
5488       if (template_id)
5489         {
5490           if (DECL_CLASS_TEMPLATE_P (val))
5491             val = lookup_template_class (val,
5492                                          TREE_OPERAND (template_id, 1),
5493                                          /*in_decl=*/NULL_TREE,
5494                                          /*context=*/NULL_TREE,
5495                                          /*entering_scope=*/0,
5496                                          tf_error | tf_warning);
5497           else if (DECL_FUNCTION_TEMPLATE_P (val)
5498                    || TREE_CODE (val) == OVERLOAD)
5499             val = lookup_template_function (val,
5500                                             TREE_OPERAND (template_id, 1));
5501           else
5502             {
5503               error ("`%D::%D' is not a template",
5504                         namespace, name);
5505               return error_mark_node;
5506             }
5507         }
5508
5509       /* If we have a single function from a using decl, pull it out.  */
5510       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5511         val = OVL_FUNCTION (val);
5512
5513       /* Ignore built-in functions that haven't been prototyped yet.  */
5514       if (!val || !DECL_P(val)
5515           || !DECL_LANG_SPECIFIC(val)
5516           || !DECL_ANTICIPATED (val))
5517         return val;
5518     }
5519
5520   error ("`%D' undeclared in namespace `%D'", name, namespace);
5521   return error_mark_node;
5522 }
5523
5524 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5525
5526 static hashval_t
5527 typename_hash (k)
5528      const void * k;
5529 {
5530   hashval_t hash;
5531   tree t = (tree) k;
5532
5533   hash = (htab_hash_pointer (TYPE_CONTEXT (t))
5534           ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
5535
5536   return hash;
5537 }
5538
5539 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5540
5541 static int
5542 typename_compare (k1, k2)
5543      const void * k1;
5544      const void * k2;
5545 {
5546   tree t1;
5547   tree t2;
5548   tree d1;
5549   tree d2;
5550
5551   t1 = (tree) k1;
5552   t2 = (tree) k2;
5553   d1 = TYPE_NAME (t1);
5554   d2 = TYPE_NAME (t2);
5555
5556   return (DECL_NAME (d1) == DECL_NAME (d2)
5557           && TYPE_CONTEXT (t1) == TYPE_CONTEXT (t2)
5558           && ((TREE_TYPE (t1) != NULL_TREE)
5559               == (TREE_TYPE (t2) != NULL_TREE))
5560           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5561           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5562 }
5563
5564 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5565    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5566    is non-NULL, this type is being created by the implicit typename
5567    extension, and BASE_TYPE is a type named `t' in some base class of
5568    `T' which depends on template parameters.
5569
5570    Returns the new TYPENAME_TYPE.  */
5571
5572 static GTY ((param_is (union tree_node))) htab_t typename_htab;
5573
5574 tree
5575 build_typename_type (context, name, fullname, base_type)
5576      tree context;
5577      tree name;
5578      tree fullname;
5579      tree base_type;
5580 {
5581   tree t;
5582   tree d;
5583   PTR *e;
5584
5585   if (typename_htab == NULL)
5586     {
5587       typename_htab = htab_create_ggc (61, &typename_hash,
5588                                        &typename_compare, NULL);
5589     }
5590
5591   /* Build the TYPENAME_TYPE.  */
5592   t = make_aggr_type (TYPENAME_TYPE);
5593   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5594   TYPENAME_TYPE_FULLNAME (t) = fullname;
5595   TREE_TYPE (t) = base_type;
5596
5597   /* Build the corresponding TYPE_DECL.  */
5598   d = build_decl (TYPE_DECL, name, t);
5599   TYPE_NAME (TREE_TYPE (d)) = d;
5600   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5601   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5602   DECL_ARTIFICIAL (d) = 1;
5603
5604   /* See if we already have this type.  */
5605   e = htab_find_slot (typename_htab, t, INSERT);
5606   if (*e)
5607     t = (tree) *e;
5608   else
5609     *e = t;
5610
5611   return t;
5612 }
5613
5614 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5615    unless an error occurs, in which case error_mark_node is returned.
5616    If we locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is
5617    set, we return that, rather than the _TYPE it corresponds to, in
5618    other cases we look through the type decl.  If TF_ERROR is set,
5619    complain about errors, otherwise be quiet.  */
5620
5621 tree
5622 make_typename_type (context, name, complain)
5623      tree context, name;
5624      tsubst_flags_t complain;
5625 {
5626   tree fullname;
5627
5628   if (TYPE_P (name))
5629     {
5630       if (!(TYPE_LANG_SPECIFIC (name)
5631             && (CLASSTYPE_IS_TEMPLATE (name)
5632                 || CLASSTYPE_USE_TEMPLATE (name))))
5633         name = TYPE_IDENTIFIER (name);
5634       else
5635         /* Create a TEMPLATE_ID_EXPR for the type.  */
5636         name = build_nt (TEMPLATE_ID_EXPR,
5637                          CLASSTYPE_TI_TEMPLATE (name),
5638                          CLASSTYPE_TI_ARGS (name));
5639     }
5640   else if (TREE_CODE (name) == TYPE_DECL)
5641     name = DECL_NAME (name);
5642
5643   fullname = name;
5644
5645   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5646     {
5647       name = TREE_OPERAND (name, 0);
5648       if (TREE_CODE (name) == TEMPLATE_DECL)
5649         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5650     }
5651   if (TREE_CODE (name) == TEMPLATE_DECL)
5652     {
5653       error ("`%D' used without template parameters", name);
5654       return error_mark_node;
5655     }
5656   if (TREE_CODE (name) != IDENTIFIER_NODE)
5657     abort ();
5658
5659   if (TREE_CODE (context) == NAMESPACE_DECL)
5660     {
5661       /* We can get here from typename_sub0 in the explicit_template_type
5662          expansion.  Just fail.  */
5663       if (complain & tf_error)
5664         error ("no class template named `%#T' in `%#T'",
5665                   name, context);
5666       return error_mark_node;
5667     }
5668
5669   if (! uses_template_parms (context)
5670       || currently_open_class (context))
5671     {
5672       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5673         {
5674           tree tmpl = NULL_TREE;
5675           if (IS_AGGR_TYPE (context))
5676             tmpl = lookup_field (context, name, 0, 0);
5677           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5678             {
5679               if (complain & tf_error)
5680                 error ("no class template named `%#T' in `%#T'",
5681                           name, context);
5682               return error_mark_node;
5683             }
5684
5685           if (complain & tf_parsing)
5686             type_access_control (context, tmpl);
5687           else
5688             enforce_access (context, tmpl);
5689
5690           return lookup_template_class (tmpl,
5691                                         TREE_OPERAND (fullname, 1),
5692                                         NULL_TREE, context,
5693                                         /*entering_scope=*/0,
5694                                         tf_error | tf_warning);
5695         }
5696       else
5697         {
5698           tree t;
5699
5700           if (!IS_AGGR_TYPE (context))
5701             {
5702               if (complain & tf_error)
5703                 error ("no type named `%#T' in `%#T'", name, context);
5704               return error_mark_node;
5705             }
5706
5707           t = lookup_field (context, name, 0, 1);
5708           if (t)
5709             {
5710               if (TREE_CODE (t) != TYPE_DECL)
5711                 {
5712                   if (complain & tf_error)
5713                     error ("no type named `%#T' in `%#T'", name, context);
5714                   return error_mark_node;
5715                 }
5716
5717               if (complain & tf_parsing)
5718                 type_access_control (context, t);
5719               else
5720                 enforce_access (context, t);
5721
5722               if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
5723                 t = TREE_TYPE (t);
5724               if (IMPLICIT_TYPENAME_P (t))
5725                 {
5726                   /* Lookup found an implicit typename that we had
5727                      injected into the current scope. Doing things
5728                      properly would have located the exact same type,
5729                      so there is no error here.  We must remove the
5730                      implicitness so that we do not warn about it.  */
5731                   t = copy_node (t);
5732                   TREE_TYPE (t) = NULL_TREE;
5733                 }
5734
5735               return t;
5736             }
5737         }
5738     }
5739
5740   /* If the CONTEXT is not a template type, then either the field is
5741      there now or its never going to be.  */
5742   if (!uses_template_parms (context))
5743     {
5744       if (complain & tf_error)
5745         error ("no type named `%#T' in `%#T'", name, context);
5746       return error_mark_node;
5747     }
5748
5749   return build_typename_type (context, name, fullname,  NULL_TREE);
5750 }
5751
5752 /* Resolve `CONTEXT::template NAME'.  Returns an appropriate type,
5753    unless an error occurs, in which case error_mark_node is returned.
5754    If we locate a TYPE_DECL, we return that, rather than the _TYPE it
5755    corresponds to.  If COMPLAIN zero, don't complain about any errors
5756    that occur.  */
5757
5758 tree
5759 make_unbound_class_template (context, name, complain)
5760      tree context, name;
5761      int complain;
5762 {
5763   tree t;
5764   tree d;
5765
5766   if (TYPE_P (name))
5767     name = TYPE_IDENTIFIER (name);
5768   else if (DECL_P (name))
5769     name = DECL_NAME (name);
5770   if (TREE_CODE (name) != IDENTIFIER_NODE)
5771     abort ();
5772
5773   if (!uses_template_parms (context)
5774       || currently_open_class (context))
5775     {
5776       tree tmpl = NULL_TREE;
5777
5778       if (IS_AGGR_TYPE (context))
5779         tmpl = lookup_field (context, name, 0, 0);
5780
5781       if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5782         {
5783           if (complain)
5784             error ("no class template named `%#T' in `%#T'", name, context);
5785           return error_mark_node;
5786         }
5787
5788       if (complain & tf_parsing)
5789         type_access_control (context, tmpl);
5790       else
5791         enforce_access (context, tmpl);
5792
5793       return tmpl;
5794     }
5795
5796   /* Build the UNBOUND_CLASS_TEMPLATE.  */
5797   t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
5798   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5799   TREE_TYPE (t) = NULL_TREE;
5800
5801   /* Build the corresponding TEMPLATE_DECL.  */
5802   d = build_decl (TEMPLATE_DECL, name, t);
5803   TYPE_NAME (TREE_TYPE (d)) = d;
5804   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5805   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5806   DECL_ARTIFICIAL (d) = 1;
5807
5808   return t;
5809 }
5810
5811 /* Select the right _DECL from multiple choices.  */
5812
5813 static tree
5814 select_decl (binding, flags)
5815      tree binding;
5816      int flags;
5817 {
5818   tree val;
5819   val = BINDING_VALUE (binding);
5820
5821   if (LOOKUP_NAMESPACES_ONLY (flags))
5822     {
5823       /* We are not interested in types.  */
5824       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5825         return val;
5826       return NULL_TREE;
5827     }
5828
5829   /* If we could have a type and
5830      we have nothing or we need a type and have none.  */
5831   if (BINDING_TYPE (binding)
5832       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5833                    && TREE_CODE (val) != TYPE_DECL)))
5834     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5835   /* Don't return non-types if we really prefer types.  */
5836   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5837            && (TREE_CODE (val) != TEMPLATE_DECL
5838                || !DECL_CLASS_TEMPLATE_P (val)))
5839     val = NULL_TREE;
5840
5841   return val;
5842 }
5843
5844 /* Unscoped lookup of a global: iterate over current namespaces,
5845    considering using-directives.  If SPACESP is non-NULL, store a list
5846    of the namespaces we've considered in it.  */
5847
5848 tree
5849 unqualified_namespace_lookup (name, flags, spacesp)
5850      tree name;
5851      int flags;
5852      tree *spacesp;
5853 {
5854   tree b = make_node (CPLUS_BINDING);
5855   tree initial = current_decl_namespace ();
5856   tree scope = initial;
5857   tree siter;
5858   struct cp_binding_level *level;
5859   tree val = NULL_TREE;
5860
5861   if (spacesp)
5862     *spacesp = NULL_TREE;
5863
5864   for (; !val; scope = CP_DECL_CONTEXT (scope))
5865     {
5866       if (spacesp)
5867         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5868       val = binding_for_name (name, scope);
5869
5870       /* Ignore anticipated built-in functions.  */
5871       if (val && BINDING_VALUE (val)
5872           && DECL_P (BINDING_VALUE (val))
5873           && DECL_LANG_SPECIFIC (BINDING_VALUE (val))
5874           && DECL_ANTICIPATED (BINDING_VALUE (val)))
5875         {
5876           BINDING_VALUE (b) = NULL_TREE;
5877           BINDING_TYPE (b) = NULL_TREE;
5878         }
5879       else
5880         {
5881           /* Initialize binding for this context.  */
5882           BINDING_VALUE (b) = BINDING_VALUE (val);
5883           BINDING_TYPE (b) = BINDING_TYPE (val);
5884         }
5885
5886       /* Add all _DECLs seen through local using-directives.  */
5887       for (level = current_binding_level;
5888            !level->namespace_p;
5889            level = level->level_chain)
5890         if (!lookup_using_namespace (name, b, level->using_directives,
5891                                      scope, flags, spacesp))
5892           /* Give up because of error.  */
5893           return error_mark_node;
5894
5895       /* Add all _DECLs seen through global using-directives.  */
5896       /* XXX local and global using lists should work equally.  */
5897       siter = initial;
5898       while (1)
5899         {
5900           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5901                                        scope, flags, spacesp))
5902             /* Give up because of error.  */
5903             return error_mark_node;
5904           if (siter == scope) break;
5905           siter = CP_DECL_CONTEXT (siter);
5906         }
5907
5908       val = select_decl (b, flags);
5909       if (scope == global_namespace)
5910         break;
5911     }
5912   return val;
5913 }
5914
5915 /* Combine prefer_type and namespaces_only into flags.  */
5916
5917 static int
5918 lookup_flags (prefer_type, namespaces_only)
5919   int prefer_type, namespaces_only;
5920 {
5921   if (namespaces_only)
5922     return LOOKUP_PREFER_NAMESPACES;
5923   if (prefer_type > 1)
5924     return LOOKUP_PREFER_TYPES;
5925   if (prefer_type > 0)
5926     return LOOKUP_PREFER_BOTH;
5927   return 0;
5928 }
5929
5930 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5931    ignore it or not.  Subroutine of lookup_name_real.  */
5932
5933 static tree
5934 qualify_lookup (val, flags)
5935      tree val;
5936      int flags;
5937 {
5938   if (val == NULL_TREE)
5939     return val;
5940   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5941     return val;
5942   if ((flags & LOOKUP_PREFER_TYPES)
5943       && (TREE_CODE (val) == TYPE_DECL
5944           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5945               && DECL_CLASS_TEMPLATE_P (val))))
5946     return val;
5947   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5948     return NULL_TREE;
5949   return val;
5950 }
5951
5952 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5953    that.  */
5954
5955 static void
5956 warn_about_implicit_typename_lookup (typename, binding)
5957      tree typename;
5958      tree binding;
5959 {
5960   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5961   tree name = DECL_NAME (typename);
5962
5963   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5964          && CLASSTYPE_TEMPLATE_INFO (subtype)
5965          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5966       && ! (TREE_CODE (binding) == TYPE_DECL
5967             && same_type_p (TREE_TYPE (binding), subtype)))
5968     {
5969       warning ("lookup of `%D' finds `%#D'",
5970                   name, binding);
5971       warning ("  instead of `%D' from dependent base class",
5972                   typename);
5973       warning ("  (use `typename %T::%D' if that's what you meant)",
5974                   constructor_name (current_class_type), name);
5975     }
5976 }
5977
5978 /* Check to see whether or not DECL is a variable that would have been
5979    in scope under the ARM, but is not in scope under the ANSI/ISO
5980    standard.  If so, issue an error message.  If name lookup would
5981    work in both cases, but return a different result, this function
5982    returns the result of ANSI/ISO lookup.  Otherwise, it returns
5983    DECL.  */
5984
5985 tree
5986 check_for_out_of_scope_variable (tree decl)
5987 {
5988   tree shadowed;
5989
5990   /* We only care about out of scope variables.  */
5991   if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
5992     return decl;
5993
5994   shadowed = DECL_SHADOWED_FOR_VAR (decl);
5995   while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
5996          && DECL_DEAD_FOR_LOCAL (shadowed))
5997     shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
5998   if (!shadowed)
5999     shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
6000   if (shadowed)
6001     {
6002       if (!DECL_ERROR_REPORTED (decl))
6003         {
6004           warning ("name lookup of `%D' changed",
6005                       DECL_NAME (decl));
6006           cp_warning_at ("  matches this `%D' under ISO standard rules",
6007                          shadowed);
6008           cp_warning_at ("  matches this `%D' under old rules", decl);
6009           DECL_ERROR_REPORTED (decl) = 1;
6010         }
6011       return shadowed;
6012     }
6013
6014   /* If we have already complained about this declaration, there's no
6015      need to do it again.  */
6016   if (DECL_ERROR_REPORTED (decl))
6017     return decl;
6018
6019   DECL_ERROR_REPORTED (decl) = 1;
6020   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
6021     {
6022       error ("name lookup of `%D' changed for new ISO `for' scoping",
6023              DECL_NAME (decl));
6024       cp_error_at ("  cannot use obsolete binding at `%D' because it has a destructor", decl);
6025       return error_mark_node;
6026     }
6027   else
6028     {
6029       pedwarn ("name lookup of `%D' changed for new ISO `for' scoping",
6030                DECL_NAME (decl));
6031       cp_pedwarn_at ("  using obsolete binding at `%D'", decl);
6032     }
6033
6034   return decl;
6035 }
6036
6037 /* Look up NAME in the current binding level and its superiors in the
6038    namespace of variables, functions and typedefs.  Return a ..._DECL
6039    node of some kind representing its definition if there is only one
6040    such declaration, or return a TREE_LIST with all the overloaded
6041    definitions if there are many, or return 0 if it is undefined.
6042
6043    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
6044    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
6045    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
6046    Otherwise we prefer non-TYPE_DECLs.
6047
6048    If NONCLASS is nonzero, we don't look for the NAME in class scope,
6049    using IDENTIFIER_CLASS_VALUE.  */
6050
6051 static tree
6052 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
6053      tree name;
6054      int prefer_type, nonclass, namespaces_only;
6055 {
6056   tree t;
6057   tree val = NULL_TREE;
6058   int yylex = 0;
6059   tree from_obj = NULL_TREE;
6060   int flags;
6061   int val_is_implicit_typename = 0;
6062
6063   /* Hack: copy flag set by parser, if set.  */
6064   if (only_namespace_names)
6065     namespaces_only = 1;
6066
6067   if (prefer_type == -2)
6068     {
6069       extern int looking_for_typename;
6070       tree type = NULL_TREE;
6071
6072       yylex = 1;
6073       prefer_type = looking_for_typename;
6074
6075       flags = lookup_flags (prefer_type, namespaces_only);
6076       /* If the next thing is '<', class templates are types.  */
6077       if (looking_for_template)
6078         flags |= LOOKUP_TEMPLATES_EXPECTED;
6079
6080       if (got_scope)
6081         type = got_scope;
6082       else if (got_object != error_mark_node)
6083         type = got_object;
6084
6085       if (type)
6086         {
6087           if (type == error_mark_node)
6088             return error_mark_node;
6089           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
6090             type = TREE_TYPE (type);
6091
6092           if (TYPE_P (type))
6093             type = complete_type (type);
6094
6095           if (TREE_CODE (type) == VOID_TYPE)
6096             type = global_namespace;
6097           if (TREE_CODE (type) == NAMESPACE_DECL)
6098             {
6099               val = make_node (CPLUS_BINDING);
6100               flags |= LOOKUP_COMPLAIN;
6101               if (!qualified_lookup_using_namespace (name, type, val, flags))
6102                 return NULL_TREE;
6103               val = select_decl (val, flags);
6104             }
6105           else if (! IS_AGGR_TYPE (type)
6106                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
6107                    || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
6108                    || TREE_CODE (type) == TYPENAME_TYPE)
6109             /* Someone else will give an error about this if needed.  */
6110             val = NULL_TREE;
6111           else if (type == current_class_type)
6112             val = IDENTIFIER_CLASS_VALUE (name);
6113           else
6114             {
6115               val = lookup_member (type, name, 0, prefer_type);
6116               if (!uses_template_parms (type))
6117                 type_access_control (type, val);
6118
6119               /* Restore the containing TYPENAME_TYPE if we looked
6120                  through it before.  */
6121               if (got_scope && got_scope != type
6122                   && val && TREE_CODE (val) == TYPE_DECL
6123                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
6124                 {
6125                   val = TREE_TYPE (val);
6126                   val = build_typename_type (got_scope, name,
6127                                              TYPENAME_TYPE_FULLNAME (val),
6128                                              TREE_TYPE (val));
6129                   val = TYPE_STUB_DECL (val);
6130                 }
6131             }
6132         }
6133       else
6134         val = NULL_TREE;
6135
6136       if (got_scope)
6137         goto done;
6138       else if (got_object && val)
6139         {
6140           from_obj = val;
6141           val = NULL_TREE;
6142         }
6143     }
6144   else
6145     {
6146       flags = lookup_flags (prefer_type, namespaces_only);
6147       /* If we're not parsing, we need to complain.  */
6148       flags |= LOOKUP_COMPLAIN;
6149     }
6150
6151   /* First, look in non-namespace scopes.  */
6152
6153   if (current_class_type == NULL_TREE)
6154     nonclass = 1;
6155
6156   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
6157     {
6158       tree binding;
6159
6160       if (!LOCAL_BINDING_P (t) && nonclass)
6161         /* We're not looking for class-scoped bindings, so keep going.  */
6162         continue;
6163
6164       /* If this is the kind of thing we're looking for, we're done.  */
6165       if (qualify_lookup (BINDING_VALUE (t), flags))
6166         binding = BINDING_VALUE (t);
6167       else if ((flags & LOOKUP_PREFER_TYPES)
6168                && qualify_lookup (BINDING_TYPE (t), flags))
6169         binding = BINDING_TYPE (t);
6170       else
6171         binding = NULL_TREE;
6172
6173       /* Handle access control on types from enclosing or base classes.  */
6174       if (binding && ! yylex
6175           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
6176         type_access_control (BINDING_LEVEL (t)->this_class, binding);
6177
6178       if (binding
6179           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
6180         {
6181           if (val_is_implicit_typename && !yylex)
6182             warn_about_implicit_typename_lookup (val, binding);
6183           val = binding;
6184           val_is_implicit_typename
6185             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
6186           if (!val_is_implicit_typename)
6187             break;
6188         }
6189     }
6190
6191   /* Now lookup in namespace scopes.  */
6192   if (!val || val_is_implicit_typename)
6193     {
6194       t = unqualified_namespace_lookup (name, flags, 0);
6195       if (t)
6196         {
6197           if (val_is_implicit_typename && !yylex)
6198             warn_about_implicit_typename_lookup (val, t);
6199           val = t;
6200         }
6201     }
6202
6203  done:
6204   if (val)
6205     {
6206       /* This should only warn about types used in qualified-ids.  */
6207       if (from_obj && from_obj != val)
6208         {
6209           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
6210               && TREE_CODE (val) == TYPE_DECL
6211               && ! same_type_p (TREE_TYPE (from_obj), TREE_TYPE (val)))
6212             pedwarn ("\
6213 lookup of `%D' in the scope of `%#T' (`%#D') \
6214 does not match lookup in the current scope (`%#D')",
6215                         name, got_object, from_obj, val);
6216
6217           /* We don't change val to from_obj if got_object depends on
6218              template parms because that breaks implicit typename for
6219              destructor calls.  */
6220           if (! uses_template_parms (got_object))
6221             val = from_obj;
6222         }
6223
6224       /* If we have a single function from a using decl, pull it out.  */
6225       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6226         val = OVL_FUNCTION (val);
6227     }
6228   else if (from_obj)
6229     val = from_obj;
6230
6231   return val;
6232 }
6233
6234 tree
6235 lookup_name_nonclass (name)
6236      tree name;
6237 {
6238   return lookup_name_real (name, 0, 1, 0);
6239 }
6240
6241 tree
6242 lookup_function_nonclass (name, args)
6243      tree name;
6244      tree args;
6245 {
6246   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6247 }
6248
6249 tree
6250 lookup_name_namespace_only (name)
6251      tree name;
6252 {
6253   /* type-or-namespace, nonclass, namespace_only */
6254   return lookup_name_real (name, 1, 1, 1);
6255 }
6256
6257 tree
6258 lookup_name (name, prefer_type)
6259      tree name;
6260      int prefer_type;
6261 {
6262   return lookup_name_real (name, prefer_type, 0, 0);
6263 }
6264
6265 /* Similar to `lookup_name' but look only in the innermost non-class
6266    binding level.  */
6267
6268 tree
6269 lookup_name_current_level (name)
6270      tree name;
6271 {
6272   struct cp_binding_level *b;
6273   tree t = NULL_TREE;
6274
6275   b = current_binding_level;
6276   while (b->parm_flag == 2)
6277     b = b->level_chain;
6278
6279   if (b->namespace_p)
6280     {
6281       t = IDENTIFIER_NAMESPACE_VALUE (name);
6282
6283       /* extern "C" function() */
6284       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6285         t = TREE_VALUE (t);
6286     }
6287   else if (IDENTIFIER_BINDING (name)
6288            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6289     {
6290       while (1)
6291         {
6292           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6293             return IDENTIFIER_VALUE (name);
6294
6295           if (b->keep == 2)
6296             b = b->level_chain;
6297           else
6298             break;
6299         }
6300     }
6301
6302   return t;
6303 }
6304
6305 /* Like lookup_name_current_level, but for types.  */
6306
6307 tree
6308 lookup_type_current_level (name)
6309      tree name;
6310 {
6311   register tree t = NULL_TREE;
6312
6313   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6314
6315   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6316       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6317     {
6318       struct cp_binding_level *b = current_binding_level;
6319       while (1)
6320         {
6321           if (purpose_member (name, b->type_shadowed))
6322             return REAL_IDENTIFIER_TYPE_VALUE (name);
6323           if (b->keep == 2)
6324             b = b->level_chain;
6325           else
6326             break;
6327         }
6328     }
6329
6330   return t;
6331 }
6332
6333 void
6334 begin_only_namespace_names ()
6335 {
6336   only_namespace_names = 1;
6337 }
6338
6339 void
6340 end_only_namespace_names ()
6341 {
6342   only_namespace_names = 0;
6343 }
6344 \f
6345 /* Push the declarations of builtin types into the namespace.
6346    RID_INDEX is the index of the builtin type
6347    in the array RID_POINTERS.  NAME is the name used when looking
6348    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6349
6350 void
6351 record_builtin_type (rid_index, name, type)
6352      enum rid rid_index;
6353      const char *name;
6354      tree type;
6355 {
6356   tree rname = NULL_TREE, tname = NULL_TREE;
6357   tree tdecl = NULL_TREE;
6358
6359   if ((int) rid_index < (int) RID_MAX)
6360     rname = ridpointers[(int) rid_index];
6361   if (name)
6362     tname = get_identifier (name);
6363
6364   TYPE_BUILT_IN (type) = 1;
6365
6366   if (tname)
6367     {
6368       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6369       set_identifier_type_value (tname, NULL_TREE);
6370       if ((int) rid_index < (int) RID_MAX)
6371         /* Built-in types live in the global namespace.  */
6372         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6373     }
6374   if (rname != NULL_TREE)
6375     {
6376       if (tname != NULL_TREE)
6377         {
6378           set_identifier_type_value (rname, NULL_TREE);
6379           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6380         }
6381       else
6382         {
6383           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6384           set_identifier_type_value (rname, NULL_TREE);
6385         }
6386     }
6387 }
6388
6389 /* Record one of the standard Java types.
6390  * Declare it as having the given NAME.
6391  * If SIZE > 0, it is the size of one of the integral types;
6392  * otherwise it is the negative of the size of one of the other types.  */
6393
6394 static tree
6395 record_builtin_java_type (name, size)
6396      const char *name;
6397      int size;
6398 {
6399   tree type, decl;
6400   if (size > 0)
6401     type = make_signed_type (size);
6402   else if (size > -32)
6403     { /* "__java_char" or ""__java_boolean".  */
6404       type = make_unsigned_type (-size);
6405       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6406     }
6407   else
6408     { /* "__java_float" or ""__java_double".  */
6409       type = make_node (REAL_TYPE);
6410       TYPE_PRECISION (type) = - size;
6411       layout_type (type);
6412     }
6413   record_builtin_type (RID_MAX, name, type);
6414   decl = TYPE_NAME (type);
6415
6416   /* Suppress generate debug symbol entries for these types,
6417      since for normal C++ they are just clutter.
6418      However, push_lang_context undoes this if extern "Java" is seen.  */
6419   DECL_IGNORED_P (decl) = 1;
6420
6421   TYPE_FOR_JAVA (type) = 1;
6422   return type;
6423 }
6424
6425 /* Push a type into the namespace so that the back-ends ignore it.  */
6426
6427 static void
6428 record_unknown_type (type, name)
6429      tree type;
6430      const char *name;
6431 {
6432   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6433   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6434   DECL_IGNORED_P (decl) = 1;
6435   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6436   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6437   TYPE_ALIGN (type) = 1;
6438   TYPE_USER_ALIGN (type) = 0;
6439   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6440 }
6441
6442 /* An string for which we should create an IDENTIFIER_NODE at
6443    startup.  */
6444
6445 typedef struct predefined_identifier
6446 {
6447   /* The name of the identifier.  */
6448   const char *const name;
6449   /* The place where the IDENTIFIER_NODE should be stored.  */
6450   tree *const node;
6451   /* Nonzero if this is the name of a constructor or destructor.  */
6452   const int ctor_or_dtor_p;
6453 } predefined_identifier;
6454
6455 /* Create all the predefined identifiers.  */
6456
6457 static void
6458 initialize_predefined_identifiers ()
6459 {
6460   const predefined_identifier *pid;
6461
6462   /* A table of identifiers to create at startup.  */
6463   static const predefined_identifier predefined_identifiers[] = {
6464     { "C++", &lang_name_cplusplus, 0 },
6465     { "C", &lang_name_c, 0 },
6466     { "Java", &lang_name_java, 0 },
6467     { CTOR_NAME, &ctor_identifier, 1 },
6468     { "__base_ctor", &base_ctor_identifier, 1 },
6469     { "__comp_ctor", &complete_ctor_identifier, 1 },
6470     { DTOR_NAME, &dtor_identifier, 1 },
6471     { "__comp_dtor", &complete_dtor_identifier, 1 },
6472     { "__base_dtor", &base_dtor_identifier, 1 },
6473     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6474     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6475     { "nelts", &nelts_identifier, 0 },
6476     { THIS_NAME, &this_identifier, 0 },
6477     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6478     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6479     { "_vptr", &vptr_identifier, 0 },
6480     { "__vtt_parm", &vtt_parm_identifier, 0 },
6481     { "std", &std_identifier, 0 },
6482     { NULL, NULL, 0 }
6483   };
6484
6485   for (pid = predefined_identifiers; pid->name; ++pid)
6486     {
6487       *pid->node = get_identifier (pid->name);
6488       if (pid->ctor_or_dtor_p)
6489         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6490     }
6491 }
6492
6493 /* Create the predefined scalar types of C,
6494    and some nodes representing standard constants (0, 1, (void *)0).
6495    Initialize the global binding level.
6496    Make definitions for built-in primitive functions.  */
6497
6498 void
6499 cxx_init_decl_processing ()
6500 {
6501   tree void_ftype;
6502   tree void_ftype_ptr;
6503
6504   /* Create all the identifiers we need.  */
6505   initialize_predefined_identifiers ();
6506
6507   /* Fill in back-end hooks.  */
6508   lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
6509
6510   /* Create the global variables.  */
6511   push_to_top_level ();
6512
6513   /* Enter the global namespace.  */
6514   my_friendly_assert (global_namespace == NULL_TREE, 375);
6515   push_namespace (get_identifier ("::"));
6516   global_namespace = current_namespace;
6517   current_lang_name = NULL_TREE;
6518
6519   /* Adjust various flags based on command-line settings.  */
6520   if (! flag_permissive && ! pedantic)
6521     flag_pedantic_errors = 1;
6522   if (!flag_no_inline)
6523     {
6524       flag_inline_trees = 1;
6525       flag_no_inline = 1;
6526     }
6527   if (flag_inline_functions)
6528     {
6529       flag_inline_trees = 2;
6530       flag_inline_functions = 0;
6531     }
6532
6533   /* Force minimum function alignment if using the least significant
6534      bit of function pointers to store the virtual bit.  */
6535   if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
6536       && force_align_functions_log < 1)
6537     force_align_functions_log = 1;
6538
6539   /* Initially, C.  */
6540   current_lang_name = lang_name_c;
6541
6542   current_function_decl = NULL_TREE;
6543   current_binding_level = NULL_BINDING_LEVEL;
6544   free_binding_level = NULL_BINDING_LEVEL;
6545
6546   build_common_tree_nodes (flag_signed_char);
6547
6548   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6549   TREE_TYPE (error_mark_list) = error_mark_node;
6550
6551   /* Make the binding_level structure for global names.  */
6552   pushlevel (0);
6553   global_binding_level = current_binding_level;
6554   /* The global level is the namespace level of ::.  */
6555   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6556   declare_namespace_level ();
6557
6558   /* Create the `std' namespace.  */
6559   push_namespace (std_identifier);
6560   std_node = current_namespace;
6561   pop_namespace ();
6562
6563   c_common_nodes_and_builtins ();
6564
6565   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6566   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6567   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6568   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6569   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6570   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6571   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6572   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6573
6574   integer_two_node = build_int_2 (2, 0);
6575   TREE_TYPE (integer_two_node) = integer_type_node;
6576   integer_three_node = build_int_2 (3, 0);
6577   TREE_TYPE (integer_three_node) = integer_type_node;
6578
6579   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6580   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6581   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6582   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6583   TYPE_PRECISION (boolean_type_node) = 1;
6584   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6585   boolean_false_node = build_int_2 (0, 0);
6586   TREE_TYPE (boolean_false_node) = boolean_type_node;
6587   boolean_true_node = build_int_2 (1, 0);
6588   TREE_TYPE (boolean_true_node) = boolean_type_node;
6589
6590   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6591
6592 #if 0
6593   record_builtin_type (RID_MAX, NULL, string_type_node);
6594 #endif
6595
6596   delta_type_node = ptrdiff_type_node;
6597   vtable_index_type = ptrdiff_type_node;
6598
6599   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6600   void_ftype = build_function_type (void_type_node, void_list_node);
6601   void_ftype_ptr = build_function_type (void_type_node,
6602                                         tree_cons (NULL_TREE,
6603                                                    ptr_type_node,
6604                                                    void_list_node));
6605   void_ftype_ptr
6606     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6607
6608   /* C++ extensions */
6609
6610   unknown_type_node = make_node (UNKNOWN_TYPE);
6611   record_unknown_type (unknown_type_node, "unknown type");
6612
6613   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6614   TREE_TYPE (unknown_type_node) = unknown_type_node;
6615
6616   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6617      result.  */
6618   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6619   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6620
6621   {
6622     /* Make sure we get a unique function type, so we can give
6623        its pointer type a name.  (This wins for gdb.) */
6624     tree vfunc_type = make_node (FUNCTION_TYPE);
6625     TREE_TYPE (vfunc_type) = integer_type_node;
6626     TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6627     layout_type (vfunc_type);
6628
6629     vtable_entry_type = build_pointer_type (vfunc_type);
6630   }
6631   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6632
6633   vtbl_type_node
6634     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6635   layout_type (vtbl_type_node);
6636   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6637   record_builtin_type (RID_MAX, NULL, vtbl_type_node);
6638   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6639   layout_type (vtbl_ptr_type_node);
6640   record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
6641
6642   push_namespace (get_identifier ("__cxxabiv1"));
6643   abi_node = current_namespace;
6644   pop_namespace ();
6645
6646   global_type_node = make_node (LANG_TYPE);
6647   record_unknown_type (global_type_node, "global type");
6648
6649   /* Now, C++.  */
6650   current_lang_name = lang_name_cplusplus;
6651
6652   {
6653     tree bad_alloc_type_node, newtype, deltype;
6654     tree ptr_ftype_sizetype;
6655
6656     push_namespace (std_identifier);
6657     bad_alloc_type_node
6658       = xref_tag (class_type, get_identifier ("bad_alloc"),
6659                   /*attributes=*/NULL_TREE, 1);
6660     pop_namespace ();
6661     ptr_ftype_sizetype
6662       = build_function_type (ptr_type_node,
6663                              tree_cons (NULL_TREE,
6664                                         size_type_node,
6665                                         void_list_node));
6666     newtype = build_exception_variant
6667       (ptr_ftype_sizetype, add_exception_specifier
6668        (NULL_TREE, bad_alloc_type_node, -1));
6669     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6670     push_cp_library_fn (NEW_EXPR, newtype);
6671     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6672     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6673     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6674   }
6675
6676   abort_fndecl
6677     = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
6678
6679   /* Perform other language dependent initializations.  */
6680   init_class_processing ();
6681   init_search_processing ();
6682   init_rtti_processing ();
6683
6684   if (flag_exceptions)
6685     init_exception_processing ();
6686
6687   if (! supports_one_only ())
6688     flag_weak = 0;
6689
6690   make_fname_decl = cp_make_fname_decl;
6691   start_fname_decls ();
6692
6693   /* Show we use EH for cleanups.  */
6694   using_eh_for_cleanups ();
6695
6696   /* Maintain consistency.  Perhaps we should just complain if they
6697      say -fwritable-strings?  */
6698   if (flag_writable_strings)
6699     flag_const_strings = 0;
6700 }
6701
6702 /* Generate an initializer for a function naming variable from
6703    NAME. NAME may be NULL, in which case we generate a special
6704    ERROR_MARK node which should be replaced later.  */
6705
6706 tree
6707 cp_fname_init (name)
6708      const char *name;
6709 {
6710   tree domain = NULL_TREE;
6711   tree type;
6712   tree init = NULL_TREE;
6713   size_t length = 0;
6714
6715   if (name)
6716     {
6717       length = strlen (name);
6718       domain = build_index_type (size_int (length));
6719       init = build_string (length + 1, name);
6720     }
6721
6722   type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
6723   type = build_cplus_array_type (type, domain);
6724
6725   if (init)
6726     TREE_TYPE (init) = type;
6727   else
6728     /* We don't know the value until instantiation time. Make
6729        something which will be digested now, but replaced later.  */
6730     init = build (ERROR_MARK, type);
6731
6732   return init;
6733 }
6734
6735 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6736    decl, NAME is the initialization string and TYPE_DEP indicates whether
6737    NAME depended on the type of the function. We make use of that to detect
6738    __PRETTY_FUNCTION__ inside a template fn. This is being done
6739    lazily at the point of first use, so we musn't push the decl now.  */
6740
6741 static tree
6742 cp_make_fname_decl (id, type_dep)
6743      tree id;
6744      int type_dep;
6745 {
6746   const char *const name = (type_dep && processing_template_decl
6747                       ? NULL : fname_as_string (type_dep));
6748   tree init = cp_fname_init (name);
6749   tree decl = build_decl (VAR_DECL, id, TREE_TYPE (init));
6750
6751   /* As we don't push the decl here, we must set the context.  */
6752   DECL_CONTEXT (decl) = current_function_decl;
6753   DECL_PRETTY_FUNCTION_P (decl) = type_dep;
6754
6755   TREE_STATIC (decl) = 1;
6756   TREE_READONLY (decl) = 1;
6757   DECL_ARTIFICIAL (decl) = 1;
6758   DECL_INITIAL (decl) = init;
6759
6760   TREE_USED (decl) = 1;
6761
6762   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6763
6764   return decl;
6765 }
6766
6767 /* Make a definition for a builtin function named NAME in the current
6768    namespace, whose data type is TYPE and whose context is CONTEXT.
6769    TYPE should be a function type with argument types.
6770
6771    CLASS and CODE tell later passes how to compile calls to this function.
6772    See tree.h for possible values.
6773
6774    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6775    the name to be called if we can't opencode the function.
6776    If ATTRS is nonzero, use that for the function's attribute
6777    list.  */
6778
6779 static tree
6780 builtin_function_1 (name, type, context, code, class, libname, attrs)
6781      const char *name;
6782      tree type;
6783      tree context;
6784      int code;
6785      enum built_in_class class;
6786      const char *libname;
6787      tree attrs;
6788 {
6789   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6790   DECL_BUILT_IN_CLASS (decl) = class;
6791   DECL_FUNCTION_CODE (decl) = code;
6792   DECL_CONTEXT (decl) = context;
6793
6794   pushdecl (decl);
6795
6796   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6797      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6798      function in the namespace.  */
6799   if (libname)
6800     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
6801   make_decl_rtl (decl, NULL);
6802
6803   /* Warn if a function in the namespace for users
6804      is used without an occasion to consider it declared.  */
6805   if (name[0] != '_' || name[1] != '_')
6806     DECL_ANTICIPATED (decl) = 1;
6807
6808   /* Possibly apply some default attributes to this built-in function.  */
6809   if (attrs)
6810     decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
6811   else
6812     decl_attributes (&decl, NULL_TREE, 0);
6813
6814   return decl;
6815 }
6816
6817 /* Entry point for the benefit of c_common_nodes_and_builtins.
6818
6819    Make a defintion for a builtin function named NAME and whose data type
6820    is TYPE.  TYPE should be a function type with argument types.  This
6821    function places the anticipated declaration in the global namespace
6822    and additionally in the std namespace if appropriate.
6823
6824    CLASS and CODE tell later passes how to compile calls to this function.
6825    See tree.h for possible values.
6826
6827    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6828    the name to be called if we can't opencode the function.
6829
6830    If ATTRS is nonzero, use that for the function's attribute
6831    list.  */
6832
6833 tree
6834 builtin_function (name, type, code, class, libname, attrs)
6835      const char *name;
6836      tree type;
6837      int code;
6838      enum built_in_class class;
6839      const char *libname;
6840      tree attrs;
6841 {
6842   /* All builtins that don't begin with an '_' should additionally
6843      go in the 'std' namespace.  */
6844   if (name[0] != '_')
6845     {
6846       push_namespace (std_identifier);
6847       builtin_function_1 (name, type, std_node, code, class, libname, attrs);
6848       pop_namespace ();
6849     }
6850
6851   return builtin_function_1 (name, type, NULL_TREE, code,
6852                              class, libname, attrs);
6853 }
6854
6855 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6856    function.  Not called directly.  */
6857
6858 static tree
6859 build_library_fn_1 (name, operator_code, type)
6860      tree name;
6861      enum tree_code operator_code;
6862      tree type;
6863 {
6864   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6865   DECL_EXTERNAL (fn) = 1;
6866   TREE_PUBLIC (fn) = 1;
6867   DECL_ARTIFICIAL (fn) = 1;
6868   TREE_NOTHROW (fn) = 1;
6869   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6870   SET_DECL_LANGUAGE (fn, lang_c);
6871   return fn;
6872 }
6873
6874 /* Returns the _DECL for a library function with C linkage.
6875    We assume that such functions never throw; if this is incorrect,
6876    callers should unset TREE_NOTHROW.  */
6877
6878 tree
6879 build_library_fn (name, type)
6880      tree name;
6881      tree type;
6882 {
6883   return build_library_fn_1 (name, ERROR_MARK, type);
6884 }
6885
6886 /* Returns the _DECL for a library function with C++ linkage.  */
6887
6888 static tree
6889 build_cp_library_fn (name, operator_code, type)
6890      tree name;
6891      enum tree_code operator_code;
6892      tree type;
6893 {
6894   tree fn = build_library_fn_1 (name, operator_code, type);
6895   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6896   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6897   SET_DECL_LANGUAGE (fn, lang_cplusplus);
6898   set_mangled_name_for_decl (fn);
6899   return fn;
6900 }
6901
6902 /* Like build_library_fn, but takes a C string instead of an
6903    IDENTIFIER_NODE.  */
6904
6905 tree
6906 build_library_fn_ptr (name, type)
6907      const char *name;
6908      tree type;
6909 {
6910   return build_library_fn (get_identifier (name), type);
6911 }
6912
6913 /* Like build_cp_library_fn, but takes a C string instead of an
6914    IDENTIFIER_NODE.  */
6915
6916 tree
6917 build_cp_library_fn_ptr (name, type)
6918      const char *name;
6919      tree type;
6920 {
6921   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6922 }
6923
6924 /* Like build_library_fn, but also pushes the function so that we will
6925    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6926
6927 tree
6928 push_library_fn (name, type)
6929      tree name, type;
6930 {
6931   tree fn = build_library_fn (name, type);
6932   pushdecl_top_level (fn);
6933   return fn;
6934 }
6935
6936 /* Like build_cp_library_fn, but also pushes the function so that it
6937    will be found by normal lookup.  */
6938
6939 static tree
6940 push_cp_library_fn (operator_code, type)
6941      enum tree_code operator_code;
6942      tree type;
6943 {
6944   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6945                                  operator_code,
6946                                  type);
6947   pushdecl (fn);
6948   return fn;
6949 }
6950
6951 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6952    a FUNCTION_TYPE.  */
6953
6954 tree
6955 push_void_library_fn (name, parmtypes)
6956      tree name, parmtypes;
6957 {
6958   tree type = build_function_type (void_type_node, parmtypes);
6959   return push_library_fn (name, type);
6960 }
6961
6962 /* Like push_library_fn, but also note that this function throws
6963    and does not return.  Used for __throw_foo and the like.  */
6964
6965 tree
6966 push_throw_library_fn (name, type)
6967      tree name, type;
6968 {
6969   tree fn = push_library_fn (name, type);
6970   TREE_THIS_VOLATILE (fn) = 1;
6971   TREE_NOTHROW (fn) = 0;
6972   return fn;
6973 }
6974
6975 /* Apply default attributes to a function, if a system function with default
6976    attributes.  */
6977
6978 void
6979 cxx_insert_default_attributes (decl)
6980      tree decl;
6981 {
6982   if (!DECL_EXTERN_C_FUNCTION_P (decl))
6983     return;
6984   if (!TREE_PUBLIC (decl))
6985     return;
6986   c_common_insert_default_attributes (decl);
6987 }
6988 \f
6989 /* When we call finish_struct for an anonymous union, we create
6990    default copy constructors and such.  But, an anonymous union
6991    shouldn't have such things; this function undoes the damage to the
6992    anonymous union type T.
6993
6994    (The reason that we create the synthesized methods is that we don't
6995    distinguish `union { int i; }' from `typedef union { int i; } U'.
6996    The first is an anonymous union; the second is just an ordinary
6997    union type.)  */
6998
6999 void
7000 fixup_anonymous_aggr (t)
7001      tree t;
7002 {
7003   tree *q;
7004
7005   /* Wipe out memory of synthesized methods */
7006   TYPE_HAS_CONSTRUCTOR (t) = 0;
7007   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
7008   TYPE_HAS_INIT_REF (t) = 0;
7009   TYPE_HAS_CONST_INIT_REF (t) = 0;
7010   TYPE_HAS_ASSIGN_REF (t) = 0;
7011   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
7012
7013   /* Splice the implicitly generated functions out of the TYPE_METHODS
7014      list.  */
7015   q = &TYPE_METHODS (t);
7016   while (*q)
7017     {
7018       if (DECL_ARTIFICIAL (*q))
7019         *q = TREE_CHAIN (*q);
7020       else
7021         q = &TREE_CHAIN (*q);
7022     }
7023
7024   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
7025   if (TYPE_METHODS (t))
7026     cp_error_at ("an anonymous union cannot have function members", t);
7027
7028   /* Anonymous aggregates cannot have fields with ctors, dtors or complex
7029      assignment operators (because they cannot have these methods themselves).
7030      For anonymous unions this is already checked because they are not allowed
7031      in any union, otherwise we have to check it.  */
7032   if (TREE_CODE (t) != UNION_TYPE)
7033     {
7034       tree field, type;
7035
7036       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
7037         if (TREE_CODE (field) == FIELD_DECL)
7038           {
7039             type = TREE_TYPE (field);
7040             if (CLASS_TYPE_P (type))
7041               {
7042                 if (TYPE_NEEDS_CONSTRUCTING (type))
7043                   cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
7044                                field);
7045                 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7046                   cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
7047                                field);
7048                 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
7049                   cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
7050                                field);
7051               }
7052           }
7053     }
7054 }
7055
7056 /* Make sure that a declaration with no declarator is well-formed, i.e.
7057    just defines a tagged type or anonymous union.
7058
7059    Returns the type defined, if any.  */
7060
7061 tree
7062 check_tag_decl (declspecs)
7063      tree declspecs;
7064 {
7065   int found_type = 0;
7066   int saw_friend = 0;
7067   int saw_typedef = 0;
7068   tree ob_modifier = NULL_TREE;
7069   register tree link;
7070   register tree t = NULL_TREE;
7071
7072   for (link = declspecs; link; link = TREE_CHAIN (link))
7073     {
7074       register tree value = TREE_VALUE (link);
7075
7076       if (TYPE_P (value)
7077           || TREE_CODE (value) == TYPE_DECL
7078           || (TREE_CODE (value) == IDENTIFIER_NODE
7079               && IDENTIFIER_GLOBAL_VALUE (value)
7080               && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value)) == TYPE_DECL))
7081         {
7082           ++found_type;
7083
7084           if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
7085             {
7086               if (! in_system_header)
7087                 pedwarn ("redeclaration of C++ built-in type `%T'", value);
7088               return NULL_TREE;
7089             }
7090
7091           if (TYPE_P (value)
7092               && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
7093                   || TREE_CODE (value) == ENUMERAL_TYPE))
7094             {
7095               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
7096               t = value;
7097             }
7098         }
7099       else if (value == ridpointers[(int) RID_TYPEDEF])
7100         saw_typedef = 1;
7101       else if (value == ridpointers[(int) RID_FRIEND])
7102         {
7103           if (current_class_type == NULL_TREE
7104               || current_scope () != current_class_type)
7105             ob_modifier = value;
7106           else
7107             saw_friend = 1;
7108         }
7109       else if (value == ridpointers[(int) RID_STATIC]
7110                || value == ridpointers[(int) RID_EXTERN]
7111                || value == ridpointers[(int) RID_AUTO]
7112                || value == ridpointers[(int) RID_REGISTER]
7113                || value == ridpointers[(int) RID_INLINE]
7114                || value == ridpointers[(int) RID_VIRTUAL]
7115                || value == ridpointers[(int) RID_CONST]
7116                || value == ridpointers[(int) RID_VOLATILE]
7117                || value == ridpointers[(int) RID_EXPLICIT]
7118                || value == ridpointers[(int) RID_THREAD])
7119         ob_modifier = value;
7120     }
7121
7122   if (found_type > 1)
7123     error ("multiple types in one declaration");
7124
7125   if (t == NULL_TREE && ! saw_friend)
7126     pedwarn ("declaration does not declare anything");
7127
7128   /* Check for an anonymous union.  */
7129   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7130            && TYPE_ANONYMOUS_P (t))
7131     {
7132       /* 7/3 In a simple-declaration, the optional init-declarator-list
7133          can be omitted only when declaring a class (clause 9) or
7134          enumeration (7.2), that is, when the decl-specifier-seq contains
7135          either a class-specifier, an elaborated-type-specifier with
7136          a class-key (9.1), or an enum-specifier.  In these cases and
7137          whenever a class-specifier or enum-specifier is present in the
7138          decl-specifier-seq, the identifiers in these specifiers are among
7139          the names being declared by the declaration (as class-name,
7140          enum-names, or enumerators, depending on the syntax).  In such
7141          cases, and except for the declaration of an unnamed bit-field (9.6),
7142          the decl-specifier-seq shall introduce one or more names into the
7143          program, or shall redeclare a name introduced by a previous
7144          declaration.  [Example:
7145              enum { };            // ill-formed
7146              typedef class { };   // ill-formed
7147          --end example]  */
7148       if (saw_typedef)
7149         {
7150           error ("missing type-name in typedef-declaration");
7151           return NULL_TREE;
7152         }
7153       /* Anonymous unions are objects, so they can have specifiers.  */;
7154       SET_ANON_AGGR_TYPE_P (t);
7155
7156       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7157         pedwarn ("ISO C++ prohibits anonymous structs");
7158     }
7159
7160   else if (ob_modifier)
7161     {
7162       if (ob_modifier == ridpointers[(int) RID_INLINE]
7163           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7164         error ("`%D' can only be specified for functions", ob_modifier);
7165       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7166         error ("`%D' can only be specified inside a class", ob_modifier);
7167       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7168         error ("`%D' can only be specified for constructors",
7169                   ob_modifier);
7170       else
7171         error ("`%D' can only be specified for objects and functions",
7172                   ob_modifier);
7173     }
7174
7175   return t;
7176 }
7177
7178 /* Called when a declaration is seen that contains no names to declare.
7179    If its type is a reference to a structure, union or enum inherited
7180    from a containing scope, shadow that tag name for the current scope
7181    with a forward reference.
7182    If its type defines a new named structure or union
7183    or defines an enum, it is valid but we need not do anything here.
7184    Otherwise, it is an error.
7185
7186    C++: may have to grok the declspecs to learn about static,
7187    complain for anonymous unions.  */
7188
7189 void
7190 shadow_tag (declspecs)
7191      tree declspecs;
7192 {
7193   tree t = check_tag_decl (declspecs);
7194
7195   if (t)
7196     maybe_process_partial_specialization (t);
7197
7198   /* This is where the variables in an anonymous union are
7199      declared.  An anonymous union declaration looks like:
7200      union { ... } ;
7201      because there is no declarator after the union, the parser
7202      sends that declaration here.  */
7203   if (t && ANON_AGGR_TYPE_P (t))
7204     {
7205       fixup_anonymous_aggr (t);
7206
7207       if (TYPE_FIELDS (t))
7208         {
7209           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7210                                       NULL);
7211           finish_anon_union (decl);
7212         }
7213     }
7214 }
7215 \f
7216 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7217
7218 tree
7219 groktypename (typename)
7220      tree typename;
7221 {
7222   tree specs, attrs;
7223   tree type;
7224   if (TREE_CODE (typename) != TREE_LIST)
7225     return typename;
7226   split_specs_attrs (TREE_PURPOSE (typename), &specs, &attrs);
7227   type = grokdeclarator (TREE_VALUE (typename), specs,
7228                          TYPENAME, 0, &attrs);
7229   if (attrs)
7230     cplus_decl_attributes (&type, attrs, 0);
7231   return type;
7232 }
7233
7234 /* Decode a declarator in an ordinary declaration or data definition.
7235    This is called as soon as the type information and variable name
7236    have been parsed, before parsing the initializer if any.
7237    Here we create the ..._DECL node, fill in its type,
7238    and put it on the list of decls for the current context.
7239    The ..._DECL node is returned as the value.
7240
7241    Exception: for arrays where the length is not specified,
7242    the type is left null, to be filled in by `cp_finish_decl'.
7243
7244    Function definitions do not come here; they go to start_function
7245    instead.  However, external and forward declarations of functions
7246    do go through here.  Structure field declarations are done by
7247    grokfield and not through here.  */
7248
7249 tree
7250 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7251      tree declarator, declspecs;
7252      int initialized;
7253      tree attributes, prefix_attributes;
7254 {
7255   tree decl;
7256   register tree type, tem;
7257   tree context;
7258
7259 #if 0
7260   /* See code below that used this.  */
7261   int init_written = initialized;
7262 #endif
7263
7264   /* This should only be done once on the top most decl.  */
7265   if (have_extern_spec)
7266     {
7267       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7268                              declspecs);
7269       have_extern_spec = false;
7270     }
7271
7272   /* An object declared as __attribute__((deprecated)) suppresses
7273      warnings of uses of other deprecated items.  */
7274   if (lookup_attribute ("deprecated", attributes))
7275     deprecated_state = DEPRECATED_SUPPRESS;
7276
7277   attributes = chainon (attributes, prefix_attributes);
7278
7279   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7280                          &attributes);
7281
7282   deprecated_state = DEPRECATED_NORMAL;
7283
7284   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7285     return NULL_TREE;
7286
7287   type = TREE_TYPE (decl);
7288
7289   if (type == error_mark_node)
7290     return NULL_TREE;
7291
7292   context = DECL_CONTEXT (decl);
7293
7294   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7295       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7296     {
7297       /* When parsing the initializer, lookup should use the object's
7298          namespace.  */
7299       push_decl_namespace (context);
7300     }
7301
7302   /* We are only interested in class contexts, later.  */
7303   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7304     context = NULL_TREE;
7305
7306   if (initialized)
7307     /* Is it valid for this decl to have an initializer at all?
7308        If not, set INITIALIZED to zero, which will indirectly
7309        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7310     switch (TREE_CODE (decl))
7311       {
7312       case TYPE_DECL:
7313         error ("typedef `%D' is initialized (use __typeof__ instead)", decl);
7314         initialized = 0;
7315         break;
7316
7317       case FUNCTION_DECL:
7318         error ("function `%#D' is initialized like a variable", decl);
7319         initialized = 0;
7320         break;
7321
7322       default:
7323         break;
7324       }
7325
7326   if (initialized)
7327     {
7328       if (! toplevel_bindings_p ()
7329           && DECL_EXTERNAL (decl))
7330         warning ("declaration of `%#D' has `extern' and is initialized",
7331                     decl);
7332       DECL_EXTERNAL (decl) = 0;
7333       if (toplevel_bindings_p ())
7334         TREE_STATIC (decl) = 1;
7335
7336       /* Tell `pushdecl' this is an initialized decl
7337          even though we don't yet have the initializer expression.
7338          Also tell `cp_finish_decl' it may store the real initializer.  */
7339       DECL_INITIAL (decl) = error_mark_node;
7340     }
7341
7342   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7343   cplus_decl_attributes (&decl, attributes, 0);
7344
7345   /* If #pragma weak was used, mark the decl weak now.  */
7346   if (current_binding_level == global_binding_level)
7347     maybe_apply_pragma_weak (decl);
7348
7349   if (TREE_CODE (decl) == FUNCTION_DECL
7350       && DECL_DECLARED_INLINE_P (decl)
7351       && DECL_UNINLINABLE (decl)
7352       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
7353     warning_with_decl (decl,
7354                        "inline function `%s' given attribute noinline");
7355
7356   if (context && COMPLETE_TYPE_P (complete_type (context)))
7357     {
7358       push_nested_class (context, 2);
7359
7360       if (TREE_CODE (decl) == VAR_DECL)
7361         {
7362           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7363           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7364             error ("`%#D' is not a static member of `%#T'", decl, context);
7365           else
7366             {
7367               if (DECL_CONTEXT (field) != context)
7368                 {
7369                   pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7370                               DECL_CONTEXT (field), DECL_NAME (decl),
7371                               context, DECL_NAME (decl));
7372                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7373                 }
7374               /* Static data member are tricky; an in-class initialization
7375                  still doesn't provide a definition, so the in-class
7376                  declaration will have DECL_EXTERNAL set, but will have an
7377                  initialization.  Thus, duplicate_decls won't warn
7378                  about this situation, and so we check here.  */
7379               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7380                 error ("duplicate initialization of %D", decl);
7381               if (duplicate_decls (decl, field))
7382                 decl = field;
7383             }
7384         }
7385       else
7386         {
7387           tree field = check_classfn (context, decl);
7388           if (field && duplicate_decls (decl, field))
7389             decl = field;
7390         }
7391
7392       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7393       DECL_IN_AGGR_P (decl) = 0;
7394       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7395           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7396         {
7397           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7398           /* [temp.expl.spec] An explicit specialization of a static data
7399              member of a template is a definition if the declaration
7400              includes an initializer; otherwise, it is a declaration.
7401
7402              We check for processing_specialization so this only applies
7403              to the new specialization syntax.  */
7404           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7405             DECL_EXTERNAL (decl) = 1;
7406         }
7407
7408       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7409         pedwarn ("declaration of `%#D' outside of class is not definition",
7410                     decl);
7411     }
7412
7413   /* Enter this declaration into the symbol table.  */
7414   tem = maybe_push_decl (decl);
7415
7416   if (processing_template_decl)
7417     tem = push_template_decl (tem);
7418
7419 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7420   /* Tell the back-end to use or not use .common as appropriate.  If we say
7421      -fconserve-space, we want this to save .data space, at the expense of
7422      wrong semantics.  If we say -fno-conserve-space, we want this to
7423      produce errors about redefs; to do this we force variables into the
7424      data segment.  */
7425   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7426 #endif
7427
7428   if (! processing_template_decl)
7429     start_decl_1 (tem);
7430
7431   return tem;
7432 }
7433
7434 void
7435 start_decl_1 (decl)
7436      tree decl;
7437 {
7438   tree type = TREE_TYPE (decl);
7439   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7440
7441   if (type == error_mark_node)
7442     return;
7443
7444   maybe_push_cleanup_level (type);
7445
7446   if (initialized)
7447     /* Is it valid for this decl to have an initializer at all?
7448        If not, set INITIALIZED to zero, which will indirectly
7449        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7450     {
7451       /* Don't allow initializations for incomplete types except for
7452          arrays which might be completed by the initialization.  */
7453       if (COMPLETE_TYPE_P (complete_type (type)))
7454         ;                       /* A complete type is ok.  */
7455       else if (TREE_CODE (type) != ARRAY_TYPE)
7456         {
7457           error ("variable `%#D' has initializer but incomplete type",
7458                     decl);
7459           initialized = 0;
7460           type = TREE_TYPE (decl) = error_mark_node;
7461         }
7462       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7463         {
7464           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7465             error ("elements of array `%#D' have incomplete type", decl);
7466           /* else we already gave an error in start_decl.  */
7467           initialized = 0;
7468         }
7469     }
7470
7471   if (!initialized
7472       && TREE_CODE (decl) != TYPE_DECL
7473       && TREE_CODE (decl) != TEMPLATE_DECL
7474       && type != error_mark_node
7475       && IS_AGGR_TYPE (type)
7476       && ! DECL_EXTERNAL (decl))
7477     {
7478       if ((! processing_template_decl || ! uses_template_parms (type))
7479           && !COMPLETE_TYPE_P (complete_type (type)))
7480         {
7481           error ("aggregate `%#D' has incomplete type and cannot be defined",
7482                  decl);
7483           /* Change the type so that assemble_variable will give
7484              DECL an rtl we can live with: (mem (const_int 0)).  */
7485           type = TREE_TYPE (decl) = error_mark_node;
7486         }
7487       else
7488         {
7489           /* If any base type in the hierarchy of TYPE needs a constructor,
7490              then we set initialized to 1.  This way any nodes which are
7491              created for the purposes of initializing this aggregate
7492              will live as long as it does.  This is necessary for global
7493              aggregates which do not have their initializers processed until
7494              the end of the file.  */
7495           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7496         }
7497     }
7498
7499   if (! initialized)
7500     DECL_INITIAL (decl) = NULL_TREE;
7501 }
7502
7503 /* Handle initialization of references.
7504    These three arguments are from `cp_finish_decl', and have the
7505    same meaning here that they do there.
7506
7507    Quotes on semantics can be found in ARM 8.4.3.  */
7508
7509 static tree
7510 grok_reference_init (decl, type, init)
7511      tree decl, type, init;
7512 {
7513   tree tmp;
7514
7515   if (init == NULL_TREE)
7516     {
7517       if ((DECL_LANG_SPECIFIC (decl) == 0
7518            || DECL_IN_AGGR_P (decl) == 0)
7519           && ! DECL_THIS_EXTERN (decl))
7520         error ("`%D' declared as reference but not initialized", decl);
7521       return NULL_TREE;
7522     }
7523
7524   if (init == error_mark_node)
7525     return NULL_TREE;
7526
7527   if (TREE_CODE (init) == CONSTRUCTOR)
7528     {
7529       error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7530       return NULL_TREE;
7531     }
7532
7533   if (TREE_CODE (init) == TREE_LIST)
7534     init = build_compound_expr (init);
7535
7536   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7537     init = convert_from_reference (init);
7538
7539   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7540       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7541     {
7542       /* Note: default conversion is only called in very special cases.  */
7543       init = default_conversion (init);
7544     }
7545
7546   /* Convert INIT to the reference type TYPE.  This may involve the
7547      creation of a temporary, whose lifetime must be the same as that
7548      of the reference.  If so, a DECL_STMT for the temporary will be
7549      added just after the DECL_STMT for DECL.  That's why we don't set
7550      DECL_INITIAL for local references (instead assigning to them
7551      explicitly); we need to allow the temporary to be initialized
7552      first.  */
7553   tmp = convert_to_reference
7554     (type, init, CONV_IMPLICIT,
7555      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7556      decl);
7557
7558   if (tmp == error_mark_node)
7559     return NULL_TREE;
7560   else if (tmp == NULL_TREE)
7561     {
7562       error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7563       return NULL_TREE;
7564     }
7565
7566   if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
7567     return tmp;
7568
7569   DECL_INITIAL (decl) = tmp;
7570
7571   return NULL_TREE;
7572 }
7573
7574 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7575    array until we finish parsing the initializer.  If that's the
7576    situation we're in, update DECL accordingly.  */
7577
7578 static void
7579 maybe_deduce_size_from_array_init (decl, init)
7580      tree decl;
7581      tree init;
7582 {
7583   tree type = TREE_TYPE (decl);
7584
7585   if (TREE_CODE (type) == ARRAY_TYPE
7586       && TYPE_DOMAIN (type) == NULL_TREE
7587       && TREE_CODE (decl) != TYPE_DECL)
7588     {
7589       /* do_default is really a C-ism to deal with tentative definitions.
7590          But let's leave it here to ease the eventual merge.  */
7591       int do_default = !DECL_EXTERNAL (decl);
7592       tree initializer = init ? init : DECL_INITIAL (decl);
7593       int failure = complete_array_type (type, initializer, do_default);
7594
7595       if (failure == 1)
7596         error ("initializer fails to determine size of `%D'", decl);
7597
7598       if (failure == 2)
7599         {
7600           if (do_default)
7601             error ("array size missing in `%D'", decl);
7602           /* If a `static' var's size isn't known, make it extern as
7603              well as static, so it does not get allocated.  If it's not
7604              `static', then don't mark it extern; finish_incomplete_decl
7605              will give it a default size and it will get allocated.  */
7606           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7607             DECL_EXTERNAL (decl) = 1;
7608         }
7609
7610       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7611           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7612                               integer_zero_node))
7613         error ("zero-size array `%D'", decl);
7614
7615       layout_decl (decl, 0);
7616     }
7617 }
7618
7619 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7620    any appropriate error messages regarding the layout.  */
7621
7622 static void
7623 layout_var_decl (decl)
7624      tree decl;
7625 {
7626   tree type = TREE_TYPE (decl);
7627 #if 0
7628   tree ttype = target_type (type);
7629 #endif
7630
7631   /* If we haven't already layed out this declaration, do so now.
7632      Note that we must not call complete type for an external object
7633      because it's type might involve templates that we are not
7634      supposed to isntantiate yet.  (And it's perfectly valid to say
7635      `extern X x' for some incomplete type `X'.)  */
7636   if (!DECL_EXTERNAL (decl))
7637     complete_type (type);
7638   if (!DECL_SIZE (decl)
7639       && TREE_TYPE (decl) != error_mark_node
7640       && (COMPLETE_TYPE_P (type)
7641           || (TREE_CODE (type) == ARRAY_TYPE
7642               && !TYPE_DOMAIN (type)
7643               && COMPLETE_TYPE_P (TREE_TYPE (type)))))
7644     layout_decl (decl, 0);
7645
7646   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7647     {
7648       /* An automatic variable with an incomplete type: that is an error.
7649          Don't talk about array types here, since we took care of that
7650          message in grokdeclarator.  */
7651       error ("storage size of `%D' isn't known", decl);
7652       TREE_TYPE (decl) = error_mark_node;
7653     }
7654 #if 0
7655   /* Keep this code around in case we later want to control debug info
7656      based on whether a type is "used".  (jason 1999-11-11) */
7657
7658   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7659     /* Let debugger know it should output info for this type.  */
7660     note_debug_info_needed (ttype);
7661
7662   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7663     note_debug_info_needed (DECL_CONTEXT (decl));
7664 #endif
7665
7666   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7667       && DECL_SIZE (decl) != NULL_TREE
7668       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7669     {
7670       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7671         constant_expression_warning (DECL_SIZE (decl));
7672       else
7673         error ("storage size of `%D' isn't constant", decl);
7674     }
7675
7676   if (TREE_STATIC (decl)
7677       && !DECL_ARTIFICIAL (decl)
7678       && current_function_decl
7679       && DECL_CONTEXT (decl) == current_function_decl)
7680     push_local_name (decl);
7681 }
7682
7683 /* If a local static variable is declared in an inline function, or if
7684    we have a weak definition, we must endeavor to create only one
7685    instance of the variable at link-time.  */
7686
7687 static void
7688 maybe_commonize_var (decl)
7689      tree decl;
7690 {
7691   /* Static data in a function with comdat linkage also has comdat
7692      linkage.  */
7693   if (TREE_STATIC (decl)
7694       /* Don't mess with __FUNCTION__.  */
7695       && ! DECL_ARTIFICIAL (decl)
7696       && current_function_decl
7697       && DECL_CONTEXT (decl) == current_function_decl
7698       && (DECL_DECLARED_INLINE_P (current_function_decl)
7699           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7700       && TREE_PUBLIC (current_function_decl))
7701     {
7702       /* If flag_weak, we don't need to mess with this, as we can just
7703          make the function weak, and let it refer to its unique local
7704          copy.  This works because we don't allow the function to be
7705          inlined.  */
7706       if (! flag_weak)
7707         {
7708           if (DECL_INTERFACE_KNOWN (current_function_decl))
7709             {
7710               TREE_PUBLIC (decl) = 1;
7711               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7712             }
7713           else if (DECL_INITIAL (decl) == NULL_TREE
7714                    || DECL_INITIAL (decl) == error_mark_node)
7715             {
7716               TREE_PUBLIC (decl) = 1;
7717               DECL_COMMON (decl) = 1;
7718             }
7719           /* else we lose. We can only do this if we can use common,
7720              which we can't if it has been initialized.  */
7721
7722           if (!TREE_PUBLIC (decl))
7723             {
7724               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7725               cp_warning_at ("  you can work around this by removing the initializer", decl);
7726             }
7727         }
7728       else
7729         comdat_linkage (decl);
7730     }
7731   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7732     /* Set it up again; we might have set DECL_INITIAL since the last
7733        time.  */
7734     comdat_linkage (decl);
7735 }
7736
7737 /* Issue an error message if DECL is an uninitialized const variable.  */
7738
7739 static void
7740 check_for_uninitialized_const_var (decl)
7741      tree decl;
7742 {
7743   tree type = TREE_TYPE (decl);
7744
7745   /* ``Unless explicitly declared extern, a const object does not have
7746      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7747      7.1.6 */
7748   if (TREE_CODE (decl) == VAR_DECL
7749       && TREE_CODE (type) != REFERENCE_TYPE
7750       && CP_TYPE_CONST_P (type)
7751       && !TYPE_NEEDS_CONSTRUCTING (type)
7752       && !DECL_INITIAL (decl))
7753     error ("uninitialized const `%D'", decl);
7754 }
7755
7756 /* FIELD is a FIELD_DECL or NULL.  In the former case, the value
7757    returned is the next FIELD_DECL (possibly FIELD itself) that can be
7758    initialized.  If there are no more such fields, the return value
7759    will be NULL.  */
7760
7761 static tree
7762 next_initializable_field (tree field)
7763 {
7764   while (field
7765          && (TREE_CODE (field) != FIELD_DECL
7766              || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
7767              || DECL_ARTIFICIAL (field)))
7768     field = TREE_CHAIN (field);
7769
7770   return field;
7771 }
7772
7773 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
7774    brace-enclosed aggregate initializer.
7775
7776    *INITP is one of a list of initializers describing a brace-enclosed
7777    initializer for an entity of the indicated aggregate TYPE.  It may
7778    not presently match the shape of the TYPE; for example:
7779
7780      struct S { int a; int b; };
7781      struct S a[] = { 1, 2, 3, 4 };
7782
7783    Here *INITP will point to TREE_LIST of four elements, rather than a
7784    list of two elements, each itself a list of two elements.  This
7785    routine transforms INIT from the former form into the latter.  The
7786    revised initializer is returned.  */
7787
7788 static tree
7789 reshape_init (tree type, tree *initp)
7790 {
7791   tree inits;
7792   tree old_init;
7793   tree old_init_value;
7794   tree new_init;
7795   bool brace_enclosed_p;
7796
7797   old_init = *initp;
7798   old_init_value = (TREE_CODE (*initp) == TREE_LIST
7799                     ? TREE_VALUE (*initp) : old_init);
7800
7801   /* For some parse errors, OLD_INIT_VALUE may be NULL.  */
7802   if (!old_init_value)
7803     {
7804       my_friendly_assert (TREE_CODE (old_init) == TREE_LIST, 20021202);
7805       TREE_VALUE (old_init) = error_mark_node;
7806       return old_init;
7807     }
7808
7809   /* If the initializer is brace-enclosed, pull initializers from the
7810      enclosed elements.  Advance past the brace-enclosed initializer
7811      now.  */
7812   if (TREE_CODE (old_init_value) == CONSTRUCTOR
7813       && TREE_HAS_CONSTRUCTOR (old_init_value))
7814     {
7815       *initp = TREE_CHAIN (old_init);
7816       TREE_CHAIN (old_init) = NULL_TREE;
7817       inits = CONSTRUCTOR_ELTS (old_init_value);
7818       initp = &inits;
7819       brace_enclosed_p = true;
7820     }
7821   else
7822     {
7823       inits = NULL_TREE;
7824       brace_enclosed_p = false;
7825     }
7826
7827   /* A non-aggregate type is always initialized with a single
7828      initializer.  */
7829   if (!CP_AGGREGATE_TYPE_P (type))
7830       {
7831         *initp = TREE_CHAIN (old_init);
7832         TREE_CHAIN (old_init) = NULL_TREE;
7833         /* It is invalid to initialize a non-aggregate type with a
7834            brace-enclosed initializer.  */
7835         if (brace_enclosed_p)
7836           {
7837             error ("brace-enclosed initializer used to initialize `%T'",
7838                    type);
7839             if (TREE_CODE (old_init) == TREE_LIST)
7840               TREE_VALUE (old_init) = error_mark_node;
7841             else
7842               old_init = error_mark_node;
7843           }
7844
7845         return old_init;
7846       }
7847
7848   /* [dcl.init.aggr]
7849
7850      All implicit type conversions (clause _conv_) are considered when
7851      initializing the aggregate member with an initializer from an
7852      initializer-list.  If the initializer can initialize a member,
7853      the member is initialized.  Otherwise, if the member is itself a
7854      non-empty subaggregate, brace elision is assumed and the
7855      initializer is considered for the initialization of the first
7856      member of the subaggregate.  */
7857   if (CLASS_TYPE_P (type)
7858       && !brace_enclosed_p
7859       && can_convert_arg (type, TREE_TYPE (old_init_value), old_init_value))
7860     {
7861       *initp = TREE_CHAIN (old_init);
7862       TREE_CHAIN (old_init) = NULL_TREE;
7863       return old_init;
7864     }
7865
7866   if (TREE_CODE (old_init_value) == STRING_CST
7867       && TREE_CODE (type) == ARRAY_TYPE
7868       && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
7869     {
7870       /* [dcl.init.string]
7871
7872          A char array (whether plain char, signed char, or unsigned char)
7873          can be initialized by a string-literal (optionally enclosed in
7874          braces); a wchar_t array can be initialized by a wide
7875          string-literal (optionally enclosed in braces).  */
7876       new_init = old_init;
7877       /* Move past the initializer.  */
7878       *initp = TREE_CHAIN (old_init);
7879       TREE_CHAIN (old_init) = NULL_TREE;
7880     }
7881   else
7882     {
7883       /* Build a CONSTRUCTOR to hold the contents of the aggregate.  */
7884       new_init = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
7885       TREE_HAS_CONSTRUCTOR (new_init) = 1;
7886
7887       if (CLASS_TYPE_P (type))
7888         {
7889           tree field;
7890
7891           field = next_initializable_field (TYPE_FIELDS (type));
7892
7893           if (!field)
7894             {
7895               /* [dcl.init.aggr]
7896
7897                  An initializer for an aggregate member that is an
7898                  empty class shall have the form of an empty
7899                  initializer-list {}.  */
7900               if (!brace_enclosed_p)
7901                 error ("initializer for `%T' must be brace-enclosed",
7902                        type);
7903             }
7904           else
7905             {
7906               /* Loop through the initializable fields, gathering
7907                  initializers.  */
7908               while (*initp && field)
7909                 {
7910                   tree field_init;
7911
7912                   field_init = reshape_init (TREE_TYPE (field), initp);
7913                   TREE_CHAIN (field_init) = CONSTRUCTOR_ELTS (new_init);
7914                   CONSTRUCTOR_ELTS (new_init) = field_init;
7915                   /* [dcl.init.aggr]
7916
7917                      When a union  is  initialized with a brace-enclosed
7918                      initializer, the braces shall only contain an
7919                      initializer for the first member of the union.  */
7920                   if (TREE_CODE (type) == UNION_TYPE)
7921                     break;
7922                   if (TREE_PURPOSE (field_init))
7923                     field = TREE_PURPOSE (field_init);
7924                   field = next_initializable_field (TREE_CHAIN (field));
7925                 }
7926             }
7927         }
7928       else if (TREE_CODE (type) == ARRAY_TYPE)
7929         {
7930           tree index;
7931           tree max_index;
7932
7933           /* If the bound of the array is known, take no more initializers
7934              than are allowed.  */
7935           max_index = (TYPE_DOMAIN (type)
7936                        ? array_type_nelts (type) : NULL_TREE);
7937           /* Loop through the array elements, gathering initializers.  */
7938           for (index = size_zero_node;
7939                *initp && (!max_index || !tree_int_cst_lt (max_index, index));
7940                index = size_binop (PLUS_EXPR, index, size_one_node))
7941             {
7942               tree element_init;
7943
7944               element_init = reshape_init (TREE_TYPE (type), initp);
7945               TREE_CHAIN (element_init) = CONSTRUCTOR_ELTS (new_init);
7946               CONSTRUCTOR_ELTS (new_init) = element_init;
7947               if (TREE_PURPOSE (element_init))
7948                 index = TREE_PURPOSE (element_init);
7949             }
7950         }
7951       else
7952         abort ();
7953
7954       /* The initializers were placed in reverse order in the
7955          CONSTRUCTOR.  */
7956       CONSTRUCTOR_ELTS (new_init) = nreverse (CONSTRUCTOR_ELTS (new_init));
7957
7958       if (TREE_CODE (old_init) == TREE_LIST)
7959         new_init = build_tree_list (TREE_PURPOSE (old_init), new_init);
7960     }
7961
7962   /* If this was a brace-enclosed initializer and all of the
7963      initializers were not used up, there is a problem.  */
7964   if (brace_enclosed_p && *initp)
7965     error ("too many initializers for `%T'", type);
7966
7967   return new_init;
7968 }
7969
7970 /* Verify INIT (the initializer for DECL), and record the
7971    initialization in DECL_INITIAL, if appropriate.
7972
7973    If the return value is non-NULL, it is an expression that must be
7974    evaluated dynamically to initialize DECL.  */
7975
7976 static tree
7977 check_initializer (tree decl, tree init, int flags)
7978 {
7979   tree type = TREE_TYPE (decl);
7980
7981   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7982   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7983     init = NULL_TREE;
7984
7985   /* If an initializer is present, DECL_INITIAL has been
7986      error_mark_node, to indicate that an as-of-yet unevaluated
7987      initialization will occur.  From now on, DECL_INITIAL reflects
7988      the static initialization -- if any -- of DECL.  */
7989   DECL_INITIAL (decl) = NULL_TREE;
7990
7991   /* Things that are going to be initialized need to have complete
7992      type.  */
7993   TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7994
7995   if (type == error_mark_node)
7996     /* We will have already complained.  */
7997     init = NULL_TREE;
7998   else if (init && COMPLETE_TYPE_P (type)
7999            && !TREE_CONSTANT (TYPE_SIZE (type)))
8000     {
8001       error ("variable-sized object `%D' may not be initialized", decl);
8002       init = NULL_TREE;
8003     }
8004   else if (TREE_CODE (type) == ARRAY_TYPE
8005            && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
8006     {
8007       error ("elements of array `%#D' have incomplete type", decl);
8008       init = NULL_TREE;
8009     }
8010   else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
8011     {
8012       error ("`%D' has incomplete type", decl);
8013       TREE_TYPE (decl) = error_mark_node;
8014       init = NULL_TREE;
8015     }
8016
8017   if (TREE_CODE (decl) == CONST_DECL)
8018     {
8019       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
8020
8021       DECL_INITIAL (decl) = init;
8022
8023       my_friendly_assert (init != NULL_TREE, 149);
8024       init = NULL_TREE;
8025     }
8026   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
8027     init = grok_reference_init (decl, type, init);
8028   else if (init)
8029     {
8030       if (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))
8031         {
8032           /* [dcl.init] paragraph 13,
8033              If T is a scalar type, then a declaration of the form
8034              T x = { a };
8035              is equivalent to
8036              T x = a;
8037
8038              reshape_init will complain about the extra braces,
8039              and doesn't do anything useful in the case where TYPE is
8040              scalar, so just don't call it.  */
8041           if (CP_AGGREGATE_TYPE_P (type))
8042             init = reshape_init (type, &init);
8043         }
8044
8045       /* If DECL has an array type without a specific bound, deduce the
8046          array size from the initializer.  */
8047       maybe_deduce_size_from_array_init (decl, init);
8048       type = TREE_TYPE (decl);
8049       if (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))
8050         TREE_TYPE (init) = type;
8051
8052       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
8053         {
8054           if (TREE_CODE (type) == ARRAY_TYPE)
8055             goto initialize_aggr;
8056           else if (TREE_CODE (init) == CONSTRUCTOR
8057                    && TREE_HAS_CONSTRUCTOR (init))
8058             {
8059               if (TYPE_NON_AGGREGATE_CLASS (type))
8060                 {
8061                   error ("`%D' must be initialized by constructor, not by `{...}'",
8062                          decl);
8063                   init = error_mark_node;
8064                 }
8065               else
8066                 goto dont_use_constructor;
8067             }
8068           else
8069             {
8070               int saved_stmts_are_full_exprs_p;
8071
8072             initialize_aggr:
8073               saved_stmts_are_full_exprs_p = 0;
8074               if (building_stmt_tree ())
8075                 {
8076                   saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
8077                   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
8078                 }
8079               init = build_aggr_init (decl, init, flags);
8080               if (building_stmt_tree ())
8081                 current_stmt_tree ()->stmts_are_full_exprs_p =
8082                   saved_stmts_are_full_exprs_p;
8083               return init;
8084             }
8085         }
8086       else
8087         {
8088         dont_use_constructor:
8089           if (TREE_CODE (init) != TREE_VEC)
8090             init = store_init_value (decl, init);
8091         }
8092     }
8093   else if (DECL_EXTERNAL (decl))
8094     ;
8095   else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
8096     goto initialize_aggr;
8097   else if (IS_AGGR_TYPE (type))
8098     {
8099       tree core_type = strip_array_types (type);
8100
8101       if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
8102         error ("structure `%D' with uninitialized const members", decl);
8103       if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
8104         error ("structure `%D' with uninitialized reference members",
8105                decl);
8106
8107       check_for_uninitialized_const_var (decl);
8108     }
8109   else
8110     check_for_uninitialized_const_var (decl);
8111
8112   if (init && init != error_mark_node)
8113     init = build (INIT_EXPR, type, decl, init);
8114
8115   return init;
8116 }
8117
8118 /* If DECL is not a local variable, give it RTL.  */
8119
8120 static void
8121 make_rtl_for_nonlocal_decl (decl, init, asmspec)
8122      tree decl;
8123      tree init;
8124      const char *asmspec;
8125 {
8126   int toplev = toplevel_bindings_p ();
8127   int defer_p;
8128
8129   /* Handle non-variables up front.  */
8130   if (TREE_CODE (decl) != VAR_DECL)
8131     {
8132       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
8133       return;
8134     }
8135
8136   /* If we see a class member here, it should be a static data
8137      member.  */
8138   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
8139     {
8140       my_friendly_assert (TREE_STATIC (decl), 19990828);
8141       /* An in-class declaration of a static data member should be
8142          external; it is only a declaration, and not a definition.  */
8143       if (init == NULL_TREE)
8144         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
8145     }
8146
8147   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
8148   if (asmspec)
8149     {
8150       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8151       /* The `register' keyword, when used together with an
8152          asm-specification, indicates that the variable should be
8153          placed in a particular register.  */
8154       if (DECL_REGISTER (decl))
8155         DECL_C_HARD_REGISTER (decl) = 1;
8156     }
8157
8158   /* We don't create any RTL for local variables.  */
8159   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
8160     return;
8161
8162   /* We defer emission of local statics until the corresponding
8163      DECL_STMT is expanded.  */
8164   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
8165
8166   /* We try to defer namespace-scope static constants so that they are
8167      not emitted into the object file unnecessarily.  */
8168   if (!DECL_VIRTUAL_P (decl)
8169       && TREE_READONLY (decl)
8170       && DECL_INITIAL (decl) != NULL_TREE
8171       && DECL_INITIAL (decl) != error_mark_node
8172       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
8173       && toplev
8174       && !TREE_PUBLIC (decl))
8175     {
8176       /* Fool with the linkage of static consts according to #pragma
8177          interface.  */
8178       if (!interface_unknown && !TREE_PUBLIC (decl))
8179         {
8180           TREE_PUBLIC (decl) = 1;
8181           DECL_EXTERNAL (decl) = interface_only;
8182         }
8183
8184       defer_p = 1;
8185     }
8186   /* Likewise for template instantiations.  */
8187   else if (DECL_COMDAT (decl))
8188     defer_p = 1;
8189
8190   /* If we're deferring the variable, we only need to make RTL if
8191      there's an ASMSPEC.  Otherwise, we'll lazily create it later when
8192      we need it.  (There's no way to lazily create RTL for things that
8193      have assembly specs because the information about the specifier
8194      isn't stored in the tree, yet)  */
8195   if (defer_p && asmspec)
8196     make_decl_rtl (decl, asmspec);
8197   /* If we're not deferring, go ahead and assemble the variable.  */
8198   else if (!defer_p)
8199     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
8200 }
8201
8202 /* The old ARM scoping rules injected variables declared in the
8203    initialization statement of a for-statement into the surrounding
8204    scope.  We support this usage, in order to be backward-compatible.
8205    DECL is a just-declared VAR_DECL; if necessary inject its
8206    declaration into the surrounding scope.  */
8207
8208 void
8209 maybe_inject_for_scope_var (decl)
8210      tree decl;
8211 {
8212   if (!DECL_NAME (decl))
8213     return;
8214
8215   /* Declarations of __FUNCTION__ and its ilk appear magically when
8216      the variable is first used.  If that happens to be inside a
8217      for-loop, we don't want to do anything special.  */
8218   if (DECL_PRETTY_FUNCTION_P (decl))
8219     return;
8220
8221   if (current_binding_level->is_for_scope)
8222     {
8223       struct cp_binding_level *outer
8224         = current_binding_level->level_chain;
8225
8226       /* Check to see if the same name is already bound at the outer
8227          level, either because it was directly declared, or because a
8228          dead for-decl got preserved.  In either case, the code would
8229          not have been valid under the ARM scope rules, so clear
8230          is_for_scope for the current_binding_level.
8231
8232          Otherwise, we need to preserve the temp slot for decl to last
8233          into the outer binding level.  */
8234
8235       tree outer_binding
8236         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
8237
8238       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
8239           && (TREE_CODE (BINDING_VALUE (outer_binding))
8240               == VAR_DECL)
8241           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
8242         {
8243           BINDING_VALUE (outer_binding)
8244             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
8245           current_binding_level->is_for_scope = 0;
8246         }
8247       else if (DECL_IN_MEMORY_P (decl))
8248         preserve_temp_slots (DECL_RTL (decl));
8249     }
8250 }
8251
8252 /* Generate code to initialize DECL (a local variable).  */
8253
8254 static void
8255 initialize_local_var (decl, init)
8256      tree decl;
8257      tree init;
8258 {
8259   tree type = TREE_TYPE (decl);
8260
8261   my_friendly_assert (TREE_CODE (decl) == VAR_DECL
8262                       || TREE_CODE (decl) == RESULT_DECL,
8263                       20021010);
8264   my_friendly_assert (!TREE_STATIC (decl), 20021010);
8265
8266   if (DECL_SIZE (decl) == NULL_TREE)
8267     {
8268       /* If we used it already as memory, it must stay in memory.  */
8269       DECL_INITIAL (decl) = NULL_TREE;
8270       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
8271     }
8272
8273   if (DECL_SIZE (decl) && type != error_mark_node)
8274     {
8275       int already_used;
8276
8277       /* Compute and store the initial value.  */
8278       already_used = TREE_USED (decl) || TREE_USED (type);
8279
8280       /* Perform the initialization.  */
8281       if (init)
8282         {
8283           int saved_stmts_are_full_exprs_p;
8284
8285           my_friendly_assert (building_stmt_tree (), 20000906);
8286           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
8287           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
8288           finish_expr_stmt (init);
8289           current_stmt_tree ()->stmts_are_full_exprs_p =
8290             saved_stmts_are_full_exprs_p;
8291         }
8292
8293       /* Set this to 0 so we can tell whether an aggregate which was
8294          initialized was ever used.  Don't do this if it has a
8295          destructor, so we don't complain about the 'resource
8296          allocation is initialization' idiom.  Now set
8297          attribute((unused)) on types so decls of that type will be
8298          marked used. (see TREE_USED, above.)  */
8299       if (TYPE_NEEDS_CONSTRUCTING (type)
8300           && ! already_used
8301           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
8302           && DECL_NAME (decl))
8303         TREE_USED (decl) = 0;
8304       else if (already_used)
8305         TREE_USED (decl) = 1;
8306     }
8307
8308   /* Generate a cleanup, if necessary.  */
8309   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8310     {
8311       tree cleanup;
8312
8313       /* Compute the cleanup.  */
8314       cleanup = cxx_maybe_build_cleanup (decl);
8315
8316       /* Record the cleanup required for this declaration.  */
8317       if (DECL_SIZE (decl) && cleanup)
8318         finish_decl_cleanup (decl, cleanup);
8319     }
8320 }
8321
8322 /* Finish processing of a declaration;
8323    install its line number and initial value.
8324    If the length of an array type is not known before,
8325    it must be determined now, from the initial value, or it is an error.
8326
8327    INIT holds the value of an initializer that should be allowed to escape
8328    the normal rules.
8329
8330    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8331    if the (init) syntax was used.  */
8332
8333 void
8334 cp_finish_decl (decl, init, asmspec_tree, flags)
8335      tree decl, init;
8336      tree asmspec_tree;
8337      int flags;
8338 {
8339   register tree type;
8340   tree ttype = NULL_TREE;
8341   const char *asmspec = NULL;
8342   int was_readonly = 0;
8343
8344   if (! decl)
8345     {
8346       if (init)
8347         error ("assignment (not initialization) in declaration");
8348       return;
8349     }
8350
8351   /* If a name was specified, get the string.  */
8352   if (current_binding_level == global_binding_level)
8353     asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
8354   if (asmspec_tree)
8355     asmspec = TREE_STRING_POINTER (asmspec_tree);
8356
8357   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8358     {
8359       error ("cannot initialize `%D' to namespace `%D'",
8360                 decl, init);
8361       init = NULL_TREE;
8362     }
8363
8364   if (current_class_type
8365       && CP_DECL_CONTEXT (decl) == current_class_type
8366       && TYPE_BEING_DEFINED (current_class_type)
8367       && (DECL_INITIAL (decl) || init))
8368     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
8369
8370   if (TREE_CODE (decl) == VAR_DECL
8371       && DECL_CONTEXT (decl)
8372       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8373       && DECL_CONTEXT (decl) != current_namespace
8374       && init)
8375     {
8376       /* Leave the namespace of the object.  */
8377       pop_decl_namespace ();
8378     }
8379
8380   type = TREE_TYPE (decl);
8381
8382   if (type == error_mark_node)
8383     return;
8384
8385   if (TYPE_HAS_MUTABLE_P (type))
8386     TREE_READONLY (decl) = 0;
8387
8388   if (processing_template_decl)
8389     {
8390       /* Add this declaration to the statement-tree.  */
8391       if (at_function_scope_p ()
8392           && TREE_CODE (decl) != RESULT_DECL)
8393         add_decl_stmt (decl);
8394
8395       if (init && DECL_INITIAL (decl))
8396         DECL_INITIAL (decl) = init;
8397       goto finish_end0;
8398     }
8399
8400   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8401   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8402
8403   /* Take care of TYPE_DECLs up front.  */
8404   if (TREE_CODE (decl) == TYPE_DECL)
8405     {
8406       if (type != error_mark_node
8407           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8408         {
8409           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8410             warning ("shadowing previous type declaration of `%#D'", decl);
8411           set_identifier_type_value (DECL_NAME (decl), type);
8412           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8413         }
8414
8415       /* If we have installed this as the canonical typedef for this
8416          type, and that type has not been defined yet, delay emitting
8417          the debug information for it, as we will emit it later.  */
8418       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8419           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8420         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8421
8422       rest_of_decl_compilation (decl, NULL,
8423                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8424       goto finish_end;
8425     }
8426
8427   if (TREE_CODE (decl) != FUNCTION_DECL)
8428     ttype = target_type (type);
8429
8430   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8431       && TYPE_NEEDS_CONSTRUCTING (type))
8432     {
8433       /* Currently, GNU C++ puts constants in text space, making them
8434          impossible to initialize.  In the future, one would hope for
8435          an operating system which understood the difference between
8436          initialization and the running of a program.  */
8437       was_readonly = 1;
8438       TREE_READONLY (decl) = 0;
8439     }
8440
8441   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8442     {
8443       /* This must override the asm specifier which was placed by
8444          grokclassfn.  Lay this out fresh.  */
8445       SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
8446       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8447       make_decl_rtl (decl, asmspec);
8448     }
8449   else if (TREE_CODE (decl) == RESULT_DECL)
8450     init = check_initializer (decl, init, flags);
8451   else if (TREE_CODE (decl) == VAR_DECL)
8452     {
8453       /* Only PODs can have thread-local storage.  Other types may require
8454          various kinds of non-trivial initialization.  */
8455       if (DECL_THREAD_LOCAL (decl) && !pod_type_p (TREE_TYPE (decl)))
8456         error ("`%D' cannot be thread-local because it has non-POD type `%T'",
8457                decl, TREE_TYPE (decl));
8458       /* Convert the initializer to the type of DECL, if we have not
8459          already initialized DECL.  */
8460       if (!DECL_INITIALIZED_P (decl)
8461           /* If !DECL_EXTERNAL then DECL is being defined.  In the
8462              case of a static data member initialized inside the
8463              class-specifier, there can be an initializer even if DECL
8464              is *not* defined.  */
8465           && (!DECL_EXTERNAL (decl) || init))
8466         {
8467           init = check_initializer (decl, init, flags);
8468           /* Thread-local storage cannot be dynamically initialized.  */
8469           if (DECL_THREAD_LOCAL (decl) && init)
8470             {
8471               error ("`%D' is thread-local and so cannot be dynamically "
8472                      "initialized", decl);
8473               init = NULL_TREE;
8474             }
8475           /* Handle:
8476
8477              [dcl.init]
8478
8479              The memory occupied by any object of static storage
8480              duration is zero-initialized at program startup before
8481              any other initialization takes place.
8482
8483              We cannot create an appropriate initializer until after
8484              the type of DECL is finalized.  If DECL_INITIAL is set,
8485              then the DECL is statically initialized, and any
8486              necessary zero-initialization has already been performed.  */
8487           if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
8488             DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
8489                                                    /*static_storage_p=*/true);
8490           /* Remember that the initialization for this variable has
8491              taken place.  */
8492           DECL_INITIALIZED_P (decl) = 1;
8493         }
8494       /* If the variable has an array type, lay out the type, even if
8495          there is no initializer.  It is valid to index through the
8496          array, and we must get TYPE_ALIGN set correctly on the array
8497          type.  */
8498       else if (TREE_CODE (type) == ARRAY_TYPE)
8499         layout_type (type);
8500     }
8501
8502   /* Add this declaration to the statement-tree.  This needs to happen
8503      after the call to check_initializer so that the DECL_STMT for a
8504      reference temp is added before the DECL_STMT for the reference itself.  */
8505   if (building_stmt_tree ()
8506       && at_function_scope_p ()
8507       && TREE_CODE (decl) != RESULT_DECL)
8508     add_decl_stmt (decl);
8509
8510   if (TREE_CODE (decl) == VAR_DECL)
8511     layout_var_decl (decl);
8512
8513   /* Output the assembler code and/or RTL code for variables and functions,
8514      unless the type is an undefined structure or union.
8515      If not, it will get done when the type is completed.  */
8516   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8517       || TREE_CODE (decl) == RESULT_DECL)
8518     {
8519       if (TREE_CODE (decl) == VAR_DECL)
8520         maybe_commonize_var (decl);
8521
8522       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8523
8524       if (TREE_CODE (type) == FUNCTION_TYPE
8525           || TREE_CODE (type) == METHOD_TYPE)
8526         abstract_virtuals_error (decl,
8527                                  strip_array_types (TREE_TYPE (type)));
8528       else
8529         abstract_virtuals_error (decl, strip_array_types (type));
8530
8531       if (TREE_CODE (decl) == FUNCTION_DECL
8532           || TREE_TYPE (decl) == error_mark_node)
8533         /* No initialization required.  */
8534         ;
8535       else if (DECL_EXTERNAL (decl)
8536                && ! (DECL_LANG_SPECIFIC (decl)
8537                      && DECL_NOT_REALLY_EXTERN (decl)))
8538         {
8539           if (init)
8540             DECL_INITIAL (decl) = init;
8541         }
8542       else
8543         {
8544           /* A variable definition.  */
8545           if (DECL_FUNCTION_SCOPE_P (decl))
8546             {
8547               /* This is a local declaration.  */
8548               if (doing_semantic_analysis_p ())
8549                 maybe_inject_for_scope_var (decl);
8550               /* Initialize the local variable.  */
8551               if (processing_template_decl)
8552                 {
8553                   if (init || DECL_INITIAL (decl) == error_mark_node)
8554                     DECL_INITIAL (decl) = init;
8555                 }
8556               else if (!TREE_STATIC (decl))
8557                 initialize_local_var (decl, init);
8558             }
8559
8560           if (TREE_STATIC (decl))
8561             expand_static_init (decl, init);
8562         }
8563     finish_end0:
8564
8565       /* Undo call to `pushclass' that was done in `start_decl'
8566          due to initialization of qualified member variable.
8567          I.e., Foo::x = 10;  */
8568       {
8569         tree context = CP_DECL_CONTEXT (decl);
8570         if (context
8571             && TYPE_P (context)
8572             && (TREE_CODE (decl) == VAR_DECL
8573                 /* We also have a pushclass done that we need to undo here
8574                    if we're at top level and declare a method.  */
8575                 || TREE_CODE (decl) == FUNCTION_DECL)
8576             /* If size hasn't been set, we're still defining it,
8577                and therefore inside the class body; don't pop
8578                the binding level..  */
8579             && COMPLETE_TYPE_P (context)
8580             && context == current_class_type)
8581           pop_nested_class ();
8582       }
8583     }
8584
8585  finish_end:
8586
8587   if (was_readonly)
8588     TREE_READONLY (decl) = 1;
8589 }
8590
8591 /* This is here for a midend callback from c-common.c */
8592
8593 void
8594 finish_decl (decl, init, asmspec_tree)
8595      tree decl, init;
8596      tree asmspec_tree;
8597 {
8598   cp_finish_decl (decl, init, asmspec_tree, 0);
8599 }
8600
8601 /* Returns a declaration for a VAR_DECL as if:
8602
8603      extern "C" TYPE NAME;
8604
8605    had been seen.  Used to create compiler-generated global
8606    variables.  */
8607
8608 tree
8609 declare_global_var (name, type)
8610      tree name;
8611      tree type;
8612 {
8613   tree decl;
8614
8615   push_to_top_level ();
8616   decl = build_decl (VAR_DECL, name, type);
8617   TREE_PUBLIC (decl) = 1;
8618   DECL_EXTERNAL (decl) = 1;
8619   DECL_ARTIFICIAL (decl) = 1;
8620   pushdecl (decl);
8621   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8622   pop_from_top_level ();
8623
8624   return decl;
8625 }
8626
8627 /* Returns a pointer to the `atexit' function.  Note that if
8628    FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
8629    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8630
8631 static tree
8632 get_atexit_node ()
8633 {
8634   tree atexit_fndecl;
8635   tree arg_types;
8636   tree fn_type;
8637   tree fn_ptr_type;
8638   const char *name;
8639
8640   if (atexit_node)
8641     return atexit_node;
8642
8643   if (flag_use_cxa_atexit)
8644     {
8645       /* The declaration for `__cxa_atexit' is:
8646
8647            int __cxa_atexit (void (*)(void *), void *, void *)
8648
8649          We build up the argument types and then then function type
8650          itself.  */
8651
8652       /* First, build the pointer-to-function type for the first
8653          argument.  */
8654       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8655       fn_type = build_function_type (void_type_node, arg_types);
8656       fn_ptr_type = build_pointer_type (fn_type);
8657       /* Then, build the rest of the argument types.  */
8658       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8659       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8660       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8661       /* And the final __cxa_atexit type.  */
8662       fn_type = build_function_type (integer_type_node, arg_types);
8663       fn_ptr_type = build_pointer_type (fn_type);
8664       name = "__cxa_atexit";
8665     }
8666   else
8667     {
8668       /* The declaration for `atexit' is:
8669
8670            int atexit (void (*)());
8671
8672          We build up the argument types and then then function type
8673          itself.  */
8674       fn_type = build_function_type (void_type_node, void_list_node);
8675       fn_ptr_type = build_pointer_type (fn_type);
8676       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8677       /* Build the final atexit type.  */
8678       fn_type = build_function_type (integer_type_node, arg_types);
8679       name = "atexit";
8680     }
8681
8682   /* Now, build the function declaration.  */
8683   push_lang_context (lang_name_c);
8684   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8685   mark_used (atexit_fndecl);
8686   pop_lang_context ();
8687   atexit_node = default_conversion (atexit_fndecl);
8688
8689   return atexit_node;
8690 }
8691
8692 /* Returns the __dso_handle VAR_DECL.  */
8693
8694 static tree
8695 get_dso_handle_node ()
8696 {
8697   if (dso_handle_node)
8698     return dso_handle_node;
8699
8700   /* Declare the variable.  */
8701   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8702                                         ptr_type_node);
8703
8704   return dso_handle_node;
8705 }
8706
8707 /* Begin a new function with internal linkage whose job will be simply
8708    to destroy some particular variable.  */
8709
8710 static tree
8711 start_cleanup_fn ()
8712 {
8713   static int counter = 0;
8714   int old_interface_only = interface_only;
8715   int old_interface_unknown = interface_unknown;
8716   char name[32];
8717   tree parmtypes;
8718   tree fntype;
8719   tree fndecl;
8720
8721   push_to_top_level ();
8722
8723   /* No need to mangle this.  */
8724   push_lang_context (lang_name_c);
8725
8726   interface_only = 0;
8727   interface_unknown = 1;
8728
8729   /* Build the parameter-types.  */
8730   parmtypes = void_list_node;
8731   /* Functions passed to __cxa_atexit take an additional parameter.
8732      We'll just ignore it.  After we implement the new calling
8733      convention for destructors, we can eliminate the use of
8734      additional cleanup functions entirely in the -fnew-abi case.  */
8735   if (flag_use_cxa_atexit)
8736     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8737   /* Build the function type itself.  */
8738   fntype = build_function_type (void_type_node, parmtypes);
8739   /* Build the name of the function.  */
8740   sprintf (name, "__tcf_%d", counter++);
8741   /* Build the function declaration.  */
8742   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8743   /* It's a function with internal linkage, generated by the
8744      compiler.  */
8745   TREE_PUBLIC (fndecl) = 0;
8746   DECL_ARTIFICIAL (fndecl) = 1;
8747   /* Make the function `inline' so that it is only emitted if it is
8748      actually needed.  It is unlikely that it will be inlined, since
8749      it is only called via a function pointer, but we avoid unnecessary
8750      emissions this way.  */
8751   DECL_INLINE (fndecl) = 1;
8752   /* Build the parameter.  */
8753   if (flag_use_cxa_atexit)
8754     {
8755       tree parmdecl;
8756
8757       parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
8758       DECL_CONTEXT (parmdecl) = fndecl;
8759       TREE_USED (parmdecl) = 1;
8760       DECL_ARGUMENTS (fndecl) = parmdecl;
8761     }
8762
8763   pushdecl (fndecl);
8764   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8765
8766   interface_unknown = old_interface_unknown;
8767   interface_only = old_interface_only;
8768
8769   pop_lang_context ();
8770
8771   return current_function_decl;
8772 }
8773
8774 /* Finish the cleanup function begun by start_cleanup_fn.  */
8775
8776 static void
8777 end_cleanup_fn ()
8778 {
8779   expand_body (finish_function (0));
8780
8781   pop_from_top_level ();
8782 }
8783
8784 /* Generate code to handle the destruction of DECL, an object with
8785    static storage duration.  */
8786
8787 void
8788 register_dtor_fn (decl)
8789      tree decl;
8790 {
8791   tree cleanup;
8792   tree compound_stmt;
8793   tree args;
8794   tree fcall;
8795
8796   int saved_flag_access_control;
8797
8798   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8799     return;
8800
8801   /* Call build_cleanup before we enter the anonymous function so that
8802      any access checks will be done relative to the current scope,
8803      rather than the scope of the anonymous function.  */
8804   build_cleanup (decl);
8805
8806   /* Now start the function.  */
8807   cleanup = start_cleanup_fn ();
8808
8809   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8810      to the original function, rather than the anonymous one.  That
8811      will make the back-end think that nested functions are in use,
8812      which causes confusion.  */
8813   saved_flag_access_control = flag_access_control;
8814   flag_access_control = 0;
8815   fcall = build_cleanup (decl);
8816   flag_access_control = saved_flag_access_control;
8817
8818   /* Create the body of the anonymous function.  */
8819   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8820   finish_expr_stmt (fcall);
8821   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8822   end_cleanup_fn ();
8823
8824   /* Call atexit with the cleanup function.  */
8825   cxx_mark_addressable (cleanup);
8826   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8827   if (flag_use_cxa_atexit)
8828     {
8829       args = tree_cons (NULL_TREE,
8830                         build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
8831                         NULL_TREE);
8832       args = tree_cons (NULL_TREE, null_pointer_node, args);
8833       args = tree_cons (NULL_TREE, cleanup, args);
8834     }
8835   else
8836     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8837   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8838 }
8839
8840 /* DECL is a VAR_DECL with static storage duration.  INIT, if present,
8841    is its initializer.  Generate code to handle the construction
8842    and destruction of DECL.  */
8843
8844 static void
8845 expand_static_init (decl, init)
8846      tree decl;
8847      tree init;
8848 {
8849   tree oldstatic;
8850
8851   my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 20021010);
8852   my_friendly_assert (TREE_STATIC (decl), 20021010);
8853
8854   /* Some variables require no initialization.  */
8855   if (!init
8856       && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8857       && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8858     return;
8859
8860   oldstatic = value_member (decl, static_aggregates);
8861
8862   if (oldstatic)
8863     {
8864       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8865         error ("multiple initializations given for `%D'", decl);
8866     }
8867   else if (! toplevel_bindings_p ())
8868     {
8869       /* Emit code to perform this initialization but once.  */
8870       tree if_stmt;
8871       tree then_clause;
8872       tree assignment;
8873       tree guard;
8874       tree guard_init;
8875
8876       /* Emit code to perform this initialization but once.  This code
8877          looks like:
8878
8879            static int guard = 0;
8880            if (!guard) {
8881              // Do initialization.
8882              guard = 1;
8883              // Register variable for destruction at end of program.
8884            }
8885
8886          Note that the `temp' variable is only set to 1 *after* the
8887          initialization is complete.  This ensures that an exception,
8888          thrown during the construction, will cause the variable to
8889          reinitialized when we pass through this code again, as per:
8890
8891            [stmt.dcl]
8892
8893            If the initialization exits by throwing an exception, the
8894            initialization is not complete, so it will be tried again
8895            the next time control enters the declaration.
8896
8897          In theory, this process should be thread-safe, too; multiple
8898          threads should not be able to initialize the variable more
8899          than once.  We don't yet attempt to ensure thread-safety.  */
8900
8901       /* Create the guard variable.  */
8902       guard = get_guard (decl);
8903
8904       /* Begin the conditional initialization.  */
8905       if_stmt = begin_if_stmt ();
8906       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8907       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8908
8909       /* Do the initialization itself.  */
8910       assignment = init ? init : NULL_TREE;
8911
8912       /* Once the assignment is complete, set TEMP to 1.  Since the
8913          construction of the static object is complete at this point,
8914          we want to make sure TEMP is set to 1 even if a temporary
8915          constructed during the initialization throws an exception
8916          when it is destroyed.  So, we combine the initialization and
8917          the assignment to TEMP into a single expression, ensuring
8918          that when we call finish_expr_stmt the cleanups will not be
8919          run until after TEMP is set to 1.  */
8920       guard_init = set_guard (guard);
8921       if (assignment)
8922         {
8923           assignment = tree_cons (NULL_TREE, assignment,
8924                                   build_tree_list (NULL_TREE,
8925                                                    guard_init));
8926           assignment = build_compound_expr (assignment);
8927         }
8928       else
8929         assignment = guard_init;
8930       finish_expr_stmt (assignment);
8931
8932       /* Use atexit to register a function for destroying this static
8933          variable.  */
8934       register_dtor_fn (decl);
8935
8936       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8937       finish_then_clause (if_stmt);
8938       finish_if_stmt ();
8939     }
8940   else
8941     static_aggregates = tree_cons (init, decl, static_aggregates);
8942 }
8943
8944 /* Finish the declaration of a catch-parameter.  */
8945
8946 tree
8947 start_handler_parms (declspecs, declarator)
8948      tree declspecs;
8949      tree declarator;
8950 {
8951   tree decl;
8952   if (declspecs)
8953     {
8954       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8955                              1, NULL);
8956       if (decl == NULL_TREE)
8957         error ("invalid catch parameter");
8958     }
8959   else
8960     decl = NULL_TREE;
8961
8962   return decl;
8963 }
8964
8965 \f
8966 /* Make TYPE a complete type based on INITIAL_VALUE.
8967    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8968    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8969
8970 int
8971 complete_array_type (type, initial_value, do_default)
8972      tree type, initial_value;
8973      int do_default;
8974 {
8975   register tree maxindex = NULL_TREE;
8976   int value = 0;
8977
8978   if (initial_value)
8979     {
8980       /* An array of character type can be initialized from a
8981          brace-enclosed string constant.  */
8982       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8983           && TREE_CODE (initial_value) == CONSTRUCTOR
8984           && CONSTRUCTOR_ELTS (initial_value)
8985           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8986               == STRING_CST)
8987           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8988         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8989
8990       /* Note MAXINDEX is really the maximum index, one less than the
8991          size.  */
8992       if (TREE_CODE (initial_value) == STRING_CST)
8993         {
8994           int eltsize
8995             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8996           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8997                                    / eltsize) - 1, 0);
8998         }
8999       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
9000         {
9001           tree elts = CONSTRUCTOR_ELTS (initial_value);
9002
9003           maxindex = ssize_int (-1);
9004           for (; elts; elts = TREE_CHAIN (elts))
9005             {
9006               if (TREE_PURPOSE (elts))
9007                 maxindex = TREE_PURPOSE (elts);
9008               else
9009                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
9010             }
9011           maxindex = copy_node (maxindex);
9012         }
9013       else
9014         {
9015           /* Make an error message unless that happened already.  */
9016           if (initial_value != error_mark_node)
9017             value = 1;
9018           else
9019             initial_value = NULL_TREE;
9020
9021           /* Prevent further error messages.  */
9022           maxindex = build_int_2 (0, 0);
9023         }
9024     }
9025
9026   if (!maxindex)
9027     {
9028       if (do_default)
9029         maxindex = build_int_2 (0, 0);
9030       value = 2;
9031     }
9032
9033   if (maxindex)
9034     {
9035       tree itype;
9036       tree domain;
9037
9038       domain = build_index_type (maxindex);
9039       TYPE_DOMAIN (type) = domain;
9040
9041       if (! TREE_TYPE (maxindex))
9042         TREE_TYPE (maxindex) = domain;
9043       if (initial_value)
9044         itype = TREE_TYPE (initial_value);
9045       else
9046         itype = NULL;
9047       if (itype && !TYPE_DOMAIN (itype))
9048         TYPE_DOMAIN (itype) = domain;
9049       /* The type of the main variant should never be used for arrays
9050          of different sizes.  It should only ever be completed with the
9051          size of the array.  */
9052       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
9053         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
9054     }
9055
9056   /* Lay out the type now that we can get the real answer.  */
9057
9058   layout_type (type);
9059
9060   return value;
9061 }
9062 \f
9063 /* Return zero if something is declared to be a member of type
9064    CTYPE when in the context of CUR_TYPE.  STRING is the error
9065    message to print in that case.  Otherwise, quietly return 1.  */
9066
9067 static int
9068 member_function_or_else (ctype, cur_type, flags)
9069      tree ctype, cur_type;
9070      enum overload_flags flags;
9071 {
9072   if (ctype && ctype != cur_type)
9073     {
9074       if (flags == DTOR_FLAG)
9075         error ("destructor for alien class `%T' cannot be a member",
9076                   ctype);
9077       else
9078         error ("constructor for alien class `%T' cannot be a member",
9079                   ctype);
9080       return 0;
9081     }
9082   return 1;
9083 }
9084 \f
9085 /* Subroutine of `grokdeclarator'.  */
9086
9087 /* Generate errors possibly applicable for a given set of specifiers.
9088    This is for ARM $7.1.2.  */
9089
9090 static void
9091 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
9092      tree object;
9093      const char *type;
9094      int virtualp, quals, friendp, raises, inlinep;
9095 {
9096   if (virtualp)
9097     error ("`%D' declared as a `virtual' %s", object, type);
9098   if (inlinep)
9099     error ("`%D' declared as an `inline' %s", object, type);
9100   if (quals)
9101     error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
9102               object, type);
9103   if (friendp)
9104     cp_error_at ("`%D' declared as a friend", object);
9105   if (raises
9106       && (TREE_CODE (object) == TYPE_DECL
9107           || (!TYPE_PTRFN_P (TREE_TYPE (object))
9108               && !TYPE_REFFN_P (TREE_TYPE (object))
9109               && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
9110     cp_error_at ("`%D' declared with an exception specification", object);
9111 }
9112
9113 /* CTYPE is class type, or null if non-class.
9114    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
9115    or METHOD_TYPE.
9116    DECLARATOR is the function's name.
9117    VIRTUALP is truthvalue of whether the function is virtual or not.
9118    FLAGS are to be passed through to `grokclassfn'.
9119    QUALS are qualifiers indicating whether the function is `const'
9120    or `volatile'.
9121    RAISES is a list of exceptions that this function can raise.
9122    CHECK is 1 if we must find this method in CTYPE, 0 if we should
9123    not look, and -1 if we should not call `grokclassfn' at all.
9124
9125    Returns `NULL_TREE' if something goes wrong, after issuing
9126    applicable error messages.  */
9127
9128 static tree
9129 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
9130             raises, check, friendp, publicp, inlinep, funcdef_flag,
9131             template_count, in_namespace)
9132      tree ctype, type;
9133      tree declarator;
9134      tree orig_declarator;
9135      int virtualp;
9136      enum overload_flags flags;
9137      tree quals, raises;
9138      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
9139      tree in_namespace;
9140 {
9141   tree decl;
9142   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
9143   int has_default_arg = 0;
9144   tree t;
9145
9146   if (raises)
9147     type = build_exception_variant (type, raises);
9148
9149   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
9150   /* Propagate volatile out from type to decl.  */
9151   if (TYPE_VOLATILE (type))
9152     TREE_THIS_VOLATILE (decl) = 1;
9153
9154   /* If this decl has namespace scope, set that up.  */
9155   if (in_namespace)
9156     set_decl_namespace (decl, in_namespace, friendp);
9157   else if (!ctype)
9158     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
9159
9160   /* `main' and builtins have implicit 'C' linkage.  */
9161   if ((MAIN_NAME_P (declarator)
9162        || (IDENTIFIER_LENGTH (declarator) > 10
9163            && IDENTIFIER_POINTER (declarator)[0] == '_'
9164            && IDENTIFIER_POINTER (declarator)[1] == '_'
9165            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
9166       && current_lang_name == lang_name_cplusplus
9167       && ctype == NULL_TREE
9168       /* NULL_TREE means global namespace.  */
9169       && DECL_CONTEXT (decl) == NULL_TREE)
9170     SET_DECL_LANGUAGE (decl, lang_c);
9171
9172   /* Should probably propagate const out from type to decl I bet (mrs).  */
9173   if (staticp)
9174     {
9175       DECL_STATIC_FUNCTION_P (decl) = 1;
9176       DECL_CONTEXT (decl) = ctype;
9177     }
9178
9179   if (ctype)
9180     DECL_CONTEXT (decl) = ctype;
9181
9182   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
9183     {
9184       if (processing_template_decl)
9185         error ("cannot declare `::main' to be a template");
9186       if (inlinep)
9187         error ("cannot declare `::main' to be inline");
9188       if (!publicp)
9189         error ("cannot declare `::main' to be static");
9190       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
9191                         integer_type_node))
9192         error ("`main' must return `int'");
9193       inlinep = 0;
9194       publicp = 1;
9195     }
9196
9197   /* Members of anonymous types and local classes have no linkage; make
9198      them internal.  */
9199   /* FIXME what if it gets a name from typedef?  */
9200   if (ctype && (TYPE_ANONYMOUS_P (ctype)
9201                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
9202     publicp = 0;
9203
9204   if (publicp)
9205     {
9206       /* [basic.link]: A name with no linkage (notably, the name of a class
9207          or enumeration declared in a local scope) shall not be used to
9208          declare an entity with linkage.
9209
9210          Only check this for public decls for now.  */
9211       t = no_linkage_check (TREE_TYPE (decl));
9212       if (t)
9213         {
9214           if (TYPE_ANONYMOUS_P (t))
9215             {
9216               if (DECL_EXTERN_C_P (decl))
9217                 /* Allow this; it's pretty common in C.  */;
9218               else
9219                 {
9220                   pedwarn ("non-local function `%#D' uses anonymous type",
9221                               decl);
9222                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
9223                     cp_pedwarn_at ("\
9224 `%#D' does not refer to the unqualified type, so it is not used for linkage",
9225                                 TYPE_NAME (t));
9226                 }
9227             }
9228           else
9229             pedwarn ("non-local function `%#D' uses local type `%T'",
9230                         decl, t);
9231         }
9232     }
9233
9234   TREE_PUBLIC (decl) = publicp;
9235   if (! publicp)
9236     {
9237       DECL_INTERFACE_KNOWN (decl) = 1;
9238       DECL_NOT_REALLY_EXTERN (decl) = 1;
9239     }
9240
9241   /* If the declaration was declared inline, mark it as such.  */
9242   if (inlinep)
9243     DECL_DECLARED_INLINE_P (decl) = 1;
9244   /* We inline functions that are explicitly declared inline, or, when
9245      the user explicitly asks us to, all functions.  */
9246   if (DECL_DECLARED_INLINE_P (decl) || flag_inline_trees == 2)
9247     DECL_INLINE (decl) = 1;
9248
9249   DECL_EXTERNAL (decl) = 1;
9250   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
9251     {
9252       error ("%smember function `%D' cannot have `%T' method qualifier",
9253                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
9254       quals = NULL_TREE;
9255     }
9256
9257   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
9258     grok_op_properties (decl, friendp);
9259
9260   if (ctype && decl_function_context (decl))
9261     DECL_NO_STATIC_CHAIN (decl) = 1;
9262
9263   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
9264     if (TREE_PURPOSE (t)
9265         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
9266       {
9267         has_default_arg = 1;
9268         break;
9269       }
9270
9271   if (friendp
9272       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
9273     {
9274       if (funcdef_flag)
9275         error
9276           ("defining explicit specialization `%D' in friend declaration",
9277            orig_declarator);
9278       else
9279         {
9280           tree fns = TREE_OPERAND (orig_declarator, 0);
9281           tree args = TREE_OPERAND (orig_declarator, 1);
9282
9283           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
9284             {
9285               /* Something like `template <class T> friend void f<T>()'.  */
9286               error ("invalid use of template-id `%D' in declaration of primary template",
9287                         orig_declarator);
9288               return NULL_TREE;
9289             }
9290
9291
9292           /* A friend declaration of the form friend void f<>().  Record
9293              the information in the TEMPLATE_ID_EXPR.  */
9294           SET_DECL_IMPLICIT_INSTANTIATION (decl);
9295
9296           if (TREE_CODE (fns) == COMPONENT_REF)
9297             {
9298               /* Due to bison parser ickiness, we will have already looked
9299                  up an operator_name or PFUNCNAME within the current class
9300                  (see template_id in parse.y). If the current class contains
9301                  such a name, we'll get a COMPONENT_REF here. Undo that.  */
9302
9303               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
9304                                   == current_class_type, 20001120);
9305               fns = TREE_OPERAND (fns, 1);
9306             }
9307           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
9308                               || TREE_CODE (fns) == LOOKUP_EXPR
9309                               || TREE_CODE (fns) == OVERLOAD, 20001120);
9310           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
9311
9312           if (has_default_arg)
9313             {
9314               error ("default arguments are not allowed in declaration of friend template specialization `%D'",
9315                         decl);
9316               return NULL_TREE;
9317             }
9318
9319           if (inlinep)
9320             {
9321               error ("`inline' is not allowed in declaration of friend template specialization `%D'",
9322                         decl);
9323               return NULL_TREE;
9324             }
9325         }
9326     }
9327
9328   if (has_default_arg)
9329     add_defarg_fn (decl);
9330
9331   if (funcdef_flag)
9332     /* Make the init_value nonzero so pushdecl knows this is not
9333        tentative.  error_mark_node is replaced later with the BLOCK.  */
9334     DECL_INITIAL (decl) = error_mark_node;
9335
9336   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
9337     TREE_NOTHROW (decl) = 1;
9338
9339   /* Caller will do the rest of this.  */
9340   if (check < 0)
9341     return decl;
9342
9343   if (flags == NO_SPECIAL && ctype && constructor_name (ctype) == declarator)
9344     DECL_CONSTRUCTOR_P (decl) = 1;
9345
9346   /* Function gets the ugly name, field gets the nice one.  This call
9347      may change the type of the function (because of default
9348      parameters)!  */
9349   if (ctype != NULL_TREE)
9350     grokclassfn (ctype, decl, flags, quals);
9351
9352   decl = check_explicit_specialization (orig_declarator, decl,
9353                                         template_count,
9354                                         2 * (funcdef_flag != 0) +
9355                                         4 * (friendp != 0));
9356   if (decl == error_mark_node)
9357     return NULL_TREE;
9358
9359   if (ctype != NULL_TREE
9360       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9361       && check)
9362     {
9363       tree old_decl;
9364
9365       old_decl = check_classfn (ctype, decl);
9366
9367       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9368         /* Because grokfndecl is always supposed to return a
9369            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9370            here.  We depend on our callers to figure out that its
9371            really a template that's being returned.  */
9372         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9373
9374       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9375           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9376         {
9377           /* Remove the `this' parm added by grokclassfn.
9378              XXX Isn't this done in start_function, too?  */
9379           revert_static_member_fn (decl);
9380           last_function_parms = TREE_CHAIN (last_function_parms);
9381         }
9382       if (old_decl && DECL_ARTIFICIAL (old_decl))
9383         error ("definition of implicitly-declared `%D'", old_decl);
9384
9385       if (old_decl)
9386         {
9387           /* Since we've smashed OLD_DECL to its
9388              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9389           if (TREE_CODE (decl) == TEMPLATE_DECL)
9390             decl = DECL_TEMPLATE_RESULT (decl);
9391
9392           /* Attempt to merge the declarations.  This can fail, in
9393              the case of some invalid specialization declarations.  */
9394           if (!duplicate_decls (decl, old_decl))
9395             error ("no `%#D' member function declared in class `%T'",
9396                       decl, ctype);
9397           return old_decl;
9398         }
9399     }
9400
9401   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9402     return NULL_TREE;
9403
9404   if (ctype == NULL_TREE || check)
9405     return decl;
9406
9407   if (virtualp)
9408     DECL_VIRTUAL_P (decl) = 1;
9409
9410   return decl;
9411 }
9412
9413 /* Create a VAR_DECL named NAME with the indicated TYPE.
9414
9415    If SCOPE is non-NULL, it is the class type or namespace containing
9416    the variable.  If SCOPE is NULL, the variable should is created in
9417    the innermost enclosings scope.  */
9418
9419 static tree
9420 grokvardecl (type, name, specbits_in, initialized, constp, scope)
9421      tree type;
9422      tree name;
9423      RID_BIT_TYPE *specbits_in;
9424      int initialized;
9425      int constp;
9426      tree scope;
9427 {
9428   tree decl;
9429   RID_BIT_TYPE specbits;
9430
9431   my_friendly_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE,
9432                       20020808);
9433
9434   specbits = *specbits_in;
9435
9436   /* Compute the scope in which to place the variable.  */
9437   if (!scope)
9438     {
9439       /* An explicit "extern" specifier indicates a namespace-scope
9440          variable.  */
9441       if (RIDBIT_SETP (RID_EXTERN, specbits))
9442         scope = current_namespace;
9443       else if (!at_function_scope_p ())
9444         {
9445           scope = current_scope ();
9446           if (!scope)
9447             scope = current_namespace;
9448         }
9449     }
9450
9451   if (scope
9452       && (/* If the variable is a namespace-scope variable declared in a
9453              template, we need DECL_LANG_SPECIFIC.  */
9454           (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
9455           /* Similarly for namespace-scope variables with language linkage
9456              other than C++.  */
9457           || (TREE_CODE (scope) == NAMESPACE_DECL
9458               && current_lang_name != lang_name_cplusplus)
9459           /* Similarly for static data members.  */
9460           || TYPE_P (scope)))
9461     decl = build_lang_decl (VAR_DECL, name, type);
9462   else
9463     decl = build_decl (VAR_DECL, name, type);
9464
9465   if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
9466     set_decl_namespace (decl, scope, 0);
9467   else
9468     DECL_CONTEXT (decl) = scope;
9469
9470   if (name && scope && current_lang_name != lang_name_c)
9471     /* We can't mangle lazily here because we don't have any
9472        way to recover whether or not a variable was `extern
9473        "C"' later.  */
9474     mangle_decl (decl);
9475
9476   if (RIDBIT_SETP (RID_EXTERN, specbits))
9477     {
9478       DECL_THIS_EXTERN (decl) = 1;
9479       DECL_EXTERNAL (decl) = !initialized;
9480     }
9481
9482   /* In class context, static means one per class,
9483      public access, and static storage.  */
9484   if (DECL_CLASS_SCOPE_P (decl))
9485     {
9486       TREE_PUBLIC (decl) = 1;
9487       TREE_STATIC (decl) = 1;
9488       DECL_EXTERNAL (decl) = 0;
9489     }
9490   /* At top level, either `static' or no s.c. makes a definition
9491      (perhaps tentative), and absence of `static' makes it public.  */
9492   else if (toplevel_bindings_p ())
9493     {
9494       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9495                             && (DECL_THIS_EXTERN (decl) || ! constp));
9496       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9497     }
9498   /* Not at top level, only `static' makes a static definition.  */
9499   else
9500     {
9501       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9502       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9503     }
9504
9505   if (RIDBIT_SETP (RID_THREAD, specbits))
9506     {
9507       if (targetm.have_tls)
9508         DECL_THREAD_LOCAL (decl) = 1;
9509       else
9510         /* A mere warning is sure to result in improper semantics
9511            at runtime.  Don't bother to allow this to compile.  */
9512         error ("thread-local storage not supported for this target");
9513     }
9514
9515   if (TREE_PUBLIC (decl))
9516     {
9517       /* [basic.link]: A name with no linkage (notably, the name of a class
9518          or enumeration declared in a local scope) shall not be used to
9519          declare an entity with linkage.
9520
9521          Only check this for public decls for now.  */
9522       tree t = no_linkage_check (TREE_TYPE (decl));
9523       if (t)
9524         {
9525           if (TYPE_ANONYMOUS_P (t))
9526             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9527           else
9528             pedwarn ("non-local variable `%#D' uses local type `%T'",
9529                         decl, t);
9530         }
9531     }
9532
9533   return decl;
9534 }
9535
9536 /* Create and return a canonical pointer to member function type, for
9537    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9538
9539 tree
9540 build_ptrmemfunc_type (type)
9541      tree type;
9542 {
9543   tree field, fields;
9544   tree t;
9545   tree unqualified_variant = NULL_TREE;
9546
9547   if (type == error_mark_node)
9548     return type;
9549
9550   /* If a canonical type already exists for this type, use it.  We use
9551      this method instead of type_hash_canon, because it only does a
9552      simple equality check on the list of field members.  */
9553
9554   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9555     return t;
9556
9557   /* Make sure that we always have the unqualified pointer-to-member
9558      type first.  */
9559   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9560     unqualified_variant
9561       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9562
9563   t = make_aggr_type (RECORD_TYPE);
9564   /* Let the front-end know this is a pointer to member function...  */
9565   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9566   /* ... and not really an aggregate.  */
9567   SET_IS_AGGR_TYPE (t, 0);
9568
9569   field = build_decl (FIELD_DECL, pfn_identifier, type);
9570   fields = field;
9571
9572   field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
9573   TREE_CHAIN (field) = fields;
9574   fields = field;
9575
9576   finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
9577
9578   /* Zap out the name so that the back-end will give us the debugging
9579      information for this anonymous RECORD_TYPE.  */
9580   TYPE_NAME (t) = NULL_TREE;
9581
9582   /* If this is not the unqualified form of this pointer-to-member
9583      type, set the TYPE_MAIN_VARIANT for this type to be the
9584      unqualified type.  Since they are actually RECORD_TYPEs that are
9585      not variants of each other, we must do this manually.  */
9586   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9587     {
9588       t = build_qualified_type (t, cp_type_quals (type));
9589       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9590       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9591       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9592     }
9593
9594   /* Cache this pointer-to-member type so that we can find it again
9595      later.  */
9596   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9597
9598   /* Seems to be wanted.  */
9599   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9600
9601   return t;
9602 }
9603
9604 /* Create and return a pointer to data member type.  */
9605
9606 tree
9607 build_ptrmem_type (tree class_type, tree member_type)
9608 {
9609   return build_pointer_type (build_offset_type (class_type, member_type));
9610 }
9611
9612 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9613    Check to see that the definition is valid.  Issue appropriate error
9614    messages.  Return 1 if the definition is particularly bad, or 0
9615    otherwise.  */
9616
9617 int
9618 check_static_variable_definition (decl, type)
9619      tree decl;
9620      tree type;
9621 {
9622   /* Motion 10 at San Diego: If a static const integral data member is
9623      initialized with an integral constant expression, the initializer
9624      may appear either in the declaration (within the class), or in
9625      the definition, but not both.  If it appears in the class, the
9626      member is a member constant.  The file-scope definition is always
9627      required.  */
9628   if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
9629     {
9630       error ("invalid in-class initialization of static data member of non-integral type `%T'",
9631              type);
9632       /* If we just return the declaration, crashes will sometimes
9633          occur.  We therefore return void_type_node, as if this was a
9634          friend declaration, to cause callers to completely ignore
9635          this declaration.  */
9636       return 1;
9637     }
9638   else if (!CP_TYPE_CONST_P (type))
9639     error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9640               decl);
9641   else if (pedantic && !INTEGRAL_TYPE_P (type))
9642     pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9643
9644   return 0;
9645 }
9646
9647 /* Given the SIZE (i.e., number of elements) in an array, compute an
9648    appropriate index type for the array.  If non-NULL, NAME is the
9649    name of the thing being declared.  */
9650
9651 tree
9652 compute_array_index_type (name, size)
9653      tree name;
9654      tree size;
9655 {
9656   tree itype;
9657
9658   /* If this involves a template parameter, it will be a constant at
9659      instantiation time, but we don't know what the value is yet.
9660      Even if no template parameters are involved, we may an expression
9661      that is not a constant; we don't even simplify `1 + 2' when
9662      processing a template.  */
9663   if (processing_template_decl)
9664     {
9665       /* Resolve a qualified reference to an enumerator or static
9666          const data member of ours.  */
9667       if (TREE_CODE (size) == SCOPE_REF
9668           && TREE_OPERAND (size, 0) == current_class_type)
9669         {
9670           tree t = lookup_field (current_class_type,
9671                                  TREE_OPERAND (size, 1), 0, 0);
9672           if (t)
9673             size = t;
9674         }
9675
9676       return build_index_type (build_min (MINUS_EXPR, sizetype,
9677                                           size, integer_one_node));
9678     }
9679
9680   /* The size might be the result of a cast.  */
9681   STRIP_TYPE_NOPS (size);
9682
9683   /* It might be a const variable or enumeration constant.  */
9684   size = decl_constant_value (size);
9685
9686   /* The array bound must be an integer type.  */
9687   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9688       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9689       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9690     {
9691       if (name)
9692         error ("size of array `%D' has non-integer type", name);
9693       else
9694         error ("size of array has non-integer type");
9695       size = integer_one_node;
9696     }
9697
9698   /* Normally, the array-bound will be a constant.  */
9699   if (TREE_CODE (size) == INTEGER_CST)
9700     {
9701       /* Check to see if the array bound overflowed.  Make that an
9702          error, no matter how generous we're being.  */
9703       int old_flag_pedantic_errors = flag_pedantic_errors;
9704       int old_pedantic = pedantic;
9705       pedantic = flag_pedantic_errors = 1;
9706       constant_expression_warning (size);
9707       pedantic = old_pedantic;
9708       flag_pedantic_errors = old_flag_pedantic_errors;
9709
9710       /* An array must have a positive number of elements.  */
9711       if (INT_CST_LT (size, integer_zero_node))
9712         {
9713           if (name)
9714             error ("size of array `%D' is negative", name);
9715           else
9716             error ("size of array is negative");
9717           size = integer_one_node;
9718         }
9719       /* Except that an extension we allow zero-sized arrays.  We
9720          always allow them in system headers because glibc uses
9721          them.  */
9722       else if (integer_zerop (size) && pedantic && !in_system_header)
9723         {
9724           if (name)
9725             pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9726           else
9727             pedwarn ("ISO C++ forbids zero-size array");
9728         }
9729     }
9730   else if (TREE_CONSTANT (size))
9731     {
9732       /* `(int) &fn' is not a valid array bound.  */
9733       if (name)
9734         error ("size of array `%D' is not an integral constant-expression",
9735                   name);
9736       else
9737         error ("size of array is not an integral constant-expression");
9738     }
9739
9740   /* Compute the index of the largest element in the array.  It is
9741      one less than the number of elements in the array.  */
9742   itype
9743     = fold (cp_build_binary_op (MINUS_EXPR,
9744                                 cp_convert (ssizetype, size),
9745                                 cp_convert (ssizetype,
9746                                             integer_one_node)));
9747
9748   /* Check for variable-sized arrays.  We allow such things as an
9749      extension, even though they are not allowed in ANSI/ISO C++.  */
9750   if (!TREE_CONSTANT (itype))
9751     {
9752       if (pedantic)
9753         {
9754           if (name)
9755             pedwarn ("ISO C++ forbids variable-size array `%D'",
9756                         name);
9757           else
9758             pedwarn ("ISO C++ forbids variable-size array");
9759         }
9760
9761       /* Create a variable-sized array index type.  */
9762       itype = variable_size (itype);
9763     }
9764   /* Make sure that there was no overflow when creating to a signed
9765      index type.  (For example, on a 32-bit machine, an array with
9766      size 2^32 - 1 is too big.)  */
9767   else if (TREE_OVERFLOW (itype))
9768     {
9769       error ("overflow in array dimension");
9770       TREE_OVERFLOW (itype) = 0;
9771     }
9772
9773   /* Create and return the appropriate index type.  */
9774   return build_index_type (itype);
9775 }
9776
9777 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9778    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9779    with this type.  */
9780
9781 static tree
9782 create_array_type_for_decl (name, type, size)
9783      tree name;
9784      tree type;
9785      tree size;
9786 {
9787   tree itype = NULL_TREE;
9788   const char* error_msg;
9789
9790   /* If things have already gone awry, bail now.  */
9791   if (type == error_mark_node || size == error_mark_node)
9792     return error_mark_node;
9793
9794   /* Assume that everything will go OK.  */
9795   error_msg = NULL;
9796
9797   /* There are some types which cannot be array elements.  */
9798   switch (TREE_CODE (type))
9799     {
9800     case VOID_TYPE:
9801       error_msg = "array of void";
9802       break;
9803
9804     case FUNCTION_TYPE:
9805       error_msg = "array of functions";
9806       break;
9807
9808     case REFERENCE_TYPE:
9809       error_msg = "array of references";
9810       break;
9811
9812     case OFFSET_TYPE:
9813       error_msg = "array of data members";
9814       break;
9815
9816     case METHOD_TYPE:
9817       error_msg = "array of function members";
9818       break;
9819
9820     default:
9821       break;
9822     }
9823
9824   /* If something went wrong, issue an error-message and return.  */
9825   if (error_msg)
9826     {
9827       if (name)
9828         error ("declaration of `%D' as %s", name, error_msg);
9829       else
9830         error ("creating %s", error_msg);
9831
9832       return error_mark_node;
9833     }
9834
9835   /* [dcl.array]
9836
9837      The constant expressions that specify the bounds of the arrays
9838      can be omitted only for the first member of the sequence.  */
9839   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9840     {
9841       if (name)
9842         error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9843                   name);
9844       else
9845         error ("multidimensional array must have bounds for all dimensions except the first");
9846
9847       return error_mark_node;
9848     }
9849
9850   /* Figure out the index type for the array.  */
9851   if (size)
9852     itype = compute_array_index_type (name, size);
9853
9854   return build_cplus_array_type (type, itype);
9855 }
9856
9857 /* Check that it's OK to declare a function with the indicated TYPE.
9858    SFK indicates the kind of special function (if any) that this
9859    function is.  OPTYPE is the type given in a conversion operator
9860    declaration.  Returns the actual return type of the function; that
9861    may be different than TYPE if an error occurs, or for certain
9862    special functions.  */
9863
9864 static tree
9865 check_special_function_return_type (sfk, type, optype)
9866      special_function_kind sfk;
9867      tree type;
9868      tree optype;
9869 {
9870   switch (sfk)
9871     {
9872     case sfk_constructor:
9873       if (type)
9874         error ("return type specification for constructor invalid");
9875
9876       type = void_type_node;
9877       break;
9878
9879     case sfk_destructor:
9880       if (type)
9881         error ("return type specification for destructor invalid");
9882       type = void_type_node;
9883       break;
9884
9885     case sfk_conversion:
9886       if (type && !same_type_p (type, optype))
9887         error ("operator `%T' declared to return `%T'", optype, type);
9888       else if (type)
9889         pedwarn ("return type specified for `operator %T'",  optype);
9890       type = optype;
9891       break;
9892
9893     default:
9894       abort ();
9895       break;
9896     }
9897
9898   return type;
9899 }
9900
9901 /* Given declspecs and a declarator,
9902    determine the name and type of the object declared
9903    and construct a ..._DECL node for it.
9904    (In one case we can return a ..._TYPE node instead.
9905     For invalid input we sometimes return 0.)
9906
9907    DECLSPECS is a chain of tree_list nodes whose value fields
9908     are the storage classes and type specifiers.
9909
9910    DECL_CONTEXT says which syntactic context this declaration is in:
9911      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9912      FUNCDEF for a function definition.  Like NORMAL but a few different
9913       error messages in each case.  Return value may be zero meaning
9914       this definition is too screwy to try to parse.
9915      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9916       handle member functions (which have FIELD context).
9917       Return value may be zero meaning this definition is too screwy to
9918       try to parse.
9919      PARM for a parameter declaration (either within a function prototype
9920       or before a function body).  Make a PARM_DECL, or return void_type_node.
9921      CATCHPARM for a parameter declaration before a catch clause.
9922      TYPENAME if for a typename (in a cast or sizeof).
9923       Don't make a DECL node; just return the ..._TYPE node.
9924      FIELD for a struct or union field; make a FIELD_DECL.
9925      BITFIELD for a field with specified width.
9926    INITIALIZED is 1 if the decl has an initializer.
9927
9928    ATTRLIST is a pointer to the list of attributes, which may be NULL
9929    if there are none; *ATTRLIST may be modified if attributes from inside
9930    the declarator should be applied to the declaration.
9931
9932    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9933    It may also be so in the PARM case, for a prototype where the
9934    argument type is specified but not the name.
9935
9936    This function is where the complicated C meanings of `static'
9937    and `extern' are interpreted.
9938
9939    For C++, if there is any monkey business to do, the function which
9940    calls this one must do it, i.e., prepending instance variables,
9941    renaming overloaded function names, etc.
9942
9943    Note that for this C++, it is an error to define a method within a class
9944    which does not belong to that class.
9945
9946    Except in the case where SCOPE_REFs are implicitly known (such as
9947    methods within a class being redundantly qualified),
9948    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9949    (class_name::decl_name).  The caller must also deal with this.
9950
9951    If a constructor or destructor is seen, and the context is FIELD,
9952    then the type gains the attribute TREE_HAS_x.  If such a declaration
9953    is erroneous, NULL_TREE is returned.
9954
9955    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9956    function, these are the qualifiers to give to the `this' pointer. We
9957    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9958
9959    May return void_type_node if the declarator turned out to be a friend.
9960    See grokfield for details.  */
9961
9962 tree
9963 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9964      tree declspecs;
9965      tree declarator;
9966      enum decl_context decl_context;
9967      int initialized;
9968      tree *attrlist;
9969 {
9970   RID_BIT_TYPE specbits;
9971   int nclasses = 0;
9972   tree spec;
9973   tree type = NULL_TREE;
9974   int longlong = 0;
9975   int type_quals;
9976   int virtualp, explicitp, friendp, inlinep, staticp;
9977   int explicit_int = 0;
9978   int explicit_char = 0;
9979   int defaulted_int = 0;
9980   int extern_langp = 0;
9981   tree dependant_name = NULL_TREE;
9982
9983   tree typedef_decl = NULL_TREE;
9984   const char *name;
9985   tree typedef_type = NULL_TREE;
9986   int funcdef_flag = 0;
9987   enum tree_code innermost_code = ERROR_MARK;
9988   int bitfield = 0;
9989 #if 0
9990   /* See the code below that used this.  */
9991   tree decl_attr = NULL_TREE;
9992 #endif
9993   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9994      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9995   tree init = NULL_TREE;
9996
9997   /* Keep track of what sort of function is being processed
9998      so that we can warn about default return values, or explicit
9999      return values which do not match prescribed defaults.  */
10000   special_function_kind sfk = sfk_none;
10001
10002   tree dname = NULL_TREE;
10003   tree ctype = current_class_type;
10004   tree ctor_return_type = NULL_TREE;
10005   enum overload_flags flags = NO_SPECIAL;
10006   tree quals = NULL_TREE;
10007   tree raises = NULL_TREE;
10008   int template_count = 0;
10009   tree in_namespace = NULL_TREE;
10010   tree returned_attrs = NULL_TREE;
10011
10012   RIDBIT_RESET_ALL (specbits);
10013   if (decl_context == FUNCDEF)
10014     funcdef_flag = 1, decl_context = NORMAL;
10015   else if (decl_context == MEMFUNCDEF)
10016     funcdef_flag = -1, decl_context = FIELD;
10017   else if (decl_context == BITFIELD)
10018     bitfield = 1, decl_context = FIELD;
10019
10020   /* Look inside a declarator for the name being declared
10021      and get it as a string, for an error message.  */
10022   {
10023     tree *next = &declarator;
10024     register tree decl;
10025     name = NULL;
10026
10027     while (next && *next)
10028       {
10029         decl = *next;
10030         switch (TREE_CODE (decl))
10031           {
10032           case TREE_LIST:
10033             /* For attributes.  */
10034             next = &TREE_VALUE (decl);
10035             break;
10036
10037           case COND_EXPR:
10038             ctype = NULL_TREE;
10039             next = &TREE_OPERAND (decl, 0);
10040             break;
10041
10042           case BIT_NOT_EXPR:    /* For C++ destructors!  */
10043             {
10044               tree name = TREE_OPERAND (decl, 0);
10045               tree rename = NULL_TREE;
10046
10047               my_friendly_assert (flags == NO_SPECIAL, 152);
10048               flags = DTOR_FLAG;
10049               sfk = sfk_destructor;
10050               if (TREE_CODE (name) == TYPE_DECL)
10051                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
10052               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
10053               if (ctype == NULL_TREE)
10054                 {
10055                   if (current_class_type == NULL_TREE)
10056                     {
10057                       error ("destructors must be member functions");
10058                       flags = NO_SPECIAL;
10059                     }
10060                   else
10061                     {
10062                       tree t = constructor_name (current_class_name);
10063                       if (t != name)
10064                         rename = t;
10065                     }
10066                 }
10067               else
10068                 {
10069                   tree t = constructor_name (ctype);
10070                   if (t != name)
10071                     rename = t;
10072                 }
10073
10074               if (rename)
10075                 {
10076                   error ("destructor `%T' must match class name `%T'",
10077                             name, rename);
10078                   TREE_OPERAND (decl, 0) = rename;
10079                 }
10080               next = &name;
10081             }
10082             break;
10083
10084           case ADDR_EXPR:       /* C++ reference declaration */
10085             /* Fall through.  */
10086           case ARRAY_REF:
10087           case INDIRECT_REF:
10088             ctype = NULL_TREE;
10089             innermost_code = TREE_CODE (decl);
10090             next = &TREE_OPERAND (decl, 0);
10091             break;
10092
10093           case CALL_EXPR:
10094             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
10095               {
10096                 /* This is actually a variable declaration using
10097                    constructor syntax.  We need to call start_decl and
10098                    cp_finish_decl so we can get the variable
10099                    initialized...  */
10100
10101                 tree attributes;
10102
10103                 if (decl_context != NORMAL)
10104                   {
10105                     error ("variable declaration is not allowed here");
10106                     return error_mark_node;
10107                   }
10108
10109                 *next = TREE_OPERAND (decl, 0);
10110                 init = CALL_DECLARATOR_PARMS (decl);
10111
10112                 if (attrlist)
10113                   {
10114                     attributes = *attrlist;
10115                   }
10116                 else
10117                   {
10118                     attributes = NULL_TREE;
10119                   }
10120
10121                 decl = start_decl (declarator, declspecs, 1,
10122                                    attributes, NULL_TREE);
10123                 decl_type_access_control (decl);
10124                 if (decl)
10125                   {
10126                     /* Look for __unused__ attribute */
10127                     if (TREE_USED (TREE_TYPE (decl)))
10128                       TREE_USED (decl) = 1;
10129                     finish_decl (decl, init, NULL_TREE);
10130                   }
10131                 else
10132                   error ("invalid declarator");
10133                 return NULL_TREE;
10134               }
10135             innermost_code = TREE_CODE (decl);
10136             if (decl_context == FIELD && ctype == NULL_TREE)
10137               ctype = current_class_type;
10138             if (ctype
10139                 && TREE_OPERAND (decl, 0)
10140                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
10141                     && constructor_name_p (DECL_NAME (TREE_OPERAND (decl, 0)),
10142                                            ctype)))
10143               TREE_OPERAND (decl, 0) = constructor_name (ctype);
10144             next = &TREE_OPERAND (decl, 0);
10145             decl = *next;
10146             if (ctype != NULL_TREE
10147                 && decl != NULL_TREE && flags != DTOR_FLAG
10148                 && decl == constructor_name (ctype))
10149               {
10150                 sfk = sfk_constructor;
10151                 ctor_return_type = ctype;
10152               }
10153             ctype = NULL_TREE;
10154             break;
10155
10156           case TEMPLATE_ID_EXPR:
10157               {
10158                 tree fns = TREE_OPERAND (decl, 0);
10159
10160                 if (TREE_CODE (fns) == LOOKUP_EXPR)
10161                   fns = TREE_OPERAND (fns, 0);
10162
10163                 dname = fns;
10164                 if (TREE_CODE (dname) == COMPONENT_REF)
10165                   dname = TREE_OPERAND (dname, 1);
10166                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
10167                   {
10168                     my_friendly_assert (is_overloaded_fn (dname),
10169                                         19990331);
10170                     dname = DECL_NAME (get_first_fn (dname));
10171                   }
10172               }
10173           /* Fall through.  */
10174
10175           case IDENTIFIER_NODE:
10176             if (TREE_CODE (decl) == IDENTIFIER_NODE)
10177               dname = decl;
10178
10179             next = 0;
10180
10181             if (C_IS_RESERVED_WORD (dname))
10182               {
10183                 error ("declarator-id missing; using reserved word `%D'",
10184                           dname);
10185                 name = IDENTIFIER_POINTER (dname);
10186               }
10187             else if (!IDENTIFIER_TYPENAME_P (dname))
10188               name = IDENTIFIER_POINTER (dname);
10189             else
10190               {
10191                 my_friendly_assert (flags == NO_SPECIAL, 154);
10192                 flags = TYPENAME_FLAG;
10193                 ctor_return_type = TREE_TYPE (dname);
10194                 sfk = sfk_conversion;
10195                 if (IDENTIFIER_GLOBAL_VALUE (dname)
10196                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
10197                         == TYPE_DECL))
10198                   name = IDENTIFIER_POINTER (dname);
10199                 else
10200                   name = "<invalid operator>";
10201               }
10202             break;
10203
10204             /* C++ extension */
10205           case SCOPE_REF:
10206             {
10207               /* Perform error checking, and decide on a ctype.  */
10208               tree cname = TREE_OPERAND (decl, 0);
10209               if (cname == NULL_TREE)
10210                 ctype = NULL_TREE;
10211               else if (TREE_CODE (cname) == NAMESPACE_DECL)
10212                 {
10213                   ctype = NULL_TREE;
10214                   in_namespace = TREE_OPERAND (decl, 0);
10215                   TREE_OPERAND (decl, 0) = NULL_TREE;
10216                 }
10217               else if (! is_aggr_type (cname, 1))
10218                 TREE_OPERAND (decl, 0) = NULL_TREE;
10219               /* Must test TREE_OPERAND (decl, 1), in case user gives
10220                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
10221               else if (TREE_OPERAND (decl, 1)
10222                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
10223                 ctype = cname;
10224               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
10225                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
10226                 {
10227                   /* This might be declaring a member of a template
10228                      parm to be a friend.  */
10229                   ctype = cname;
10230                   dependant_name = TREE_OPERAND (decl, 1);
10231                 }
10232               else if (ctype == NULL_TREE)
10233                 ctype = cname;
10234               else if (TREE_COMPLEXITY (decl) == current_class_depth)
10235                 TREE_OPERAND (decl, 0) = ctype;
10236               else
10237                 {
10238                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
10239                     {
10240                       error ("type `%T' is not derived from type `%T'",
10241                                 cname, ctype);
10242                       TREE_OPERAND (decl, 0) = NULL_TREE;
10243                     }
10244                   else
10245                     ctype = cname;
10246                 }
10247
10248               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
10249                   && constructor_name_p (DECL_NAME (TREE_OPERAND (decl, 1)),
10250                                          ctype))
10251                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
10252               next = &TREE_OPERAND (decl, 1);
10253               decl = *next;
10254               if (ctype)
10255                 {
10256                   if (TREE_CODE (decl) == IDENTIFIER_NODE
10257                       && constructor_name (ctype) == decl)
10258                     {
10259                       sfk = sfk_constructor;
10260                       ctor_return_type = ctype;
10261                     }
10262                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
10263                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
10264                            && constructor_name_p (TREE_OPERAND (decl, 0),
10265                                                   ctype))
10266                     {
10267                       sfk = sfk_destructor;
10268                       ctor_return_type = ctype;
10269                       flags = DTOR_FLAG;
10270                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
10271                       next = &TREE_OPERAND (decl, 0);
10272                     }
10273                 }
10274             }
10275             break;
10276
10277           case ERROR_MARK:
10278             next = 0;
10279             break;
10280
10281           case TYPE_DECL:
10282             /* Parse error puts this typespec where
10283                a declarator should go.  */
10284             error ("`%T' specified as declarator-id", DECL_NAME (decl));
10285             if (TREE_TYPE (decl) == current_class_type)
10286               error ("  perhaps you want `%T' for a constructor",
10287                         current_class_name);
10288             dname = DECL_NAME (decl);
10289             name = IDENTIFIER_POINTER (dname);
10290
10291             /* Avoid giving two errors for this.  */
10292             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
10293
10294             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
10295             *next = dname;
10296             next = 0;
10297             break;
10298
10299           case BASELINK:
10300             next = &BASELINK_FUNCTIONS (decl);
10301             break;
10302
10303           case TEMPLATE_DECL:
10304             /* Sometimes, we see a template-name used as part of a
10305                decl-specifier like in
10306                   std::allocator alloc;
10307                Handle that gracefully.  */
10308             error ("invalid use of template-name '%E' in a declarator", decl);
10309             return error_mark_node;
10310             break;
10311
10312           default:
10313             my_friendly_assert (0, 20020917);
10314           }
10315       }
10316   }
10317
10318   /* A function definition's declarator must have the form of
10319      a function declarator.  */
10320
10321   if (funcdef_flag && innermost_code != CALL_EXPR)
10322     return 0;
10323
10324   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
10325       && innermost_code != CALL_EXPR
10326       && ! (ctype && declspecs == NULL_TREE))
10327     {
10328       error ("declaration of `%D' as non-function", dname);
10329       return void_type_node;
10330     }
10331
10332   /* Anything declared one level down from the top level
10333      must be one of the parameters of a function
10334      (because the body is at least two levels down).  */
10335
10336   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10337      by not allowing C++ class definitions to specify their parameters
10338      with xdecls (must be spec.d in the parmlist).
10339
10340      Since we now wait to push a class scope until we are sure that
10341      we are in a legitimate method context, we must set oldcname
10342      explicitly (since current_class_name is not yet alive).
10343
10344      We also want to avoid calling this a PARM if it is in a namespace.  */
10345
10346   if (decl_context == NORMAL && !toplevel_bindings_p ())
10347     {
10348       struct cp_binding_level *b = current_binding_level;
10349       current_binding_level = b->level_chain;
10350       if (current_binding_level != 0 && toplevel_bindings_p ())
10351         decl_context = PARM;
10352       current_binding_level = b;
10353     }
10354
10355   if (name == NULL)
10356     name = decl_context == PARM ? "parameter" : "type name";
10357
10358   /* Look through the decl specs and record which ones appear.
10359      Some typespecs are defined as built-in typenames.
10360      Others, the ones that are modifiers of other types,
10361      are represented by bits in SPECBITS: set the bits for
10362      the modifiers that appear.  Storage class keywords are also in SPECBITS.
10363
10364      If there is a typedef name or a type, store the type in TYPE.
10365      This includes builtin typedefs such as `int'.
10366
10367      Set EXPLICIT_INT if the type is `int' or `char' and did not
10368      come from a user typedef.
10369
10370      Set LONGLONG if `long' is mentioned twice.
10371
10372      For C++, constructors and destructors have their own fast treatment.  */
10373
10374   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10375     {
10376       register int i;
10377       register tree id;
10378
10379       /* Certain parse errors slip through.  For example,
10380          `int class;' is not caught by the parser. Try
10381          weakly to recover here.  */
10382       if (TREE_CODE (spec) != TREE_LIST)
10383         return 0;
10384
10385       id = TREE_VALUE (spec);
10386
10387       /* If the entire declaration is itself tagged as deprecated then
10388          suppress reports of deprecated items.  */
10389       if (!adding_implicit_members && id && TREE_DEPRECATED (id))
10390         {
10391           if (deprecated_state != DEPRECATED_SUPPRESS)
10392             warn_deprecated_use (id);
10393         }
10394
10395       if (TREE_CODE (id) == IDENTIFIER_NODE)
10396         {
10397           if (id == ridpointers[(int) RID_INT]
10398               || id == ridpointers[(int) RID_CHAR]
10399               || id == ridpointers[(int) RID_BOOL]
10400               || id == ridpointers[(int) RID_WCHAR])
10401             {
10402               if (type)
10403                 {
10404                   if (id == ridpointers[(int) RID_BOOL])
10405                     error ("`bool' is now a keyword");
10406                   else
10407                     error ("extraneous `%T' ignored", id);
10408                 }
10409               else
10410                 {
10411                   if (id == ridpointers[(int) RID_INT])
10412                     explicit_int = 1;
10413                   else if (id == ridpointers[(int) RID_CHAR])
10414                     explicit_char = 1;
10415                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10416                 }
10417               goto found;
10418             }
10419           /* C++ aggregate types.  */
10420           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10421             {
10422               if (type)
10423                 error ("multiple declarations `%T' and `%T'", type, id);
10424               else
10425                 type = IDENTIFIER_TYPE_VALUE (id);
10426               goto found;
10427             }
10428
10429           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10430             {
10431               if (ridpointers[i] == id)
10432                 {
10433                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10434                     {
10435                       if (pedantic && ! in_system_header && warn_long_long)
10436                         pedwarn ("ISO C++ does not support `long long'");
10437                       if (longlong)
10438                         error ("`long long long' is too long for GCC");
10439                       else
10440                         longlong = 1;
10441                     }
10442                   else if (RIDBIT_SETP (i, specbits))
10443                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10444
10445                   /* Diagnose "__thread extern".  Recall that this list
10446                      is in the reverse order seen in the text.  */
10447                   if (i == (int)RID_THREAD)
10448                     {
10449                       if (RIDBIT_SETP (RID_EXTERN, specbits))
10450                         error ("`__thread' before `extern'");
10451                       if (RIDBIT_SETP (RID_STATIC, specbits))
10452                         error ("`__thread' before `static'");
10453                     }
10454
10455                   if (i == (int)RID_EXTERN
10456                       && TREE_PURPOSE (spec) == error_mark_node)
10457                     /* This extern was part of a language linkage.  */
10458                     extern_langp = 1;
10459
10460                   RIDBIT_SET (i, specbits);
10461                   goto found;
10462                 }
10463             }
10464         }
10465       else if (TREE_CODE (id) == TYPE_DECL)
10466         {
10467           if (type)
10468             error ("multiple declarations `%T' and `%T'", type,
10469                       TREE_TYPE (id));
10470           else
10471             {
10472               type = TREE_TYPE (id);
10473               TREE_VALUE (spec) = type;
10474               typedef_decl = id;
10475             }
10476           goto found;
10477         }
10478       if (type)
10479         error ("two or more data types in declaration of `%s'", name);
10480       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10481         {
10482           register tree t = lookup_name (id, 1);
10483           if (!t || TREE_CODE (t) != TYPE_DECL)
10484             error ("`%s' fails to be a typedef or built in type",
10485                    IDENTIFIER_POINTER (id));
10486           else
10487             {
10488               type = TREE_TYPE (t);
10489               typedef_decl = t;
10490             }
10491         }
10492       else if (id != error_mark_node)
10493         /* Can't change CLASS nodes into RECORD nodes here!  */
10494         type = id;
10495
10496     found: ;
10497     }
10498
10499 #if 0
10500   /* See the code below that used this.  */
10501   if (typedef_decl)
10502     decl_attr = DECL_ATTRIBUTES (typedef_decl);
10503 #endif
10504   typedef_type = type;
10505
10506   /* No type at all: default to `int', and set DEFAULTED_INT
10507      because it was not a user-defined typedef.  */
10508
10509   if (type == NULL_TREE
10510       && (RIDBIT_SETP (RID_SIGNED, specbits)
10511           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10512           || RIDBIT_SETP (RID_LONG, specbits)
10513           || RIDBIT_SETP (RID_SHORT, specbits)))
10514     {
10515       /* These imply 'int'.  */
10516       type = integer_type_node;
10517       defaulted_int = 1;
10518     }
10519
10520   if (sfk != sfk_none)
10521     type = check_special_function_return_type (sfk, type,
10522                                                ctor_return_type);
10523   else if (type == NULL_TREE)
10524     {
10525       int is_main;
10526
10527       explicit_int = -1;
10528
10529       /* We handle `main' specially here, because 'main () { }' is so
10530          common.  With no options, it is allowed.  With -Wreturn-type,
10531          it is a warning.  It is only an error with -pedantic-errors.  */
10532       is_main = (funcdef_flag
10533                  && dname && MAIN_NAME_P (dname)
10534                  && ctype == NULL_TREE
10535                  && in_namespace == NULL_TREE
10536                  && current_namespace == global_namespace);
10537
10538       if (in_system_header || flag_ms_extensions)
10539         /* Allow it, sigh.  */;
10540       else if (pedantic || ! is_main)
10541         pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10542                     name);
10543       else if (warn_return_type)
10544         warning ("ISO C++ forbids declaration of `%s' with no type",
10545                     name);
10546
10547       type = integer_type_node;
10548     }
10549
10550   if (type && IMPLICIT_TYPENAME_P (type))
10551     {
10552       /* The implicit typename extension is deprecated and will be
10553          removed.  Warn about its use now.  */
10554       warning ("`%T' is implicitly a typename", type);
10555       cp_deprecated ("implicit typename");
10556
10557       /* Now remove its implicitness, so that we don't warn again.
10558          For instance this might be a typedef, and we do not want to
10559          warn on uses of the typedef itself.  Simply clearing the
10560          TREE_TYPE is insufficient.  */
10561       type = copy_node (type);
10562       TREE_TYPE (type) = NULL_TREE;
10563     }
10564
10565   ctype = NULL_TREE;
10566
10567   /* Now process the modifiers that were specified
10568      and check for invalid combinations.  */
10569
10570   /* Long double is a special combination.  */
10571
10572   if (RIDBIT_SETP (RID_LONG, specbits)
10573       && TYPE_MAIN_VARIANT (type) == double_type_node)
10574     {
10575       RIDBIT_RESET (RID_LONG, specbits);
10576       type = build_qualified_type (long_double_type_node,
10577                                    cp_type_quals (type));
10578     }
10579
10580   /* Check all other uses of type modifiers.  */
10581
10582   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10583       || RIDBIT_SETP (RID_SIGNED, specbits)
10584       || RIDBIT_SETP (RID_LONG, specbits)
10585       || RIDBIT_SETP (RID_SHORT, specbits))
10586     {
10587       int ok = 0;
10588
10589       if (TREE_CODE (type) == REAL_TYPE)
10590         error ("short, signed or unsigned invalid for `%s'", name);
10591       else if (TREE_CODE (type) != INTEGER_TYPE)
10592         error ("long, short, signed or unsigned invalid for `%s'", name);
10593       else if (RIDBIT_SETP (RID_LONG, specbits)
10594                && RIDBIT_SETP (RID_SHORT, specbits))
10595         error ("long and short specified together for `%s'", name);
10596       else if ((RIDBIT_SETP (RID_LONG, specbits)
10597                 || RIDBIT_SETP (RID_SHORT, specbits))
10598                && explicit_char)
10599         error ("long or short specified with char for `%s'", name);
10600       else if ((RIDBIT_SETP (RID_LONG, specbits)
10601                 || RIDBIT_SETP (RID_SHORT, specbits))
10602                && TREE_CODE (type) == REAL_TYPE)
10603         error ("long or short specified with floating type for `%s'", name);
10604       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10605                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10606         error ("signed and unsigned given together for `%s'", name);
10607       else
10608         {
10609           ok = 1;
10610           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10611             {
10612               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10613                        name);
10614               if (flag_pedantic_errors)
10615                 ok = 0;
10616             }
10617         }
10618
10619       /* Discard the type modifiers if they are invalid.  */
10620       if (! ok)
10621         {
10622           RIDBIT_RESET (RID_UNSIGNED, specbits);
10623           RIDBIT_RESET (RID_SIGNED, specbits);
10624           RIDBIT_RESET (RID_LONG, specbits);
10625           RIDBIT_RESET (RID_SHORT, specbits);
10626           longlong = 0;
10627         }
10628     }
10629
10630   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10631       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10632     {
10633       error ("complex invalid for `%s'", name);
10634       RIDBIT_RESET (RID_COMPLEX, specbits);
10635     }
10636
10637   /* Decide whether an integer type is signed or not.
10638      Optionally treat bitfields as signed by default.  */
10639   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10640       /* [class.bit]
10641
10642          It is implementation-defined whether a plain (neither
10643          explicitly signed or unsigned) char, short, int, or long
10644          bit-field is signed or unsigned.
10645
10646          Naturally, we extend this to long long as well.  Note that
10647          this does not include wchar_t.  */
10648       || (bitfield && !flag_signed_bitfields
10649           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10650           /* A typedef for plain `int' without `signed' can be
10651              controlled just like plain `int', but a typedef for
10652              `signed int' cannot be so controlled.  */
10653           && !(typedef_decl
10654                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10655           && (TREE_CODE (type) == INTEGER_TYPE
10656               || TREE_CODE (type) == CHAR_TYPE)
10657           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10658     {
10659       if (longlong)
10660         type = long_long_unsigned_type_node;
10661       else if (RIDBIT_SETP (RID_LONG, specbits))
10662         type = long_unsigned_type_node;
10663       else if (RIDBIT_SETP (RID_SHORT, specbits))
10664         type = short_unsigned_type_node;
10665       else if (type == char_type_node)
10666         type = unsigned_char_type_node;
10667       else if (typedef_decl)
10668         type = c_common_unsigned_type (type);
10669       else
10670         type = unsigned_type_node;
10671     }
10672   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10673            && type == char_type_node)
10674     type = signed_char_type_node;
10675   else if (longlong)
10676     type = long_long_integer_type_node;
10677   else if (RIDBIT_SETP (RID_LONG, specbits))
10678     type = long_integer_type_node;
10679   else if (RIDBIT_SETP (RID_SHORT, specbits))
10680     type = short_integer_type_node;
10681
10682   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10683     {
10684       /* If we just have "complex", it is equivalent to
10685          "complex double", but if any modifiers at all are specified it is
10686          the complex form of TYPE.  E.g, "complex short" is
10687          "complex short int".  */
10688
10689       if (defaulted_int && ! longlong
10690           && ! (RIDBIT_SETP (RID_LONG, specbits)
10691                 || RIDBIT_SETP (RID_SHORT, specbits)
10692                 || RIDBIT_SETP (RID_SIGNED, specbits)
10693                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10694         type = complex_double_type_node;
10695       else if (type == integer_type_node)
10696         type = complex_integer_type_node;
10697       else if (type == float_type_node)
10698         type = complex_float_type_node;
10699       else if (type == double_type_node)
10700         type = complex_double_type_node;
10701       else if (type == long_double_type_node)
10702         type = complex_long_double_type_node;
10703       else
10704         type = build_complex_type (type);
10705     }
10706
10707   type_quals = TYPE_UNQUALIFIED;
10708   if (RIDBIT_SETP (RID_CONST, specbits))
10709     type_quals |= TYPE_QUAL_CONST;
10710   if (RIDBIT_SETP (RID_VOLATILE, specbits))
10711     type_quals |= TYPE_QUAL_VOLATILE;
10712   if (RIDBIT_SETP (RID_RESTRICT, specbits))
10713     type_quals |= TYPE_QUAL_RESTRICT;
10714   if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
10715     error ("qualifiers are not allowed on declaration of `operator %T'",
10716               ctor_return_type);
10717
10718   type_quals |= cp_type_quals (type);
10719   type = cp_build_qualified_type_real
10720     (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
10721                          ? tf_ignore_bad_quals : 0) | tf_error | tf_warning));
10722   /* We might have ignored or rejected some of the qualifiers.  */
10723   type_quals = cp_type_quals (type);
10724
10725   staticp = 0;
10726   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10727   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10728   RIDBIT_RESET (RID_VIRTUAL, specbits);
10729   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10730   RIDBIT_RESET (RID_EXPLICIT, specbits);
10731
10732   if (RIDBIT_SETP (RID_STATIC, specbits))
10733     staticp = 1 + (decl_context == FIELD);
10734
10735   if (virtualp && staticp == 2)
10736     {
10737       error ("member `%D' cannot be declared both virtual and static",
10738                 dname);
10739       staticp = 0;
10740     }
10741   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10742   RIDBIT_RESET (RID_FRIEND, specbits);
10743
10744   if (dependant_name && !friendp)
10745     {
10746       error ("`%T::%D' is not a valid declarator", ctype, dependant_name);
10747       return void_type_node;
10748     }
10749
10750   /* Warn if two storage classes are given. Default to `auto'.  */
10751
10752   if (RIDBIT_ANY_SET (specbits))
10753     {
10754       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10755       if (RIDBIT_SETP (RID_EXTERN, specbits) && !extern_langp) nclasses++;
10756       if (RIDBIT_SETP (RID_THREAD, specbits)) nclasses++;
10757       if (decl_context == PARM && nclasses > 0)
10758         error ("storage class specifiers invalid in parameter declarations");
10759       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10760         {
10761           if (decl_context == PARM)
10762             error ("typedef declaration invalid in parameter declaration");
10763           nclasses++;
10764         }
10765       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10766       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10767       if (!nclasses && !friendp && extern_langp)
10768         nclasses++;
10769     }
10770
10771   /* Give error if `virtual' is used outside of class declaration.  */
10772   if (virtualp
10773       && (current_class_name == NULL_TREE || decl_context != FIELD))
10774     {
10775       error ("virtual outside class declaration");
10776       virtualp = 0;
10777     }
10778
10779   /* Static anonymous unions are dealt with here.  */
10780   if (staticp && decl_context == TYPENAME
10781       && TREE_CODE (declspecs) == TREE_LIST
10782       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10783     decl_context = FIELD;
10784
10785   /* Warn about storage classes that are invalid for certain
10786      kinds of declarations (parameters, typenames, etc.).  */
10787
10788   /* "static __thread" and "extern __thread" are allowed.  */
10789   if (nclasses == 2
10790       && RIDBIT_SETP (RID_THREAD, specbits)
10791       && (RIDBIT_SETP (RID_EXTERN, specbits)
10792           || RIDBIT_SETP (RID_STATIC, specbits)))
10793     nclasses = 1;
10794
10795   if (nclasses > 1)
10796     error ("multiple storage classes in declaration of `%s'", name);
10797   else if (decl_context != NORMAL && nclasses > 0)
10798     {
10799       if ((decl_context == PARM || decl_context == CATCHPARM)
10800           && (RIDBIT_SETP (RID_REGISTER, specbits)
10801               || RIDBIT_SETP (RID_AUTO, specbits)))
10802         ;
10803       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10804         ;
10805       else if (decl_context == FIELD
10806                /* C++ allows static class elements  */
10807                && RIDBIT_SETP (RID_STATIC, specbits))
10808         /* C++ also allows inlines and signed and unsigned elements,
10809            but in those cases we don't come in here.  */
10810         ;
10811       else
10812         {
10813           if (decl_context == FIELD)
10814             {
10815               tree tmp = NULL_TREE;
10816               register int op = 0;
10817
10818               if (declarator)
10819                 {
10820                   /* Avoid trying to get an operand off an identifier node.  */
10821                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10822                     tmp = declarator;
10823                   else
10824                     tmp = TREE_OPERAND (declarator, 0);
10825                   op = IDENTIFIER_OPNAME_P (tmp);
10826                   if (IDENTIFIER_TYPENAME_P (tmp))
10827                     {
10828                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10829                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10830                               == TYPE_DECL))
10831                         name = IDENTIFIER_POINTER (tmp);
10832                       else
10833                         name = "<invalid operator>";
10834                     }
10835                 }
10836               error ("storage class specified for %s `%s'",
10837                      op ? "member operator" : "field",
10838                      name);
10839             }
10840           else
10841             {
10842               if (decl_context == PARM || decl_context == CATCHPARM)
10843                 error ("storage class specified for parameter `%s'", name);
10844               else
10845                 error ("storage class specified for typename");
10846             }
10847           RIDBIT_RESET (RID_REGISTER, specbits);
10848           RIDBIT_RESET (RID_AUTO, specbits);
10849           RIDBIT_RESET (RID_EXTERN, specbits);
10850           RIDBIT_RESET (RID_THREAD, specbits);
10851         }
10852     }
10853   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10854     {
10855       if (toplevel_bindings_p ())
10856         {
10857           /* It's common practice (and completely valid) to have a const
10858              be initialized and declared extern.  */
10859           if (!(type_quals & TYPE_QUAL_CONST))
10860             warning ("`%s' initialized and declared `extern'", name);
10861         }
10862       else
10863         error ("`%s' has both `extern' and initializer", name);
10864     }
10865   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10866            && ! toplevel_bindings_p ())
10867     error ("nested function `%s' declared `extern'", name);
10868   else if (toplevel_bindings_p ())
10869     {
10870       if (RIDBIT_SETP (RID_AUTO, specbits))
10871         error ("top-level declaration of `%s' specifies `auto'", name);
10872     }
10873   else if (RIDBIT_SETP (RID_THREAD, specbits)
10874            && !RIDBIT_SETP (RID_EXTERN, specbits)
10875            && !RIDBIT_SETP (RID_STATIC, specbits))
10876     {
10877       error ("function-scope `%s' implicitly auto and declared `__thread'",
10878              name);
10879       RIDBIT_RESET (RID_THREAD, specbits);
10880     }
10881
10882   if (nclasses > 0 && friendp)
10883     error ("storage class specifiers invalid in friend function declarations");
10884
10885   /* Now figure out the structure of the declarator proper.
10886      Descend through it, creating more complex types, until we reach
10887      the declared identifier (or NULL_TREE, in an abstract declarator).  */
10888
10889   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10890          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10891     {
10892       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10893          an INDIRECT_REF (for *...),
10894          a CALL_EXPR (for ...(...)),
10895          an identifier (for the name being declared)
10896          or a null pointer (for the place in an absolute declarator
10897          where the name was omitted).
10898          For the last two cases, we have just exited the loop.
10899
10900          For C++ it could also be
10901          a SCOPE_REF (for class :: ...).  In this case, we have converted
10902          sensible names to types, and those are the values we use to
10903          qualify the member name.
10904          an ADDR_EXPR (for &...),
10905          a BIT_NOT_EXPR (for destructors)
10906
10907          At this point, TYPE is the type of elements of an array,
10908          or for a function to return, or for a pointer to point to.
10909          After this sequence of ifs, TYPE is the type of the
10910          array or function or pointer, and DECLARATOR has had its
10911          outermost layer removed.  */
10912
10913       if (type == error_mark_node)
10914         {
10915           if (TREE_CODE (declarator) == SCOPE_REF)
10916             declarator = TREE_OPERAND (declarator, 1);
10917           else
10918             declarator = TREE_OPERAND (declarator, 0);
10919           continue;
10920         }
10921       if (quals != NULL_TREE
10922           && (declarator == NULL_TREE
10923               || TREE_CODE (declarator) != SCOPE_REF))
10924         {
10925           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10926             ctype = TYPE_METHOD_BASETYPE (type);
10927           if (ctype != NULL_TREE)
10928             {
10929               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10930               grok_method_quals (ctype, dummy, quals);
10931               type = TREE_TYPE (dummy);
10932               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10933               quals = NULL_TREE;
10934             }
10935         }
10936
10937       switch (TREE_CODE (declarator))
10938         {
10939         case TREE_LIST:
10940           {
10941             /* We encode a declarator with embedded attributes using
10942                a TREE_LIST.  */
10943             tree attrs = TREE_PURPOSE (declarator);
10944             tree inner_decl;
10945             int attr_flags;
10946
10947             declarator = TREE_VALUE (declarator);
10948             inner_decl = declarator;
10949             while (inner_decl != NULL_TREE
10950                    && TREE_CODE (inner_decl) == TREE_LIST)
10951               inner_decl = TREE_VALUE (inner_decl);
10952             attr_flags = 0;
10953             if (inner_decl == NULL_TREE
10954                 || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
10955               attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
10956             if (TREE_CODE (inner_decl) == CALL_EXPR)
10957               attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
10958             if (TREE_CODE (inner_decl) == ARRAY_REF)
10959               attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
10960             returned_attrs = decl_attributes (&type,
10961                                               chainon (returned_attrs, attrs),
10962                                               attr_flags);
10963           }
10964           break;
10965
10966         case ARRAY_REF:
10967           {
10968             register tree size;
10969
10970             size = TREE_OPERAND (declarator, 1);
10971
10972             /* VC++ spells a zero-sized array with [].  */
10973             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10974                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10975               size = integer_zero_node;
10976
10977             declarator = TREE_OPERAND (declarator, 0);
10978
10979             type = create_array_type_for_decl (dname, type, size);
10980
10981             ctype = NULL_TREE;
10982           }
10983           break;
10984
10985         case CALL_EXPR:
10986           {
10987             tree arg_types;
10988             int funcdecl_p;
10989             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10990             tree inner_decl = TREE_OPERAND (declarator, 0);
10991
10992             /* Declaring a function type.
10993                Make sure we have a valid type for the function to return.  */
10994
10995             /* We now know that the TYPE_QUALS don't apply to the
10996                decl, but to its return type.  */
10997             type_quals = TYPE_UNQUALIFIED;
10998
10999             /* Warn about some types functions can't return.  */
11000
11001             if (TREE_CODE (type) == FUNCTION_TYPE)
11002               {
11003                 error ("`%s' declared as function returning a function", name);
11004                 type = integer_type_node;
11005               }
11006             if (TREE_CODE (type) == ARRAY_TYPE)
11007               {
11008                 error ("`%s' declared as function returning an array", name);
11009                 type = integer_type_node;
11010               }
11011
11012             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
11013               inner_decl = TREE_OPERAND (inner_decl, 1);
11014
11015             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
11016               inner_decl = dname;
11017
11018             /* Pick up type qualifiers which should be applied to `this'.  */
11019             quals = CALL_DECLARATOR_QUALS (declarator);
11020
11021             /* Pick up the exception specifications.  */
11022             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
11023
11024             /* Say it's a definition only for the CALL_EXPR
11025                closest to the identifier.  */
11026             funcdecl_p
11027               = inner_decl
11028               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
11029                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
11030                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
11031
11032             if (ctype == NULL_TREE
11033                 && decl_context == FIELD
11034                 && funcdecl_p
11035                 && (friendp == 0 || dname == current_class_name))
11036               ctype = current_class_type;
11037
11038             if (ctype && sfk == sfk_conversion)
11039               TYPE_HAS_CONVERSION (ctype) = 1;
11040             if (ctype && constructor_name (ctype) == dname)
11041               {
11042                 /* We are within a class's scope. If our declarator name
11043                    is the same as the class name, and we are defining
11044                    a function, then it is a constructor/destructor, and
11045                    therefore returns a void type.  */
11046
11047                 if (flags == DTOR_FLAG)
11048                   {
11049                     /* ISO C++ 12.4/2.  A destructor may not be
11050                        declared const or volatile.  A destructor may
11051                        not be static.  */
11052                     if (staticp == 2)
11053                       error ("destructor cannot be static member function");
11054                     if (quals)
11055                       {
11056                         error ("destructors may not be `%s'",
11057                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
11058                         quals = NULL_TREE;
11059                       }
11060                     if (decl_context == FIELD)
11061                       {
11062                         if (! member_function_or_else (ctype,
11063                                                        current_class_type,
11064                                                        flags))
11065                           return void_type_node;
11066                       }
11067                   }
11068                 else            /* It's a constructor.  */
11069                   {
11070                     if (explicitp == 1)
11071                       explicitp = 2;
11072                     /* ISO C++ 12.1.  A constructor may not be
11073                        declared const or volatile.  A constructor may
11074                        not be virtual.  A constructor may not be
11075                        static.  */
11076                     if (staticp == 2)
11077                       error ("constructor cannot be static member function");
11078                     if (virtualp)
11079                       {
11080                         pedwarn ("constructors cannot be declared virtual");
11081                         virtualp = 0;
11082                       }
11083                     if (quals)
11084                       {
11085                         error ("constructors may not be `%s'",
11086                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
11087                         quals = NULL_TREE;
11088                       }
11089                     {
11090                       RID_BIT_TYPE tmp_bits;
11091                       memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
11092                       RIDBIT_RESET (RID_INLINE, tmp_bits);
11093                       RIDBIT_RESET (RID_STATIC, tmp_bits);
11094                       if (RIDBIT_ANY_SET (tmp_bits))
11095                         error ("return value type specifier for constructor ignored");
11096                     }
11097                     if (decl_context == FIELD)
11098                       {
11099                         if (! member_function_or_else (ctype,
11100                                                        current_class_type,
11101                                                        flags))
11102                           return void_type_node;
11103                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
11104                         if (sfk != sfk_constructor)
11105                           return NULL_TREE;
11106                       }
11107                   }
11108                 if (decl_context == FIELD)
11109                   staticp = 0;
11110               }
11111             else if (friendp)
11112               {
11113                 if (initialized)
11114                   error ("can't initialize friend function `%s'", name);
11115                 if (virtualp)
11116                   {
11117                     /* Cannot be both friend and virtual.  */
11118                     error ("virtual functions cannot be friends");
11119                     RIDBIT_RESET (RID_FRIEND, specbits);
11120                     friendp = 0;
11121                   }
11122                 if (decl_context == NORMAL)
11123                   error ("friend declaration not in class definition");
11124                 if (current_function_decl && funcdef_flag)
11125                   error ("can't define friend function `%s' in a local class definition",
11126                             name);
11127               }
11128
11129             /* Construct the function type and go to the next
11130                inner layer of declarator.  */
11131
11132             declarator = TREE_OPERAND (declarator, 0);
11133
11134             /* FIXME: This is where default args should be fully
11135                processed.  */
11136
11137             arg_types = grokparms (inner_parms);
11138
11139             if (declarator && flags == DTOR_FLAG)
11140               {
11141                 /* A destructor declared in the body of a class will
11142                    be represented as a BIT_NOT_EXPR.  But, we just
11143                    want the underlying IDENTIFIER.  */
11144                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
11145                   declarator = TREE_OPERAND (declarator, 0);
11146
11147                 if (arg_types != void_list_node)
11148                   {
11149                     error ("destructors may not have parameters");
11150                     arg_types = void_list_node;
11151                     last_function_parms = NULL_TREE;
11152                   }
11153               }
11154
11155             /* ANSI says that `const int foo ();'
11156                does not make the function foo const.  */
11157             type = build_function_type (type, arg_types);
11158
11159             {
11160               tree t;
11161               for (t = arg_types; t; t = TREE_CHAIN (t))
11162                 if (TREE_PURPOSE (t)
11163                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
11164                   {
11165                     add_defarg_fn (type);
11166                     break;
11167                   }
11168             }
11169           }
11170           break;
11171
11172         case ADDR_EXPR:
11173         case INDIRECT_REF:
11174           /* Filter out pointers-to-references and references-to-references.
11175              We can get these if a TYPE_DECL is used.  */
11176
11177           if (TREE_CODE (type) == REFERENCE_TYPE)
11178             {
11179               error (TREE_CODE (declarator) == ADDR_EXPR
11180                      ? "cannot declare reference to `%#T'"
11181                      : "cannot declare pointer to `%#T'", type);
11182               type = TREE_TYPE (type);
11183             }
11184           else if (VOID_TYPE_P (type)
11185                    && (ctype || TREE_CODE (declarator) == ADDR_EXPR))
11186             error (ctype ? "cannot declare pointer to `%#T' member"
11187                      : "cannot declare reference to `%#T'", type);
11188
11189           /* Merge any constancy or volatility into the target type
11190              for the pointer.  */
11191
11192           /* We now know that the TYPE_QUALS don't apply to the decl,
11193              but to the target of the pointer.  */
11194           type_quals = TYPE_UNQUALIFIED;
11195
11196           if (TREE_CODE (declarator) == ADDR_EXPR)
11197             {
11198               if (!VOID_TYPE_P (type))
11199                 type = build_reference_type (type);
11200             }
11201           else if (TREE_CODE (type) == METHOD_TYPE)
11202             type = build_ptrmemfunc_type (build_pointer_type (type));
11203           else if (ctype)
11204             type = build_ptrmem_type (ctype, type);
11205           else
11206             type = build_pointer_type (type);
11207
11208           /* Process a list of type modifier keywords (such as
11209              const or volatile) that were given inside the `*' or `&'.  */
11210
11211           if (TREE_TYPE (declarator))
11212             {
11213               register tree typemodlist;
11214               int erred = 0;
11215               int constp = 0;
11216               int volatilep = 0;
11217               int restrictp = 0;
11218
11219               for (typemodlist = TREE_TYPE (declarator); typemodlist;
11220                    typemodlist = TREE_CHAIN (typemodlist))
11221                 {
11222                   tree qualifier = TREE_VALUE (typemodlist);
11223
11224                   if (qualifier == ridpointers[(int) RID_CONST])
11225                     {
11226                       constp++;
11227                       type_quals |= TYPE_QUAL_CONST;
11228                     }
11229                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
11230                     {
11231                       volatilep++;
11232                       type_quals |= TYPE_QUAL_VOLATILE;
11233                     }
11234                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
11235                     {
11236                       restrictp++;
11237                       type_quals |= TYPE_QUAL_RESTRICT;
11238                     }
11239                   else if (!erred)
11240                     {
11241                       erred = 1;
11242                       error ("invalid type modifier within pointer declarator");
11243                     }
11244                 }
11245               if (constp > 1)
11246                 pedwarn ("duplicate `const'");
11247               if (volatilep > 1)
11248                 pedwarn ("duplicate `volatile'");
11249               if (restrictp > 1)
11250                 pedwarn ("duplicate `restrict'");
11251               type = cp_build_qualified_type (type, type_quals);
11252               type_quals = cp_type_quals (type);
11253             }
11254           declarator = TREE_OPERAND (declarator, 0);
11255           ctype = NULL_TREE;
11256           break;
11257
11258         case SCOPE_REF:
11259           {
11260             /* We have converted type names to NULL_TREE if the
11261                name was bogus, or to a _TYPE node, if not.
11262
11263                The variable CTYPE holds the type we will ultimately
11264                resolve to.  The code here just needs to build
11265                up appropriate member types.  */
11266             tree sname = TREE_OPERAND (declarator, 1);
11267             tree t;
11268
11269             /* Destructors can have their visibilities changed as well.  */
11270             if (TREE_CODE (sname) == BIT_NOT_EXPR)
11271               sname = TREE_OPERAND (sname, 0);
11272
11273             if (TREE_COMPLEXITY (declarator) == 0)
11274               /* This needs to be here, in case we are called
11275                  multiple times.  */ ;
11276             else if (TREE_COMPLEXITY (declarator) == -1)
11277               /* Namespace member.  */
11278               pop_decl_namespace ();
11279             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
11280               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
11281             else if (!TREE_OPERAND (declarator, 0)
11282                      || !IS_AGGR_TYPE_CODE
11283                           (TREE_CODE (TREE_OPERAND (declarator, 0))))
11284               ;
11285             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
11286               {
11287                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
11288                    that refer to ctype.  They couldn't be resolved earlier
11289                    because we hadn't pushed into the class yet.
11290                    Example: resolve 'B<T>::type' in
11291                    'B<typename B<T>::type> B<T>::f () { }'.  */
11292                 if (current_template_parms
11293                     && uses_template_parms (type)
11294                     && uses_template_parms (current_class_type))
11295                   {
11296                     tree args = current_template_args ();
11297                     type = tsubst (type, args, tf_error | tf_warning,
11298                                    NULL_TREE);
11299                   }
11300
11301                 /* This pop_nested_class corresponds to the
11302                    push_nested_class used to push into class scope for
11303                    parsing the argument list of a function decl, in
11304                    qualified_id.  */
11305                 pop_nested_class ();
11306                 TREE_COMPLEXITY (declarator) = current_class_depth;
11307               }
11308             else
11309               abort ();
11310
11311             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
11312               {
11313                 /* We had a reference to a global decl, or
11314                    perhaps we were given a non-aggregate typedef,
11315                    in which case we cleared this out, and should just
11316                    keep going as though it wasn't there.  */
11317                 declarator = sname;
11318                 continue;
11319               }
11320             ctype = TREE_OPERAND (declarator, 0);
11321
11322             t = ctype;
11323             while (t != NULL_TREE && CLASS_TYPE_P (t))
11324               {
11325                 /* You're supposed to have one `template <...>'
11326                    for every template class, but you don't need one
11327                    for a full specialization.  For example:
11328
11329                      template <class T> struct S{};
11330                      template <> struct S<int> { void f(); };
11331                      void S<int>::f () {}
11332
11333                    is correct; there shouldn't be a `template <>' for
11334                    the definition of `S<int>::f'.  */
11335                 if (CLASSTYPE_TEMPLATE_INFO (t)
11336                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
11337                         || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
11338                     && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
11339                   template_count += 1;
11340
11341                 t = TYPE_MAIN_DECL (t);
11342                 t = DECL_CONTEXT (t);
11343               }
11344
11345             if (sname == NULL_TREE)
11346               goto done_scoping;
11347
11348             if (TREE_CODE (sname) == IDENTIFIER_NODE)
11349               {
11350                 /* This is the `standard' use of the scoping operator:
11351                    basetype :: member .  */
11352
11353                 if (ctype == current_class_type)
11354                   {
11355                     /* class A {
11356                          void A::f ();
11357                        };
11358
11359                        Is this ill-formed?  */
11360
11361                     if (pedantic)
11362                       pedwarn ("extra qualification `%T::' on member `%s' ignored",
11363                                   ctype, name);
11364                   }
11365                 else if (TREE_CODE (type) == FUNCTION_TYPE)
11366                   {
11367                     if (current_class_type == NULL_TREE || friendp)
11368                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11369                                                       TYPE_ARG_TYPES (type));
11370                     else
11371                       {
11372                         error ("cannot declare member function `%T::%s' within `%T'",
11373                                   ctype, name, current_class_type);
11374                         return void_type_node;
11375                       }
11376                   }
11377                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
11378                          || COMPLETE_TYPE_P (complete_type (ctype)))
11379                   {
11380                     /* Have to move this code elsewhere in this function.
11381                        this code is used for i.e., typedef int A::M; M *pm;
11382
11383                        It is?  How? jason 10/2/94 */
11384
11385                     if (current_class_type)
11386                       {
11387                         error ("cannot declare member `%T::%s' within `%T'",
11388                                   ctype, name, current_class_type);
11389                         return void_type_node;
11390                       }
11391                   }
11392                 else
11393                   {
11394                     cxx_incomplete_type_error (NULL_TREE, ctype);
11395                     return error_mark_node;
11396                   }
11397
11398                 declarator = sname;
11399               }
11400             else if (TREE_CODE (sname) == SCOPE_REF)
11401               abort ();
11402             else
11403               {
11404               done_scoping:
11405                 declarator = TREE_OPERAND (declarator, 1);
11406                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
11407                   /* In this case, we will deal with it later.  */
11408                   ;
11409                 else if (TREE_CODE (type) == FUNCTION_TYPE)
11410                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11411                                                   TYPE_ARG_TYPES (type));
11412               }
11413           }
11414           break;
11415
11416         case BIT_NOT_EXPR:
11417           declarator = TREE_OPERAND (declarator, 0);
11418           break;
11419
11420         case BASELINK:
11421           declarator = BASELINK_FUNCTIONS (declarator);
11422           break;
11423
11424         case RECORD_TYPE:
11425         case UNION_TYPE:
11426         case ENUMERAL_TYPE:
11427           declarator = NULL_TREE;
11428           break;
11429
11430         case ERROR_MARK:
11431           declarator = NULL_TREE;
11432           break;
11433
11434         default:
11435           abort ();
11436         }
11437     }
11438
11439   if (returned_attrs)
11440     {
11441       if (attrlist)
11442         *attrlist = chainon (returned_attrs, *attrlist);
11443       else
11444         attrlist = &returned_attrs;
11445     }
11446
11447   /* Now TYPE has the actual type.  */
11448
11449   /* Did array size calculations overflow?  */
11450
11451   if (TREE_CODE (type) == ARRAY_TYPE
11452       && COMPLETE_TYPE_P (type)
11453       && TREE_OVERFLOW (TYPE_SIZE (type)))
11454     {
11455       error ("size of array `%s' is too large", name);
11456       /* If we proceed with the array type as it is, we'll eventually
11457          crash in tree_low_cst().  */
11458       type = error_mark_node;
11459     }
11460
11461   if (decl_context == FIELD
11462       && !processing_template_decl
11463       && variably_modified_type_p (type))
11464     {
11465       error ("data member may not have variably modified type `%T'", type);
11466       type = error_mark_node;
11467     }
11468
11469   if (explicitp == 1 || (explicitp && friendp))
11470     {
11471       /* [dcl.fct.spec] The explicit specifier shall only be used in
11472          declarations of constructors within a class definition.  */
11473       error ("only declarations of constructors can be `explicit'");
11474       explicitp = 0;
11475     }
11476
11477   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11478     {
11479       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11480         {
11481           error ("non-member `%s' cannot be declared `mutable'", name);
11482           RIDBIT_RESET (RID_MUTABLE, specbits);
11483         }
11484       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11485         {
11486           error ("non-object member `%s' cannot be declared `mutable'", name);
11487           RIDBIT_RESET (RID_MUTABLE, specbits);
11488         }
11489       else if (TREE_CODE (type) == FUNCTION_TYPE
11490                || TREE_CODE (type) == METHOD_TYPE)
11491         {
11492           error ("function `%s' cannot be declared `mutable'", name);
11493           RIDBIT_RESET (RID_MUTABLE, specbits);
11494         }
11495       else if (staticp)
11496         {
11497           error ("static `%s' cannot be declared `mutable'", name);
11498           RIDBIT_RESET (RID_MUTABLE, specbits);
11499         }
11500       else if (type_quals & TYPE_QUAL_CONST)
11501         {
11502           error ("const `%s' cannot be declared `mutable'", name);
11503           RIDBIT_RESET (RID_MUTABLE, specbits);
11504         }
11505     }
11506
11507   if (declarator == NULL_TREE
11508       || TREE_CODE (declarator) == IDENTIFIER_NODE
11509       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11510           && (TREE_CODE (type) == FUNCTION_TYPE
11511               || TREE_CODE (type) == METHOD_TYPE)))
11512     /* OK */;
11513   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11514     {
11515       error ("template-id `%D' used as a declarator", declarator);
11516       declarator = dname;
11517     }
11518   else
11519     /* Unexpected declarator format.  */
11520     abort ();
11521
11522   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11523
11524   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11525     {
11526       tree decl;
11527
11528       /* Note that the grammar rejects storage classes
11529          in typenames, fields or parameters.  */
11530       if (current_lang_name == lang_name_java)
11531         TYPE_FOR_JAVA (type) = 1;
11532
11533       if (decl_context == FIELD)
11534         {
11535           if (declarator == constructor_name (current_class_type))
11536             pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11537                         declarator);
11538           decl = build_lang_decl (TYPE_DECL, declarator, type);
11539         }
11540       else
11541         {
11542           decl = build_decl (TYPE_DECL, declarator, type);
11543           if (!current_function_decl)
11544             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11545         }
11546
11547       /* If the user declares "typedef struct {...} foo" then the
11548          struct will have an anonymous name.  Fill that name in now.
11549          Nothing can refer to it, so nothing needs know about the name
11550          change.  */
11551       if (type != error_mark_node
11552           && declarator
11553           && TYPE_NAME (type)
11554           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11555           && TYPE_ANONYMOUS_P (type)
11556           /* Don't do this if there are attributes.  */
11557           && (!attrlist || !*attrlist)
11558           && cp_type_quals (type) == TYPE_UNQUALIFIED)
11559         {
11560           tree oldname = TYPE_NAME (type);
11561           tree t;
11562
11563           /* Replace the anonymous name with the real name everywhere.  */
11564           lookup_tag_reverse (type, declarator);
11565           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11566             if (TYPE_NAME (t) == oldname)
11567               TYPE_NAME (t) = decl;
11568
11569           if (TYPE_LANG_SPECIFIC (type))
11570             TYPE_WAS_ANONYMOUS (type) = 1;
11571
11572           /* If this is a typedef within a template class, the nested
11573              type is a (non-primary) template.  The name for the
11574              template needs updating as well.  */
11575           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11576             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11577               = TYPE_IDENTIFIER (type);
11578
11579           /* FIXME remangle member functions; member functions of a
11580              type with external linkage have external linkage.  */
11581         }
11582
11583       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11584         {
11585           cp_error_at ("typedef name may not be class-qualified", decl);
11586           return NULL_TREE;
11587         }
11588       else if (quals)
11589         {
11590           if (ctype == NULL_TREE)
11591             {
11592               if (TREE_CODE (type) != METHOD_TYPE)
11593                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11594               else
11595                 ctype = TYPE_METHOD_BASETYPE (type);
11596             }
11597           if (ctype != NULL_TREE)
11598             grok_method_quals (ctype, decl, quals);
11599         }
11600
11601       if (RIDBIT_SETP (RID_SIGNED, specbits)
11602           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11603         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11604
11605       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11606                       inlinep, friendp, raises != NULL_TREE);
11607
11608       return decl;
11609     }
11610
11611   /* Detect the case of an array type of unspecified size
11612      which came, as such, direct from a typedef name.
11613      We must copy the type, so that the array's domain can be
11614      individually set by the object's initializer.  */
11615
11616   if (type && typedef_type
11617       && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
11618       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
11619     type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
11620
11621   /* Detect where we're using a typedef of function type to declare a
11622      function. last_function_parms will not be set, so we must create
11623      it now.  */
11624
11625   if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
11626     {
11627       tree decls = NULL_TREE;
11628       tree args;
11629
11630       for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
11631         {
11632           tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
11633
11634           TREE_CHAIN (decl) = decls;
11635           decls = decl;
11636         }
11637
11638       last_function_parms = nreverse (decls);
11639     }
11640
11641   /* If this is a type name (such as, in a cast or sizeof),
11642      compute the type and return it now.  */
11643
11644   if (decl_context == TYPENAME)
11645     {
11646       /* Note that the grammar rejects storage classes
11647          in typenames, fields or parameters.  */
11648       if (type_quals != TYPE_UNQUALIFIED)
11649         type_quals = TYPE_UNQUALIFIED;
11650
11651       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11652       if (friendp)
11653         {
11654           if (type_quals != TYPE_UNQUALIFIED)
11655             {
11656               error ("type qualifiers specified for friend class declaration");
11657               type_quals = TYPE_UNQUALIFIED;
11658             }
11659           if (inlinep)
11660             {
11661               error ("`inline' specified for friend class declaration");
11662               inlinep = 0;
11663             }
11664
11665           if (!current_aggr)
11666             {
11667               /* Don't allow friend declaration without a class-key.  */
11668               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11669                 pedwarn ("template parameters cannot be friends");
11670               else if (TREE_CODE (type) == TYPENAME_TYPE)
11671                 pedwarn ("friend declaration requires class-key, "
11672                          "i.e. `friend class %T::%D'",
11673                          TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
11674               else
11675                 pedwarn ("friend declaration requires class-key, "
11676                          "i.e. `friend %#T'",
11677                          type);
11678             }
11679
11680           /* Only try to do this stuff if we didn't already give up.  */
11681           if (type != integer_type_node)
11682             {
11683               decl_type_access_control (TYPE_NAME (type));
11684
11685               /* A friendly class?  */
11686               if (current_class_type)
11687                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11688               else
11689                 error ("trying to make class `%T' a friend of global scope",
11690                           type);
11691
11692               type = void_type_node;
11693             }
11694         }
11695       else if (quals)
11696         {
11697           if (ctype == NULL_TREE)
11698             {
11699               if (TREE_CODE (type) != METHOD_TYPE)
11700                 error ("invalid qualifiers on non-member function type");
11701               else
11702                 ctype = TYPE_METHOD_BASETYPE (type);
11703             }
11704           if (ctype)
11705             {
11706               tree dummy = build_decl (TYPE_DECL, declarator, type);
11707               grok_method_quals (ctype, dummy, quals);
11708               type = TREE_TYPE (dummy);
11709             }
11710         }
11711
11712       return type;
11713     }
11714   else if (declarator == NULL_TREE && decl_context != PARM
11715            && decl_context != CATCHPARM
11716            && TREE_CODE (type) != UNION_TYPE
11717            && ! bitfield)
11718     {
11719       error ("abstract declarator `%T' used as declaration", type);
11720       declarator = make_anon_name ();
11721     }
11722
11723   /* `void' at top level (not within pointer)
11724      is allowed only in typedefs or type names.
11725      We don't complain about parms either, but that is because
11726      a better error message can be made later.  */
11727
11728   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11729     {
11730       if (! declarator)
11731         error ("unnamed variable or field declared void");
11732       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11733         {
11734           if (IDENTIFIER_OPNAME_P (declarator))
11735             abort ();
11736           else
11737             error ("variable or field `%s' declared void", name);
11738         }
11739       else
11740         error ("variable or field declared void");
11741       type = integer_type_node;
11742     }
11743
11744   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11745      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11746
11747   if (decl_context == PARM || decl_context == CATCHPARM)
11748     {
11749       if (ctype || in_namespace)
11750         error ("cannot use `::' in parameter declaration");
11751
11752       /* A parameter declared as an array of T is really a pointer to T.
11753          One declared as a function is really a pointer to a function.
11754          One declared as a member is really a pointer to member.  */
11755
11756       if (TREE_CODE (type) == ARRAY_TYPE)
11757         {
11758           /* Transfer const-ness of array into that of type pointed to.  */
11759           type = build_pointer_type (TREE_TYPE (type));
11760           type_quals = TYPE_UNQUALIFIED;
11761         }
11762       else if (TREE_CODE (type) == FUNCTION_TYPE)
11763         type = build_pointer_type (type);
11764       else if (TREE_CODE (type) == OFFSET_TYPE)
11765         type = build_pointer_type (type);
11766     }
11767
11768   {
11769     register tree decl;
11770
11771     if (decl_context == PARM)
11772       {
11773         decl = cp_build_parm_decl (declarator, type);
11774
11775         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11776                         inlinep, friendp, raises != NULL_TREE);
11777       }
11778     else if (decl_context == FIELD)
11779       {
11780         if (type == error_mark_node)
11781           {
11782             /* Happens when declaring arrays of sizes which
11783                are error_mark_node, for example.  */
11784             decl = NULL_TREE;
11785           }
11786         else if (in_namespace && !friendp)
11787           {
11788             /* Something like struct S { int N::j; };  */
11789             error ("invalid use of `::'");
11790             decl = NULL_TREE;
11791           }
11792         else if (TREE_CODE (type) == FUNCTION_TYPE)
11793           {
11794             int publicp = 0;
11795             tree function_context;
11796
11797             /* We catch the others as conflicts with the builtin
11798                typedefs.  */
11799             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11800               {
11801                 error ("function `%D' cannot be declared friend",
11802                           declarator);
11803                 friendp = 0;
11804               }
11805
11806             if (friendp == 0)
11807               {
11808                 if (ctype == NULL_TREE)
11809                   ctype = current_class_type;
11810
11811                 if (ctype == NULL_TREE)
11812                   {
11813                     error ("can't make `%D' into a method -- not in a class",
11814                               declarator);
11815                     return void_type_node;
11816                   }
11817
11818                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11819                    ARM 9.5 */
11820                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11821                   {
11822                     error ("function `%D' declared virtual inside a union",
11823                               declarator);
11824                     return void_type_node;
11825                   }
11826
11827                 if (declarator == ansi_opname (NEW_EXPR)
11828                     || declarator == ansi_opname (VEC_NEW_EXPR)
11829                     || declarator == ansi_opname (DELETE_EXPR)
11830                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11831                   {
11832                     if (virtualp)
11833                       {
11834                         error ("`%D' cannot be declared virtual, since it is always static",
11835                                   declarator);
11836                         virtualp = 0;
11837                       }
11838                   }
11839                 else if (staticp < 2)
11840                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11841                                                   TYPE_ARG_TYPES (type));
11842               }
11843
11844             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11845             function_context = (ctype != NULL_TREE) ?
11846               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11847             publicp = (! friendp || ! staticp)
11848               && function_context == NULL_TREE;
11849             decl = grokfndecl (ctype, type,
11850                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11851                                ? declarator : dname,
11852                                declarator,
11853                                virtualp, flags, quals, raises,
11854                                friendp ? -1 : 0, friendp, publicp, inlinep,
11855                                funcdef_flag, template_count, in_namespace);
11856             if (decl == NULL_TREE)
11857               return decl;
11858 #if 0
11859             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11860             /* The decl and setting of decl_attr is also turned off.  */
11861             decl = build_decl_attribute_variant (decl, decl_attr);
11862 #endif
11863
11864             /* [class.conv.ctor]
11865
11866                A constructor declared without the function-specifier
11867                explicit that can be called with a single parameter
11868                specifies a conversion from the type of its first
11869                parameter to the type of its class.  Such a constructor
11870                is called a converting constructor.  */
11871             if (explicitp == 2)
11872               DECL_NONCONVERTING_P (decl) = 1;
11873             else if (DECL_CONSTRUCTOR_P (decl))
11874               {
11875                 /* The constructor can be called with exactly one
11876                    parameter if there is at least one parameter, and
11877                    any subsequent parameters have default arguments.
11878                    Ignore any compiler-added parms.  */
11879                 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
11880
11881                 if (arg_types == void_list_node
11882                     || (arg_types
11883                         && TREE_CHAIN (arg_types)
11884                         && TREE_CHAIN (arg_types) != void_list_node
11885                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11886                   DECL_NONCONVERTING_P (decl) = 1;
11887               }
11888           }
11889         else if (TREE_CODE (type) == METHOD_TYPE)
11890           {
11891             /* We only get here for friend declarations of
11892                members of other classes.  */
11893             /* All method decls are public, so tell grokfndecl to set
11894                TREE_PUBLIC, also.  */
11895             decl = grokfndecl (ctype, type, declarator, declarator,
11896                                virtualp, flags, quals, raises,
11897                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11898                                template_count, in_namespace);
11899             if (decl == NULL_TREE)
11900               return NULL_TREE;
11901           }
11902         else if (!staticp && ! processing_template_decl
11903                  && !COMPLETE_TYPE_P (complete_type (type))
11904                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11905           {
11906             if (declarator)
11907               error ("field `%D' has incomplete type", declarator);
11908             else
11909               error ("name `%T' has incomplete type", type);
11910
11911             /* If we're instantiating a template, tell them which
11912                instantiation made the field's type be incomplete.  */
11913             if (current_class_type
11914                 && TYPE_NAME (current_class_type)
11915                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11916                 && declspecs && TREE_VALUE (declspecs)
11917                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11918               error ("  in instantiation of template `%T'",
11919                         current_class_type);
11920
11921             type = error_mark_node;
11922             decl = NULL_TREE;
11923           }
11924         else
11925           {
11926             if (friendp)
11927               {
11928                 error ("`%s' is neither function nor member function; cannot be declared friend",
11929                        IDENTIFIER_POINTER (declarator));
11930                 friendp = 0;
11931               }
11932             decl = NULL_TREE;
11933           }
11934
11935         if (friendp)
11936           {
11937             /* Friends are treated specially.  */
11938             if (ctype == current_class_type)
11939               warning ("member functions are implicitly friends of their class");
11940             else
11941               {
11942                 tree t = NULL_TREE;
11943                 if (decl && DECL_NAME (decl))
11944                   {
11945                     if (template_class_depth (current_class_type) == 0)
11946                       {
11947                         decl
11948                           = check_explicit_specialization
11949                           (declarator, decl,
11950                            template_count, 2 * (funcdef_flag != 0) + 4);
11951                         if (decl == error_mark_node)
11952                           return error_mark_node;
11953                       }
11954
11955                     t = do_friend (ctype, declarator, decl,
11956                                    last_function_parms, *attrlist,
11957                                    flags, quals, funcdef_flag);
11958                   }
11959                 if (t && funcdef_flag)
11960                   return t;
11961
11962                 return void_type_node;
11963               }
11964           }
11965
11966         /* Structure field.  It may not be a function, except for C++ */
11967
11968         if (decl == NULL_TREE)
11969           {
11970             if (initialized)
11971               {
11972                 if (!staticp)
11973                   {
11974                     /* An attempt is being made to initialize a non-static
11975                        member.  But, from [class.mem]:
11976
11977                        4 A member-declarator can contain a
11978                        constant-initializer only if it declares a static
11979                        member (_class.static_) of integral or enumeration
11980                        type, see _class.static.data_.
11981
11982                        This used to be relatively common practice, but
11983                        the rest of the compiler does not correctly
11984                        handle the initialization unless the member is
11985                        static so we make it static below.  */
11986                     pedwarn ("ISO C++ forbids initialization of member `%D'",
11987                                 declarator);
11988                     pedwarn ("making `%D' static", declarator);
11989                     staticp = 1;
11990                   }
11991
11992                 if (uses_template_parms (type))
11993                   /* We'll check at instantiation time.  */
11994                   ;
11995                 else if (check_static_variable_definition (declarator,
11996                                                            type))
11997                   /* If we just return the declaration, crashes
11998                      will sometimes occur.  We therefore return
11999                      void_type_node, as if this was a friend
12000                      declaration, to cause callers to completely
12001                      ignore this declaration.  */
12002                   return void_type_node;
12003               }
12004
12005             /* 9.2p13 [class.mem] */
12006             if (declarator == constructor_name (current_class_type)
12007                 /* The standard does not allow non-static data members
12008                    here either, but we agreed at the 10/99 meeting
12009                    to change that in TC 1 so that they are allowed in
12010                    classes with no user-defined constructors.  */
12011                 && staticp)
12012               pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
12013                           declarator);
12014
12015             if (staticp)
12016               {
12017                 /* C++ allows static class members.  All other work
12018                    for this is done by grokfield.  */
12019                 decl = build_lang_decl (VAR_DECL, declarator, type);
12020                 TREE_STATIC (decl) = 1;
12021                 /* In class context, 'static' means public access.  */
12022                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
12023               }
12024             else
12025               {
12026                 decl = build_decl (FIELD_DECL, declarator, type);
12027                 DECL_NONADDRESSABLE_P (decl) = bitfield;
12028                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
12029                   {
12030                     DECL_MUTABLE_P (decl) = 1;
12031                     RIDBIT_RESET (RID_MUTABLE, specbits);
12032                   }
12033               }
12034
12035             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
12036                             inlinep, friendp, raises != NULL_TREE);
12037           }
12038       }
12039     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
12040       {
12041         tree original_name;
12042         int publicp = 0;
12043
12044         if (! declarator)
12045           return NULL_TREE;
12046
12047         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
12048           original_name = dname;
12049         else
12050           original_name = declarator;
12051
12052         if (RIDBIT_SETP (RID_AUTO, specbits))
12053           error ("storage class `auto' invalid for function `%s'", name);
12054         else if (RIDBIT_SETP (RID_REGISTER, specbits))
12055           error ("storage class `register' invalid for function `%s'", name);
12056         else if (RIDBIT_SETP (RID_THREAD, specbits))
12057           error ("storage class `__thread' invalid for function `%s'", name);
12058
12059         /* Function declaration not at top level.
12060            Storage classes other than `extern' are not allowed
12061            and `extern' makes no difference.  */
12062         if (! toplevel_bindings_p ()
12063             && (RIDBIT_SETP (RID_STATIC, specbits)
12064                 || RIDBIT_SETP (RID_INLINE, specbits))
12065             && pedantic)
12066           {
12067             if (RIDBIT_SETP (RID_STATIC, specbits))
12068               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
12069             else
12070               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
12071           }
12072
12073         if (ctype == NULL_TREE)
12074           {
12075             if (virtualp)
12076               {
12077                 error ("virtual non-class function `%s'", name);
12078                 virtualp = 0;
12079               }
12080           }
12081         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
12082           type = build_cplus_method_type (ctype, TREE_TYPE (type),
12083                                           TYPE_ARG_TYPES (type));
12084
12085         /* Record presence of `static'.  */
12086         publicp = (ctype != NULL_TREE
12087                    || RIDBIT_SETP (RID_EXTERN, specbits)
12088                    || !RIDBIT_SETP (RID_STATIC, specbits));
12089
12090         decl = grokfndecl (ctype, type, original_name, declarator,
12091                            virtualp, flags, quals, raises,
12092                            1, friendp,
12093                            publicp, inlinep, funcdef_flag,
12094                            template_count, in_namespace);
12095         if (decl == NULL_TREE)
12096           return NULL_TREE;
12097
12098         if (staticp == 1)
12099           {
12100             int invalid_static = 0;
12101
12102             /* Don't allow a static member function in a class, and forbid
12103                declaring main to be static.  */
12104             if (TREE_CODE (type) == METHOD_TYPE)
12105               {
12106                 pedwarn ("cannot declare member function `%D' to have static linkage", decl);
12107                 invalid_static = 1;
12108               }
12109             else if (current_function_decl)
12110               {
12111                 /* FIXME need arm citation */
12112                 error ("cannot declare static function inside another function");
12113                 invalid_static = 1;
12114               }
12115
12116             if (invalid_static)
12117               {
12118                 staticp = 0;
12119                 RIDBIT_RESET (RID_STATIC, specbits);
12120               }
12121           }
12122       }
12123     else
12124       {
12125         /* It's a variable.  */
12126
12127         /* An uninitialized decl with `extern' is a reference.  */
12128         decl = grokvardecl (type, declarator, &specbits,
12129                             initialized,
12130                             (type_quals & TYPE_QUAL_CONST) != 0,
12131                             ctype ? ctype : in_namespace);
12132         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
12133                         inlinep, friendp, raises != NULL_TREE);
12134
12135         if (ctype)
12136           {
12137             DECL_CONTEXT (decl) = ctype;
12138             if (staticp == 1)
12139               {
12140                 pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
12141                 staticp = 0;
12142                 RIDBIT_RESET (RID_STATIC, specbits);
12143               }
12144             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
12145               {
12146                 error ("static member `%D' declared `register'", decl);
12147                 RIDBIT_RESET (RID_REGISTER, specbits);
12148               }
12149             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
12150               {
12151                 pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
12152                             decl);
12153                 RIDBIT_RESET (RID_EXTERN, specbits);
12154               }
12155           }
12156       }
12157
12158     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
12159
12160     /* Record `register' declaration for warnings on &
12161        and in case doing stupid register allocation.  */
12162
12163     if (RIDBIT_SETP (RID_REGISTER, specbits))
12164       DECL_REGISTER (decl) = 1;
12165
12166     if (RIDBIT_SETP (RID_EXTERN, specbits))
12167       DECL_THIS_EXTERN (decl) = 1;
12168
12169     if (RIDBIT_SETP (RID_STATIC, specbits))
12170       DECL_THIS_STATIC (decl) = 1;
12171
12172     /* Record constancy and volatility.  There's no need to do this
12173        when processing a template; we'll do this for the instantiated
12174        declaration based on the type of DECL.  */
12175     if (!processing_template_decl)
12176       c_apply_type_quals_to_decl (type_quals, decl);
12177
12178     return decl;
12179   }
12180 }
12181 \f
12182 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
12183    An empty exprlist is a parmlist.  An exprlist which
12184    contains only identifiers at the global level
12185    is a parmlist.  Otherwise, it is an exprlist.  */
12186
12187 int
12188 parmlist_is_exprlist (exprs)
12189      tree exprs;
12190 {
12191   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
12192     return 0;
12193
12194   if (toplevel_bindings_p ())
12195     {
12196       /* At the global level, if these are all identifiers,
12197          then it is a parmlist.  */
12198       while (exprs)
12199         {
12200           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
12201             return 1;
12202           exprs = TREE_CHAIN (exprs);
12203         }
12204       return 0;
12205     }
12206   return 1;
12207 }
12208
12209 /* Subroutine of start_function.  Ensure that each of the parameter
12210    types (as listed in PARMS) is complete, as is required for a
12211    function definition.  */
12212
12213 static void
12214 require_complete_types_for_parms (parms)
12215      tree parms;
12216 {
12217   for (; parms; parms = TREE_CHAIN (parms))
12218     {
12219       if (VOID_TYPE_P (TREE_TYPE (parms)))
12220         /* grokparms will have already issued an error */
12221         TREE_TYPE (parms) = error_mark_node;
12222       else if (complete_type_or_else (TREE_TYPE (parms), parms))
12223         layout_decl (parms, 0);
12224       else
12225         TREE_TYPE (parms) = error_mark_node;
12226     }
12227 }
12228
12229 /* Returns nonzero if T is a local variable.  */
12230
12231 int
12232 local_variable_p (t)
12233      tree t;
12234 {
12235   if ((TREE_CODE (t) == VAR_DECL
12236        /* A VAR_DECL with a context that is a _TYPE is a static data
12237           member.  */
12238        && !TYPE_P (CP_DECL_CONTEXT (t))
12239        /* Any other non-local variable must be at namespace scope.  */
12240        && !DECL_NAMESPACE_SCOPE_P (t))
12241       || (TREE_CODE (t) == PARM_DECL))
12242     return 1;
12243
12244   return 0;
12245 }
12246
12247 /* Returns nonzero if T is an automatic local variable or a label.
12248    (These are the declarations that need to be remapped when the code
12249    containing them is duplicated.)  */
12250
12251 int
12252 nonstatic_local_decl_p (t)
12253      tree t;
12254 {
12255   return ((local_variable_p (t) && !TREE_STATIC (t))
12256           || TREE_CODE (t) == LABEL_DECL
12257           || TREE_CODE (t) == RESULT_DECL);
12258 }
12259
12260 /* Like local_variable_p, but suitable for use as a tree-walking
12261    function.  */
12262
12263 static tree
12264 local_variable_p_walkfn (tp, walk_subtrees, data)
12265      tree *tp;
12266      int *walk_subtrees ATTRIBUTE_UNUSED;
12267      void *data ATTRIBUTE_UNUSED;
12268 {
12269   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
12270           ? *tp : NULL_TREE);
12271 }
12272
12273 /* Check that ARG, which is a default-argument expression for a
12274    parameter DECL, is valid.  Returns ARG, or ERROR_MARK_NODE, if
12275    something goes wrong.  DECL may also be a _TYPE node, rather than a
12276    DECL, if there is no DECL available.  */
12277
12278 tree
12279 check_default_argument (decl, arg)
12280      tree decl;
12281      tree arg;
12282 {
12283   tree var;
12284   tree decl_type;
12285
12286   if (TREE_CODE (arg) == DEFAULT_ARG)
12287     /* We get a DEFAULT_ARG when looking at an in-class declaration
12288        with a default argument.  Ignore the argument for now; we'll
12289        deal with it after the class is complete.  */
12290     return arg;
12291
12292   if (processing_template_decl || uses_template_parms (arg))
12293     /* We don't do anything checking until instantiation-time.  Note
12294        that there may be uninstantiated arguments even for an
12295        instantiated function, since default arguments are not
12296        instantiated until they are needed.  */
12297     return arg;
12298
12299   if (TYPE_P (decl))
12300     {
12301       decl_type = decl;
12302       decl = NULL_TREE;
12303     }
12304   else
12305     decl_type = TREE_TYPE (decl);
12306
12307   if (arg == error_mark_node
12308       || decl == error_mark_node
12309       || TREE_TYPE (arg) == error_mark_node
12310       || decl_type == error_mark_node)
12311     /* Something already went wrong.  There's no need to check
12312        further.  */
12313     return error_mark_node;
12314
12315   /* [dcl.fct.default]
12316
12317      A default argument expression is implicitly converted to the
12318      parameter type.  */
12319   if (!TREE_TYPE (arg)
12320       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
12321     {
12322       if (decl)
12323         error ("default argument for `%#D' has type `%T'",
12324                   decl, TREE_TYPE (arg));
12325       else
12326         error ("default argument for parameter of type `%T' has type `%T'",
12327                   decl_type, TREE_TYPE (arg));
12328
12329       return error_mark_node;
12330     }
12331
12332   /* [dcl.fct.default]
12333
12334      Local variables shall not be used in default argument
12335      expressions.
12336
12337      The keyword `this' shall not be used in a default argument of a
12338      member function.  */
12339   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
12340                                       NULL);
12341   if (var)
12342     {
12343       error ("default argument `%E' uses local variable `%D'",
12344                 arg, var);
12345       return error_mark_node;
12346     }
12347
12348   /* All is well.  */
12349   return arg;
12350 }
12351
12352 /* Decode the list of parameter types for a function type.
12353    Given the list of things declared inside the parens,
12354    return a list of types.
12355
12356    We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
12357    flag. If unset, we append void_list_node. A parmlist declared
12358    as `(void)' is accepted as the empty parmlist.
12359
12360    Also set last_function_parms to the chain of PARM_DECLs.  */
12361
12362 static tree
12363 grokparms (first_parm)
12364      tree first_parm;
12365 {
12366   tree result = NULL_TREE;
12367   tree decls = NULL_TREE;
12368   int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
12369   tree parm, chain;
12370   int any_error = 0;
12371
12372   my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
12373
12374   for (parm = first_parm; parm != NULL_TREE; parm = chain)
12375     {
12376       tree type = NULL_TREE;
12377       tree decl = TREE_VALUE (parm);
12378       tree init = TREE_PURPOSE (parm);
12379       tree specs, attrs;
12380
12381       chain = TREE_CHAIN (parm);
12382       /* @@ weak defense against parse errors.  */
12383       if (TREE_CODE (decl) != VOID_TYPE
12384           && TREE_CODE (decl) != TREE_LIST)
12385         {
12386           /* Give various messages as the need arises.  */
12387           if (TREE_CODE (decl) == STRING_CST)
12388             error ("invalid string constant `%E'", decl);
12389           else if (TREE_CODE (decl) == INTEGER_CST)
12390             error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12391           continue;
12392         }
12393
12394       if (parm == void_list_node)
12395         break;
12396
12397       split_specs_attrs (TREE_PURPOSE (decl), &specs, &attrs);
12398       decl = grokdeclarator (TREE_VALUE (decl), specs,
12399                              PARM, init != NULL_TREE, &attrs);
12400       if (! decl || TREE_TYPE (decl) == error_mark_node)
12401         continue;
12402
12403       if (attrs)
12404         cplus_decl_attributes (&decl, attrs, 0);
12405
12406       type = TREE_TYPE (decl);
12407       if (VOID_TYPE_P (type))
12408         {
12409           if (same_type_p (type, void_type_node)
12410               && !DECL_NAME (decl) && !result && !chain && !ellipsis)
12411             /* this is a parmlist of `(void)', which is ok.  */
12412             break;
12413           cxx_incomplete_type_error (decl, type);
12414           /* It's not a good idea to actually create parameters of
12415              type `void'; other parts of the compiler assume that a
12416              void type terminates the parameter list.  */
12417           type = error_mark_node;
12418           TREE_TYPE (decl) = error_mark_node;
12419         }
12420
12421       if (type != error_mark_node)
12422         {
12423           /* Top-level qualifiers on the parameters are
12424              ignored for function types.  */
12425           type = TYPE_MAIN_VARIANT (type);
12426           if (TREE_CODE (type) == METHOD_TYPE)
12427             {
12428               error ("parameter `%D' invalidly declared method type", decl);
12429               type = build_pointer_type (type);
12430               TREE_TYPE (decl) = type;
12431             }
12432           else if (TREE_CODE (type) == OFFSET_TYPE)
12433             {
12434               error ("parameter `%D' invalidly declared offset type", decl);
12435               type = build_pointer_type (type);
12436               TREE_TYPE (decl) = type;
12437             }
12438           else if (abstract_virtuals_error (decl, type))
12439             any_error = 1;  /* Seems like a good idea.  */
12440           else if (POINTER_TYPE_P (type))
12441             {
12442               /* [dcl.fct]/6, parameter types cannot contain pointers
12443                  (references) to arrays of unknown bound.  */
12444               tree t = TREE_TYPE (type);
12445               int ptr = TYPE_PTR_P (type);
12446
12447               while (1)
12448                 {
12449                   if (TYPE_PTR_P (t))
12450                     ptr = 1;
12451                   else if (TREE_CODE (t) != ARRAY_TYPE)
12452                     break;
12453                   else if (!TYPE_DOMAIN (t))
12454                     break;
12455                   t = TREE_TYPE (t);
12456                 }
12457               if (TREE_CODE (t) == ARRAY_TYPE)
12458                 error ("parameter `%D' includes %s to array of unknown bound `%T'",
12459                           decl, ptr ? "pointer" : "reference", t);
12460             }
12461
12462           if (!any_error && init)
12463             init = check_default_argument (decl, init);
12464           else
12465             init = NULL_TREE;
12466         }
12467
12468       TREE_CHAIN (decl) = decls;
12469       decls = decl;
12470       result = tree_cons (init, type, result);
12471     }
12472   decls = nreverse (decls);
12473   result = nreverse (result);
12474   if (!ellipsis)
12475     result = chainon (result, void_list_node);
12476   last_function_parms = decls;
12477
12478   return result;
12479 }
12480
12481 \f
12482 /* D is a constructor or overloaded `operator='.
12483
12484    Let T be the class in which D is declared. Then, this function
12485    returns:
12486
12487    -1 if D's is an ill-formed constructor or copy assignment operator
12488       whose first parameter is of type `T'.
12489    0  if D is not a copy constructor or copy assignment
12490       operator.
12491    1  if D is a copy constructor or copy assignment operator whose
12492       first parameter is a reference to const qualified T.
12493    2  if D is a copy constructor or copy assignment operator whose
12494       first parameter is a reference to non-const qualified T.
12495
12496    This function can be used as a predicate. Positive values indicate
12497    a copy constructor and nonzero values indicate a copy assignment
12498    operator.  */
12499
12500 int
12501 copy_fn_p (d)
12502      tree d;
12503 {
12504   tree args;
12505   tree arg_type;
12506   int result = 1;
12507
12508   my_friendly_assert (DECL_FUNCTION_MEMBER_P (d), 20011208);
12509
12510   if (DECL_TEMPLATE_INFO (d) && is_member_template (DECL_TI_TEMPLATE (d)))
12511     /* Instantiations of template member functions are never copy
12512        functions.  Note that member functions of templated classes are
12513        represented as template functions internally, and we must
12514        accept those as copy functions.  */
12515     return 0;
12516
12517   args = FUNCTION_FIRST_USER_PARMTYPE (d);
12518   if (!args)
12519     return 0;
12520
12521   arg_type = TREE_VALUE (args);
12522
12523   if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
12524     {
12525       /* Pass by value copy assignment operator.  */
12526       result = -1;
12527     }
12528   else if (TREE_CODE (arg_type) == REFERENCE_TYPE
12529            && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
12530     {
12531       if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
12532         result = 2;
12533     }
12534   else
12535     return 0;
12536
12537   args = TREE_CHAIN (args);
12538
12539   if (args && args != void_list_node && !TREE_PURPOSE (args))
12540     /* There are more non-optional args.  */
12541     return 0;
12542
12543   return result;
12544 }
12545
12546 /* Remember any special properties of member function DECL.  */
12547
12548 void grok_special_member_properties (decl)
12549      tree decl;
12550 {
12551   if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl))
12552     ; /* Not special.  */
12553   else if (DECL_CONSTRUCTOR_P (decl))
12554     {
12555       int ctor = copy_fn_p (decl);
12556
12557       if (ctor > 0)
12558         {
12559           /* [class.copy]
12560
12561              A non-template constructor for class X is a copy
12562              constructor if its first parameter is of type X&, const
12563              X&, volatile X& or const volatile X&, and either there
12564              are no other parameters or else all other parameters have
12565              default arguments.  */
12566           TYPE_HAS_INIT_REF (DECL_CONTEXT (decl)) = 1;
12567           if (ctor > 1)
12568             TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl)) = 1;
12569         }
12570       else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
12571         TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl)) = 1;
12572     }
12573   else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
12574     {
12575       /* [class.copy]
12576
12577          A non-template assignment operator for class X is a copy
12578          assignment operator if its parameter is of type X, X&, const
12579          X&, volatile X& or const volatile X&.  */
12580
12581       int assop = copy_fn_p (decl);
12582
12583       if (assop)
12584         {
12585           TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12586           if (assop != 1)
12587             TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12588           if (DECL_PURE_VIRTUAL_P (decl))
12589             TYPE_HAS_ABSTRACT_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12590         }
12591     }
12592 }
12593
12594 /* Check a constructor DECL has the correct form.  Complains
12595    if the class has a constructor of the form X(X).  */
12596
12597 int
12598 grok_ctor_properties (ctype, decl)
12599      tree ctype, decl;
12600 {
12601   int ctor_parm = copy_fn_p (decl);
12602
12603   if (ctor_parm < 0)
12604     {
12605       /* [class.copy]
12606
12607          A declaration of a constructor for a class X is ill-formed if
12608          its first parameter is of type (optionally cv-qualified) X
12609          and either there are no other parameters or else all other
12610          parameters have default arguments.
12611
12612          We *don't* complain about member template instantiations that
12613          have this form, though; they can occur as we try to decide
12614          what constructor to use during overload resolution.  Since
12615          overload resolution will never prefer such a constructor to
12616          the non-template copy constructor (which is either explicitly
12617          or implicitly defined), there's no need to worry about their
12618          existence.  Theoretically, they should never even be
12619          instantiated, but that's hard to forestall.  */
12620       error ("invalid constructor; you probably meant `%T (const %T&)'",
12621                 ctype, ctype);
12622       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12623       return 0;
12624     }
12625
12626   return 1;
12627 }
12628
12629 /* An operator with this code is unary, but can also be binary.  */
12630
12631 static int
12632 ambi_op_p (code)
12633      enum tree_code code;
12634 {
12635   return (code == INDIRECT_REF
12636           || code == ADDR_EXPR
12637           || code == CONVERT_EXPR
12638           || code == NEGATE_EXPR
12639           || code == PREINCREMENT_EXPR
12640           || code == PREDECREMENT_EXPR);
12641 }
12642
12643 /* An operator with this name can only be unary.  */
12644
12645 static int
12646 unary_op_p (code)
12647      enum tree_code code;
12648 {
12649   return (code == TRUTH_NOT_EXPR
12650           || code == BIT_NOT_EXPR
12651           || code == COMPONENT_REF
12652           || code == TYPE_EXPR);
12653 }
12654
12655 /* Do a little sanity-checking on how they declared their operator.  */
12656
12657 void
12658 grok_op_properties (decl, friendp)
12659      tree decl;
12660      int friendp;
12661 {
12662   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12663   tree argtype;
12664   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12665   tree name = DECL_NAME (decl);
12666   enum tree_code operator_code;
12667   int arity;
12668
12669   /* Count the number of arguments.  */
12670   for (argtype = argtypes, arity = 0;
12671        argtype && argtype != void_list_node;
12672        argtype = TREE_CHAIN (argtype))
12673     ++arity;
12674
12675   if (current_class_type == NULL_TREE)
12676     friendp = 1;
12677
12678   if (DECL_CONV_FN_P (decl))
12679     operator_code = TYPE_EXPR;
12680   else
12681     do
12682       {
12683 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)       \
12684         if (ansi_opname (CODE) == name)                         \
12685           {                                                     \
12686             operator_code = (CODE);                             \
12687             break;                                              \
12688           }                                                     \
12689         else if (ansi_assopname (CODE) == name)                 \
12690           {                                                     \
12691             operator_code = (CODE);                             \
12692             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;              \
12693             break;                                              \
12694           }
12695
12696 #include "operators.def"
12697 #undef DEF_OPERATOR
12698
12699         abort ();
12700       }
12701     while (0);
12702   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12703   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12704
12705   if (! friendp)
12706     {
12707       switch (operator_code)
12708         {
12709         case CALL_EXPR:
12710           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12711           break;
12712
12713         case ARRAY_REF:
12714           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12715           break;
12716
12717         case COMPONENT_REF:
12718         case MEMBER_REF:
12719           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12720           break;
12721
12722         case NEW_EXPR:
12723           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12724           break;
12725
12726         case DELETE_EXPR:
12727           TYPE_GETS_DELETE (current_class_type) |= 1;
12728           break;
12729
12730         case VEC_NEW_EXPR:
12731           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12732           break;
12733
12734         case VEC_DELETE_EXPR:
12735           TYPE_GETS_DELETE (current_class_type) |= 2;
12736           break;
12737
12738         default:
12739           break;
12740         }
12741     }
12742
12743   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12744     {
12745       /* When the compiler encounters the definition of A::operator new, it
12746          doesn't look at the class declaration to find out if it's static.  */
12747       if (methodp)
12748         revert_static_member_fn (decl);
12749
12750       TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12751     }
12752   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12753     {
12754       if (methodp)
12755         revert_static_member_fn (decl);
12756
12757       TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12758     }
12759   else
12760     {
12761       /* An operator function must either be a non-static member function
12762          or have at least one parameter of a class, a reference to a class,
12763          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12764       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12765         {
12766           if (operator_code == TYPE_EXPR
12767               || operator_code == CALL_EXPR
12768               || operator_code == COMPONENT_REF
12769               || operator_code == ARRAY_REF
12770               || operator_code == NOP_EXPR)
12771             error ("`%D' must be a nonstatic member function", decl);
12772           else
12773             {
12774               tree p = argtypes;
12775
12776               if (DECL_STATIC_FUNCTION_P (decl))
12777                 error ("`%D' must be either a non-static member function or a non-member function", decl);
12778
12779               if (p)
12780                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12781                   {
12782                     tree arg = TREE_VALUE (p);
12783                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12784                       arg = TREE_TYPE (arg);
12785
12786                     /* This lets bad template code slip through.  */
12787                     if (IS_AGGR_TYPE (arg)
12788                         || TREE_CODE (arg) == ENUMERAL_TYPE
12789                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12790                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12791                       goto foundaggr;
12792                   }
12793               error
12794                 ("`%D' must have an argument of class or enumerated type",
12795                  decl);
12796             foundaggr:
12797               ;
12798             }
12799         }
12800
12801       if (operator_code == CALL_EXPR)
12802         return;                 /* No restrictions on args.  */
12803
12804       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12805         {
12806           tree t = TREE_TYPE (name);
12807           if (! friendp)
12808             {
12809               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12810               const char *what = 0;
12811
12812               if (ref)
12813                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12814
12815               if (TREE_CODE (t) == VOID_TYPE)
12816                 what = "void";
12817               else if (t == current_class_type)
12818                 what = "the same type";
12819               /* Don't force t to be complete here.  */
12820               else if (IS_AGGR_TYPE (t)
12821                        && COMPLETE_TYPE_P (t)
12822                        && DERIVED_FROM_P (t, current_class_type))
12823                 what = "a base class";
12824
12825               if (what)
12826                 warning ("conversion to %s%s will never use a type conversion operator",
12827                          ref ? "a reference to " : "", what);
12828             }
12829         }
12830       if (operator_code == COND_EXPR)
12831         {
12832           /* 13.4.0.3 */
12833           error ("ISO C++ prohibits overloading operator ?:");
12834         }
12835       else if (ambi_op_p (operator_code))
12836         {
12837           if (arity == 1)
12838             /* We pick the one-argument operator codes by default, so
12839                we don't have to change anything.  */
12840             ;
12841           else if (arity == 2)
12842             {
12843               /* If we thought this was a unary operator, we now know
12844                  it to be a binary operator.  */
12845               switch (operator_code)
12846                 {
12847                 case INDIRECT_REF:
12848                   operator_code = MULT_EXPR;
12849                   break;
12850
12851                 case ADDR_EXPR:
12852                   operator_code = BIT_AND_EXPR;
12853                   break;
12854
12855                 case CONVERT_EXPR:
12856                   operator_code = PLUS_EXPR;
12857                   break;
12858
12859                 case NEGATE_EXPR:
12860                   operator_code = MINUS_EXPR;
12861                   break;
12862
12863                 case PREINCREMENT_EXPR:
12864                   operator_code = POSTINCREMENT_EXPR;
12865                   break;
12866
12867                 case PREDECREMENT_EXPR:
12868                   operator_code = POSTDECREMENT_EXPR;
12869                   break;
12870
12871                 default:
12872                   abort ();
12873                 }
12874
12875               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12876
12877               if ((operator_code == POSTINCREMENT_EXPR
12878                    || operator_code == POSTDECREMENT_EXPR)
12879                   && ! processing_template_decl
12880                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12881                 {
12882                   if (methodp)
12883                     error ("postfix `%D' must take `int' as its argument",
12884                               decl);
12885                   else
12886                     error
12887                       ("postfix `%D' must take `int' as its second argument",
12888                        decl);
12889                 }
12890             }
12891           else
12892             {
12893               if (methodp)
12894                 error ("`%D' must take either zero or one argument", decl);
12895               else
12896                 error ("`%D' must take either one or two arguments", decl);
12897             }
12898
12899           /* More Effective C++ rule 6.  */
12900           if (warn_ecpp
12901               && (operator_code == POSTINCREMENT_EXPR
12902                   || operator_code == POSTDECREMENT_EXPR
12903                   || operator_code == PREINCREMENT_EXPR
12904                   || operator_code == PREDECREMENT_EXPR))
12905             {
12906               tree arg = TREE_VALUE (argtypes);
12907               tree ret = TREE_TYPE (TREE_TYPE (decl));
12908               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12909                 arg = TREE_TYPE (arg);
12910               arg = TYPE_MAIN_VARIANT (arg);
12911               if (operator_code == PREINCREMENT_EXPR
12912                   || operator_code == PREDECREMENT_EXPR)
12913                 {
12914                   if (TREE_CODE (ret) != REFERENCE_TYPE
12915                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12916                                        arg))
12917                     warning ("prefix `%D' should return `%T'", decl,
12918                                 build_reference_type (arg));
12919                 }
12920               else
12921                 {
12922                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12923                     warning ("postfix `%D' should return `%T'", decl, arg);
12924                 }
12925             }
12926         }
12927       else if (unary_op_p (operator_code))
12928         {
12929           if (arity != 1)
12930             {
12931               if (methodp)
12932                 error ("`%D' must take `void'", decl);
12933               else
12934                 error ("`%D' must take exactly one argument", decl);
12935             }
12936         }
12937       else /* if (binary_op_p (operator_code)) */
12938         {
12939           if (arity != 2)
12940             {
12941               if (methodp)
12942                 error ("`%D' must take exactly one argument", decl);
12943               else
12944                 error ("`%D' must take exactly two arguments", decl);
12945             }
12946
12947           /* More Effective C++ rule 7.  */
12948           if (warn_ecpp
12949               && (operator_code == TRUTH_ANDIF_EXPR
12950                   || operator_code == TRUTH_ORIF_EXPR
12951                   || operator_code == COMPOUND_EXPR))
12952             warning ("user-defined `%D' always evaluates both arguments",
12953                         decl);
12954         }
12955
12956       /* Effective C++ rule 23.  */
12957       if (warn_ecpp
12958           && arity == 2
12959           && !DECL_ASSIGNMENT_OPERATOR_P (decl)
12960           && (operator_code == PLUS_EXPR
12961               || operator_code == MINUS_EXPR
12962               || operator_code == TRUNC_DIV_EXPR
12963               || operator_code == MULT_EXPR
12964               || operator_code == TRUNC_MOD_EXPR)
12965           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12966         warning ("`%D' should return by value", decl);
12967
12968       /* [over.oper]/8 */
12969       for (; argtypes && argtypes != void_list_node;
12970           argtypes = TREE_CHAIN (argtypes))
12971         if (TREE_PURPOSE (argtypes))
12972           {
12973             TREE_PURPOSE (argtypes) = NULL_TREE;
12974             if (operator_code == POSTINCREMENT_EXPR
12975                 || operator_code == POSTDECREMENT_EXPR)
12976               {
12977                 if (pedantic)
12978                   pedwarn ("`%D' cannot have default arguments", decl);
12979               }
12980             else
12981               error ("`%D' cannot have default arguments", decl);
12982           }
12983
12984     }
12985 }
12986 \f
12987 static const char *
12988 tag_name (code)
12989      enum tag_types code;
12990 {
12991   switch (code)
12992     {
12993     case record_type:
12994       return "struct";
12995     case class_type:
12996       return "class";
12997     case union_type:
12998       return "union ";
12999     case enum_type:
13000       return "enum";
13001     default:
13002       abort ();
13003     }
13004 }
13005
13006 /* Get the struct, enum or union (CODE says which) with tag NAME.
13007    Define the tag as a forward-reference if it is not defined.
13008
13009    C++: If a class derivation is given, process it here, and report
13010    an error if multiple derivation declarations are not identical.
13011
13012    If this is a definition, come in through xref_tag and only look in
13013    the current frame for the name (since C++ allows new names in any
13014    scope.)  */
13015
13016 tree
13017 xref_tag (enum tag_types tag_code, tree name, tree attributes,
13018           bool globalize)
13019 {
13020   enum tree_code code;
13021   register tree ref, t;
13022   struct cp_binding_level *b = current_binding_level;
13023   tree context = NULL_TREE;
13024
13025   switch (tag_code)
13026     {
13027     case record_type:
13028     case class_type:
13029       code = RECORD_TYPE;
13030       break;
13031     case union_type:
13032       code = UNION_TYPE;
13033       break;
13034     case enum_type:
13035       code = ENUMERAL_TYPE;
13036       break;
13037     default:
13038       abort ();
13039     }
13040
13041   /* If a cross reference is requested, look up the type
13042      already defined for this tag and return it.  */
13043   if (TYPE_P (name))
13044     {
13045       t = name;
13046       name = TYPE_IDENTIFIER (t);
13047     }
13048   else
13049     t = IDENTIFIER_TYPE_VALUE (name);
13050
13051   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
13052   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
13053     {
13054       static int explained;
13055       tree shadowed;
13056
13057       warning ("`%s %T' declares a new type at namespace scope",
13058                   tag_name (tag_code), name);
13059       if (!explained++)
13060         warning ("  names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'",
13061                     tag_name (tag_code),
13062                     constructor_name (current_class_type),
13063                     TYPE_IDENTIFIER (t));
13064
13065       /* We need to remove the class scope binding for the
13066          TYPENAME_TYPE as otherwise poplevel_class gets confused.  */
13067       for (shadowed = b->class_shadowed;
13068            shadowed;
13069            shadowed = TREE_CHAIN (shadowed))
13070         if (TREE_TYPE (shadowed) == TYPE_NAME (t))
13071           {
13072             TREE_PURPOSE (shadowed) = NULL_TREE;
13073             break;
13074           }
13075     }
13076
13077   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
13078       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
13079     t = NULL_TREE;
13080
13081   if (! globalize)
13082     {
13083       /* If we know we are defining this tag, only look it up in
13084          this scope and don't try to find it as a type.  */
13085       ref = lookup_tag (code, name, b, 1);
13086     }
13087   else
13088     {
13089       if (t)
13090         {
13091           ref = follow_tag_typedef (t);
13092
13093           /* [dcl.type.elab] If the identifier resolves to a
13094              typedef-name or a template type-parameter, the
13095              elaborated-type-specifier is ill-formed.  */
13096           if (!ref)
13097             {
13098               pedwarn ("using typedef-name `%D' after `%s'",
13099                        TYPE_NAME (t), tag_name (tag_code));
13100               ref = t;
13101             }
13102           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
13103             error ("using template type parameter `%T' after `%s'",
13104                    t, tag_name (tag_code));
13105         }
13106       else
13107         ref = lookup_tag (code, name, b, 0);
13108
13109       if (! ref)
13110         {
13111           /* Try finding it as a type declaration.  If that wins,
13112              use it.  */
13113           ref = lookup_name (name, 1);
13114
13115           if (ref != NULL_TREE
13116               && processing_template_decl
13117               && DECL_CLASS_TEMPLATE_P (ref)
13118               && template_class_depth (current_class_type) == 0)
13119             /* Since GLOBALIZE is true, we're declaring a global
13120                template, so we want this type.  */
13121             ref = DECL_TEMPLATE_RESULT (ref);
13122
13123           if (ref && TREE_CODE (ref) == TYPE_DECL
13124               && TREE_CODE (TREE_TYPE (ref)) == code)
13125             ref = TREE_TYPE (ref);
13126           else
13127             ref = NULL_TREE;
13128         }
13129
13130       if (ref && current_class_type
13131           && template_class_depth (current_class_type)
13132           && PROCESSING_REAL_TEMPLATE_DECL_P ())
13133         {
13134           /* Since GLOBALIZE is nonzero, we are not looking at a
13135              definition of this tag.  Since, in addition, we are currently
13136              processing a (member) template declaration of a template
13137              class, we must be very careful; consider:
13138
13139                template <class X>
13140                struct S1
13141
13142                template <class U>
13143                struct S2
13144                { template <class V>
13145                friend struct S1; };
13146
13147              Here, the S2::S1 declaration should not be confused with the
13148              outer declaration.  In particular, the inner version should
13149              have a template parameter of level 2, not level 1.  This
13150              would be particularly important if the member declaration
13151              were instead:
13152
13153                template <class V = U> friend struct S1;
13154
13155              say, when we should tsubst into `U' when instantiating
13156              S2.  On the other hand, when presented with:
13157
13158                  template <class T>
13159                  struct S1 {
13160                    template <class U>
13161                    struct S2 {};
13162                    template <class U>
13163                    friend struct S2;
13164                  };
13165
13166               we must find the inner binding eventually.  We
13167               accomplish this by making sure that the new type we
13168               create to represent this declaration has the right
13169               TYPE_CONTEXT.  */
13170           context = TYPE_CONTEXT (ref);
13171           ref = NULL_TREE;
13172         }
13173     }
13174
13175   if (! ref)
13176     {
13177       /* If no such tag is yet defined, create a forward-reference node
13178          and record it as the "definition".
13179          When a real declaration of this type is found,
13180          the forward-reference will be altered into a real type.  */
13181       if (code == ENUMERAL_TYPE)
13182         {
13183           error ("use of enum `%#D' without previous declaration", name);
13184
13185           ref = make_node (ENUMERAL_TYPE);
13186
13187           /* Give the type a default layout like unsigned int
13188              to avoid crashing if it does not get defined.  */
13189           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
13190           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
13191           TYPE_USER_ALIGN (ref) = 0;
13192           TREE_UNSIGNED (ref) = 1;
13193           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
13194           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
13195           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
13196
13197           /* Enable us to recognize when a type is created in class context.
13198              To do nested classes correctly, this should probably be cleared
13199              out when we leave this classes scope.  Currently this in only
13200              done in `start_enum'.  */
13201
13202           pushtag (name, ref, globalize);
13203         }
13204       else
13205         {
13206           struct cp_binding_level *old_b = class_binding_level;
13207
13208           ref = make_aggr_type (code);
13209           TYPE_CONTEXT (ref) = context;
13210
13211 #ifdef NONNESTED_CLASSES
13212           /* Class types don't nest the way enums do.  */
13213           class_binding_level = (struct cp_binding_level *)0;
13214 #endif
13215           pushtag (name, ref, globalize);
13216           class_binding_level = old_b;
13217         }
13218     }
13219   else
13220     {
13221       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
13222         redeclare_class_template (ref, current_template_parms);
13223     }
13224
13225   TYPE_ATTRIBUTES (ref) = attributes;
13226
13227   return ref;
13228 }
13229
13230 tree
13231 xref_tag_from_type (old, id, globalize)
13232      tree old, id;
13233      int globalize;
13234 {
13235   enum tag_types tag_kind;
13236
13237   if (TREE_CODE (old) == RECORD_TYPE)
13238     tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
13239   else
13240     tag_kind  = union_type;
13241
13242   if (id == NULL_TREE)
13243     id = TYPE_IDENTIFIER (old);
13244
13245   return xref_tag (tag_kind, id, /*attributes=*/NULL_TREE, globalize);
13246 }
13247
13248 /* REF is a type (named NAME), for which we have just seen some
13249    baseclasses.  BINFO is a list of those baseclasses; the
13250    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
13251    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
13252    struct, or union.  */
13253
13254 void
13255 xref_basetypes (ref, binfo)
13256      tree ref;
13257      tree binfo;
13258 {
13259   /* In the declaration `A : X, Y, ... Z' we mark all the types
13260      (A, X, Y, ..., Z) so we can check for duplicates.  */
13261   tree binfos;
13262   tree base;
13263
13264   int i, len;
13265   enum tag_types tag_code;
13266
13267   if (TREE_CODE (ref) == UNION_TYPE)
13268     {
13269       error ("derived union `%T' invalid", ref);
13270       return;
13271     }
13272
13273   tag_code = (CLASSTYPE_DECLARED_CLASS (ref) ? class_type : record_type);
13274
13275   len = list_length (binfo);
13276
13277   /* First, make sure that any templates in base-classes are
13278      instantiated.  This ensures that if we call ourselves recursively
13279      we do not get confused about which classes are marked and which
13280      are not.  */
13281   for (base = binfo; base; base = TREE_CHAIN (base))
13282     complete_type (TREE_VALUE (base));
13283
13284   SET_CLASSTYPE_MARKED (ref);
13285   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
13286
13287   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
13288     {
13289       /* The base of a derived struct is public by default.  */
13290       int via_public
13291         = (TREE_PURPOSE (binfo) == access_public_node
13292            || TREE_PURPOSE (binfo) == access_public_virtual_node
13293            || (tag_code != class_type
13294                && (TREE_PURPOSE (binfo) == access_default_node
13295                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
13296       int via_protected
13297         = (TREE_PURPOSE (binfo) == access_protected_node
13298            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
13299       int via_virtual
13300         = (TREE_PURPOSE (binfo) == access_private_virtual_node
13301            || TREE_PURPOSE (binfo) == access_protected_virtual_node
13302            || TREE_PURPOSE (binfo) == access_public_virtual_node
13303            || TREE_PURPOSE (binfo) == access_default_virtual_node);
13304       tree basetype = TREE_VALUE (binfo);
13305       tree base_binfo;
13306
13307       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
13308         basetype = TREE_TYPE (basetype);
13309       if (!basetype
13310           || (TREE_CODE (basetype) != RECORD_TYPE
13311               && TREE_CODE (basetype) != TYPENAME_TYPE
13312               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
13313               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
13314         {
13315           error ("base type `%T' fails to be a struct or class type",
13316                     TREE_VALUE (binfo));
13317           continue;
13318         }
13319
13320       /* This code replaces similar code in layout_basetypes.
13321          We put the complete_type first for implicit `typename'.  */
13322       if (!COMPLETE_TYPE_P (basetype)
13323           && ! (current_template_parms && uses_template_parms (basetype)))
13324         {
13325           error ("base class `%T' has incomplete type", basetype);
13326           continue;
13327         }
13328       else
13329         {
13330           if (CLASSTYPE_MARKED (basetype))
13331             {
13332               if (basetype == ref)
13333                 error ("recursive type `%T' undefined", basetype);
13334               else
13335                 error ("duplicate base type `%T' invalid", basetype);
13336               continue;
13337             }
13338
13339           if (TYPE_FOR_JAVA (basetype)
13340               && (current_lang_depth () == 0))
13341             TYPE_FOR_JAVA (ref) = 1;
13342
13343           /* Note that the BINFO records which describe individual
13344              inheritances are *not* shared in the lattice!  They
13345              cannot be shared because a given baseclass may be
13346              inherited with different `accessibility' by different
13347              derived classes.  (Each BINFO record describing an
13348              individual inheritance contains flags which say what
13349              the `accessibility' of that particular inheritance is.)  */
13350
13351           base_binfo
13352             = make_binfo (size_zero_node, basetype,
13353                           CLASS_TYPE_P (basetype)
13354                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13355                           CLASS_TYPE_P (basetype)
13356                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13357
13358           TREE_VEC_ELT (binfos, i) = base_binfo;
13359           TREE_VIA_PUBLIC (base_binfo) = via_public;
13360           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13361           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13362           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13363
13364           /* We need to unshare the binfos now so that lookups during class
13365              definition work.  */
13366           unshare_base_binfos (base_binfo);
13367
13368           SET_CLASSTYPE_MARKED (basetype);
13369
13370           /* We are free to modify these bits because they are meaningless
13371              at top level, and BASETYPE is a top-level type.  */
13372           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13373             {
13374               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13375               /* Converting to a virtual base class requires looking
13376                  up the offset of the virtual base.  */
13377               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13378             }
13379
13380           if (CLASS_TYPE_P (basetype))
13381             {
13382               TYPE_HAS_NEW_OPERATOR (ref)
13383                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13384               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13385                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13386               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13387               /* If the base-class uses multiple inheritance, so do we.  */
13388               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13389                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13390               /* Likewise, if converting to a base of the base may require
13391                  code, then we may need to generate code to convert to a
13392                  base as well.  */
13393               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13394                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13395             }
13396
13397           i += 1;
13398         }
13399     }
13400   if (i)
13401     TREE_VEC_LENGTH (binfos) = i;
13402   else
13403     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13404
13405   if (i > 1)
13406     {
13407       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13408       /* If there is more than one non-empty they cannot be at the same
13409          address.  */
13410       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13411     }
13412
13413   /* Unmark all the types.  */
13414   while (--i >= 0)
13415     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13416   CLEAR_CLASSTYPE_MARKED (ref);
13417
13418   /* Now that we know all the base-classes, set up the list of virtual
13419      bases.  */
13420   get_vbase_types (ref);
13421 }
13422
13423 \f
13424 /* Begin compiling the definition of an enumeration type.
13425    NAME is its name (or null if anonymous).
13426    Returns the type object, as yet incomplete.
13427    Also records info about it so that build_enumerator
13428    may be used to declare the individual values as they are read.  */
13429
13430 tree
13431 start_enum (name)
13432      tree name;
13433 {
13434   register tree enumtype = NULL_TREE;
13435   struct cp_binding_level *b = current_binding_level;
13436
13437   /* If this is the real definition for a previous forward reference,
13438      fill in the contents in the same object that used to be the
13439      forward reference.  */
13440
13441   if (name != NULL_TREE)
13442     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13443
13444   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13445     {
13446       error ("multiple definition of `%#T'", enumtype);
13447       cp_error_at ("previous definition here", enumtype);
13448       /* Clear out TYPE_VALUES, and start again.  */
13449       TYPE_VALUES (enumtype) = NULL_TREE;
13450     }
13451   else
13452     {
13453       enumtype = make_node (ENUMERAL_TYPE);
13454       pushtag (name, enumtype, 0);
13455     }
13456
13457   return enumtype;
13458 }
13459
13460 /* After processing and defining all the values of an enumeration type,
13461    install their decls in the enumeration type and finish it off.
13462    ENUMTYPE is the type object and VALUES a list of name-value pairs.  */
13463
13464 void
13465 finish_enum (enumtype)
13466      tree enumtype;
13467 {
13468   tree pair;
13469   tree minnode;
13470   tree maxnode;
13471   tree t;
13472   bool unsignedp;
13473   int lowprec;
13474   int highprec;
13475   int precision;
13476
13477   /* We built up the VALUES in reverse order.  */
13478   TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
13479
13480   /* [dcl.enum]
13481
13482      Following the closing brace of an enum-specifier, each
13483      enumerator has the type of its enumeration.  Prior to the
13484      closing brace, the type of each enumerator is the type of
13485      its initializing value.  */
13486   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13487     TREE_TYPE (TREE_VALUE (pair)) = enumtype;
13488
13489   /* For an enum defined in a template, all further processing is
13490      postponed until the template is instantiated.  */
13491   if (processing_template_decl)
13492     {
13493       if (at_function_scope_p ())
13494         add_stmt (build_min (TAG_DEFN, enumtype));
13495       return;
13496     }
13497
13498   /* Figure out what the minimum and maximum values of the enumerators
13499      are.  */
13500   if (TYPE_VALUES (enumtype))
13501     {
13502       minnode = maxnode = NULL_TREE;
13503
13504       for (pair = TYPE_VALUES (enumtype);
13505            pair;
13506            pair = TREE_CHAIN (pair))
13507         {
13508           tree value;
13509
13510           value = DECL_INITIAL (TREE_VALUE (pair));
13511
13512           if (!minnode)
13513             minnode = maxnode = value;
13514           else if (tree_int_cst_lt (maxnode, value))
13515             maxnode = value;
13516           else if (tree_int_cst_lt (value, minnode))
13517             minnode = value;
13518         }
13519     }
13520   else
13521     minnode = maxnode = integer_zero_node;
13522
13523   /* Compute the number of bits require to represent all values of the
13524      enumeration.  We must do this before the type of MINNODE and
13525      MAXNODE are transformed, since min_precision relies on the
13526      TREE_TYPE of the value it is passed.  */
13527   unsignedp = tree_int_cst_sgn (minnode) >= 0;
13528   lowprec = min_precision (minnode, unsignedp);
13529   highprec = min_precision (maxnode, unsignedp);
13530   precision = MAX (lowprec, highprec);
13531
13532   /* Set the TREE_TYPE for the values as well.  That's so that when we
13533      call decl_constant_value we get an entity of the right type (but
13534      with the constant value).  In addition, transform the TYPE_VALUES
13535      list to contain the values, rather than the CONST_DECLs for them.  */
13536   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13537     {
13538       tree value = DECL_INITIAL (TREE_VALUE (pair));
13539
13540       TREE_TYPE (value) = enumtype;
13541       TREE_VALUE (pair) = value;
13542     }
13543
13544   /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13545   TYPE_SIZE (enumtype) = NULL_TREE;
13546   TYPE_PRECISION (enumtype) = precision;
13547   if (unsignedp)
13548     fixup_unsigned_type (enumtype);
13549   else
13550     fixup_signed_type (enumtype);
13551
13552   if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13553     /* Use the width of the narrowest normal C type which is wide
13554        enough.  */
13555     TYPE_PRECISION (enumtype) = TYPE_PRECISION (c_common_type_for_size
13556                                                 (precision, 1));
13557   else
13558     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13559
13560   TYPE_SIZE (enumtype) = NULL_TREE;
13561   layout_type (enumtype);
13562
13563   /* Fix up all variant types of this enum type.  */
13564   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13565     {
13566       TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13567       TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
13568       TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
13569       TYPE_SIZE (t) = TYPE_SIZE (enumtype);
13570       TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
13571       TYPE_MODE (t) = TYPE_MODE (enumtype);
13572       TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
13573       TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
13574       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
13575       TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype);
13576     }
13577
13578   /* Finish debugging output for this type.  */
13579   rest_of_type_compilation (enumtype, namespace_bindings_p ());
13580 }
13581
13582 /* Build and install a CONST_DECL for an enumeration constant of the
13583    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13584    Assignment of sequential values by default is handled here.  */
13585
13586 void
13587 build_enumerator (name, value, enumtype)
13588      tree name;
13589      tree value;
13590      tree enumtype;
13591 {
13592   tree decl;
13593   tree context;
13594   tree type;
13595   tree values;
13596
13597   /* Remove no-op casts from the value.  */
13598   if (value)
13599     STRIP_TYPE_NOPS (value);
13600
13601   if (! processing_template_decl)
13602     {
13603       /* Validate and default VALUE.  */
13604       if (value != NULL_TREE)
13605         {
13606           value = decl_constant_value (value);
13607
13608           if (TREE_CODE (value) == INTEGER_CST)
13609             {
13610               value = default_conversion (value);
13611               constant_expression_warning (value);
13612             }
13613           else
13614             {
13615               error ("enumerator value for `%D' not integer constant", name);
13616               value = NULL_TREE;
13617             }
13618         }
13619
13620       /* Default based on previous value.  */
13621       if (value == NULL_TREE && ! processing_template_decl)
13622         {
13623           tree prev_value;
13624
13625           if (TYPE_VALUES (enumtype))
13626             {
13627               /* The next value is the previous value ...  */
13628               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13629               /* ... plus one.  */
13630               value = cp_build_binary_op (PLUS_EXPR,
13631                                           prev_value,
13632                                           integer_one_node);
13633
13634               if (tree_int_cst_lt (value, prev_value))
13635                 error ("overflow in enumeration values at `%D'", name);
13636             }
13637           else
13638             value = integer_zero_node;
13639         }
13640
13641       /* Remove no-op casts from the value.  */
13642       if (value)
13643         STRIP_TYPE_NOPS (value);
13644 #if 0
13645       /* To fix MAX_VAL enum consts. (bkoz)  */
13646       TREE_TYPE (value) = integer_type_node;
13647 #endif
13648     }
13649
13650   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13651      Even in other cases, we will later (in finish_enum) be setting
13652      the type of VALUE.  But, we don't need to make a copy if this
13653      VALUE is one of the enumeration constants for this same
13654      enumeration type.  */
13655   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13656     if (TREE_VALUE (values) == value)
13657       break;
13658   /* If we didn't break out of the loop, then we do need a copy.  */
13659   if (!values && value)
13660     value = copy_node (value);
13661
13662   /* C++ associates enums with global, function, or class declarations.  */
13663   context = current_scope ();
13664
13665   /* Build the actual enumeration constant.  Note that the enumeration
13666     constants have the type of their initializers until the
13667     enumeration is complete:
13668
13669       [ dcl.enum ]
13670
13671       Following the closing brace of an enum-specifier, each enumer-
13672       ator has the type of its enumeration.  Prior to the closing
13673       brace, the type of each enumerator is the type of its
13674       initializing value.
13675
13676     In finish_enum we will reset the type.  Of course, if we're
13677     processing a template, there may be no value.  */
13678   type = value ? TREE_TYPE (value) : NULL_TREE;
13679
13680   if (context && context == current_class_type)
13681     /* This enum declaration is local to the class.  We need the full
13682        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13683     decl = build_lang_decl (CONST_DECL, name, type);
13684   else
13685     /* It's a global enum, or it's local to a function.  (Note local to
13686       a function could mean local to a class method.  */
13687     decl = build_decl (CONST_DECL, name, type);
13688
13689   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13690   DECL_INITIAL (decl) = value;
13691   TREE_READONLY (decl) = 1;
13692
13693   if (context && context == current_class_type)
13694     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13695       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13696       things like `S::i' later.)  */
13697     finish_member_declaration (decl);
13698   else
13699     pushdecl (decl);
13700
13701   /* Add this enumeration constant to the list for this type.  */
13702   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13703 }
13704
13705 \f
13706 /* We're defining DECL.  Make sure that it's type is OK.  */
13707
13708 static void
13709 check_function_type (decl, current_function_parms)
13710      tree decl;
13711      tree current_function_parms;
13712 {
13713   tree fntype = TREE_TYPE (decl);
13714   tree return_type = complete_type (TREE_TYPE (fntype));
13715
13716   /* In a function definition, arg types must be complete.  */
13717   require_complete_types_for_parms (current_function_parms);
13718
13719   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13720     {
13721       error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13722
13723       /* Make it return void instead, but don't change the
13724          type of the DECL_RESULT, in case we have a named return value.  */
13725       if (TREE_CODE (fntype) == METHOD_TYPE)
13726         {
13727           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13728           TREE_TYPE (decl)
13729             = build_cplus_method_type (ctype,
13730                                        void_type_node,
13731                                        FUNCTION_ARG_CHAIN (decl));
13732         }
13733       else
13734         TREE_TYPE (decl)
13735           = build_function_type (void_type_node,
13736                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13737       TREE_TYPE (decl)
13738         = build_exception_variant (fntype,
13739                                    TYPE_RAISES_EXCEPTIONS (fntype));
13740     }
13741   else
13742     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13743 }
13744
13745 /* Create the FUNCTION_DECL for a function definition.
13746    DECLSPECS and DECLARATOR are the parts of the declaration;
13747    they describe the function's name and the type it returns,
13748    but twisted together in a fashion that parallels the syntax of C.
13749
13750    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13751    DECLARATOR is really the DECL for the function we are about to
13752    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13753    indicating that the function is an inline defined in-class.
13754
13755    This function creates a binding context for the function body
13756    as well as setting up the FUNCTION_DECL in current_function_decl.
13757
13758    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13759    (it defines a datum instead), we return 0, which tells
13760    yyparse to report a parse error.
13761
13762    For C++, we must first check whether that datum makes any sense.
13763    For example, "class A local_a(1,2);" means that variable local_a
13764    is an aggregate of type A, which should have a constructor
13765    applied to it with the argument list [1, 2].  */
13766
13767 int
13768 start_function (declspecs, declarator, attrs, flags)
13769      tree declspecs, declarator, attrs;
13770      int flags;
13771 {
13772   tree decl1;
13773   tree ctype = NULL_TREE;
13774   tree fntype;
13775   tree restype;
13776   int doing_friend = 0;
13777   struct cp_binding_level *bl;
13778   tree current_function_parms;
13779
13780   /* Sanity check.  */
13781   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13782   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13783
13784   /* This should only be done once on the top most decl.  */
13785   if (have_extern_spec)
13786     {
13787       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13788       have_extern_spec = false;
13789     }
13790
13791   if (flags & SF_PRE_PARSED)
13792     {
13793       decl1 = declarator;
13794
13795       fntype = TREE_TYPE (decl1);
13796       if (TREE_CODE (fntype) == METHOD_TYPE)
13797         ctype = TYPE_METHOD_BASETYPE (fntype);
13798
13799       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13800          the (lexical) scope of the class in which it is defined.  */
13801       if (!ctype && DECL_FRIEND_P (decl1))
13802         {
13803           ctype = DECL_FRIEND_CONTEXT (decl1);
13804
13805           /* CTYPE could be null here if we're dealing with a template;
13806              for example, `inline friend float foo()' inside a template
13807              will have no CTYPE set.  */
13808           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13809             ctype = NULL_TREE;
13810           else
13811             doing_friend = 1;
13812         }
13813
13814       last_function_parms = DECL_ARGUMENTS (decl1);
13815     }
13816   else
13817     {
13818       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL);
13819       /* If the declarator is not suitable for a function definition,
13820          cause a syntax error.  */
13821       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
13822         return 0;
13823
13824       cplus_decl_attributes (&decl1, attrs, 0);
13825
13826       /* If #pragma weak was used, mark the decl weak now.  */
13827       if (current_binding_level == global_binding_level)
13828         maybe_apply_pragma_weak (decl1);
13829
13830       fntype = TREE_TYPE (decl1);
13831
13832       restype = TREE_TYPE (fntype);
13833       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13834         {
13835           error ("semicolon missing after declaration of `%#T'", restype);
13836           shadow_tag (build_tree_list (NULL_TREE, restype));
13837           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13838           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13839             fntype = build_function_type (integer_type_node,
13840                                           TYPE_ARG_TYPES (fntype));
13841           else
13842             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13843                                               integer_type_node,
13844                                               TYPE_ARG_TYPES (fntype));
13845           TREE_TYPE (decl1) = fntype;
13846         }
13847
13848       if (TREE_CODE (fntype) == METHOD_TYPE)
13849         ctype = TYPE_METHOD_BASETYPE (fntype);
13850       else if (DECL_MAIN_P (decl1))
13851         {
13852           /* If this doesn't return integer_type, complain.  */
13853           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13854             {
13855               if (pedantic || warn_return_type)
13856                 pedwarn ("return type for `main' changed to `int'");
13857               TREE_TYPE (decl1) = fntype = default_function_type;
13858             }
13859         }
13860     }
13861
13862   if (DECL_DECLARED_INLINE_P (decl1)
13863       && lookup_attribute ("noinline", attrs))
13864     warning_with_decl (decl1,
13865                        "inline function `%s' given attribute noinline");
13866
13867   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13868     /* This is a constructor, we must ensure that any default args
13869        introduced by this definition are propagated to the clones
13870        now. The clones are used directly in overload resolution.  */
13871     adjust_clone_args (decl1);
13872
13873   /* Sometimes we don't notice that a function is a static member, and
13874      build a METHOD_TYPE for it.  Fix that up now.  */
13875   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13876       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13877     {
13878       revert_static_member_fn (decl1);
13879       last_function_parms = TREE_CHAIN (last_function_parms);
13880       ctype = NULL_TREE;
13881     }
13882
13883   /* Warn if function was previously implicitly declared
13884      (but not if we warned then).  */
13885   if (! warn_implicit
13886       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13887     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13888
13889   /* Set up current_class_type, and enter the scope of the class, if
13890      appropriate.  */
13891   if (ctype)
13892     push_nested_class (ctype, 1);
13893   else if (DECL_STATIC_FUNCTION_P (decl1))
13894     push_nested_class (DECL_CONTEXT (decl1), 2);
13895
13896   /* Now that we have entered the scope of the class, we must restore
13897      the bindings for any template parameters surrounding DECL1, if it
13898      is an inline member template.  (Order is important; consider the
13899      case where a template parameter has the same name as a field of
13900      the class.)  It is not until after this point that
13901      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13902   if (flags & SF_INCLASS_INLINE)
13903     maybe_begin_member_template_processing (decl1);
13904
13905   /* Effective C++ rule 15.  */
13906   if (warn_ecpp
13907       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13908       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13909     warning ("`operator=' should return a reference to `*this'");
13910
13911   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13912      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13913   if (!DECL_INITIAL (decl1))
13914     DECL_INITIAL (decl1) = error_mark_node;
13915
13916   /* This function exists in static storage.
13917      (This does not mean `static' in the C sense!)  */
13918   TREE_STATIC (decl1) = 1;
13919
13920   /* We must call push_template_decl after current_class_type is set
13921      up.  (If we are processing inline definitions after exiting a
13922      class scope, current_class_type will be NULL_TREE until set above
13923      by push_nested_class.)  */
13924   if (processing_template_decl)
13925     decl1 = push_template_decl (decl1);
13926
13927   /* We are now in the scope of the function being defined.  */
13928   current_function_decl = decl1;
13929
13930   /* Save the parm names or decls from this function's declarator
13931      where store_parm_decls will find them.  */
13932   current_function_parms = last_function_parms;
13933
13934   /* Make sure the parameter and return types are reasonable.  When
13935      you declare a function, these types can be incomplete, but they
13936      must be complete when you define the function.  */
13937   if (! processing_template_decl)
13938     check_function_type (decl1, current_function_parms);
13939
13940   /* Build the return declaration for the function.  */
13941   restype = TREE_TYPE (fntype);
13942   /* Promote the value to int before returning it.  */
13943   if (c_promoting_integer_type_p (restype))
13944     restype = type_promotes_to (restype);
13945   if (DECL_RESULT (decl1) == NULL_TREE)
13946     {
13947       DECL_RESULT (decl1)
13948         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13949       c_apply_type_quals_to_decl (cp_type_quals (restype),
13950                                   DECL_RESULT (decl1));
13951     }
13952
13953   /* Initialize RTL machinery.  We cannot do this until
13954      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13955      even when processing a template; this is how we get
13956      CFUN set up, and our per-function variables initialized.
13957      FIXME factor out the non-RTL stuff.  */
13958   bl = current_binding_level;
13959   init_function_start (decl1, input_filename, lineno);
13960   current_binding_level = bl;
13961
13962   /* Even though we're inside a function body, we still don't want to
13963      call expand_expr to calculate the size of a variable-sized array.
13964      We haven't necessarily assigned RTL to all variables yet, so it's
13965      not safe to try to expand expressions involving them.  */
13966   immediate_size_expand = 0;
13967   cfun->x_dont_save_pending_sizes_p = 1;
13968
13969   /* Start the statement-tree, start the tree now.  */
13970   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13971
13972   /* Let the user know we're compiling this function.  */
13973   announce_function (decl1);
13974
13975   /* Record the decl so that the function name is defined.
13976      If we already have a decl for this name, and it is a FUNCTION_DECL,
13977      use the old decl.  */
13978   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13979     {
13980       /* A specialization is not used to guide overload resolution.  */
13981       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13982           && ! DECL_FUNCTION_MEMBER_P (decl1))
13983         decl1 = pushdecl (decl1);
13984       else
13985         {
13986           /* We need to set the DECL_CONTEXT.  */
13987           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13988             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13989           /* And make sure we have enough default args.  */
13990           check_default_args (decl1);
13991         }
13992       fntype = TREE_TYPE (decl1);
13993     }
13994
13995   /* Reset these in case the call to pushdecl changed them.  */
13996   current_function_decl = decl1;
13997   cfun->decl = decl1;
13998
13999   /* If we are (erroneously) defining a function that we have already
14000      defined before, wipe out what we knew before.  */
14001   if (!DECL_PENDING_INLINE_P (decl1))
14002     DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
14003
14004   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
14005     {
14006       /* We know that this was set up by `grokclassfn'.  We do not
14007          wait until `store_parm_decls', since evil parse errors may
14008          never get us to that point.  Here we keep the consistency
14009          between `current_class_type' and `current_class_ptr'.  */
14010       tree t = DECL_ARGUMENTS (decl1);
14011
14012       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
14013                           162);
14014       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
14015                           19990811);
14016
14017       cp_function_chain->x_current_class_ref
14018         = build_indirect_ref (t, NULL);
14019       cp_function_chain->x_current_class_ptr = t;
14020
14021       /* Constructors and destructors need to know whether they're "in
14022          charge" of initializing virtual base classes.  */
14023       t = TREE_CHAIN (t);
14024       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
14025         {
14026           current_in_charge_parm = t;
14027           t = TREE_CHAIN (t);
14028         }
14029       if (DECL_HAS_VTT_PARM_P (decl1))
14030         {
14031           if (DECL_NAME (t) != vtt_parm_identifier)
14032             abort ();
14033           current_vtt_parm = t;
14034         }
14035     }
14036
14037   if (DECL_INTERFACE_KNOWN (decl1))
14038     {
14039       tree ctx = decl_function_context (decl1);
14040
14041       if (DECL_NOT_REALLY_EXTERN (decl1))
14042         DECL_EXTERNAL (decl1) = 0;
14043
14044       if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
14045           && TREE_PUBLIC (ctx))
14046         /* This is a function in a local class in an extern inline
14047            function.  */
14048         comdat_linkage (decl1);
14049     }
14050   /* If this function belongs to an interface, it is public.
14051      If it belongs to someone else's interface, it is also external.
14052      This only affects inlines and template instantiations.  */
14053   else if (interface_unknown == 0
14054            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
14055                || flag_alt_external_templates))
14056     {
14057       if (DECL_DECLARED_INLINE_P (decl1)
14058           || DECL_TEMPLATE_INSTANTIATION (decl1)
14059           || processing_template_decl)
14060         {
14061           DECL_EXTERNAL (decl1)
14062             = (interface_only
14063                || (DECL_DECLARED_INLINE_P (decl1)
14064                    && ! flag_implement_inlines
14065                    && !DECL_VINDEX (decl1)));
14066
14067           /* For WIN32 we also want to put these in linkonce sections.  */
14068           maybe_make_one_only (decl1);
14069         }
14070       else
14071         DECL_EXTERNAL (decl1) = 0;
14072       DECL_NOT_REALLY_EXTERN (decl1) = 0;
14073       DECL_INTERFACE_KNOWN (decl1) = 1;
14074     }
14075   else if (interface_unknown && interface_only
14076            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
14077                || flag_alt_external_templates))
14078     {
14079       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
14080          interface, we will have interface_only set but not
14081          interface_known.  In that case, we don't want to use the normal
14082          heuristics because someone will supply a #pragma implementation
14083          elsewhere, and deducing it here would produce a conflict.  */
14084       comdat_linkage (decl1);
14085       DECL_EXTERNAL (decl1) = 0;
14086       DECL_INTERFACE_KNOWN (decl1) = 1;
14087       DECL_DEFER_OUTPUT (decl1) = 1;
14088     }
14089   else
14090     {
14091       /* This is a definition, not a reference.
14092          So clear DECL_EXTERNAL.  */
14093       DECL_EXTERNAL (decl1) = 0;
14094
14095       if ((DECL_DECLARED_INLINE_P (decl1)
14096            || DECL_TEMPLATE_INSTANTIATION (decl1))
14097           && ! DECL_INTERFACE_KNOWN (decl1)
14098           /* Don't try to defer nested functions for now.  */
14099           && ! decl_function_context (decl1))
14100         DECL_DEFER_OUTPUT (decl1) = 1;
14101       else
14102         DECL_INTERFACE_KNOWN (decl1) = 1;
14103     }
14104
14105   pushlevel (0);
14106   current_binding_level->parm_flag = 1;
14107
14108   ++function_depth;
14109
14110   if (DECL_DESTRUCTOR_P (decl1))
14111     {
14112       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14113       DECL_CONTEXT (dtor_label) = current_function_decl;
14114     }
14115
14116   start_fname_decls ();
14117
14118   store_parm_decls (current_function_parms);
14119
14120   return 1;
14121 }
14122 \f
14123 /* Store the parameter declarations into the current function declaration.
14124    This is called after parsing the parameter declarations, before
14125    digesting the body of the function.
14126
14127    Also install to binding contour return value identifier, if any.  */
14128
14129 static void
14130 store_parm_decls (current_function_parms)
14131      tree current_function_parms;
14132 {
14133   register tree fndecl = current_function_decl;
14134   register tree parm;
14135
14136   /* This is a chain of any other decls that came in among the parm
14137      declarations.  If a parm is declared with  enum {foo, bar} x;
14138      then CONST_DECLs for foo and bar are put here.  */
14139   tree nonparms = NULL_TREE;
14140
14141   if (current_function_parms)
14142     {
14143       /* This case is when the function was defined with an ANSI prototype.
14144          The parms already have decls, so we need not do anything here
14145          except record them as in effect
14146          and complain if any redundant old-style parm decls were written.  */
14147
14148       tree specparms = current_function_parms;
14149       tree next;
14150
14151       /* Must clear this because it might contain TYPE_DECLs declared
14152              at class level.  */
14153       storedecls (NULL_TREE);
14154
14155       /* If we're doing semantic analysis, then we'll call pushdecl
14156              for each of these.  We must do them in reverse order so that
14157              they end in the correct forward order.  */
14158       specparms = nreverse (specparms);
14159
14160       for (parm = specparms; parm; parm = next)
14161         {
14162           next = TREE_CHAIN (parm);
14163           if (TREE_CODE (parm) == PARM_DECL)
14164             {
14165               if (DECL_NAME (parm) == NULL_TREE
14166                   || TREE_CODE (parm) != VOID_TYPE)
14167                 pushdecl (parm);
14168               else
14169                 error ("parameter `%D' declared void", parm);
14170             }
14171           else
14172             {
14173               /* If we find an enum constant or a type tag,
14174                  put it aside for the moment.  */
14175               TREE_CHAIN (parm) = NULL_TREE;
14176               nonparms = chainon (nonparms, parm);
14177             }
14178         }
14179
14180       /* Get the decls in their original chain order and record in the
14181          function.  This is all and only the PARM_DECLs that were
14182          pushed into scope by the loop above.  */
14183       DECL_ARGUMENTS (fndecl) = getdecls ();
14184       storetags (gettags ());
14185     }
14186   else
14187     DECL_ARGUMENTS (fndecl) = NULL_TREE;
14188
14189   /* Now store the final chain of decls for the arguments
14190      as the decl-chain of the current lexical scope.
14191      Put the enumerators in as well, at the front so that
14192      DECL_ARGUMENTS is not modified.  */
14193   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
14194
14195   /* Do the starting of the exception specifications, if we have any.  */
14196   if (flag_exceptions && !processing_template_decl
14197       && flag_enforce_eh_specs
14198       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14199     current_eh_spec_block = begin_eh_spec_block ();
14200 }
14201
14202 \f
14203 /* We have finished doing semantic analysis on DECL, but have not yet
14204    generated RTL for its body.  Save away our current state, so that
14205    when we want to generate RTL later we know what to do.  */
14206
14207 static void
14208 save_function_data (decl)
14209      tree decl;
14210 {
14211   struct language_function *f;
14212
14213   /* Save the language-specific per-function data so that we can
14214      get it back when we really expand this function.  */
14215   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14216                       19990908);
14217
14218   /* Make a copy.  */
14219   f = ((struct language_function *)
14220        ggc_alloc (sizeof (struct language_function)));
14221   memcpy (f, cp_function_chain, sizeof (struct language_function));
14222   DECL_SAVED_FUNCTION_DATA (decl) = f;
14223
14224   /* Clear out the bits we don't need.  */
14225   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
14226   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
14227   f->x_named_label_uses = NULL;
14228   f->bindings = NULL;
14229   f->x_local_names = NULL;
14230
14231   /* When we get back here again, we will be expanding.  */
14232   f->x_expanding_p = 1;
14233
14234   /* If we've already decided that we cannot inline this function, we
14235      must remember that fact when we actually go to expand the
14236      function.  */
14237   if (current_function_cannot_inline)
14238     {
14239       f->cannot_inline = current_function_cannot_inline;
14240       DECL_INLINE (decl) = 0;
14241     }
14242 }
14243
14244 /* Add a note to mark the beginning of the main body of the constructor.
14245    This is used to set up the data structures for the cleanup regions for
14246    fully-constructed bases and members.  */
14247
14248 static void
14249 begin_constructor_body ()
14250 {
14251 }
14252
14253 /* Add a note to mark the end of the main body of the constructor.  This is
14254    used to end the cleanup regions for fully-constructed bases and
14255    members.  */
14256
14257 static void
14258 finish_constructor_body ()
14259 {
14260 }
14261
14262 /* Do all the processing for the beginning of a destructor; set up the
14263    vtable pointers and cleanups for bases and members.  */
14264
14265 static void
14266 begin_destructor_body ()
14267 {
14268   tree if_stmt;
14269   tree compound_stmt;
14270
14271   /* If the dtor is empty, and we know there is not any possible
14272      way we could use any vtable entries, before they are possibly
14273      set by a base class dtor, we don't have to setup the vtables,
14274      as we know that any base class dtor will set up any vtables
14275      it needs.  We avoid MI, because one base class dtor can do a
14276      virtual dispatch to an overridden function that would need to
14277      have a non-related vtable set up, we cannot avoid setting up
14278      vtables in that case.  We could change this to see if there
14279      is just one vtable.
14280
14281      ??? In the destructor for a class, the vtables are set
14282      appropriately for that class.  There will be no non-related
14283      vtables.  jason 2001-12-11.  */
14284   if_stmt = begin_if_stmt ();
14285
14286   /* If it is not safe to avoid setting up the vtables, then
14287      someone will change the condition to be boolean_true_node.
14288      (Actually, for now, we do not have code to set the condition
14289      appropriately, so we just assume that we always need to
14290      initialize the vtables.)  */
14291   finish_if_stmt_cond (boolean_true_node, if_stmt);
14292
14293   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14294
14295   /* Make all virtual function table pointers in non-virtual base
14296      classes point to CURRENT_CLASS_TYPE's virtual function
14297      tables.  */
14298   initialize_vtbl_ptrs (current_class_ptr);
14299
14300   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14301   finish_then_clause (if_stmt);
14302   finish_if_stmt ();
14303
14304   /* And insert cleanups for our bases and members so that they
14305      will be properly destroyed if we throw.  */
14306   push_base_cleanups ();
14307 }
14308
14309 /* At the end of every destructor we generate code to delete the object if
14310    necessary.  Do that now.  */
14311
14312 static void
14313 finish_destructor_body ()
14314 {
14315   tree exprstmt;
14316
14317   /* Any return from a destructor will end up here; that way all base
14318      and member cleanups will be run when the function returns.  */
14319   add_stmt (build_stmt (LABEL_STMT, dtor_label));
14320
14321   /* In a virtual destructor, we must call delete.  */
14322   if (DECL_VIRTUAL_P (current_function_decl))
14323     {
14324       tree if_stmt;
14325       tree virtual_size = cxx_sizeof (current_class_type);
14326
14327       /* [class.dtor]
14328
14329       At the point of definition of a virtual destructor (including
14330       an implicit definition), non-placement operator delete shall
14331       be looked up in the scope of the destructor's class and if
14332       found shall be accessible and unambiguous.  */
14333       exprstmt = build_op_delete_call
14334         (DELETE_EXPR, current_class_ptr, virtual_size,
14335          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14336
14337       if_stmt = begin_if_stmt ();
14338       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14339                                   current_in_charge_parm,
14340                                   integer_one_node),
14341                            if_stmt);
14342       finish_expr_stmt (exprstmt);
14343       finish_then_clause (if_stmt);
14344       finish_if_stmt ();
14345     }
14346 }
14347
14348 /* Do the necessary processing for the beginning of a function body, which
14349    in this case includes member-initializers, but not the catch clauses of
14350    a function-try-block.  Currently, this means opening a binding level
14351    for the member-initializers (in a ctor) and member cleanups (in a dtor).
14352    In other functions, this isn't necessary, but it doesn't hurt.  */
14353
14354 tree
14355 begin_function_body ()
14356 {
14357   tree stmt;
14358
14359   if (processing_template_decl)
14360     /* Do nothing now.  */;
14361   else
14362     /* Always keep the BLOCK node associated with the outermost pair of
14363        curly braces of a function.  These are needed for correct
14364        operation of dwarfout.c.  */
14365     keep_next_level (1);
14366
14367   stmt = begin_compound_stmt (0);
14368   COMPOUND_STMT_BODY_BLOCK (stmt) = 1;
14369
14370   if (processing_template_decl)
14371     /* Do nothing now.  */;
14372   else if (DECL_CONSTRUCTOR_P (current_function_decl))
14373     begin_constructor_body ();
14374   else if (DECL_DESTRUCTOR_P (current_function_decl))
14375     begin_destructor_body ();
14376
14377   return stmt;
14378 }
14379
14380 /* Do the processing for the end of a function body.  Currently, this means
14381    closing out the cleanups for fully-constructed bases and members, and in
14382    the case of the destructor, deleting the object if desired.  Again, this
14383    is only meaningful for [cd]tors, since they are the only functions where
14384    there is a significant distinction between the main body and any
14385    function catch clauses.  Handling, say, main() return semantics here
14386    would be wrong, as flowing off the end of a function catch clause for
14387    main() would also need to return 0.  */
14388
14389 void
14390 finish_function_body (compstmt)
14391      tree compstmt;
14392 {
14393   /* Close the block.  */
14394   finish_compound_stmt (0, compstmt);
14395
14396   if (processing_template_decl)
14397     /* Do nothing now.  */;
14398   else if (DECL_CONSTRUCTOR_P (current_function_decl))
14399     finish_constructor_body ();
14400   else if (DECL_DESTRUCTOR_P (current_function_decl))
14401     finish_destructor_body ();
14402 }
14403
14404 /* Finish up a function declaration and compile that function
14405    all the way to assembler language output.  The free the storage
14406    for the function definition.
14407
14408    FLAGS is a bitwise or of the following values:
14409      2 - INCLASS_INLINE
14410        We just finished processing the body of an in-class inline
14411        function definition.  (This processing will have taken place
14412        after the class definition is complete.)  */
14413
14414 tree
14415 finish_function (flags)
14416      int flags;
14417 {
14418   register tree fndecl = current_function_decl;
14419   tree fntype, ctype = NULL_TREE;
14420   int inclass_inline = (flags & 2) != 0;
14421   int nested;
14422
14423   /* When we get some parse errors, we can end up without a
14424      current_function_decl, so cope.  */
14425   if (fndecl == NULL_TREE)
14426     return error_mark_node;
14427
14428   nested = function_depth > 1;
14429   fntype = TREE_TYPE (fndecl);
14430
14431   /*  TREE_READONLY (fndecl) = 1;
14432       This caused &foo to be of type ptr-to-const-function
14433       which then got a warning when stored in a ptr-to-function variable.  */
14434
14435   my_friendly_assert (building_stmt_tree (), 20000911);
14436
14437   finish_fname_decls ();
14438
14439   /* For a cloned function, we've already got all the code we need;
14440      there's no need to add any extra bits.  */
14441   if (!DECL_CLONED_FUNCTION_P (fndecl))
14442     {
14443       if (DECL_MAIN_P (current_function_decl))
14444         {
14445           /* Make it so that `main' always returns 0 by default.  */
14446 #if VMS_TARGET
14447           finish_return_stmt (integer_one_node);
14448 #else
14449           finish_return_stmt (integer_zero_node);
14450 #endif
14451         }
14452
14453       /* Finish dealing with exception specifiers.  */
14454       if (flag_exceptions && !processing_template_decl
14455           && flag_enforce_eh_specs
14456           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14457         finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14458                               (TREE_TYPE (current_function_decl)),
14459                               current_eh_spec_block);
14460     }
14461
14462   /* If we're saving up tree structure, tie off the function now.  */
14463   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14464
14465   /* This must come after expand_function_end because cleanups might
14466      have declarations (from inline functions) that need to go into
14467      this function's blocks.  */
14468
14469   /* If the current binding level isn't the outermost binding level
14470      for this function, either there is a bug, or we have experienced
14471      syntax errors and the statement tree is malformed.  */
14472   if (current_binding_level->parm_flag != 1)
14473     {
14474       /* Make sure we have already experienced errors.  */
14475       if (errorcount == 0)
14476         abort ();
14477
14478       /* Throw away the broken statement tree and extra binding
14479          levels.  */
14480       DECL_SAVED_TREE (fndecl) = build_stmt (COMPOUND_STMT, NULL_TREE);
14481
14482       while (current_binding_level->parm_flag != 1)
14483         {
14484           if (current_binding_level->parm_flag == 2)
14485             pop_nested_class ();
14486           else
14487             poplevel (0, 0, 0);
14488         }
14489     }
14490   poplevel (1, 0, 1);
14491
14492   /* Set up the named return value optimization, if we can.  Here, we
14493      eliminate the copy from the nrv into the RESULT_DECL and any cleanup
14494      for the nrv.  genrtl_start_function and declare_return_variable
14495      handle making the nrv and RESULT_DECL share space.  */
14496   if (current_function_return_value)
14497     {
14498       tree r = current_function_return_value;
14499       /* This is only worth doing for fns that return in memory--and
14500          simpler, since we don't have to worry about promoted modes.  */
14501       if (r != error_mark_node
14502           && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl))))
14503         {
14504           DECL_ALIGN (r) = DECL_ALIGN (DECL_RESULT (fndecl));
14505           walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl),
14506                                         nullify_returns_r, r);
14507         }
14508       else
14509         /* Clear it so genrtl_start_function and declare_return_variable
14510            know we're not optimizing.  */
14511         current_function_return_value = NULL_TREE;
14512     }
14513
14514   /* Remember that we were in class scope.  */
14515   if (current_class_name)
14516     ctype = current_class_type;
14517
14518   /* Must mark the RESULT_DECL as being in this function.  */
14519   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14520
14521   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14522      to the FUNCTION_DECL node itself.  */
14523   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14524
14525   /* Save away current state, if appropriate.  */
14526   if (!processing_template_decl)
14527     save_function_data (fndecl);
14528
14529   /* If this function calls `setjmp' it cannot be inlined.  When
14530      `longjmp' is called it is not guaranteed to restore the value of
14531      local variables that have been modified since the call to
14532      `setjmp'.  So, if were to inline this function into some caller
14533      `c', then when we `longjmp', we might not restore all variables
14534      in `c'.  (It might seem, at first blush, that there's no way for
14535      this function to modify local variables in `c', but their
14536      addresses may have been stored somewhere accessible to this
14537      function.)  */
14538   if (!processing_template_decl && calls_setjmp_p (fndecl))
14539     DECL_UNINLINABLE (fndecl) = 1;
14540
14541   /* Complain if there's just no return statement.  */
14542   if (warn_return_type
14543       && !processing_template_decl
14544       && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
14545       && !current_function_returns_value && !current_function_returns_null
14546       /* Don't complain if we abort or throw.  */
14547       && !current_function_returns_abnormally
14548       && !DECL_NAME (DECL_RESULT (fndecl))
14549       /* Normally, with -Wreturn-type, flow will complain.  Unless we're an
14550          inline function, as we might never be compiled separately.  */
14551       && DECL_INLINE (fndecl))
14552     warning ("no return statement in function returning non-void");
14553
14554   /* Clear out memory we no longer need.  */
14555   free_after_parsing (cfun);
14556   /* Since we never call rest_of_compilation, we never clear
14557      CFUN.  Do so explicitly.  */
14558   free_after_compilation (cfun);
14559   cfun = NULL;
14560
14561   /* If this is an in-class inline definition, we may have to pop the
14562      bindings for the template parameters that we added in
14563      maybe_begin_member_template_processing when start_function was
14564      called.  */
14565   if (inclass_inline)
14566     maybe_end_member_template_processing ();
14567
14568   /* Leave the scope of the class.  */
14569   if (ctype)
14570     pop_nested_class ();
14571
14572   --function_depth;
14573
14574   /* Clean up.  */
14575   if (! nested)
14576     /* Let the error reporting routines know that we're outside a
14577        function.  For a nested function, this value is used in
14578        cxx_pop_function_context and then reset via pop_function_context.  */
14579     current_function_decl = NULL_TREE;
14580
14581   return fndecl;
14582 }
14583 \f
14584 /* Create the FUNCTION_DECL for a function definition.
14585    DECLSPECS and DECLARATOR are the parts of the declaration;
14586    they describe the return type and the name of the function,
14587    but twisted together in a fashion that parallels the syntax of C.
14588
14589    This function creates a binding context for the function body
14590    as well as setting up the FUNCTION_DECL in current_function_decl.
14591
14592    Returns a FUNCTION_DECL on success.
14593
14594    If the DECLARATOR is not suitable for a function (it defines a datum
14595    instead), we return 0, which tells yyparse to report a parse error.
14596
14597    May return void_type_node indicating that this method is actually
14598    a friend.  See grokfield for more details.
14599
14600    Came here with a `.pushlevel' .
14601
14602    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14603    CHANGES TO CODE IN `grokfield'.  */
14604
14605 tree
14606 start_method (declspecs, declarator, attrlist)
14607      tree declarator, declspecs, attrlist;
14608 {
14609   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14610                                 &attrlist);
14611
14612   /* Something too ugly to handle.  */
14613   if (fndecl == NULL_TREE)
14614     return NULL_TREE;
14615
14616   if (attrlist)
14617     cplus_decl_attributes (&fndecl, attrlist, 0);
14618
14619   /* Pass friends other than inline friend functions back.  */
14620   if (fndecl == void_type_node)
14621     return fndecl;
14622
14623   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14624     /* Not a function, tell parser to report parse error.  */
14625     return NULL_TREE;
14626
14627   if (DECL_IN_AGGR_P (fndecl))
14628     {
14629       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14630         {
14631           if (DECL_CONTEXT (fndecl)
14632               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14633             error ("`%D' is already defined in class `%T'", fndecl,
14634                       DECL_CONTEXT (fndecl));
14635         }
14636       return void_type_node;
14637     }
14638
14639   check_template_shadow (fndecl);
14640
14641   DECL_DECLARED_INLINE_P (fndecl) = 1;
14642
14643   if (flag_default_inline)
14644     DECL_INLINE (fndecl) = 1;
14645
14646   /* We process method specializations in finish_struct_1.  */
14647   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14648     fndecl = push_template_decl (fndecl);
14649
14650   if (! DECL_FRIEND_P (fndecl))
14651     {
14652       if (TREE_CHAIN (fndecl))
14653         {
14654           fndecl = copy_node (fndecl);
14655           TREE_CHAIN (fndecl) = NULL_TREE;
14656         }
14657       grok_special_member_properties (fndecl);
14658     }
14659
14660   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14661
14662   /* Make a place for the parms */
14663   pushlevel (0);
14664   current_binding_level->parm_flag = 1;
14665
14666   DECL_IN_AGGR_P (fndecl) = 1;
14667   return fndecl;
14668 }
14669
14670 /* Go through the motions of finishing a function definition.
14671    We don't compile this method until after the whole class has
14672    been processed.
14673
14674    FINISH_METHOD must return something that looks as though it
14675    came from GROKFIELD (since we are defining a method, after all).
14676
14677    This is called after parsing the body of the function definition.
14678    STMTS is the chain of statements that makes up the function body.
14679
14680    DECL is the ..._DECL that `start_method' provided.  */
14681
14682 tree
14683 finish_method (decl)
14684      tree decl;
14685 {
14686   register tree fndecl = decl;
14687   tree old_initial;
14688
14689   register tree link;
14690
14691   if (decl == void_type_node)
14692     return decl;
14693
14694   old_initial = DECL_INITIAL (fndecl);
14695
14696   /* Undo the level for the parms (from start_method).
14697      This is like poplevel, but it causes nothing to be
14698      saved.  Saving information here confuses symbol-table
14699      output routines.  Besides, this information will
14700      be correctly output when this method is actually
14701      compiled.  */
14702
14703   /* Clear out the meanings of the local variables of this level;
14704      also record in each decl which block it belongs to.  */
14705
14706   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14707     {
14708       if (DECL_NAME (link) != NULL_TREE)
14709         pop_binding (DECL_NAME (link), link);
14710       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14711       DECL_CONTEXT (link) = NULL_TREE;
14712     }
14713
14714   poplevel (0, 0, 0);
14715
14716   DECL_INITIAL (fndecl) = old_initial;
14717
14718   /* We used to check if the context of FNDECL was different from
14719      current_class_type as another way to get inside here.  This didn't work
14720      for String.cc in libg++.  */
14721   if (DECL_FRIEND_P (fndecl))
14722     {
14723       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14724         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14725       decl = void_type_node;
14726     }
14727
14728   return decl;
14729 }
14730 \f
14731
14732 /* VAR is a VAR_DECL.  If its type is incomplete, remember VAR so that
14733    we can lay it out later, when and if its type becomes complete.  */
14734
14735 void
14736 maybe_register_incomplete_var (var)
14737      tree var;
14738 {
14739   my_friendly_assert (TREE_CODE (var) == VAR_DECL, 20020406);
14740
14741   /* Keep track of variables with incomplete types.  */
14742   if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
14743       && DECL_EXTERNAL (var))
14744     {
14745       tree inner_type = TREE_TYPE (var);
14746
14747       while (TREE_CODE (inner_type) == ARRAY_TYPE)
14748         inner_type = TREE_TYPE (inner_type);
14749       inner_type = TYPE_MAIN_VARIANT (inner_type);
14750
14751       if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
14752           /* RTTI TD entries are created while defining the type_info.  */
14753           || (TYPE_LANG_SPECIFIC (inner_type)
14754               && TYPE_BEING_DEFINED (inner_type)))
14755         incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
14756     }
14757 }
14758
14759 /* Called when a class type (given by TYPE) is defined.  If there are
14760    any existing VAR_DECLs whose type hsa been completed by this
14761    declaration, update them now.  */
14762
14763 void
14764 complete_vars (type)
14765      tree type;
14766 {
14767   tree *list = &incomplete_vars;
14768
14769   my_friendly_assert (CLASS_TYPE_P (type), 20020406);
14770   while (*list)
14771     {
14772       if (same_type_p (type, TREE_PURPOSE (*list)))
14773         {
14774           tree var = TREE_VALUE (*list);
14775           /* Complete the type of the variable.  The VAR_DECL itself
14776              will be laid out in expand_expr.  */
14777           complete_type (TREE_TYPE (var));
14778           /* Remove this entry from the list.  */
14779           *list = TREE_CHAIN (*list);
14780         }
14781       else
14782         list = &TREE_CHAIN (*list);
14783     }
14784 }
14785
14786 /* If DECL is of a type which needs a cleanup, build that cleanup
14787    here.  */
14788
14789 tree
14790 cxx_maybe_build_cleanup (decl)
14791      tree decl;
14792 {
14793   tree type = TREE_TYPE (decl);
14794
14795   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14796     {
14797       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14798       tree rval;
14799
14800       if (TREE_CODE (type) == ARRAY_TYPE)
14801         rval = decl;
14802       else
14803         {
14804           cxx_mark_addressable (decl);
14805           rval = build_unary_op (ADDR_EXPR, decl, 0);
14806         }
14807
14808       /* Optimize for space over speed here.  */
14809       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14810           || flag_expensive_optimizations)
14811         flags |= LOOKUP_NONVIRTUAL;
14812
14813       rval = build_delete (TREE_TYPE (rval), rval,
14814                            sfk_complete_destructor, flags, 0);
14815
14816       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14817           && ! TYPE_HAS_DESTRUCTOR (type))
14818         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14819                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14820
14821       return rval;
14822     }
14823   return NULL_TREE;
14824 }
14825 \f
14826 /* When a stmt has been parsed, this function is called.  */
14827
14828 void
14829 finish_stmt ()
14830 {
14831   /* Always assume this statement was not an expression statement.  If
14832      it actually was an expression statement, its our callers
14833      responsibility to fix this up.  */
14834   last_expr_type = NULL_TREE;
14835 }
14836
14837 /* DECL was originally constructed as a non-static member function,
14838    but turned out to be static.  Update it accordingly.  */
14839
14840 void
14841 revert_static_member_fn (decl)
14842      tree decl;
14843 {
14844   tree tmp;
14845   tree function = TREE_TYPE (decl);
14846   tree args = TYPE_ARG_TYPES (function);
14847
14848   if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
14849       != TYPE_UNQUALIFIED)
14850     error ("static member function `%#D' declared with type qualifiers",
14851               decl);
14852
14853   args = TREE_CHAIN (args);
14854   tmp = build_function_type (TREE_TYPE (function), args);
14855   tmp = build_qualified_type (tmp, cp_type_quals (function));
14856   tmp = build_exception_variant (tmp,
14857                                  TYPE_RAISES_EXCEPTIONS (function));
14858   TREE_TYPE (decl) = tmp;
14859   if (DECL_ARGUMENTS (decl))
14860     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14861   DECL_STATIC_FUNCTION_P (decl) = 1;
14862 }
14863
14864 /* Initialize the variables used during compilation of a C++
14865    function.  */
14866
14867 void
14868 cxx_push_function_context (f)
14869      struct function *f;
14870 {
14871   struct language_function *p
14872     = ((struct language_function *)
14873        ggc_alloc_cleared (sizeof (struct language_function)));
14874   f->language = p;
14875
14876   /* It takes an explicit call to expand_body to generate RTL for a
14877      function.  */
14878   expanding_p = 0;
14879
14880   /* Whenever we start a new function, we destroy temporaries in the
14881      usual way.  */
14882   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14883 }
14884
14885 /* Free the language-specific parts of F, now that we've finished
14886    compiling the function.  */
14887
14888 void
14889 cxx_pop_function_context (f)
14890      struct function *f;
14891 {
14892   f->language = 0;
14893 }
14894
14895 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
14896    one of the language-independent trees.  */
14897
14898 enum cp_tree_node_structure_enum
14899 cp_tree_node_structure (t)
14900      union lang_tree_node *t;
14901 {
14902   switch (TREE_CODE (&t->generic))
14903     {
14904     case DEFAULT_ARG:           return TS_CP_IDENTIFIER;
14905     case IDENTIFIER_NODE:       return TS_CP_IDENTIFIER;
14906     case CPLUS_BINDING:         return TS_CP_BINDING;
14907     case OVERLOAD:              return TS_CP_OVERLOAD;
14908     case TEMPLATE_PARM_INDEX:   return TS_CP_TPI;
14909     case PTRMEM_CST:            return TS_CP_PTRMEM;
14910     case WRAPPER:               return TS_CP_WRAPPER;
14911     case SRCLOC:                return TS_CP_SRCLOC;
14912     default:                    return TS_CP_GENERIC;
14913     }
14914 }
14915
14916 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14917    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
14918
14919 tree
14920 identifier_global_value (t)
14921      tree t;
14922 {
14923   return IDENTIFIER_GLOBAL_VALUE (t);
14924 }
14925
14926 /* Build the void_list_node (void_type_node having been created).  */
14927 tree
14928 build_void_list_node ()
14929 {
14930   tree t = build_tree_list (NULL_TREE, void_type_node);
14931   TREE_PARMLIST (t) = 1;
14932   return t;
14933 }
14934
14935 static int
14936 cp_missing_noreturn_ok_p (decl)
14937      tree decl;
14938 {
14939   /* A missing noreturn is ok for the `main' function.  */
14940   return DECL_MAIN_P (decl);
14941 }
14942
14943 #include "gt-cp-decl.h"
14944 #include "gtype-cp.h"