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 GCC.
   7
   8 GCC 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 GCC 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 GCC; 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 void push_local_name PARAMS ((tree));
  73 static void warn_extern_redeclared_static PARAMS ((tree, tree));
  74 static tree grok_reference_init PARAMS ((tree, tree, tree));
  75 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
  76                               enum overload_flags, tree,
  77                               tree, int, int, int, int, int, int, tree));
  78 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
  79 static tree follow_tag_typedef PARAMS ((tree));
  80 static tree lookup_tag PARAMS ((enum tree_code, tree,
  81                               struct cp_binding_level *, int));
  82 static void set_identifier_type_value_with_scope
  83         PARAMS ((tree, tree, struct cp_binding_level *));
  84 static void record_unknown_type PARAMS ((tree, const char *));
  85 static tree builtin_function_1 PARAMS ((const char *, tree, tree, int,
  86                                       enum built_in_class, const char *,
  87                                       tree));
  88 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
  89 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
  90 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
  91                                   int));
  92 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct cp_binding_level*));
  93 static void check_for_uninitialized_const_var PARAMS ((tree));
  94 static hashval_t typename_hash PARAMS ((const void *));
  95 static int typename_compare PARAMS ((const void *, const void *));
  96 static void push_binding PARAMS ((tree, tree, struct cp_binding_level*));
  97 static int add_binding PARAMS ((tree, tree));
  98 static void pop_binding PARAMS ((tree, tree));
  99 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 100 static tree find_binding PARAMS ((tree, tree));
 101 static tree select_decl PARAMS ((tree, int));
 102 static int lookup_flags PARAMS ((int, int));
 103 static tree qualify_lookup PARAMS ((tree, int));
 104 static tree record_builtin_java_type PARAMS ((const char *, int));
 105 static const char *tag_name PARAMS ((enum tag_types code));
 106 static void find_class_binding_level PARAMS ((void));
 107 static struct cp_binding_level *innermost_nonclass_level PARAMS ((void));
 108 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 109 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 110 static int walk_globals_r PARAMS ((tree, void *));
 111 static int walk_vtables_r PARAMS ((tree, void*));
 112 static void add_decl_to_level PARAMS ((tree, struct cp_binding_level *));
 113 static tree make_label_decl PARAMS ((tree, int));
 114 static void use_label PARAMS ((tree));
 115 static void check_previous_goto_1 PARAMS ((tree, struct cp_binding_level *, tree,
 116                                            const char *, int));
 117 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 118 static void check_switch_goto PARAMS ((struct cp_binding_level *));
 119 static void check_previous_gotos PARAMS ((tree));
 120 static void pop_label PARAMS ((tree, tree));
 121 static void pop_labels PARAMS ((tree));
 122 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 123 static void layout_var_decl PARAMS ((tree));
 124 static void maybe_commonize_var PARAMS ((tree));
 125 static tree check_initializer (tree, tree, int);
 126 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 127 static void save_function_data PARAMS ((tree));
 128 static void check_function_type PARAMS ((tree, tree));
 129 static void begin_constructor_body PARAMS ((void));
 130 static void finish_constructor_body PARAMS ((void));
 131 static void begin_destructor_body PARAMS ((void));
 132 static void finish_destructor_body PARAMS ((void));
 133 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 134 static tree get_atexit_node PARAMS ((void));
 135 static tree get_dso_handle_node PARAMS ((void));
 136 static tree start_cleanup_fn PARAMS ((void));
 137 static void end_cleanup_fn PARAMS ((void));
 138 static tree cp_make_fname_decl PARAMS ((tree, int));
 139 static void initialize_predefined_identifiers PARAMS ((void));
 140 static tree check_special_function_return_type
 141   PARAMS ((special_function_kind, tree, tree));
 142 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 143 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 144 static void store_parm_decls PARAMS ((tree));
 145 static int cp_missing_noreturn_ok_p PARAMS ((tree));
 146 static void initialize_local_var (tree, tree);
 147 static void expand_static_init (tree, tree);
 148 static tree next_initializable_field (tree);
 149 static tree reshape_init (tree, tree *);
 150
 151 #if defined (DEBUG_BINDING_LEVELS)
 152 static void indent PARAMS ((void));
 153 #endif
 154
 155 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 156 tree error_mark_list;
 157
 158 /* The following symbols are subsumed in the cp_global_trees array, and
 159    listed here individually for documentation purposes.
 160
 161    C++ extensions
 162         tree wchar_decl_node;
 163
 164         tree vtable_entry_type;
 165         tree delta_type_node;
 166         tree __t_desc_type_node;
 167         tree ti_desc_type_node;
 168         tree bltn_desc_type_node, ptr_desc_type_node;
 169         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 170         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 171         tree ptm_desc_type_node;
 172         tree base_desc_type_node;
 173
 174         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 175         tree unknown_type_node;
 176
 177    Array type `vtable_entry_type[]'
 178
 179         tree vtbl_type_node;
 180         tree vtbl_ptr_type_node;
 181
 182    Namespaces,
 183
 184         tree std_node;
 185         tree abi_node;
 186
 187    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 188    one that the user will declare, but sufficient to be called
 189    by routines that want to abort the program.
 190
 191         tree abort_fndecl;
 192
 193    The FUNCTION_DECL for the default `::operator delete'.
 194
 195         tree global_delete_fndecl;
 196
 197    Used by RTTI
 198         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 199         tree tinfo_var_id;
 200
 201 */
 202
 203 tree cp_global_trees[CPTI_MAX];
 204
 205 /* Indicates that there is a type value in some namespace, although
 206    that is not necessarily in scope at the moment.  */
 207
 208 static GTY(()) tree global_type_node;
 209
 210 /* Expect only namespace names now.  */
 211 static int only_namespace_names;
 212
 213 /* Used only for jumps to as-yet undefined labels, since jumps to
 214    defined labels can have their validity checked immediately.  */
 215
 216 struct named_label_use_list GTY(())
 217 {
 218   struct cp_binding_level *binding_level;
 219   tree names_in_scope;
 220   tree label_decl;
 221   const char *filename_o_goto;
 222   int lineno_o_goto;
 223   struct named_label_use_list *next;
 224 };
 225
 226 #define named_label_uses cp_function_chain->x_named_label_uses
 227
 228 #define local_names cp_function_chain->x_local_names
 229
 230 /* A list of objects which have constructors or destructors
 231    which reside in the global scope.  The decl is stored in
 232    the TREE_VALUE slot and the initializer is stored
 233    in the TREE_PURPOSE slot.  */
 234 tree static_aggregates;
 235
 236 /* -- end of C++ */
 237
 238 /* A node for the integer constants 2, and 3.  */
 239
 240 tree integer_two_node, integer_three_node;
 241
 242 /* Similar, for last_function_parm_tags.  */
 243 tree last_function_parms;
 244
 245 /* A list of all LABEL_DECLs in the function that have names.  Here so
 246    we can clear out their names' definitions at the end of the
 247    function, and so we can check the validity of jumps to these labels.  */
 248
 249 struct named_label_list GTY(())
 250 {
 251   struct cp_binding_level *binding_level;
 252   tree names_in_scope;
 253   tree old_value;
 254   tree label_decl;
 255   tree bad_decls;
 256   struct named_label_list *next;
 257   unsigned int in_try_scope : 1;
 258   unsigned int in_catch_scope : 1;
 259 };
 260
 261 #define named_labels cp_function_chain->x_named_labels
 262 \f
 263 /* The name of the anonymous namespace, throughout this translation
 264    unit.  */
 265 tree anonymous_namespace_name;
 266
 267 /* The number of function bodies which we are currently processing.
 268    (Zero if we are at namespace scope, one inside the body of a
 269    function, two inside the body of a function in a local class, etc.)  */
 270 int function_depth;
 271
 272 /* States indicating how grokdeclarator() should handle declspecs marked
 273    with __attribute__((deprecated)).  An object declared as
 274    __attribute__((deprecated)) suppresses warnings of uses of other
 275    deprecated items.  */
 276
 277 enum deprecated_states {
 278   DEPRECATED_NORMAL,
 279   DEPRECATED_SUPPRESS
 280 };
 281
 282 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
 283
 284 /* Set by add_implicitly_declared_members() to keep those members from
 285    being flagged as deprecated or reported as using deprecated
 286    types.  */
 287 int adding_implicit_members = 0;
 288
 289 /* True if a declaration with an `extern' linkage specifier is being
 290    processed.  */
 291 bool have_extern_spec;
 292
 293 \f
 294 /* For each binding contour we allocate a binding_level structure
 295    which records the names defined in that contour.
 296    Contours include:
 297     0) the global one
 298     1) one for each function definition,
 299        where internal declarations of the parameters appear.
 300     2) one for each compound statement,
 301        to record its declarations.
 302
 303    The current meaning of a name can be found by searching the levels
 304    from the current one out to the global one.
 305
 306    Off to the side, may be the class_binding_level.  This exists only
 307    to catch class-local declarations.  It is otherwise nonexistent.
 308
 309    Also there may be binding levels that catch cleanups that must be
 310    run when exceptions occur.  Thus, to see whether a name is bound in
 311    the current scope, it is not enough to look in the
 312    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 313    instead.  */
 314
 315 /* Note that the information in the `names' component of the global contour
 316    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 317
 318 struct cp_binding_level GTY(())
 319   {
 320     /* A chain of _DECL nodes for all variables, constants, functions,
 321        and typedef types.  These are in the reverse of the order
 322        supplied.  There may be OVERLOADs on this list, too, but they
 323        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 324     tree names;
 325
 326     /* Count of elements in names chain.  */
 327     size_t names_size;
 328
 329     /* A chain of NAMESPACE_DECL nodes.  */
 330     tree namespaces;
 331
 332     /* A chain of VTABLE_DECL nodes.  */
 333     tree vtables;
 334
 335     /* A list of structure, union and enum definitions, for looking up
 336        tag names.
 337        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 338        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 339        or ENUMERAL_TYPE node.
 340
 341        C++: the TREE_VALUE nodes can be simple types for
 342        component_bindings.  */
 343     tree tags;
 344
 345     /* A list of USING_DECL nodes.  */
 346     tree usings;
 347
 348     /* A list of used namespaces. PURPOSE is the namespace,
 349        VALUE the common ancestor with this binding_level's namespace.  */
 350     tree using_directives;
 351
 352     /* If this binding level is the binding level for a class, then
 353        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 354        is the name of an entity bound in the class.  The TREE_TYPE is
 355        the DECL bound by this name in the class.  */
 356     tree class_shadowed;
 357
 358     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 359        is used for all binding levels. In addition the TREE_VALUE is the
 360        IDENTIFIER_TYPE_VALUE before we entered the class.  */
 361     tree type_shadowed;
 362
 363     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 364        label in this scope.  The TREE_PURPOSE is the previous value of
 365        the IDENTIFIER_LABEL VALUE.  */
 366     tree shadowed_labels;
 367
 368     /* For each level (except not the global one),
 369        a chain of BLOCK nodes for all the levels
 370        that were entered and exited one level down.  */
 371     tree blocks;
 372
 373     /* The _TYPE node for this level, if parm_flag == 2.  */
 374     tree this_class;
 375
 376     /* The binding level which this one is contained in (inherits from).  */
 377     struct cp_binding_level *level_chain;
 378
 379     /* List of VAR_DECLS saved from a previous for statement.
 380        These would be dead in ISO-conforming code, but might
 381        be referenced in ARM-era code.  These are stored in a
 382        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 383     tree dead_vars_from_for;
 384
 385     /* 1 for the level that holds the parameters of a function.
 386        2 for the level that holds a class declaration.  */
 387     unsigned parm_flag : 2;
 388
 389     /* 1 means make a BLOCK for this level regardless of all else.
 390        2 for temporary binding contours created by the compiler.  */
 391     unsigned keep : 2;
 392
 393     /* Nonzero if this level "doesn't exist" for tags.  */
 394     unsigned tag_transparent : 1;
 395
 396     /* Nonzero if this level can safely have additional
 397        cleanup-needing variables added to it.  */
 398     unsigned more_cleanups_ok : 1;
 399     unsigned have_cleanups : 1;
 400
 401     /* Nonzero if this scope is for storing the decls for template
 402        parameters and generic decls; these decls will be discarded and
 403        replaced with a TEMPLATE_DECL.  */
 404     unsigned template_parms_p : 1;
 405
 406     /* Nonzero if this scope corresponds to the `<>' in a
 407        `template <>' clause.  Whenever this flag is set,
 408        TEMPLATE_PARMS_P will be set as well.  */
 409     unsigned template_spec_p : 1;
 410
 411     /* This is set for a namespace binding level.  */
 412     unsigned namespace_p : 1;
 413
 414     /* True if this level is that of a for-statement where we need to
 415        worry about ambiguous (ARM or ISO) scope rules.  */
 416     unsigned is_for_scope : 1;
 417
 418     /* True if this level corresponds to a TRY block.  Currently this
 419        information is only available while building the tree structure.  */
 420     unsigned is_try_scope : 1;
 421
 422     /* True if this level corresponds to a CATCH block.  Currently this
 423        information is only available while building the tree structure.  */
 424     unsigned is_catch_scope : 1;
 425
 426     /* Three bits left for this word.  */
 427
 428     /* Binding depth at which this level began.  */
 429     unsigned binding_depth;
 430   };
 431
 432 #define NULL_BINDING_LEVEL ((struct cp_binding_level *) NULL)
 433
 434 /* The binding level currently in effect.  */
 435
 436 #define current_binding_level                   \
 437   (cfun && cp_function_chain->bindings          \
 438    ? cp_function_chain->bindings                \
 439    : scope_chain->bindings)
 440
 441 /* The binding level of the current class, if any.  */
 442
 443 #define class_binding_level scope_chain->class_bindings
 444
 445 /* A chain of binding_level structures awaiting reuse.  */
 446
 447 static GTY((deletable (""))) struct cp_binding_level *free_binding_level;
 448
 449 /* The outermost binding level, for names of file scope.
 450    This is created when the compiler is started and exists
 451    through the entire run.  */
 452
 453 static GTY(()) struct cp_binding_level *global_binding_level;
 454
 455 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 456
 457 static int keep_next_level_flag;
 458
 459 /* A TREE_LIST of VAR_DECLs.  The TREE_PURPOSE is a RECORD_TYPE or
 460    UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type.  At the
 461    time the VAR_DECL was declared, the type was incomplete.  */
 462
 463 static GTY(()) tree incomplete_vars;
 464
 465 #if defined(DEBUG_BINDING_LEVELS)
 466 static int binding_depth = 0;
 467 static int is_class_level = 0;
 468
 469 static void
 470 indent ()
 471 {
 472   register unsigned i;
 473
 474   for (i = 0; i < binding_depth*2; i++)
 475     putc (' ', stderr);
 476 }
 477 #endif /* defined(DEBUG_BINDING_LEVELS) */
 478
 479 static tree pushdecl_with_scope PARAMS ((tree, struct cp_binding_level *));
 480
 481 static void
 482 push_binding_level (newlevel, tag_transparent, keep)
 483      struct cp_binding_level *newlevel;
 484      int tag_transparent, keep;
 485 {
 486   /* Add this level to the front of the chain (stack) of levels that
 487      are active.  */
 488   memset ((char*) newlevel, 0, sizeof (struct cp_binding_level));
 489   newlevel->level_chain = current_binding_level;
 490   current_binding_level = newlevel;
 491   newlevel->tag_transparent = tag_transparent;
 492   newlevel->more_cleanups_ok = 1;
 493
 494   newlevel->keep = keep;
 495 #if defined(DEBUG_BINDING_LEVELS)
 496   newlevel->binding_depth = binding_depth;
 497   indent ();
 498   fprintf (stderr, "push %s level 0x%08x line %d\n",
 499            (is_class_level) ? "class" : "block", newlevel, lineno);
 500   is_class_level = 0;
 501   binding_depth++;
 502 #endif /* defined(DEBUG_BINDING_LEVELS) */
 503 }
 504
 505 /* Find the innermost enclosing class scope, and reset
 506    CLASS_BINDING_LEVEL appropriately.  */
 507
 508 static void
 509 find_class_binding_level ()
 510 {
 511   struct cp_binding_level *level = current_binding_level;
 512
 513   while (level && level->parm_flag != 2)
 514     level = level->level_chain;
 515   if (level && level->parm_flag == 2)
 516     class_binding_level = level;
 517   else
 518     class_binding_level = 0;
 519 }
 520
 521 static void
 522 pop_binding_level ()
 523 {
 524   if (global_binding_level)
 525     {
 526       /* Cannot pop a level, if there are none left to pop.  */
 527       if (current_binding_level == global_binding_level)
 528         abort ();
 529     }
 530   /* Pop the current level, and free the structure for reuse.  */
 531 #if defined(DEBUG_BINDING_LEVELS)
 532   binding_depth--;
 533   indent ();
 534   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 535           (is_class_level) ? "class" : "block",
 536           current_binding_level, lineno);
 537   if (is_class_level != (current_binding_level == class_binding_level))
 538     {
 539       indent ();
 540       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 541     }
 542   is_class_level = 0;
 543 #endif /* defined(DEBUG_BINDING_LEVELS) */
 544   {
 545     register struct cp_binding_level *level = current_binding_level;
 546     current_binding_level = current_binding_level->level_chain;
 547     level->level_chain = free_binding_level;
 548 #if 0 /* defined(DEBUG_BINDING_LEVELS) */
 549     if (level->binding_depth != binding_depth)
 550       abort ();
 551 #endif /* defined(DEBUG_BINDING_LEVELS) */
 552     free_binding_level = level;
 553     find_class_binding_level ();
 554   }
 555 }
 556
 557 static void
 558 suspend_binding_level ()
 559 {
 560   if (class_binding_level)
 561     current_binding_level = class_binding_level;
 562
 563   if (global_binding_level)
 564     {
 565       /* Cannot suspend a level, if there are none left to suspend.  */
 566       if (current_binding_level == global_binding_level)
 567         abort ();
 568     }
 569   /* Suspend the current level.  */
 570 #if defined(DEBUG_BINDING_LEVELS)
 571   binding_depth--;
 572   indent ();
 573   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 574           (is_class_level) ? "class" : "block",
 575           current_binding_level, lineno);
 576   if (is_class_level != (current_binding_level == class_binding_level))
 577     {
 578       indent ();
 579       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 580     }
 581   is_class_level = 0;
 582 #endif /* defined(DEBUG_BINDING_LEVELS) */
 583   current_binding_level = current_binding_level->level_chain;
 584   find_class_binding_level ();
 585 }
 586
 587 static void
 588 resume_binding_level (b)
 589      struct cp_binding_level *b;
 590 {
 591   /* Resuming binding levels is meant only for namespaces,
 592      and those cannot nest into classes.  */
 593   my_friendly_assert(!class_binding_level, 386);
 594   /* Also, resuming a non-directly nested namespace is a no-no.  */
 595   my_friendly_assert(b->level_chain == current_binding_level, 386);
 596   current_binding_level = b;
 597 #if defined(DEBUG_BINDING_LEVELS)
 598   b->binding_depth = binding_depth;
 599   indent ();
 600   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 601            (is_class_level) ? "class" : "block", b, lineno);
 602   is_class_level = 0;
 603   binding_depth++;
 604 #endif /* defined(DEBUG_BINDING_LEVELS) */
 605 }
 606 \f
 607 /* Create a new `struct cp_binding_level'.  */
 608
 609 static
 610 struct cp_binding_level *
 611 make_binding_level ()
 612 {
 613   /* NOSTRICT */
 614   return (struct cp_binding_level *) ggc_alloc (sizeof (struct cp_binding_level));
 615 }
 616
 617 /* Nonzero if we are currently in the global binding level.  */
 618
 619 int
 620 global_bindings_p ()
 621 {
 622   return current_binding_level == global_binding_level;
 623 }
 624
 625 /* Return the innermost binding level that is not for a class scope.  */
 626
 627 static struct cp_binding_level *
 628 innermost_nonclass_level ()
 629 {
 630   struct cp_binding_level *b;
 631
 632   b = current_binding_level;
 633   while (b->parm_flag == 2)
 634     b = b->level_chain;
 635
 636   return b;
 637 }
 638
 639 /* Nonzero if we are currently in a toplevel binding level.  This
 640    means either the global binding level or a namespace in a toplevel
 641    binding level.  Since there are no non-toplevel namespace levels,
 642    this really means any namespace or template parameter level.  We
 643    also include a class whose context is toplevel.  */
 644
 645 int
 646 toplevel_bindings_p ()
 647 {
 648   struct cp_binding_level *b = innermost_nonclass_level ();
 649
 650   return b->namespace_p || b->template_parms_p;
 651 }
 652
 653 /* Nonzero if this is a namespace scope, or if we are defining a class
 654    which is itself at namespace scope, or whose enclosing class is
 655    such a class, etc.  */
 656
 657 int
 658 namespace_bindings_p ()
 659 {
 660   struct cp_binding_level *b = innermost_nonclass_level ();
 661
 662   return b->namespace_p;
 663 }
 664
 665 /* If KEEP is nonzero, make a BLOCK node for the next binding level,
 666    unconditionally.  Otherwise, use the normal logic to decide whether
 667    or not to create a BLOCK.  */
 668
 669 void
 670 keep_next_level (keep)
 671      int keep;
 672 {
 673   keep_next_level_flag = keep;
 674 }
 675
 676 /* Nonzero if the current level needs to have a BLOCK made.  */
 677
 678 int
 679 kept_level_p ()
 680 {
 681   return (current_binding_level->blocks != NULL_TREE
 682           || current_binding_level->keep
 683           || current_binding_level->names != NULL_TREE
 684           || (current_binding_level->tags != NULL_TREE
 685               && !current_binding_level->tag_transparent));
 686 }
 687
 688 static void
 689 declare_namespace_level ()
 690 {
 691   current_binding_level->namespace_p = 1;
 692 }
 693
 694 /* Returns nonzero if this scope was created to store template
 695    parameters.  */
 696
 697 int
 698 template_parm_scope_p ()
 699 {
 700   return current_binding_level->template_parms_p;
 701 }
 702
 703 /* Returns the kind of template specialization we are currently
 704    processing, given that it's declaration contained N_CLASS_SCOPES
 705    explicit scope qualifications.  */
 706
 707 tmpl_spec_kind
 708 current_tmpl_spec_kind (n_class_scopes)
 709      int n_class_scopes;
 710 {
 711   int n_template_parm_scopes = 0;
 712   int seen_specialization_p = 0;
 713   int innermost_specialization_p = 0;
 714   struct cp_binding_level *b;
 715
 716   /* Scan through the template parameter scopes.  */
 717   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 718     {
 719       /* If we see a specialization scope inside a parameter scope,
 720          then something is wrong.  That corresponds to a declaration
 721          like:
 722
 723             template <class T> template <> ...
 724
 725          which is always invalid since [temp.expl.spec] forbids the
 726          specialization of a class member template if the enclosing
 727          class templates are not explicitly specialized as well.  */
 728       if (b->template_spec_p)
 729         {
 730           if (n_template_parm_scopes == 0)
 731             innermost_specialization_p = 1;
 732           else
 733             seen_specialization_p = 1;
 734         }
 735       else if (seen_specialization_p == 1)
 736         return tsk_invalid_member_spec;
 737
 738       ++n_template_parm_scopes;
 739     }
 740
 741   /* Handle explicit instantiations.  */
 742   if (processing_explicit_instantiation)
 743     {
 744       if (n_template_parm_scopes != 0)
 745         /* We've seen a template parameter list during an explicit
 746            instantiation.  For example:
 747
 748              template <class T> template void f(int);
 749
 750            This is erroneous.  */
 751         return tsk_invalid_expl_inst;
 752       else
 753         return tsk_expl_inst;
 754     }
 755
 756   if (n_template_parm_scopes < n_class_scopes)
 757     /* We've not seen enough template headers to match all the
 758        specialized classes present.  For example:
 759
 760          template <class T> void R<T>::S<T>::f(int);
 761
 762        This is invalid; there needs to be one set of template
 763        parameters for each class.  */
 764     return tsk_insufficient_parms;
 765   else if (n_template_parm_scopes == n_class_scopes)
 766     /* We're processing a non-template declaration (even though it may
 767        be a member of a template class.)  For example:
 768
 769          template <class T> void S<T>::f(int);
 770
 771        The `class T' maches the `S<T>', leaving no template headers
 772        corresponding to the `f'.  */
 773     return tsk_none;
 774   else if (n_template_parm_scopes > n_class_scopes + 1)
 775     /* We've got too many template headers.  For example:
 776
 777          template <> template <class T> void f (T);
 778
 779        There need to be more enclosing classes.  */
 780     return tsk_excessive_parms;
 781   else
 782     /* This must be a template.  It's of the form:
 783
 784          template <class T> template <class U> void S<T>::f(U);
 785
 786        This is a specialization if the innermost level was a
 787        specialization; otherwise it's just a definition of the
 788        template.  */
 789     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 790 }
 791
 792 void
 793 set_class_shadows (shadows)
 794      tree shadows;
 795 {
 796   class_binding_level->class_shadowed = shadows;
 797 }
 798
 799 /* Enter a new binding level.
 800    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 801    not for that of tags.  */
 802
 803 void
 804 pushlevel (tag_transparent)
 805      int tag_transparent;
 806 {
 807   struct cp_binding_level *newlevel;
 808
 809   if (cfun && !doing_semantic_analysis_p ())
 810     return;
 811
 812   /* Reuse or create a struct for this binding level.  */
 813 #if defined(DEBUG_BINDING_LEVELS)
 814   if (0)
 815 #else /* !defined(DEBUG_BINDING_LEVELS) */
 816   if (free_binding_level)
 817 #endif /* !defined(DEBUG_BINDING_LEVELS) */
 818     {
 819       newlevel = free_binding_level;
 820       free_binding_level = free_binding_level->level_chain;
 821     }
 822   else
 823     newlevel = make_binding_level ();
 824
 825   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 826   keep_next_level_flag = 0;
 827 }
 828
 829 /* We're defining an object of type TYPE.  If it needs a cleanup, but
 830    we're not allowed to add any more objects with cleanups to the current
 831    scope, create a new binding level.  */
 832
 833 void
 834 maybe_push_cleanup_level (type)
 835      tree type;
 836 {
 837   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
 838       && current_binding_level->more_cleanups_ok == 0)
 839     {
 840       keep_next_level (2);
 841       pushlevel (1);
 842       clear_last_expr ();
 843       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
 844     }
 845 }
 846
 847 /* Enter a new scope.  The KIND indicates what kind of scope is being
 848    created.  */
 849
 850 void
 851 begin_scope (sk)
 852      scope_kind sk;
 853 {
 854   pushlevel (0);
 855
 856   switch (sk)
 857     {
 858     case sk_template_spec:
 859       current_binding_level->template_spec_p = 1;
 860       /* Fall through.  */
 861
 862     case sk_template_parms:
 863       current_binding_level->template_parms_p = 1;
 864       break;
 865
 866     default:
 867       abort ();
 868     }
 869 }
 870
 871 /* Exit the current scope.  */
 872
 873 void
 874 finish_scope ()
 875 {
 876   poplevel (0, 0, 0);
 877 }
 878
 879 void
 880 note_level_for_for ()
 881 {
 882   current_binding_level->is_for_scope = 1;
 883 }
 884
 885 /* Record that the current binding level represents a try block.  */
 886
 887 void
 888 note_level_for_try ()
 889 {
 890   current_binding_level->is_try_scope = 1;
 891 }
 892
 893 /* Record that the current binding level represents a catch block.  */
 894
 895 void
 896 note_level_for_catch ()
 897 {
 898   current_binding_level->is_catch_scope = 1;
 899 }
 900
 901 /* For a binding between a name and an entity at a block scope,
 902    this is the `struct cp_binding_level' for the block.  */
 903 #define BINDING_LEVEL(NODE) \
 904   (((struct tree_binding*)(NODE))->scope.level)
 905
 906 /* A free list of CPLUS_BINDING nodes, connected by their
 907    TREE_CHAINs.  */
 908
 909 static GTY((deletable (""))) tree free_bindings;
 910
 911 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 912    level at which this declaration is being bound.  */
 913
 914 static void
 915 push_binding (id, decl, level)
 916      tree id;
 917      tree decl;
 918      struct cp_binding_level* level;
 919 {
 920   tree binding;
 921
 922   if (free_bindings)
 923     {
 924       binding = free_bindings;
 925       free_bindings = TREE_CHAIN (binding);
 926     }
 927   else
 928     binding = make_node (CPLUS_BINDING);
 929
 930   /* Now, fill in the binding information.  */
 931   BINDING_VALUE (binding) = decl;
 932   BINDING_TYPE (binding) = NULL_TREE;
 933   BINDING_LEVEL (binding) = level;
 934   INHERITED_VALUE_BINDING_P (binding) = 0;
 935   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 936   BINDING_HAS_LEVEL_P (binding) = 1;
 937
 938   /* And put it on the front of the list of bindings for ID.  */
 939   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 940   IDENTIFIER_BINDING (id) = binding;
 941 }
 942
 943 /* ID is already bound in the current scope.  But, DECL is an
 944    additional binding for ID in the same scope.  This is the `struct
 945    stat' hack whereby a non-typedef class-name or enum-name can be
 946    bound at the same level as some other kind of entity.  It's the
 947    responsibility of the caller to check that inserting this name is
 948    valid here.  Returns nonzero if the new binding was successful.  */
 949 static int
 950 add_binding (id, decl)
 951      tree id;
 952      tree decl;
 953 {
 954   tree binding = IDENTIFIER_BINDING (id);
 955   int ok = 1;
 956
 957   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 958     /* The new name is the type name.  */
 959     BINDING_TYPE (binding) = decl;
 960   else if (!BINDING_VALUE (binding))
 961     /* This situation arises when push_class_level_binding moves an
 962        inherited type-binding out of the way to make room for a new
 963        value binding.  */
 964     BINDING_VALUE (binding) = decl;
 965   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 966            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 967     {
 968       /* The old binding was a type name.  It was placed in
 969          BINDING_VALUE because it was thought, at the point it was
 970          declared, to be the only entity with such a name.  Move the
 971          type name into the type slot; it is now hidden by the new
 972          binding.  */
 973       BINDING_TYPE (binding) = BINDING_VALUE (binding);
 974       BINDING_VALUE (binding) = decl;
 975       INHERITED_VALUE_BINDING_P (binding) = 0;
 976     }
 977   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 978            && TREE_CODE (decl) == TYPE_DECL
 979            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
 980            && (same_type_p (TREE_TYPE (decl),
 981                             TREE_TYPE (BINDING_VALUE (binding)))
 982                /* If either type involves template parameters, we must
 983                   wait until instantiation.  */
 984                || uses_template_parms (TREE_TYPE (decl))
 985                || uses_template_parms (TREE_TYPE (BINDING_VALUE (binding)))))
 986     /* We have two typedef-names, both naming the same type to have
 987        the same name.  This is OK because of:
 988
 989          [dcl.typedef]
 990
 991          In a given scope, a typedef specifier can be used to redefine
 992          the name of any type declared in that scope to refer to the
 993          type to which it already refers.  */
 994     ok = 0;
 995   /* There can be two block-scope declarations of the same variable,
 996      so long as they are `extern' declarations.  */
 997   else if (TREE_CODE (decl) == VAR_DECL
 998            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
 999            && DECL_EXTERNAL (decl)
1000            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1001     {
1002       duplicate_decls (decl, BINDING_VALUE (binding));
1003       ok = 0;
1004     }
1005   else
1006     {
1007       error ("declaration of `%#D'", decl);
1008       cp_error_at ("conflicts with previous declaration `%#D'",
1009                    BINDING_VALUE (binding));
1010       ok = 0;
1011     }
1012
1013   return ok;
1014 }
1015
1016 /* Add DECL to the list of things declared in B.  */
1017
1018 static void
1019 add_decl_to_level (decl, b)
1020      tree decl;
1021      struct cp_binding_level *b;
1022 {
1023   if (TREE_CODE (decl) == NAMESPACE_DECL
1024       && !DECL_NAMESPACE_ALIAS (decl))
1025     {
1026       TREE_CHAIN (decl) = b->namespaces;
1027       b->namespaces = decl;
1028     }
1029   else if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
1030     {
1031       TREE_CHAIN (decl) = b->vtables;
1032       b->vtables = decl;
1033     }
1034   else
1035     {
1036       /* We build up the list in reverse order, and reverse it later if
1037          necessary.  */
1038       TREE_CHAIN (decl) = b->names;
1039       b->names = decl;
1040       b->names_size++;
1041     }
1042 }
1043
1044 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1045    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1046    doesn't really belong to this binding level, that it got here
1047    through a using-declaration.  */
1048
1049 void
1050 push_local_binding (id, decl, flags)
1051      tree id;
1052      tree decl;
1053      int flags;
1054 {
1055   struct cp_binding_level *b;
1056
1057   /* Skip over any local classes.  This makes sense if we call
1058      push_local_binding with a friend decl of a local class.  */
1059   b = current_binding_level;
1060   while (b->parm_flag == 2)
1061     b = b->level_chain;
1062
1063   if (lookup_name_current_level (id))
1064     {
1065       /* Supplement the existing binding.  */
1066       if (!add_binding (id, decl))
1067         /* It didn't work.  Something else must be bound at this
1068            level.  Do not add DECL to the list of things to pop
1069            later.  */
1070         return;
1071     }
1072   else
1073     /* Create a new binding.  */
1074     push_binding (id, decl, b);
1075
1076   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1077     /* We must put the OVERLOAD into a TREE_LIST since the
1078        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1079        decls that got here through a using-declaration.  */
1080     decl = build_tree_list (NULL_TREE, decl);
1081
1082   /* And put DECL on the list of things declared by the current
1083      binding level.  */
1084   add_decl_to_level (decl, b);
1085 }
1086
1087 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1088    binding was successful.  */
1089
1090 int
1091 push_class_binding (id, decl)
1092      tree id;
1093      tree decl;
1094 {
1095   int result = 1;
1096   tree binding = IDENTIFIER_BINDING (id);
1097   tree context;
1098
1099   /* Note that we declared this value so that we can issue an error if
1100      this is an invalid redeclaration of a name already used for some
1101      other purpose.  */
1102   note_name_declared_in_class (id, decl);
1103
1104   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1105     /* Supplement the existing binding.  */
1106     result = add_binding (id, decl);
1107   else
1108     /* Create a new binding.  */
1109     push_binding (id, decl, class_binding_level);
1110
1111   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1112      class-level declaration.  Note that we do not use DECL here
1113      because of the possibility of the `struct stat' hack; if DECL is
1114      a class-name or enum-name we might prefer a field-name, or some
1115      such.  */
1116   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1117
1118   /* If this is a binding from a base class, mark it as such.  */
1119   binding = IDENTIFIER_BINDING (id);
1120   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1121     {
1122       /* Any implicit typename must be from a base-class.  The
1123          context for an implicit typename declaration is always
1124          the derived class in which the lookup was done, so the checks
1125          based on the context of DECL below will not trigger.  */
1126       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1127         INHERITED_VALUE_BINDING_P (binding) = 1;
1128       else
1129         {
1130           if (TREE_CODE (decl) == OVERLOAD)
1131             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1132           else
1133             {
1134               my_friendly_assert (DECL_P (decl), 0);
1135               context = context_for_name_lookup (decl);
1136             }
1137
1138           if (is_properly_derived_from (current_class_type, context))
1139             INHERITED_VALUE_BINDING_P (binding) = 1;
1140           else
1141             INHERITED_VALUE_BINDING_P (binding) = 0;
1142         }
1143     }
1144   else if (BINDING_VALUE (binding) == decl)
1145     /* We only encounter a TREE_LIST when push_class_decls detects an
1146        ambiguity.  Such an ambiguity can be overridden by a definition
1147        in this class.  */
1148     INHERITED_VALUE_BINDING_P (binding) = 1;
1149
1150   return result;
1151 }
1152
1153 /* Remove the binding for DECL which should be the innermost binding
1154    for ID.  */
1155
1156 static void
1157 pop_binding (id, decl)
1158      tree id;
1159      tree decl;
1160 {
1161   tree binding;
1162
1163   if (id == NULL_TREE)
1164     /* It's easiest to write the loops that call this function without
1165        checking whether or not the entities involved have names.  We
1166        get here for such an entity.  */
1167     return;
1168
1169   /* Get the innermost binding for ID.  */
1170   binding = IDENTIFIER_BINDING (id);
1171
1172   /* The name should be bound.  */
1173   my_friendly_assert (binding != NULL_TREE, 0);
1174
1175   /* The DECL will be either the ordinary binding or the type
1176      binding for this identifier.  Remove that binding.  */
1177   if (BINDING_VALUE (binding) == decl)
1178     BINDING_VALUE (binding) = NULL_TREE;
1179   else if (BINDING_TYPE (binding) == decl)
1180     BINDING_TYPE (binding) = NULL_TREE;
1181   else
1182     abort ();
1183
1184   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1185     {
1186       /* We're completely done with the innermost binding for this
1187          identifier.  Unhook it from the list of bindings.  */
1188       IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1189
1190       /* Add it to the free list.  */
1191       TREE_CHAIN (binding) = free_bindings;
1192       free_bindings = binding;
1193
1194       /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
1195          it.  */
1196       BINDING_LEVEL (binding) = NULL;
1197     }
1198 }
1199
1200 /* When a label goes out of scope, check to see if that label was used
1201    in a valid manner, and issue any appropriate warnings or errors.  */
1202
1203 static void
1204 pop_label (label, old_value)
1205      tree label;
1206      tree old_value;
1207 {
1208   if (!processing_template_decl && doing_semantic_analysis_p ())
1209     {
1210       if (DECL_INITIAL (label) == NULL_TREE)
1211         {
1212           cp_error_at ("label `%D' used but not defined", label);
1213           /* Avoid crashing later.  */
1214           define_label (input_filename, 1, DECL_NAME (label));
1215         }
1216       else if (warn_unused_label && !TREE_USED (label))
1217         cp_warning_at ("label `%D' defined but not used", label);
1218     }
1219
1220   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1221 }
1222
1223 /* At the end of a function, all labels declared within the function
1224    go out of scope.  BLOCK is the top-level block for the
1225    function.  */
1226
1227 static void
1228 pop_labels (block)
1229      tree block;
1230 {
1231   struct named_label_list *link;
1232
1233   /* Clear out the definitions of all label names, since their scopes
1234      end here.  */
1235   for (link = named_labels; link; link = link->next)
1236     {
1237       pop_label (link->label_decl, link->old_value);
1238       /* Put the labels into the "variables" of the top-level block,
1239          so debugger can see them.  */
1240       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1241       BLOCK_VARS (block) = link->label_decl;
1242     }
1243
1244   named_labels = NULL;
1245 }
1246
1247 /* Exit a binding level.
1248    Pop the level off, and restore the state of the identifier-decl mappings
1249    that were in effect when this level was entered.
1250
1251    If KEEP == 1, this level had explicit declarations, so
1252    and create a "block" (a BLOCK node) for the level
1253    to record its declarations and subblocks for symbol table output.
1254
1255    If FUNCTIONBODY is nonzero, this level is the body of a function,
1256    so create a block as if KEEP were set and also clear out all
1257    label names.
1258
1259    If REVERSE is nonzero, reverse the order of decls before putting
1260    them into the BLOCK.  */
1261
1262 tree
1263 poplevel (keep, reverse, functionbody)
1264      int keep;
1265      int reverse;
1266      int functionbody;
1267 {
1268   register tree link;
1269   /* The chain of decls was accumulated in reverse order.
1270      Put it into forward order, just for cleanliness.  */
1271   tree decls;
1272   int tmp = functionbody;
1273   int real_functionbody;
1274   tree tags;
1275   tree subblocks;
1276   tree block = NULL_TREE;
1277   tree decl;
1278   int leaving_for_scope;
1279
1280   if (cfun && !doing_semantic_analysis_p ())
1281     return NULL_TREE;
1282
1283   my_friendly_assert (current_binding_level->parm_flag != 2,
1284                       19990916);
1285
1286   real_functionbody = (current_binding_level->keep == 2
1287                        ? ((functionbody = 0), tmp) : functionbody);
1288   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1289   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1290
1291   my_friendly_assert (!current_binding_level->class_shadowed,
1292                       19990414);
1293
1294   /* We used to use KEEP == 2 to indicate that the new block should go
1295      at the beginning of the list of blocks at this binding level,
1296      rather than the end.  This hack is no longer used.  */
1297   my_friendly_assert (keep == 0 || keep == 1, 0);
1298
1299   if (current_binding_level->keep == 1)
1300     keep = 1;
1301
1302   /* Any uses of undefined labels, and any defined labels, now operate
1303      under constraints of next binding contour.  */
1304   if (cfun && !functionbody)
1305     {
1306       struct cp_binding_level *level_chain;
1307       level_chain = current_binding_level->level_chain;
1308       if (level_chain)
1309         {
1310           struct named_label_use_list *uses;
1311           struct named_label_list *labels;
1312           for (labels = named_labels; labels; labels = labels->next)
1313             if (labels->binding_level == current_binding_level)
1314               {
1315                 tree decl;
1316                 if (current_binding_level->is_try_scope)
1317                   labels->in_try_scope = 1;
1318                 if (current_binding_level->is_catch_scope)
1319                   labels->in_catch_scope = 1;
1320                 for (decl = labels->names_in_scope; decl;
1321                      decl = TREE_CHAIN (decl))
1322                   if (decl_jump_unsafe (decl))
1323                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1324                                                    labels->bad_decls);
1325                 labels->binding_level = level_chain;
1326                 labels->names_in_scope = level_chain->names;
1327               }
1328
1329           for (uses = named_label_uses; uses; uses = uses->next)
1330             if (uses->binding_level == current_binding_level)
1331               {
1332                 uses->binding_level = level_chain;
1333                 uses->names_in_scope = level_chain->names;
1334               }
1335         }
1336     }
1337
1338   /* Get the decls in the order they were written.
1339      Usually current_binding_level->names is in reverse order.
1340      But parameter decls were previously put in forward order.  */
1341
1342   if (reverse)
1343     current_binding_level->names
1344       = decls = nreverse (current_binding_level->names);
1345   else
1346     decls = current_binding_level->names;
1347
1348   /* Output any nested inline functions within this block
1349      if they weren't already output.  */
1350   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1351     if (TREE_CODE (decl) == FUNCTION_DECL
1352         && ! TREE_ASM_WRITTEN (decl)
1353         && DECL_INITIAL (decl) != NULL_TREE
1354         && TREE_ADDRESSABLE (decl)
1355         && decl_function_context (decl) == current_function_decl)
1356       {
1357         /* If this decl was copied from a file-scope decl
1358            on account of a block-scope extern decl,
1359            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1360         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1361           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1362         else
1363           {
1364             push_function_context ();
1365             output_inline_function (decl);
1366             pop_function_context ();
1367           }
1368       }
1369
1370   /* When not in function-at-a-time mode, expand_end_bindings will
1371      warn about unused variables.  But, in function-at-a-time mode
1372      expand_end_bindings is not passed the list of variables in the
1373      current scope, and therefore no warning is emitted.  So, we
1374      explicitly warn here.  */
1375   if (!processing_template_decl)
1376     warn_about_unused_variables (getdecls ());
1377
1378   /* If there were any declarations or structure tags in that level,
1379      or if this level is a function body,
1380      create a BLOCK to record them for the life of this function.  */
1381   block = NULL_TREE;
1382   if (keep == 1 || functionbody)
1383     block = make_node (BLOCK);
1384   if (block != NULL_TREE)
1385     {
1386       BLOCK_VARS (block) = decls;
1387       BLOCK_SUBBLOCKS (block) = subblocks;
1388     }
1389
1390   /* In each subblock, record that this is its superior.  */
1391   if (keep >= 0)
1392     for (link = subblocks; link; link = TREE_CHAIN (link))
1393       BLOCK_SUPERCONTEXT (link) = block;
1394
1395   /* We still support the old for-scope rules, whereby the variables
1396      in a for-init statement were in scope after the for-statement
1397      ended.  We only use the new rules in flag_new_for_scope is
1398      nonzero.  */
1399   leaving_for_scope
1400     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1401
1402   /* Remove declarations for all the DECLs in this level.  */
1403   for (link = decls; link; link = TREE_CHAIN (link))
1404     {
1405       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1406           && DECL_NAME (link))
1407         {
1408           tree outer_binding
1409             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1410           tree ns_binding;
1411
1412           if (!outer_binding)
1413             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1414           else
1415             ns_binding = NULL_TREE;
1416
1417           if (outer_binding
1418               && (BINDING_LEVEL (outer_binding)
1419                   == current_binding_level->level_chain))
1420             /* We have something like:
1421
1422                  int i;
1423                  for (int i; ;);
1424
1425                and we are leaving the `for' scope.  There's no reason to
1426                keep the binding of the inner `i' in this case.  */
1427             pop_binding (DECL_NAME (link), link);
1428           else if ((outer_binding
1429                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1430                         == TYPE_DECL))
1431                    || (ns_binding
1432                        && TREE_CODE (ns_binding) == TYPE_DECL))
1433             /* Here, we have something like:
1434
1435                  typedef int I;
1436
1437                  void f () {
1438                    for (int I; ;);
1439                  }
1440
1441                We must pop the for-scope binding so we know what's a
1442                type and what isn't.  */
1443             pop_binding (DECL_NAME (link), link);
1444           else
1445             {
1446               /* Mark this VAR_DECL as dead so that we can tell we left it
1447                  there only for backward compatibility.  */
1448               DECL_DEAD_FOR_LOCAL (link) = 1;
1449
1450               /* Keep track of what should of have happenned when we
1451                  popped the binding.  */
1452               if (outer_binding && BINDING_VALUE (outer_binding))
1453                 DECL_SHADOWED_FOR_VAR (link)
1454                   = BINDING_VALUE (outer_binding);
1455
1456               /* Add it to the list of dead variables in the next
1457                  outermost binding to that we can remove these when we
1458                  leave that binding.  */
1459               current_binding_level->level_chain->dead_vars_from_for
1460                 = tree_cons (NULL_TREE, link,
1461                              current_binding_level->level_chain->
1462                              dead_vars_from_for);
1463
1464               /* Although we don't pop the CPLUS_BINDING, we do clear
1465                  its BINDING_LEVEL since the level is going away now.  */
1466               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1467                 = 0;
1468             }
1469         }
1470       else
1471         {
1472           /* Remove the binding.  */
1473           decl = link;
1474           if (TREE_CODE (decl) == TREE_LIST)
1475             decl = TREE_VALUE (decl);
1476           if (DECL_P (decl))
1477             pop_binding (DECL_NAME (decl), decl);
1478           else if (TREE_CODE (decl) == OVERLOAD)
1479             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1480           else
1481             abort ();
1482         }
1483     }
1484
1485   /* Remove declarations for any `for' variables from inner scopes
1486      that we kept around.  */
1487   for (link = current_binding_level->dead_vars_from_for;
1488        link; link = TREE_CHAIN (link))
1489     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1490
1491   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1492   for (link = current_binding_level->type_shadowed;
1493        link; link = TREE_CHAIN (link))
1494     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1495
1496   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1497   for (link = current_binding_level->shadowed_labels;
1498        link;
1499        link = TREE_CHAIN (link))
1500     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1501
1502   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1503      list if a `using' declaration put them there.  The debugging
1504      back-ends won't understand OVERLOAD, so we remove them here.
1505      Because the BLOCK_VARS are (temporarily) shared with
1506      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1507      popped all the bindings.  */
1508   if (block)
1509     {
1510       tree* d;
1511
1512       for (d = &BLOCK_VARS (block); *d; )
1513         {
1514           if (TREE_CODE (*d) == TREE_LIST)
1515             *d = TREE_CHAIN (*d);
1516           else
1517             d = &TREE_CHAIN (*d);
1518         }
1519     }
1520
1521   /* If the level being exited is the top level of a function,
1522      check over all the labels.  */
1523   if (functionbody)
1524     {
1525       /* Since this is the top level block of a function, the vars are
1526          the function's parameters.  Don't leave them in the BLOCK
1527          because they are found in the FUNCTION_DECL instead.  */
1528       BLOCK_VARS (block) = 0;
1529       pop_labels (block);
1530     }
1531
1532   tmp = current_binding_level->keep;
1533
1534   pop_binding_level ();
1535   if (functionbody)
1536     DECL_INITIAL (current_function_decl) = block;
1537   else if (block)
1538     current_binding_level->blocks
1539       = chainon (current_binding_level->blocks, block);
1540
1541   /* If we did not make a block for the level just exited,
1542      any blocks made for inner levels
1543      (since they cannot be recorded as subblocks in that level)
1544      must be carried forward so they will later become subblocks
1545      of something else.  */
1546   else if (subblocks)
1547     current_binding_level->blocks
1548       = chainon (current_binding_level->blocks, subblocks);
1549
1550   /* Each and every BLOCK node created here in `poplevel' is important
1551      (e.g. for proper debugging information) so if we created one
1552      earlier, mark it as "used".  */
1553   if (block)
1554     TREE_USED (block) = 1;
1555
1556   /* Take care of compiler's internal binding structures.  */
1557   if (tmp == 2)
1558     {
1559       tree scope_stmts;
1560
1561       scope_stmts
1562         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1563       if (block)
1564         {
1565           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1566           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1567         }
1568
1569       block = poplevel (keep, reverse, functionbody);
1570     }
1571
1572   return block;
1573 }
1574
1575 /* Delete the node BLOCK from the current binding level.
1576    This is used for the block inside a stmt expr ({...})
1577    so that the block can be reinserted where appropriate.  */
1578
1579 void
1580 delete_block (block)
1581      tree block;
1582 {
1583   tree t;
1584   if (current_binding_level->blocks == block)
1585     current_binding_level->blocks = TREE_CHAIN (block);
1586   for (t = current_binding_level->blocks; t;)
1587     {
1588       if (TREE_CHAIN (t) == block)
1589         TREE_CHAIN (t) = TREE_CHAIN (block);
1590       else
1591         t = TREE_CHAIN (t);
1592     }
1593   TREE_CHAIN (block) = NULL_TREE;
1594   /* Clear TREE_USED which is always set by poplevel.
1595      The flag is set again if insert_block is called.  */
1596   TREE_USED (block) = 0;
1597 }
1598
1599 /* Insert BLOCK at the end of the list of subblocks of the
1600    current binding level.  This is used when a BIND_EXPR is expanded,
1601    to handle the BLOCK node inside the BIND_EXPR.  */
1602
1603 void
1604 insert_block (block)
1605      tree block;
1606 {
1607   TREE_USED (block) = 1;
1608   current_binding_level->blocks
1609     = chainon (current_binding_level->blocks, block);
1610 }
1611
1612 /* Set the BLOCK node for the innermost scope
1613    (the one we are currently in).  */
1614
1615 void
1616 set_block (block)
1617     tree block ATTRIBUTE_UNUSED;
1618 {
1619   /* The RTL expansion machinery requires us to provide this callback,
1620      but it is not applicable in function-at-a-time mode.  */
1621   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1622 }
1623
1624 /* Do a pushlevel for class declarations.  */
1625
1626 void
1627 pushlevel_class ()
1628 {
1629   register struct cp_binding_level *newlevel;
1630
1631   /* Reuse or create a struct for this binding level.  */
1632 #if defined(DEBUG_BINDING_LEVELS)
1633   if (0)
1634 #else /* !defined(DEBUG_BINDING_LEVELS) */
1635   if (free_binding_level)
1636 #endif /* !defined(DEBUG_BINDING_LEVELS) */
1637     {
1638       newlevel = free_binding_level;
1639       free_binding_level = free_binding_level->level_chain;
1640     }
1641   else
1642     newlevel = make_binding_level ();
1643
1644 #if defined(DEBUG_BINDING_LEVELS)
1645   is_class_level = 1;
1646 #endif /* defined(DEBUG_BINDING_LEVELS) */
1647
1648   push_binding_level (newlevel, 0, 0);
1649
1650   class_binding_level = current_binding_level;
1651   class_binding_level->parm_flag = 2;
1652   class_binding_level->this_class = current_class_type;
1653 }
1654
1655 /* ...and a poplevel for class declarations.  */
1656
1657 void
1658 poplevel_class ()
1659 {
1660   register struct cp_binding_level *level = class_binding_level;
1661   tree shadowed;
1662
1663   my_friendly_assert (level != 0, 354);
1664
1665   /* If we're leaving a toplevel class, don't bother to do the setting
1666      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1667      shouldn't even be used when current_class_type isn't set, and second,
1668      if we don't touch it here, we're able to use the cache effect if the
1669      next time we're entering a class scope, it is the same class.  */
1670   if (current_class_depth != 1)
1671     {
1672       struct cp_binding_level* b;
1673
1674       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1675       for (shadowed = level->class_shadowed;
1676            shadowed;
1677            shadowed = TREE_CHAIN (shadowed))
1678         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1679
1680       /* Find the next enclosing class, and recreate
1681          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1682       b = level->level_chain;
1683       while (b && b->parm_flag != 2)
1684         b = b->level_chain;
1685
1686       if (b)
1687         for (shadowed = b->class_shadowed;
1688              shadowed;
1689              shadowed = TREE_CHAIN (shadowed))
1690           {
1691             tree t;
1692
1693             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1694             while (t && BINDING_LEVEL (t) != b)
1695               t = TREE_CHAIN (t);
1696
1697             if (t)
1698               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1699                 = BINDING_VALUE (t);
1700           }
1701     }
1702   else
1703     /* Remember to save what IDENTIFIER's were bound in this scope so we
1704        can recover from cache misses.  */
1705     {
1706       previous_class_type = current_class_type;
1707       previous_class_values = class_binding_level->class_shadowed;
1708     }
1709   for (shadowed = level->type_shadowed;
1710        shadowed;
1711        shadowed = TREE_CHAIN (shadowed))
1712     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1713
1714   /* Remove the bindings for all of the class-level declarations.  */
1715   for (shadowed = level->class_shadowed;
1716        shadowed;
1717        shadowed = TREE_CHAIN (shadowed))
1718     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1719
1720   /* Now, pop out of the binding level which we created up in the
1721      `pushlevel_class' routine.  */
1722 #if defined(DEBUG_BINDING_LEVELS)
1723   is_class_level = 1;
1724 #endif /* defined(DEBUG_BINDING_LEVELS) */
1725
1726   pop_binding_level ();
1727 }
1728
1729 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1730    for any names in enclosing classes.  */
1731
1732 void
1733 clear_identifier_class_values ()
1734 {
1735   tree t;
1736
1737   if (!class_binding_level)
1738     return;
1739
1740   for (t = class_binding_level->class_shadowed;
1741        t;
1742        t = TREE_CHAIN (t))
1743     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1744 }
1745
1746 /* Returns nonzero if T is a virtual function table.  */
1747
1748 int
1749 vtable_decl_p (t, data)
1750      tree t;
1751      void *data ATTRIBUTE_UNUSED;
1752 {
1753   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1754 }
1755
1756 /* Returns nonzero if T is a TYPE_DECL for a type with virtual
1757    functions.  */
1758
1759 int
1760 vtype_decl_p (t, data)
1761      tree t;
1762      void *data ATTRIBUTE_UNUSED;
1763 {
1764   return (TREE_CODE (t) == TYPE_DECL
1765           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1766           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1767 }
1768
1769 /* Return the declarations that are members of the namespace NS.  */
1770
1771 tree
1772 cp_namespace_decls (ns)
1773      tree ns;
1774 {
1775   return NAMESPACE_LEVEL (ns)->names;
1776 }
1777
1778 struct walk_globals_data {
1779   walk_globals_pred p;
1780   walk_globals_fn f;
1781   void *data;
1782 };
1783
1784 /* Walk the vtable declarations in NAMESPACE.  Whenever one is found
1785    for which P returns nonzero, call F with its address.  If any call
1786    to F returns a nonzero value, return a nonzero value.  */
1787
1788 static int
1789 walk_vtables_r (namespace, data)
1790      tree namespace;
1791      void *data;
1792 {
1793   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1794   walk_globals_fn f = wgd->f;
1795   void *d = wgd->data;
1796   tree decl = NAMESPACE_LEVEL (namespace)->vtables;
1797   int result = 0;
1798
1799   for (; decl ; decl = TREE_CHAIN (decl))
1800     result |= (*f) (&decl, d);
1801
1802   return result;
1803 }
1804
1805 /* Walk the vtable declarations.  Whenever one is found for which P
1806    returns nonzero, call F with its address.  If any call to F
1807    returns a nonzero value, return a nonzero value.  */
1808 bool
1809 walk_vtables (walk_globals_pred p, walk_globals_fn f, void *data)
1810 {
1811   struct walk_globals_data wgd;
1812   wgd.p = p;
1813   wgd.f = f;
1814   wgd.data = data;
1815
1816   return walk_namespaces (walk_vtables_r, &wgd);
1817 }
1818
1819 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1820    itself, calling F for each.  The DATA is passed to F as well.  */
1821
1822 static int
1823 walk_namespaces_r (namespace, f, data)
1824      tree namespace;
1825      walk_namespaces_fn f;
1826      void *data;
1827 {
1828   int result = 0;
1829   tree current = NAMESPACE_LEVEL (namespace)->namespaces;
1830
1831   result |= (*f) (namespace, data);
1832
1833   for (; current; current = TREE_CHAIN (current))
1834     result |= walk_namespaces_r (current, f, data);
1835
1836   return result;
1837 }
1838
1839 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1840    F as well.  */
1841
1842 int
1843 walk_namespaces (f, data)
1844      walk_namespaces_fn f;
1845      void *data;
1846 {
1847   return walk_namespaces_r (global_namespace, f, data);
1848 }
1849
1850 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1851    for which P returns nonzero, call F with its address.  If any call
1852    to F returns a nonzero value, return a nonzero value.  */
1853
1854 static int
1855 walk_globals_r (namespace, data)
1856      tree namespace;
1857      void *data;
1858 {
1859   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1860   walk_globals_pred p = wgd->p;
1861   walk_globals_fn f = wgd->f;
1862   void *d = wgd->data;
1863   tree *t;
1864   int result = 0;
1865
1866   t = &NAMESPACE_LEVEL (namespace)->names;
1867
1868   while (*t)
1869     {
1870       tree glbl = *t;
1871
1872       if ((*p) (glbl, d))
1873         result |= (*f) (t, d);
1874
1875       /* If F changed *T, then *T still points at the next item to
1876          examine.  */
1877       if (*t == glbl)
1878         t = &TREE_CHAIN (*t);
1879     }
1880
1881   return result;
1882 }
1883
1884 /* Walk the global declarations.  Whenever one is found for which P
1885    returns true, call F with its address.  If any call to F
1886    returns true, return true.  */
1887
1888 bool
1889 walk_globals (walk_globals_pred p, walk_globals_fn f, void *data)
1890 {
1891   struct walk_globals_data wgd;
1892   wgd.p = p;
1893   wgd.f = f;
1894   wgd.data = data;
1895
1896   return walk_namespaces (walk_globals_r, &wgd);
1897 }
1898
1899 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1900    DATA is non-NULL, this is the last time we will call
1901    wrapup_global_declarations for this NAMESPACE.  */
1902
1903 int
1904 wrapup_globals_for_namespace (namespace, data)
1905      tree namespace;
1906      void *data;
1907 {
1908   tree globals = cp_namespace_decls (namespace);
1909   int len = NAMESPACE_LEVEL (namespace)->names_size;
1910   tree *vec = (tree *) alloca (sizeof (tree) * len);
1911   int i;
1912   int result;
1913   tree decl;
1914   int last_time = (data != 0);
1915
1916   if (last_time && namespace == global_namespace)
1917     /* Let compile_file handle the global namespace.  */
1918     return 0;
1919
1920   /* Process the decls in reverse order--earliest first.
1921      Put them into VEC from back to front, then take out from front.  */
1922   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1923     vec[len - i - 1] = decl;
1924
1925   if (last_time)
1926     {
1927       check_global_declarations (vec, len);
1928       return 0;
1929     }
1930
1931   /* Write out any globals that need to be output.  */
1932   result = wrapup_global_declarations (vec, len);
1933
1934   return result;
1935 }
1936
1937 \f
1938 /* For debugging.  */
1939 static int no_print_functions = 0;
1940 static int no_print_builtins = 0;
1941
1942 void
1943 print_binding_level (lvl)
1944      struct cp_binding_level *lvl;
1945 {
1946   tree t;
1947   int i = 0, len;
1948   fprintf (stderr, " blocks=");
1949   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1950   if (lvl->tag_transparent)
1951     fprintf (stderr, " tag-transparent");
1952   if (lvl->more_cleanups_ok)
1953     fprintf (stderr, " more-cleanups-ok");
1954   if (lvl->have_cleanups)
1955     fprintf (stderr, " have-cleanups");
1956   fprintf (stderr, "\n");
1957   if (lvl->names)
1958     {
1959       fprintf (stderr, " names:\t");
1960       /* We can probably fit 3 names to a line?  */
1961       for (t = lvl->names; t; t = TREE_CHAIN (t))
1962         {
1963           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1964             continue;
1965           if (no_print_builtins
1966               && (TREE_CODE (t) == TYPE_DECL)
1967               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
1968             continue;
1969
1970           /* Function decls tend to have longer names.  */
1971           if (TREE_CODE (t) == FUNCTION_DECL)
1972             len = 3;
1973           else
1974             len = 2;
1975           i += len;
1976           if (i > 6)
1977             {
1978               fprintf (stderr, "\n\t");
1979               i = len;
1980             }
1981           print_node_brief (stderr, "", t, 0);
1982           if (t == error_mark_node)
1983             break;
1984         }
1985       if (i)
1986         fprintf (stderr, "\n");
1987     }
1988   if (lvl->tags)
1989     {
1990       fprintf (stderr, " tags:\t");
1991       i = 0;
1992       for (t = lvl->tags; t; t = TREE_CHAIN (t))
1993         {
1994           if (TREE_PURPOSE (t) == NULL_TREE)
1995             len = 3;
1996           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1997             len = 2;
1998           else
1999             len = 4;
2000           i += len;
2001           if (i > 5)
2002             {
2003               fprintf (stderr, "\n\t");
2004               i = len;
2005             }
2006           if (TREE_PURPOSE (t) == NULL_TREE)
2007             {
2008               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2009               fprintf (stderr, ">");
2010             }
2011           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2012             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2013           else
2014             {
2015               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2016               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2017               fprintf (stderr, ">");
2018             }
2019         }
2020       if (i)
2021         fprintf (stderr, "\n");
2022     }
2023   if (lvl->class_shadowed)
2024     {
2025       fprintf (stderr, " class-shadowed:");
2026       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2027         {
2028           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2029         }
2030       fprintf (stderr, "\n");
2031     }
2032   if (lvl->type_shadowed)
2033     {
2034       fprintf (stderr, " type-shadowed:");
2035       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2036         {
2037           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2038         }
2039       fprintf (stderr, "\n");
2040     }
2041 }
2042
2043 void
2044 print_other_binding_stack (stack)
2045      struct cp_binding_level *stack;
2046 {
2047   struct cp_binding_level *level;
2048   for (level = stack; level != global_binding_level; level = level->level_chain)
2049     {
2050       fprintf (stderr, "binding level ");
2051       fprintf (stderr, HOST_PTR_PRINTF, level);
2052       fprintf (stderr, "\n");
2053       print_binding_level (level);
2054     }
2055 }
2056
2057 void
2058 print_binding_stack ()
2059 {
2060   struct cp_binding_level *b;
2061   fprintf (stderr, "current_binding_level=");
2062   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2063   fprintf (stderr, "\nclass_binding_level=");
2064   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2065   fprintf (stderr, "\nglobal_binding_level=");
2066   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2067   fprintf (stderr, "\n");
2068   if (class_binding_level)
2069     {
2070       for (b = class_binding_level; b; b = b->level_chain)
2071         if (b == current_binding_level)
2072           break;
2073       if (b)
2074         b = class_binding_level;
2075       else
2076         b = current_binding_level;
2077     }
2078   else
2079     b = current_binding_level;
2080   print_other_binding_stack (b);
2081   fprintf (stderr, "global:\n");
2082   print_binding_level (global_binding_level);
2083 }
2084
2085 /* Namespace binding access routines: The namespace_bindings field of
2086    the identifier is polymorphic, with three possible values:
2087    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2088    indicating the BINDING_VALUE of global_namespace.  */
2089
2090 /* Check whether the a binding for the name to scope is known.
2091    Assumes that the bindings of the name are already a list
2092    of bindings. Returns the binding found, or NULL_TREE.  */
2093
2094 static tree
2095 find_binding (name, scope)
2096      tree name;
2097      tree scope;
2098 {
2099   tree iter, prev = NULL_TREE;
2100
2101   scope = ORIGINAL_NAMESPACE (scope);
2102
2103   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2104        iter = TREE_CHAIN (iter))
2105     {
2106       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2107       if (BINDING_SCOPE (iter) == scope)
2108         {
2109           /* Move binding found to the front of the list, so
2110              subsequent lookups will find it faster.  */
2111           if (prev)
2112             {
2113               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2114               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2115               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2116             }
2117           return iter;
2118         }
2119       prev = iter;
2120     }
2121   return NULL_TREE;
2122 }
2123
2124 /* Always returns a binding for name in scope. If the
2125    namespace_bindings is not a list, convert it to one first.
2126    If no binding is found, make a new one.  */
2127
2128 tree
2129 binding_for_name (name, scope)
2130      tree name;
2131      tree scope;
2132 {
2133   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2134   tree result;
2135
2136   scope = ORIGINAL_NAMESPACE (scope);
2137
2138   if (b && TREE_CODE (b) != CPLUS_BINDING)
2139     {
2140       /* Get rid of optimization for global scope.  */
2141       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2142       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2143       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2144     }
2145   if (b && (result = find_binding (name, scope)))
2146     return result;
2147   /* Not found, make a new one.  */
2148   result = make_node (CPLUS_BINDING);
2149   TREE_CHAIN (result) = b;
2150   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2151   BINDING_SCOPE (result) = scope;
2152   BINDING_TYPE (result) = NULL_TREE;
2153   BINDING_VALUE (result) = NULL_TREE;
2154   return result;
2155 }
2156
2157 /* Return the binding value for name in scope, considering that
2158    namespace_binding may or may not be a list of CPLUS_BINDINGS.  */
2159
2160 tree
2161 namespace_binding (name, scope)
2162      tree name;
2163      tree scope;
2164 {
2165   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2166   if (b == NULL_TREE)
2167     return NULL_TREE;
2168   if (scope == NULL_TREE)
2169     scope = global_namespace;
2170   if (TREE_CODE (b) != CPLUS_BINDING)
2171     return (scope == global_namespace) ? b : NULL_TREE;
2172   name = find_binding (name,scope);
2173   if (name == NULL_TREE)
2174     return name;
2175   return BINDING_VALUE (name);
2176 }
2177
2178 /* Set the binding value for name in scope. If modifying the binding
2179    of global_namespace is attempted, try to optimize it.  */
2180
2181 void
2182 set_namespace_binding (name, scope, val)
2183      tree name;
2184      tree scope;
2185      tree val;
2186 {
2187   tree b;
2188
2189   if (scope == NULL_TREE)
2190     scope = global_namespace;
2191
2192   if (scope == global_namespace)
2193     {
2194       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2195       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2196         {
2197           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2198           return;
2199         }
2200     }
2201   b = binding_for_name (name, scope);
2202   BINDING_VALUE (b) = val;
2203 }
2204
2205 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2206    select a name that is unique to this compilation unit.  */
2207
2208 void
2209 push_namespace (name)
2210      tree name;
2211 {
2212   tree d = NULL_TREE;
2213   int need_new = 1;
2214   int implicit_use = 0;
2215   int global = 0;
2216   if (!global_namespace)
2217     {
2218       /* This must be ::.  */
2219       my_friendly_assert (name == get_identifier ("::"), 377);
2220       global = 1;
2221     }
2222   else if (!name)
2223     {
2224       /* The name of anonymous namespace is unique for the translation
2225          unit.  */
2226       if (!anonymous_namespace_name)
2227         anonymous_namespace_name = get_file_function_name ('N');
2228       name = anonymous_namespace_name;
2229       d = IDENTIFIER_NAMESPACE_VALUE (name);
2230       if (d)
2231         /* Reopening anonymous namespace.  */
2232         need_new = 0;
2233       implicit_use = 1;
2234     }
2235   else
2236     {
2237       /* Check whether this is an extended namespace definition.  */
2238       d = IDENTIFIER_NAMESPACE_VALUE (name);
2239       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2240         {
2241           need_new = 0;
2242           if (DECL_NAMESPACE_ALIAS (d))
2243             {
2244               error ("namespace alias `%D' not allowed here, assuming `%D'",
2245                         d, DECL_NAMESPACE_ALIAS (d));
2246               d = DECL_NAMESPACE_ALIAS (d);
2247             }
2248         }
2249     }
2250
2251   if (need_new)
2252     {
2253       /* Make a new namespace, binding the name to it.  */
2254       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2255       /* The global namespace is not pushed, and the global binding
2256          level is set elsewhere.  */
2257       if (!global)
2258         {
2259           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2260           d = pushdecl (d);
2261           pushlevel (0);
2262           declare_namespace_level ();
2263           NAMESPACE_LEVEL (d) = current_binding_level;
2264         }
2265     }
2266   else
2267     resume_binding_level (NAMESPACE_LEVEL (d));
2268
2269   if (implicit_use)
2270     do_using_directive (d);
2271   /* Enter the name space.  */
2272   current_namespace = d;
2273 }
2274
2275 /* Pop from the scope of the current namespace.  */
2276
2277 void
2278 pop_namespace ()
2279 {
2280   my_friendly_assert (current_namespace != global_namespace, 20010801);
2281   current_namespace = CP_DECL_CONTEXT (current_namespace);
2282   /* The binding level is not popped, as it might be re-opened later.  */
2283   suspend_binding_level ();
2284 }
2285
2286 /* Push into the scope of the namespace NS, even if it is deeply
2287    nested within another namespace.  */
2288
2289 void
2290 push_nested_namespace (ns)
2291      tree ns;
2292 {
2293   if (ns == global_namespace)
2294     push_to_top_level ();
2295   else
2296     {
2297       push_nested_namespace (CP_DECL_CONTEXT (ns));
2298       push_namespace (DECL_NAME (ns));
2299     }
2300 }
2301
2302 /* Pop back from the scope of the namespace NS, which was previously
2303    entered with push_nested_namespace.  */
2304
2305 void
2306 pop_nested_namespace (ns)
2307      tree ns;
2308 {
2309   while (ns != global_namespace)
2310     {
2311       pop_namespace ();
2312       ns = CP_DECL_CONTEXT (ns);
2313     }
2314
2315   pop_from_top_level ();
2316 }
2317
2318 \f
2319 /* Subroutines for reverting temporarily to top-level for instantiation
2320    of templates and such.  We actually need to clear out the class- and
2321    local-value slots of all identifiers, so that only the global values
2322    are at all visible.  Simply setting current_binding_level to the global
2323    scope isn't enough, because more binding levels may be pushed.  */
2324 struct saved_scope *scope_chain;
2325
2326 static tree
2327 store_bindings (names, old_bindings)
2328      tree names, old_bindings;
2329 {
2330   tree t;
2331   tree search_bindings = old_bindings;
2332
2333   for (t = names; t; t = TREE_CHAIN (t))
2334     {
2335       tree binding, t1, id;
2336
2337       if (TREE_CODE (t) == TREE_LIST)
2338         id = TREE_PURPOSE (t);
2339       else
2340         id = DECL_NAME (t);
2341
2342       if (!id
2343           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2344              we have no IDENTIFIER_BINDING if we have left the class
2345              scope, but cached the class-level declarations.  */
2346           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2347         continue;
2348
2349       for (t1 = search_bindings; t1; t1 = TREE_CHAIN (t1))
2350         if (TREE_VEC_ELT (t1, 0) == id)
2351           goto skip_it;
2352
2353       my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2354       binding = make_tree_vec (4);
2355       TREE_VEC_ELT (binding, 0) = id;
2356       TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2357       TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2358       TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2359       IDENTIFIER_BINDING (id) = NULL_TREE;
2360       IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2361       TREE_CHAIN (binding) = old_bindings;
2362       old_bindings = binding;
2363     skip_it:
2364       ;
2365     }
2366   return old_bindings;
2367 }
2368
2369 void
2370 maybe_push_to_top_level (pseudo)
2371      int pseudo;
2372 {
2373   struct saved_scope *s;
2374   struct cp_binding_level *b;
2375   tree old_bindings;
2376   int need_pop;
2377
2378   s = (struct saved_scope *) ggc_alloc_cleared (sizeof (struct saved_scope));
2379
2380   b = scope_chain ? current_binding_level : 0;
2381
2382   /* If we're in the middle of some function, save our state.  */
2383   if (cfun)
2384     {
2385       need_pop = 1;
2386       push_function_context_to (NULL_TREE);
2387     }
2388   else
2389     need_pop = 0;
2390
2391   old_bindings = NULL_TREE;
2392   if (scope_chain && previous_class_type)
2393     old_bindings = store_bindings (previous_class_values, old_bindings);
2394
2395   /* Have to include global_binding_level, because class-level decls
2396      aren't listed anywhere useful.  */
2397   for (; b; b = b->level_chain)
2398     {
2399       tree t;
2400
2401       /* Template IDs are inserted into the global level. If they were
2402          inserted into namespace level, finish_file wouldn't find them
2403          when doing pending instantiations. Therefore, don't stop at
2404          namespace level, but continue until :: .  */
2405       if (b == global_binding_level || (pseudo && b->template_parms_p))
2406         break;
2407
2408       old_bindings = store_bindings (b->names, old_bindings);
2409       /* We also need to check class_shadowed to save class-level type
2410          bindings, since pushclass doesn't fill in b->names.  */
2411       if (b->parm_flag == 2)
2412         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2413
2414       /* Unwind type-value slots back to top level.  */
2415       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2416         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2417     }
2418   s->prev = scope_chain;
2419   s->old_bindings = old_bindings;
2420   s->bindings = b;
2421   s->need_pop_function_context = need_pop;
2422   s->function_decl = current_function_decl;
2423   s->last_parms = last_function_parms;
2424   s->check_access = flag_access_control;
2425
2426   scope_chain = s;
2427   current_function_decl = NULL_TREE;
2428   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2429   current_lang_name = lang_name_cplusplus;
2430   current_namespace = global_namespace;
2431 }
2432
2433 void
2434 push_to_top_level ()
2435 {
2436   maybe_push_to_top_level (0);
2437 }
2438
2439 void
2440 pop_from_top_level ()
2441 {
2442   struct saved_scope *s = scope_chain;
2443   tree t;
2444
2445   /* Clear out class-level bindings cache.  */
2446   if (previous_class_type)
2447     invalidate_class_lookup_cache ();
2448
2449   current_lang_base = 0;
2450
2451   scope_chain = s->prev;
2452   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2453     {
2454       tree id = TREE_VEC_ELT (t, 0);
2455
2456       SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2457       IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2458       IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2459     }
2460
2461   /* If we were in the middle of compiling a function, restore our
2462      state.  */
2463   if (s->need_pop_function_context)
2464     pop_function_context_from (NULL_TREE);
2465   current_function_decl = s->function_decl;
2466   last_function_parms = s->last_parms;
2467 }
2468 \f
2469 /* Push a definition of struct, union or enum tag "name".
2470    into binding_level "b".   "type" should be the type node,
2471    We assume that the tag "name" is not already defined.
2472
2473    Note that the definition may really be just a forward reference.
2474    In that case, the TYPE_SIZE will be a NULL_TREE.
2475
2476    C++ gratuitously puts all these tags in the name space.  */
2477
2478 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2479    record the shadowed value for this binding contour.  TYPE is
2480    the type that ID maps to.  */
2481
2482 static void
2483 set_identifier_type_value_with_scope (id, type, b)
2484      tree id;
2485      tree type;
2486      struct cp_binding_level *b;
2487 {
2488   if (!b->namespace_p)
2489     {
2490       /* Shadow the marker, not the real thing, so that the marker
2491          gets restored later.  */
2492       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2493       b->type_shadowed
2494         = tree_cons (id, old_type_value, b->type_shadowed);
2495     }
2496   else
2497     {
2498       tree binding = binding_for_name (id, current_namespace);
2499       BINDING_TYPE (binding) = type;
2500       /* Store marker instead of real type.  */
2501       type = global_type_node;
2502     }
2503   SET_IDENTIFIER_TYPE_VALUE (id, type);
2504 }
2505
2506 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2507
2508 void
2509 set_identifier_type_value (id, type)
2510      tree id;
2511      tree type;
2512 {
2513   set_identifier_type_value_with_scope (id, type, current_binding_level);
2514 }
2515
2516 /* Return the type associated with id.  */
2517
2518 tree
2519 identifier_type_value (id)
2520      tree id;
2521 {
2522   /* There is no type with that name, anywhere.  */
2523   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2524     return NULL_TREE;
2525   /* This is not the type marker, but the real thing.  */
2526   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2527     return REAL_IDENTIFIER_TYPE_VALUE (id);
2528   /* Have to search for it. It must be on the global level, now.
2529      Ask lookup_name not to return non-types. */
2530   id = lookup_name_real (id, 2, 1, 0, LOOKUP_COMPLAIN);
2531   if (id)
2532     return TREE_TYPE (id);
2533   return NULL_TREE;
2534 }
2535
2536 /* Pop off extraneous binding levels left over due to syntax errors.
2537
2538    We don't pop past namespaces, as they might be valid.  */
2539
2540 void
2541 pop_everything ()
2542 {
2543 #ifdef DEBUG_BINDING_LEVELS
2544   fprintf (stderr, "XXX entering pop_everything ()\n");
2545 #endif
2546   while (!toplevel_bindings_p ())
2547     {
2548       if (current_binding_level->parm_flag == 2)
2549         pop_nested_class ();
2550       else
2551         poplevel (0, 0, 0);
2552     }
2553 #ifdef DEBUG_BINDING_LEVELS
2554   fprintf (stderr, "XXX leaving pop_everything ()\n");
2555 #endif
2556 }
2557
2558 /* The type TYPE is being declared.  If it is a class template, or a
2559    specialization of a class template, do any processing required and
2560    perform error-checking.  If IS_FRIEND is nonzero, this TYPE is
2561    being declared a friend.  B is the binding level at which this TYPE
2562    should be bound.
2563
2564    Returns the TYPE_DECL for TYPE, which may have been altered by this
2565    processing.  */
2566
2567 static tree
2568 maybe_process_template_type_declaration (type, globalize, b)
2569      tree type;
2570      int globalize;
2571      struct cp_binding_level* b;
2572 {
2573   tree decl = TYPE_NAME (type);
2574
2575   if (processing_template_parmlist)
2576     /* You can't declare a new template type in a template parameter
2577        list.  But, you can declare a non-template type:
2578
2579          template <class A*> struct S;
2580
2581        is a forward-declaration of `A'.  */
2582     ;
2583   else
2584     {
2585       maybe_check_template_type (type);
2586
2587       my_friendly_assert (IS_AGGR_TYPE (type)
2588                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2589
2590
2591       if (processing_template_decl)
2592         {
2593           /* This may change after the call to
2594              push_template_decl_real, but we want the original value.  */
2595           tree name = DECL_NAME (decl);
2596
2597           decl = push_template_decl_real (decl, globalize);
2598           /* If the current binding level is the binding level for the
2599              template parameters (see the comment in
2600              begin_template_parm_list) and the enclosing level is a class
2601              scope, and we're not looking at a friend, push the
2602              declaration of the member class into the class scope.  In the
2603              friend case, push_template_decl will already have put the
2604              friend into global scope, if appropriate.  */
2605           if (TREE_CODE (type) != ENUMERAL_TYPE
2606               && !globalize && b->template_parms_p
2607               && b->level_chain->parm_flag == 2)
2608             {
2609               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2610               /* Put this tag on the list of tags for the class, since
2611                  that won't happen below because B is not the class
2612                  binding level, but is instead the pseudo-global level.  */
2613               b->level_chain->tags =
2614                 tree_cons (name, type, b->level_chain->tags);
2615               if (!COMPLETE_TYPE_P (current_class_type))
2616                 {
2617                   maybe_add_class_template_decl_list (current_class_type,
2618                                                       type, /*friend_p=*/0);
2619                   CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2620                 }
2621             }
2622         }
2623     }
2624
2625   return decl;
2626 }
2627
2628 /* In C++, you don't have to write `struct S' to refer to `S'; you
2629    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2630    if the user had written `typedef struct S S'.  Create and return
2631    the TYPE_DECL for TYPE.  */
2632
2633 tree
2634 create_implicit_typedef (name, type)
2635      tree name;
2636      tree type;
2637 {
2638   tree decl;
2639
2640   decl = build_decl (TYPE_DECL, name, type);
2641   DECL_ARTIFICIAL (decl) = 1;
2642   /* There are other implicit type declarations, like the one *within*
2643      a class that allows you to write `S::S'.  We must distinguish
2644      amongst these.  */
2645   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2646   TYPE_NAME (type) = decl;
2647
2648   return decl;
2649 }
2650
2651 /* Remember a local name for name-mangling purposes.  */
2652
2653 static void
2654 push_local_name (decl)
2655      tree decl;
2656 {
2657   size_t i, nelts;
2658   tree t, name;
2659
2660   if (!local_names)
2661     VARRAY_TREE_INIT (local_names, 8, "local_names");
2662
2663   name = DECL_NAME (decl);
2664
2665   nelts = VARRAY_ACTIVE_SIZE (local_names);
2666   for (i = 0; i < nelts; i++)
2667     {
2668       t = VARRAY_TREE (local_names, i);
2669       if (DECL_NAME (t) == name)
2670         {
2671           if (!DECL_LANG_SPECIFIC (decl))
2672             retrofit_lang_decl (decl);
2673           DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
2674           if (DECL_LANG_SPECIFIC (t))
2675             DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
2676           else
2677             DECL_DISCRIMINATOR (decl) = 1;
2678
2679           VARRAY_TREE (local_names, i) = decl;
2680           return;
2681         }
2682     }
2683
2684   VARRAY_PUSH_TREE (local_names, decl);
2685 }
2686
2687 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2688    Normally put it into the inner-most non-tag-transparent scope,
2689    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2690    The latter is needed for implicit declarations.  */
2691
2692 void
2693 pushtag (name, type, globalize)
2694      tree name, type;
2695      int globalize;
2696 {
2697   register struct cp_binding_level *b;
2698
2699   b = current_binding_level;
2700   while (b->tag_transparent
2701          || (b->parm_flag == 2
2702              && (globalize
2703                  /* We may be defining a new type in the initializer
2704                     of a static member variable. We allow this when
2705                     not pedantic, and it is particularly useful for
2706                     type punning via an anonymous union.  */
2707                  || COMPLETE_TYPE_P (b->this_class))))
2708     b = b->level_chain;
2709
2710   b->tags = tree_cons (name, type, b->tags);
2711
2712   if (name)
2713     {
2714       /* Do C++ gratuitous typedefing.  */
2715       if (IDENTIFIER_TYPE_VALUE (name) != type)
2716         {
2717           register tree d = NULL_TREE;
2718           int in_class = 0;
2719           tree context = TYPE_CONTEXT (type);
2720
2721           if (! context)
2722             {
2723               tree cs = current_scope ();
2724
2725               if (! globalize)
2726                 context = cs;
2727               else if (cs != NULL_TREE && TYPE_P (cs))
2728                 /* When declaring a friend class of a local class, we want
2729                    to inject the newly named class into the scope
2730                    containing the local class, not the namespace scope.  */
2731                 context = decl_function_context (get_type_decl (cs));
2732             }
2733           if (!context)
2734             context = current_namespace;
2735
2736           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2737               || b->parm_flag == 2)
2738             in_class = 1;
2739
2740           if (current_lang_name == lang_name_java)
2741             TYPE_FOR_JAVA (type) = 1;
2742
2743           d = create_implicit_typedef (name, type);
2744           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2745           if (! in_class)
2746             set_identifier_type_value_with_scope (name, type, b);
2747
2748           d = maybe_process_template_type_declaration (type,
2749                                                        globalize, b);
2750
2751           if (b->parm_flag == 2)
2752             {
2753               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2754                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2755                    class.  But if it's a member template class, we
2756                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2757                    is done later.  */
2758                 finish_member_declaration (d);
2759               else
2760                 pushdecl_class_level (d);
2761             }
2762           else
2763             d = pushdecl_with_scope (d, b);
2764
2765           /* FIXME what if it gets a name from typedef?  */
2766           if (ANON_AGGRNAME_P (name))
2767             DECL_IGNORED_P (d) = 1;
2768
2769           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2770
2771           /* If this is a local class, keep track of it.  We need this
2772              information for name-mangling, and so that it is possible to find
2773              all function definitions in a translation unit in a convenient
2774              way.  (It's otherwise tricky to find a member function definition
2775              it's only pointed to from within a local class.)  */
2776           if (TYPE_CONTEXT (type)
2777               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2778               && !processing_template_decl)
2779             VARRAY_PUSH_TREE (local_classes, type);
2780         }
2781       if (b->parm_flag == 2)
2782         {
2783           if (!COMPLETE_TYPE_P (current_class_type))
2784             {
2785               maybe_add_class_template_decl_list (current_class_type,
2786                                                   type, /*friend_p=*/0);
2787               CLASSTYPE_TAGS (current_class_type) = b->tags;
2788             }
2789         }
2790     }
2791
2792   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2793     /* Use the canonical TYPE_DECL for this node.  */
2794     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2795   else
2796     {
2797       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2798          will be the tagged type we just added to the current
2799          binding level.  This fake NULL-named TYPE_DECL node helps
2800          dwarfout.c to know when it needs to output a
2801          representation of a tagged type, and it also gives us a
2802          convenient place to record the "scope start" address for
2803          the tagged type.  */
2804
2805       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2806       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2807     }
2808 }
2809
2810 /* Counter used to create anonymous type names.  */
2811
2812 static int anon_cnt = 0;
2813
2814 /* Return an IDENTIFIER which can be used as a name for
2815    anonymous structs and unions.  */
2816
2817 tree
2818 make_anon_name ()
2819 {
2820   char buf[32];
2821
2822   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2823   return get_identifier (buf);
2824 }
2825
2826 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2827    This keeps dbxout from getting confused.  */
2828
2829 void
2830 clear_anon_tags ()
2831 {
2832   register struct cp_binding_level *b;
2833   register tree tags;
2834   static int last_cnt = 0;
2835
2836   /* Fast out if no new anon names were declared.  */
2837   if (last_cnt == anon_cnt)
2838     return;
2839
2840   b = current_binding_level;
2841   while (b->tag_transparent)
2842     b = b->level_chain;
2843   tags = b->tags;
2844   while (tags)
2845     {
2846       /* A NULL purpose means we have already processed all tags
2847          from here to the end of the list.  */
2848       if (TREE_PURPOSE (tags) == NULL_TREE)
2849         break;
2850       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2851         TREE_PURPOSE (tags) = NULL_TREE;
2852       tags = TREE_CHAIN (tags);
2853     }
2854   last_cnt = anon_cnt;
2855 }
2856 \f
2857 /* Subroutine of duplicate_decls: return truthvalue of whether
2858    or not types of these decls match.
2859
2860    For C++, we must compare the parameter list so that `int' can match
2861    `int&' in a parameter position, but `int&' is not confused with
2862    `const int&'.  */
2863
2864 int
2865 decls_match (newdecl, olddecl)
2866      tree newdecl, olddecl;
2867 {
2868   int types_match;
2869
2870   if (newdecl == olddecl)
2871     return 1;
2872
2873   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2874     /* If the two DECLs are not even the same kind of thing, we're not
2875        interested in their types.  */
2876     return 0;
2877
2878   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2879     {
2880       tree f1 = TREE_TYPE (newdecl);
2881       tree f2 = TREE_TYPE (olddecl);
2882       tree p1 = TYPE_ARG_TYPES (f1);
2883       tree p2 = TYPE_ARG_TYPES (f2);
2884
2885       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2886           && ! (DECL_EXTERN_C_P (newdecl)
2887                 && DECL_EXTERN_C_P (olddecl)))
2888         return 0;
2889
2890       if (TREE_CODE (f1) != TREE_CODE (f2))
2891         return 0;
2892
2893       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2894         {
2895           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
2896               && (DECL_BUILT_IN (olddecl)
2897 #ifndef NO_IMPLICIT_EXTERN_C
2898                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
2899                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
2900 #endif
2901               ))
2902             {
2903               types_match = self_promoting_args_p (p1);
2904               if (p1 == void_list_node)
2905                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2906             }
2907 #ifndef NO_IMPLICIT_EXTERN_C
2908           else if (p1 == NULL_TREE
2909                    && (DECL_EXTERN_C_P (olddecl)
2910                        && DECL_IN_SYSTEM_HEADER (olddecl)
2911                        && !DECL_CLASS_SCOPE_P (olddecl))
2912                    && (DECL_EXTERN_C_P (newdecl)
2913                        && DECL_IN_SYSTEM_HEADER (newdecl)
2914                        && !DECL_CLASS_SCOPE_P (newdecl)))
2915             {
2916               types_match = self_promoting_args_p (p2);
2917               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2918             }
2919 #endif
2920           else
2921             types_match = compparms (p1, p2);
2922         }
2923       else
2924         types_match = 0;
2925     }
2926   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2927     {
2928       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2929                                 DECL_TEMPLATE_PARMS (olddecl)))
2930         return 0;
2931
2932       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
2933           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
2934         return 0;
2935
2936       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2937         types_match = 1;
2938       else
2939         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2940                                    DECL_TEMPLATE_RESULT (newdecl));
2941     }
2942   else
2943     {
2944       if (TREE_TYPE (newdecl) == error_mark_node)
2945         types_match = TREE_TYPE (olddecl) == error_mark_node;
2946       else if (TREE_TYPE (olddecl) == NULL_TREE)
2947         types_match = TREE_TYPE (newdecl) == NULL_TREE;
2948       else if (TREE_TYPE (newdecl) == NULL_TREE)
2949         types_match = 0;
2950       else
2951         types_match = comptypes (TREE_TYPE (newdecl),
2952                                  TREE_TYPE (olddecl),
2953                                  COMPARE_REDECLARATION);
2954     }
2955
2956   return types_match;
2957 }
2958
2959 /* If NEWDECL is `static' and an `extern' was seen previously,
2960    warn about it.  OLDDECL is the previous declaration.
2961
2962    Note that this does not apply to the C++ case of declaring
2963    a variable `extern const' and then later `const'.
2964
2965    Don't complain about built-in functions, since they are beyond
2966    the user's control.  */
2967
2968 static void
2969 warn_extern_redeclared_static (newdecl, olddecl)
2970      tree newdecl, olddecl;
2971 {
2972   static const char *const explicit_extern_static_warning
2973     = "`%D' was declared `extern' and later `static'";
2974   static const char *const implicit_extern_static_warning
2975     = "`%D' was declared implicitly `extern' and later `static'";
2976
2977   tree name;
2978
2979   if (TREE_CODE (newdecl) == TYPE_DECL
2980       || TREE_CODE (newdecl) == TEMPLATE_DECL
2981       || TREE_CODE (newdecl) == CONST_DECL)
2982     return;
2983
2984   /* Don't get confused by static member functions; that's a different
2985      use of `static'.  */
2986   if (TREE_CODE (newdecl) == FUNCTION_DECL
2987       && DECL_STATIC_FUNCTION_P (newdecl))
2988     return;
2989
2990   /* If the old declaration was `static', or the new one isn't, then
2991      then everything is OK.  */
2992   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
2993     return;
2994
2995   /* It's OK to declare a builtin function as `static'.  */
2996   if (TREE_CODE (olddecl) == FUNCTION_DECL
2997       && DECL_ARTIFICIAL (olddecl))
2998     return;
2999
3000   name = DECL_ASSEMBLER_NAME (newdecl);
3001   pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3002               ? implicit_extern_static_warning
3003               : explicit_extern_static_warning, newdecl);
3004   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3005 }
3006
3007 /* Handle when a new declaration NEWDECL has the same name as an old
3008    one OLDDECL in the same binding contour.  Prints an error message
3009    if appropriate.
3010
3011    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3012    Otherwise, return 0.  */
3013
3014 int
3015 duplicate_decls (newdecl, olddecl)
3016      tree newdecl, olddecl;
3017 {
3018   unsigned olddecl_uid = DECL_UID (olddecl);
3019   int olddecl_friend = 0, types_match = 0;
3020   int new_defines_function = 0;
3021
3022   if (newdecl == olddecl)
3023     return 1;
3024
3025   types_match = decls_match (newdecl, olddecl);
3026
3027   /* If either the type of the new decl or the type of the old decl is an
3028      error_mark_node, then that implies that we have already issued an
3029      error (earlier) for some bogus type specification, and in that case,
3030      it is rather pointless to harass the user with yet more error message
3031      about the same declaration, so just pretend the types match here.  */
3032   if (TREE_TYPE (newdecl) == error_mark_node
3033       || TREE_TYPE (olddecl) == error_mark_node)
3034     types_match = 1;
3035
3036   if (DECL_P (olddecl)
3037       && TREE_CODE (newdecl) == FUNCTION_DECL
3038       && TREE_CODE (olddecl) == FUNCTION_DECL
3039       && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
3040     {
3041       if (DECL_DECLARED_INLINE_P (newdecl)
3042           && DECL_UNINLINABLE (newdecl)
3043           && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
3044         /* Already warned elsewhere.  */;
3045       else if (DECL_DECLARED_INLINE_P (olddecl)
3046                && DECL_UNINLINABLE (olddecl)
3047                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
3048         /* Already warned.  */;
3049       else if (DECL_DECLARED_INLINE_P (newdecl)
3050                && DECL_UNINLINABLE (olddecl)
3051                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
3052         {
3053           warning_with_decl (newdecl,
3054                              "function `%s' redeclared as inline");
3055           warning_with_decl (olddecl,
3056                              "previous declaration of function `%s' with attribute noinline");
3057         }
3058       else if (DECL_DECLARED_INLINE_P (olddecl)
3059                && DECL_UNINLINABLE (newdecl)
3060                && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
3061         {
3062           warning_with_decl (newdecl,
3063                              "function `%s' redeclared with attribute noinline");
3064           warning_with_decl (olddecl,
3065                              "previous declaration of function `%s' was inline");
3066         }
3067     }
3068
3069   /* Check for redeclaration and other discrepancies.  */
3070   if (TREE_CODE (olddecl) == FUNCTION_DECL
3071       && DECL_ARTIFICIAL (olddecl))
3072     {
3073       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3074         {
3075           /* Avoid warnings redeclaring anticipated built-ins.  */
3076           if (DECL_ANTICIPATED (olddecl))
3077             return 0;
3078
3079           /* If you declare a built-in or predefined function name as static,
3080              the old definition is overridden, but optionally warn this was a
3081              bad choice of name.  */
3082           if (! TREE_PUBLIC (newdecl))
3083             {
3084               if (warn_shadow)
3085                 warning ("shadowing %s function `%#D'",
3086                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3087                             olddecl);
3088               /* Discard the old built-in function.  */
3089               return 0;
3090             }
3091           /* If the built-in is not ansi, then programs can override
3092              it even globally without an error.  */
3093           else if (! DECL_BUILT_IN (olddecl))
3094             warning ("library function `%#D' redeclared as non-function `%#D'",
3095                         olddecl, newdecl);
3096           else
3097             {
3098               error ("declaration of `%#D'", newdecl);
3099               error ("conflicts with built-in declaration `%#D'",
3100                         olddecl);
3101             }
3102           return 0;
3103         }
3104       else if (!types_match)
3105         {
3106           /* Avoid warnings redeclaring anticipated built-ins.  */
3107           if (DECL_ANTICIPATED (olddecl))
3108             ;  /* Do nothing yet.  */
3109           else if ((DECL_EXTERN_C_P (newdecl)
3110                && DECL_EXTERN_C_P (olddecl))
3111               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3112                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3113             {
3114               /* A near match; override the builtin.  */
3115
3116               if (TREE_PUBLIC (newdecl))
3117                 {
3118                   warning ("new declaration `%#D'", newdecl);
3119                   warning ("ambiguates built-in declaration `%#D'",
3120                               olddecl);
3121                 }
3122               else if (warn_shadow)
3123                 warning ("shadowing %s function `%#D'",
3124                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3125                             olddecl);
3126             }
3127           else
3128             /* Discard the old built-in function.  */
3129             return 0;
3130
3131           /* Replace the old RTL to avoid problems with inlining.  */
3132           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3133         }
3134
3135       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3136         {
3137           /* If a builtin function is redeclared as `static', merge
3138              the declarations, but make the original one static.  */
3139           DECL_THIS_STATIC (olddecl) = 1;
3140           TREE_PUBLIC (olddecl) = 0;
3141
3142           /* Make the old declaration consistent with the new one so
3143              that all remnants of the builtin-ness of this function
3144              will be banished.  */
3145           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3146           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3147         }
3148     }
3149   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3150     {
3151       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3152            && TREE_CODE (newdecl) != TYPE_DECL
3153            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3154                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3155           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3156               && TREE_CODE (olddecl) != TYPE_DECL
3157               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3158                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3159                         == TYPE_DECL))))
3160         {
3161           /* We do nothing special here, because C++ does such nasty
3162              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3163              get shadowed, and know that if we need to find a TYPE_DECL
3164              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3165              slot of the identifier.  */
3166           return 0;
3167         }
3168
3169       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3170            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3171           || (TREE_CODE (olddecl) == FUNCTION_DECL
3172               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3173         return 0;
3174
3175       error ("`%#D' redeclared as different kind of symbol", newdecl);
3176       if (TREE_CODE (olddecl) == TREE_LIST)
3177         olddecl = TREE_VALUE (olddecl);
3178       cp_error_at ("previous declaration of `%#D'", olddecl);
3179
3180       /* New decl is completely inconsistent with the old one =>
3181          tell caller to replace the old one.  */
3182
3183       return 0;
3184     }
3185   else if (!types_match)
3186     {
3187       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3188         /* These are certainly not duplicate declarations; they're
3189            from different scopes.  */
3190         return 0;
3191
3192       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3193         {
3194           /* The name of a class template may not be declared to refer to
3195              any other template, class, function, object, namespace, value,
3196              or type in the same scope.  */
3197           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3198               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3199             {
3200               error ("declaration of template `%#D'", newdecl);
3201               cp_error_at ("conflicts with previous declaration `%#D'",
3202                            olddecl);
3203             }
3204           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3205                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3206                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3207                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3208                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3209                                            DECL_TEMPLATE_PARMS (olddecl))
3210                    /* Template functions can be disambiguated by
3211                       return type.  */
3212                    && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
3213                                    TREE_TYPE (TREE_TYPE (olddecl))))
3214             {
3215               error ("new declaration `%#D'", newdecl);
3216               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3217             }
3218           return 0;
3219         }
3220       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3221         {
3222           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3223             {
3224               error ("declaration of C function `%#D' conflicts with",
3225                         newdecl);
3226               cp_error_at ("previous declaration `%#D' here", olddecl);
3227             }
3228           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3229                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3230             {
3231               error ("new declaration `%#D'", newdecl);
3232               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3233             }
3234           else
3235             return 0;
3236         }
3237
3238       /* Already complained about this, so don't do so again.  */
3239       else if (current_class_type == NULL_TREE
3240           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3241         {
3242           error ("conflicting types for `%#D'", newdecl);
3243           cp_error_at ("previous declaration as `%#D'", olddecl);
3244         }
3245     }
3246   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3247             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3248                  && (!DECL_TEMPLATE_INFO (newdecl)
3249                      || (DECL_TI_TEMPLATE (newdecl)
3250                          != DECL_TI_TEMPLATE (olddecl))))
3251                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3252                     && (!DECL_TEMPLATE_INFO (olddecl)
3253                         || (DECL_TI_TEMPLATE (olddecl)
3254                             != DECL_TI_TEMPLATE (newdecl))))))
3255     /* It's OK to have a template specialization and a non-template
3256        with the same type, or to have specializations of two
3257        different templates with the same type.  Note that if one is a
3258        specialization, and the other is an instantiation of the same
3259        template, that we do not exit at this point.  That situation
3260        can occur if we instantiate a template class, and then
3261        specialize one of its methods.  This situation is valid, but
3262        the declarations must be merged in the usual way.  */
3263     return 0;
3264   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3265            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3266                 && !DECL_USE_TEMPLATE (newdecl))
3267                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3268                    && !DECL_USE_TEMPLATE (olddecl))))
3269     /* One of the declarations is a template instantiation, and the
3270        other is not a template at all.  That's OK.  */
3271     return 0;
3272   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3273            && DECL_NAMESPACE_ALIAS (newdecl)
3274            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3275     /* Redeclaration of namespace alias, ignore it.  */
3276     return 1;
3277   else
3278     {
3279       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3280       if (errmsg)
3281         {
3282           error (errmsg, newdecl);
3283           if (DECL_NAME (olddecl) != NULL_TREE)
3284             cp_error_at ((DECL_INITIAL (olddecl)
3285                           && namespace_bindings_p ())
3286                          ? "`%#D' previously defined here"
3287                          : "`%#D' previously declared here", olddecl);
3288           return 0;
3289         }
3290       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3291                && DECL_INITIAL (olddecl) != NULL_TREE
3292                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3293                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3294         {
3295           /* Prototype decl follows defn w/o prototype.  */
3296           cp_warning_at ("prototype for `%#D'", newdecl);
3297           cp_warning_at ("follows non-prototype definition here", olddecl);
3298         }
3299       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3300                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3301         {
3302           /* extern "C" int foo ();
3303              int foo () { bar (); }
3304              is OK.  */
3305           if (current_lang_depth () == 0)
3306             SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3307           else
3308             {
3309               cp_error_at ("previous declaration of `%#D' with %L linkage",
3310                            olddecl, DECL_LANGUAGE (olddecl));
3311               error ("conflicts with new declaration with %L linkage",
3312                         DECL_LANGUAGE (newdecl));
3313             }
3314         }
3315
3316       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3317         ;
3318       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3319         {
3320           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3321           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3322           int i = 1;
3323
3324           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3325             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3326
3327           for (; t1 && t1 != void_list_node;
3328                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3329             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3330               {
3331                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3332                                            TREE_PURPOSE (t2)))
3333                   {
3334                     pedwarn ("default argument given for parameter %d of `%#D'",
3335                              i, newdecl);
3336                     cp_pedwarn_at ("after previous specification in `%#D'",
3337                                    olddecl);
3338                   }
3339                 else
3340                   {
3341                     error ("default argument given for parameter %d of `%#D'",
3342                               i, newdecl);
3343                     cp_error_at ("after previous specification in `%#D'",
3344                                  olddecl);
3345                   }
3346               }
3347
3348           if (DECL_DECLARED_INLINE_P (newdecl)
3349               && ! DECL_DECLARED_INLINE_P (olddecl)
3350               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3351             {
3352               warning ("`%#D' was used before it was declared inline",
3353                           newdecl);
3354               cp_warning_at ("previous non-inline declaration here",
3355                              olddecl);
3356             }
3357         }
3358     }
3359
3360   /* Do not merge an implicit typedef with an explicit one.  In:
3361
3362        class A;
3363        ...
3364        typedef class A A __attribute__ ((foo));
3365
3366      the attribute should apply only to the typedef.  */
3367   if (TREE_CODE (olddecl) == TYPE_DECL
3368       && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
3369           || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
3370     return 0;
3371
3372   /* If new decl is `static' and an `extern' was seen previously,
3373      warn about it.  */
3374   warn_extern_redeclared_static (newdecl, olddecl);
3375
3376   /* We have committed to returning 1 at this point.  */
3377   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3378     {
3379       /* Now that functions must hold information normally held
3380          by field decls, there is extra work to do so that
3381          declaration information does not get destroyed during
3382          definition.  */
3383       if (DECL_VINDEX (olddecl))
3384         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3385       if (DECL_CONTEXT (olddecl))
3386         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3387       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3388       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3389       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3390       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3391       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3392       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3393       if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
3394         SET_OVERLOADED_OPERATOR_CODE
3395           (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
3396       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3397
3398       /* Optionally warn about more than one declaration for the same
3399          name, but don't warn about a function declaration followed by a
3400          definition.  */
3401       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3402           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3403           /* Don't warn about extern decl followed by definition.  */
3404           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3405           /* Don't warn about friends, let add_friend take care of it.  */
3406           && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
3407         {
3408           warning ("redundant redeclaration of `%D' in same scope", newdecl);
3409           cp_warning_at ("previous declaration of `%D'", olddecl);
3410         }
3411     }
3412
3413   /* Deal with C++: must preserve virtual function table size.  */
3414   if (TREE_CODE (olddecl) == TYPE_DECL)
3415     {
3416       register tree newtype = TREE_TYPE (newdecl);
3417       register tree oldtype = TREE_TYPE (olddecl);
3418
3419       if (newtype != error_mark_node && oldtype != error_mark_node
3420           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3421         CLASSTYPE_FRIEND_CLASSES (newtype)
3422           = CLASSTYPE_FRIEND_CLASSES (oldtype);
3423 \
3424       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3425     }
3426
3427   /* Copy all the DECL_... slots specified in the new decl
3428      except for any that we copy here from the old type.  */
3429   DECL_ATTRIBUTES (newdecl)
3430     = (*targetm.merge_decl_attributes) (olddecl, newdecl);
3431
3432   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3433     {
3434       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3435       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3436         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3437                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3438
3439       /* If the new declaration is a definition, update the file and
3440          line information on the declaration.  */
3441       if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
3442           && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
3443         {
3444           DECL_SOURCE_LOCATION (olddecl)
3445             = DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (olddecl))
3446             = DECL_SOURCE_LOCATION (newdecl);
3447         }
3448
3449       return 1;
3450     }
3451
3452   if (types_match)
3453     {
3454       /* Automatically handles default parameters.  */
3455       tree oldtype = TREE_TYPE (olddecl);
3456       tree newtype;
3457
3458       /* Merge the data types specified in the two decls.  */
3459       newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3460
3461       /* If merge_types produces a non-typedef type, just use the old type.  */
3462       if (TREE_CODE (newdecl) == TYPE_DECL
3463           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3464         newtype = oldtype;
3465
3466       if (TREE_CODE (newdecl) == VAR_DECL)
3467         {
3468           DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3469           DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
3470         }
3471
3472       /* Do this after calling `merge_types' so that default
3473          parameters don't confuse us.  */
3474       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3475           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3476               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3477         {
3478           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3479                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3480           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3481                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3482
3483           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3484               && DECL_SOURCE_LINE (olddecl) != 0
3485               && flag_exceptions
3486               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3487                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3488             {
3489               error ("declaration of `%F' throws different exceptions",
3490                         newdecl);
3491               cp_error_at ("than previous declaration `%F'", olddecl);
3492             }
3493         }
3494       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3495
3496       /* Lay the type out, unless already done.  */
3497       if (! same_type_p (newtype, oldtype)
3498           && TREE_TYPE (newdecl) != error_mark_node
3499           && !(processing_template_decl && uses_template_parms (newdecl)))
3500         layout_type (TREE_TYPE (newdecl));
3501
3502       if ((TREE_CODE (newdecl) == VAR_DECL
3503            || TREE_CODE (newdecl) == PARM_DECL
3504            || TREE_CODE (newdecl) == RESULT_DECL
3505            || TREE_CODE (newdecl) == FIELD_DECL
3506            || TREE_CODE (newdecl) == TYPE_DECL)
3507           && !(processing_template_decl && uses_template_parms (newdecl)))
3508         layout_decl (newdecl, 0);
3509
3510       /* Merge the type qualifiers.  */
3511       if (TREE_READONLY (newdecl))
3512         TREE_READONLY (olddecl) = 1;
3513       if (TREE_THIS_VOLATILE (newdecl))
3514         TREE_THIS_VOLATILE (olddecl) = 1;
3515
3516       /* Merge the initialization information.  */
3517       if (DECL_INITIAL (newdecl) == NULL_TREE
3518           && DECL_INITIAL (olddecl) != NULL_TREE)
3519         {
3520           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3521           DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
3522           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3523               && DECL_LANG_SPECIFIC (newdecl)
3524               && DECL_LANG_SPECIFIC (olddecl))
3525             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3526         }
3527
3528       /* Merge the section attribute.
3529          We want to issue an error if the sections conflict but that must be
3530          done later in decl_attributes since we are called before attributes
3531          are assigned.  */
3532       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3533         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3534
3535       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3536         {
3537           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3538             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3539           DECL_NO_LIMIT_STACK (newdecl)
3540             |= DECL_NO_LIMIT_STACK (olddecl);
3541           /* Keep the old RTL.  */
3542           COPY_DECL_RTL (olddecl, newdecl);
3543         }
3544       else if (TREE_CODE (newdecl) == VAR_DECL
3545                && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
3546         {
3547           /* Keep the old RTL.  We cannot keep the old RTL if the old
3548              declaration was for an incomplete object and the new
3549              declaration is not since many attributes of the RTL will
3550              change.  */
3551           COPY_DECL_RTL (olddecl, newdecl);
3552         }
3553     }
3554   /* If cannot merge, then use the new type and qualifiers,
3555      and don't preserve the old rtl.  */
3556   else
3557     {
3558       /* Clean out any memory we had of the old declaration.  */
3559       tree oldstatic = value_member (olddecl, static_aggregates);
3560       if (oldstatic)
3561         TREE_VALUE (oldstatic) = error_mark_node;
3562
3563       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3564       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3565       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3566       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3567     }
3568
3569   /* Merge the storage class information.  */
3570   merge_weak (newdecl, olddecl);
3571
3572   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3573   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3574   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3575   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3576   if (! DECL_EXTERNAL (olddecl))
3577     DECL_EXTERNAL (newdecl) = 0;
3578
3579   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3580     {
3581       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3582       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3583       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3584       DECL_TEMPLATE_INSTANTIATED (newdecl)
3585         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3586       /* Don't really know how much of the language-specific
3587          values we should copy from old to new.  */
3588       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3589       DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
3590         DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
3591       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3592       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3593       DECL_INITIALIZED_IN_CLASS_P (newdecl)
3594         |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
3595       olddecl_friend = DECL_FRIEND_P (olddecl);
3596
3597       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3598       if (TREE_CODE (newdecl) == FUNCTION_DECL
3599           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3600         {
3601           DECL_BEFRIENDING_CLASSES (newdecl)
3602             = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3603                        DECL_BEFRIENDING_CLASSES (olddecl));
3604           DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
3605         }
3606     }
3607
3608   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3609     {
3610       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3611           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3612         {
3613           /* If newdecl is not a specialization, then it is not a
3614              template-related function at all.  And that means that we
3615              shoud have exited above, returning 0.  */
3616           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3617                               0);
3618
3619           if (TREE_USED (olddecl))
3620             /* From [temp.expl.spec]:
3621
3622                If a template, a member template or the member of a class
3623                template is explicitly specialized then that
3624                specialization shall be declared before the first use of
3625                that specialization that would cause an implicit
3626                instantiation to take place, in every translation unit in
3627                which such a use occurs.  */
3628             error ("explicit specialization of %D after first use",
3629                       olddecl);
3630
3631           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3632
3633           /* [temp.expl.spec/14] We don't inline explicit specialization
3634              just because the primary template says so.  */
3635         }
3636       else
3637         {
3638           if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3639             DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3640
3641           DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
3642
3643           /* If either decl says `inline', this fn is inline, unless
3644              its definition was passed already.  */
3645           if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3646             DECL_INLINE (olddecl) = 1;
3647           DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3648
3649           DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
3650             = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
3651         }
3652
3653       /* Preserve abstractness on cloned [cd]tors.  */
3654       DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
3655
3656       if (! types_match)
3657         {
3658           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3659           COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
3660           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3661         }
3662       if (! types_match || new_defines_function)
3663         {
3664           /* These need to be copied so that the names are available.
3665              Note that if the types do match, we'll preserve inline
3666              info and other bits, but if not, we won't.  */
3667           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3668           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3669         }
3670       if (new_defines_function)
3671         /* If defining a function declared with other language
3672            linkage, use the previously declared language linkage.  */
3673         SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3674       else if (types_match)
3675         {
3676           /* If redeclaring a builtin function, and not a definition,
3677              it stays built in.  */
3678           if (DECL_BUILT_IN (olddecl))
3679             {
3680               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3681               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3682               /* If we're keeping the built-in definition, keep the rtl,
3683                  regardless of declaration matches.  */
3684               SET_DECL_RTL (newdecl, DECL_RTL (olddecl));
3685             }
3686           else
3687             DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
3688
3689           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3690           /* Don't clear out the arguments if we're redefining a function.  */
3691           if (DECL_ARGUMENTS (olddecl))
3692             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3693         }
3694     }
3695   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3696     NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3697
3698   /* Now preserve various other info from the definition.  */
3699   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3700   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3701   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3702   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3703
3704   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3705     {
3706       int function_size;
3707
3708       function_size = sizeof (struct tree_decl);
3709
3710       memcpy ((char *) olddecl + sizeof (struct tree_common),
3711               (char *) newdecl + sizeof (struct tree_common),
3712               function_size - sizeof (struct tree_common));
3713
3714       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3715         {
3716           /* If newdecl is a template instantiation, it is possible that
3717              the following sequence of events has occurred:
3718
3719              o A friend function was declared in a class template.  The
3720              class template was instantiated.
3721
3722              o The instantiation of the friend declaration was
3723              recorded on the instantiation list, and is newdecl.
3724
3725              o Later, however, instantiate_class_template called pushdecl
3726              on the newdecl to perform name injection.  But, pushdecl in
3727              turn called duplicate_decls when it discovered that another
3728              declaration of a global function with the same name already
3729              existed.
3730
3731              o Here, in duplicate_decls, we decided to clobber newdecl.
3732
3733              If we're going to do that, we'd better make sure that
3734              olddecl, and not newdecl, is on the list of
3735              instantiations so that if we try to do the instantiation
3736              again we won't get the clobbered declaration.  */
3737
3738           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3739           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3740
3741           for (; decls; decls = TREE_CHAIN (decls))
3742             if (TREE_VALUE (decls) == newdecl)
3743               TREE_VALUE (decls) = olddecl;
3744         }
3745     }
3746   else
3747     {
3748       memcpy ((char *) olddecl + sizeof (struct tree_common),
3749               (char *) newdecl + sizeof (struct tree_common),
3750               sizeof (struct tree_decl) - sizeof (struct tree_common)
3751               + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
3752     }
3753
3754   DECL_UID (olddecl) = olddecl_uid;
3755   if (olddecl_friend)
3756     DECL_FRIEND_P (olddecl) = 1;
3757
3758   /* NEWDECL contains the merged attribute lists.
3759      Update OLDDECL to be the same.  */
3760   DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
3761
3762   return 1;
3763 }
3764
3765 /* Record a decl-node X as belonging to the current lexical scope.
3766    Check for errors (such as an incompatible declaration for the same
3767    name already seen in the same scope).
3768
3769    Returns either X or an old decl for the same name.
3770    If an old decl is returned, it may have been smashed
3771    to agree with what X says.  */
3772
3773 tree
3774 pushdecl (x)
3775      tree x;
3776 {
3777   register tree t;
3778   register tree name;
3779   int need_new_binding;
3780
3781   /* We shouldn't be calling pushdecl when we're generating RTL for a
3782      function that we already did semantic analysis on previously.  */
3783   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3784                       19990913);
3785
3786   need_new_binding = 1;
3787
3788   if (DECL_TEMPLATE_PARM_P (x))
3789     /* Template parameters have no context; they are not X::T even
3790        when declared within a class or namespace.  */
3791     ;
3792   else
3793     {
3794       if (current_function_decl && x != current_function_decl
3795           /* A local declaration for a function doesn't constitute
3796              nesting.  */
3797           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3798           /* A local declaration for an `extern' variable is in the
3799              scope of the current namespace, not the current
3800              function.  */
3801           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3802           && !DECL_CONTEXT (x))
3803         DECL_CONTEXT (x) = current_function_decl;
3804
3805       /* If this is the declaration for a namespace-scope function,
3806          but the declaration itself is in a local scope, mark the
3807          declaration.  */
3808       if (TREE_CODE (x) == FUNCTION_DECL
3809           && DECL_NAMESPACE_SCOPE_P (x)
3810           && current_function_decl
3811           && x != current_function_decl)
3812         DECL_LOCAL_FUNCTION_P (x) = 1;
3813     }
3814
3815   name = DECL_NAME (x);
3816   if (name)
3817     {
3818       int different_binding_level = 0;
3819
3820       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3821         name = TREE_OPERAND (name, 0);
3822
3823       /* In case this decl was explicitly namespace-qualified, look it
3824          up in its namespace context.  */
3825       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3826           && namespace_bindings_p ())
3827         t = namespace_binding (name, DECL_CONTEXT (x));
3828       else
3829         t = lookup_name_current_level (name);
3830
3831       /* [basic.link] If there is a visible declaration of an entity
3832          with linkage having the same name and type, ignoring entities
3833          declared outside the innermost enclosing namespace scope, the
3834          block scope declaration declares that same entity and
3835          receives the linkage of the previous declaration.  */
3836       if (! t && current_function_decl && x != current_function_decl
3837           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3838           && DECL_EXTERNAL (x))
3839         {
3840           /* Look in block scope.  */
3841           t = IDENTIFIER_VALUE (name);
3842           /* Or in the innermost namespace.  */
3843           if (! t)
3844             t = namespace_binding (name, DECL_CONTEXT (x));
3845           /* Does it have linkage?  Note that if this isn't a DECL, it's an
3846              OVERLOAD, which is OK.  */
3847           if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3848             t = NULL_TREE;
3849           if (t)
3850             different_binding_level = 1;
3851         }
3852
3853       /* If we are declaring a function, and the result of name-lookup
3854          was an OVERLOAD, look for an overloaded instance that is
3855          actually the same as the function we are declaring.  (If
3856          there is one, we have to merge our declaration with the
3857          previous declaration.)  */
3858       if (t && TREE_CODE (t) == OVERLOAD)
3859         {
3860           tree match;
3861
3862           if (TREE_CODE (x) == FUNCTION_DECL)
3863             for (match = t; match; match = OVL_NEXT (match))
3864               {
3865                 if (decls_match (OVL_CURRENT (match), x))
3866                   break;
3867               }
3868           else
3869             /* Just choose one.  */
3870             match = t;
3871
3872           if (match)
3873             t = OVL_CURRENT (match);
3874           else
3875             t = NULL_TREE;
3876         }
3877
3878       if (t == error_mark_node)
3879         {
3880           /* error_mark_node is 0 for a while during initialization!  */
3881           t = NULL_TREE;
3882           cp_error_at ("`%#D' used prior to declaration", x);
3883         }
3884       else if (t != NULL_TREE)
3885         {
3886           if (different_binding_level)
3887             {
3888               if (decls_match (x, t))
3889                 /* The standard only says that the local extern
3890                    inherits linkage from the previous decl; in
3891                    particular, default args are not shared.  It would
3892                    be nice to propagate inlining info, though.  FIXME.  */
3893                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3894             }
3895           else if (TREE_CODE (t) == PARM_DECL)
3896             {
3897               if (DECL_CONTEXT (t) == NULL_TREE)
3898                 /* This is probaby caused by too many errors, but calling
3899                    abort will say that if errors have occurred.  */
3900                 abort ();
3901
3902               /* Check for duplicate params.  */
3903               if (duplicate_decls (x, t))
3904                 return t;
3905             }
3906           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3907                     || DECL_FUNCTION_TEMPLATE_P (x))
3908                    && is_overloaded_fn (t))
3909             /* Don't do anything just yet.  */;
3910           else if (t == wchar_decl_node)
3911             {
3912               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3913                 pedwarn ("redeclaration of `wchar_t' as `%T'",
3914                             TREE_TYPE (x));
3915
3916               /* Throw away the redeclaration.  */
3917               return t;
3918             }
3919           else if (TREE_CODE (t) != TREE_CODE (x))
3920             {
3921               if (duplicate_decls (x, t))
3922                 return t;
3923             }
3924           else if (duplicate_decls (x, t))
3925             {
3926               if (TREE_CODE (t) == TYPE_DECL)
3927                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3928               else if (TREE_CODE (t) == FUNCTION_DECL)
3929                 check_default_args (t);
3930
3931               return t;
3932             }
3933           else if (DECL_MAIN_P (x))
3934             {
3935               /* A redeclaration of main, but not a duplicate of the
3936                  previous one.
3937
3938                  [basic.start.main]
3939
3940                  This function shall not be overloaded.  */
3941               cp_error_at ("invalid redeclaration of `%D'", t);
3942               error ("as `%D'", x);
3943               /* We don't try to push this declaration since that
3944                  causes a crash.  */
3945               return x;
3946             }
3947         }
3948
3949       check_template_shadow (x);
3950
3951       /* If this is a function conjured up by the backend, massage it
3952          so it looks friendly.  */
3953       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3954         {
3955           retrofit_lang_decl (x);
3956           SET_DECL_LANGUAGE (x, lang_c);
3957         }
3958
3959       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3960         {
3961           t = push_overloaded_decl (x, PUSH_LOCAL);
3962           if (t != x)
3963             return t;
3964           if (!namespace_bindings_p ())
3965             /* We do not need to create a binding for this name;
3966                push_overloaded_decl will have already done so if
3967                necessary.  */
3968             need_new_binding = 0;
3969         }
3970       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3971         {
3972           t = push_overloaded_decl (x, PUSH_GLOBAL);
3973           if (t == x)
3974             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3975           return t;
3976         }
3977
3978       /* If declaring a type as a typedef, copy the type (unless we're
3979          at line 0), and install this TYPE_DECL as the new type's typedef
3980          name.  See the extensive comment in ../c-decl.c (pushdecl).  */
3981       if (TREE_CODE (x) == TYPE_DECL)
3982         {
3983           tree type = TREE_TYPE (x);
3984           if (DECL_SOURCE_LINE (x) == 0)
3985             {
3986               if (TYPE_NAME (type) == 0)
3987                 TYPE_NAME (type) = x;
3988             }
3989           else if (type != error_mark_node && TYPE_NAME (type) != x
3990                    /* We don't want to copy the type when all we're
3991                       doing is making a TYPE_DECL for the purposes of
3992                       inlining.  */
3993                    && (!TYPE_NAME (type)
3994                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3995             {
3996               DECL_ORIGINAL_TYPE (x) = type;
3997               type = build_type_copy (type);
3998               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3999               TYPE_NAME (type) = x;
4000               TREE_TYPE (x) = type;
4001             }
4002
4003           if (type != error_mark_node
4004               && TYPE_NAME (type)
4005               && TYPE_IDENTIFIER (type))
4006             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4007                                                   current_binding_level);
4008
4009         }
4010
4011       /* Multiple external decls of the same identifier ought to match.
4012
4013          We get warnings about inline functions where they are defined.
4014          We get warnings about other functions from push_overloaded_decl.
4015
4016          Avoid duplicate warnings where they are used.  */
4017       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4018         {
4019           tree decl;
4020
4021           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4022           if (decl && TREE_CODE (decl) == OVERLOAD)
4023             decl = OVL_FUNCTION (decl);
4024
4025           if (decl && decl != error_mark_node
4026               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4027               /* If different sort of thing, we already gave an error.  */
4028               && TREE_CODE (decl) == TREE_CODE (x)
4029               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4030             {
4031               pedwarn ("type mismatch with previous external decl", x);
4032               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4033             }
4034         }
4035
4036       /* This name is new in its binding level.
4037          Install the new declaration and return it.  */
4038       if (namespace_bindings_p ())
4039         {
4040           /* Install a global value.  */
4041
4042           /* If the first global decl has external linkage,
4043              warn if we later see static one.  */
4044           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4045             TREE_PUBLIC (name) = 1;
4046
4047           /* Bind the name for the entity.  */
4048           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4049                 && t != NULL_TREE)
4050               && (TREE_CODE (x) == TYPE_DECL
4051                   || TREE_CODE (x) == VAR_DECL
4052                   || TREE_CODE (x) == ALIAS_DECL
4053                   || TREE_CODE (x) == NAMESPACE_DECL
4054                   || TREE_CODE (x) == CONST_DECL
4055                   || TREE_CODE (x) == TEMPLATE_DECL))
4056             SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
4057
4058           /* Don't forget if the function was used via an implicit decl.  */
4059           if (IDENTIFIER_IMPLICIT_DECL (name)
4060               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4061             TREE_USED (x) = 1;
4062
4063           /* Don't forget if its address was taken in that way.  */
4064           if (IDENTIFIER_IMPLICIT_DECL (name)
4065               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4066             TREE_ADDRESSABLE (x) = 1;
4067
4068           /* Warn about mismatches against previous implicit decl.  */
4069           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4070               /* If this real decl matches the implicit, don't complain.  */
4071               && ! (TREE_CODE (x) == FUNCTION_DECL
4072                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4073             warning
4074               ("`%D' was previously implicitly declared to return `int'", x);
4075
4076           /* If new decl is `static' and an `extern' was seen previously,
4077              warn about it.  */
4078           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4079             warn_extern_redeclared_static (x, t);
4080         }
4081       else
4082         {
4083           /* Here to install a non-global value.  */
4084           tree oldlocal = IDENTIFIER_VALUE (name);
4085           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4086
4087           if (need_new_binding)
4088             {
4089               push_local_binding (name, x, 0);
4090               /* Because push_local_binding will hook X on to the
4091                  current_binding_level's name list, we don't want to
4092                  do that again below.  */
4093               need_new_binding = 0;
4094             }
4095
4096           /* If this is a TYPE_DECL, push it into the type value slot.  */
4097           if (TREE_CODE (x) == TYPE_DECL)
4098             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4099                                                   current_binding_level);
4100
4101           /* Clear out any TYPE_DECL shadowed by a namespace so that
4102              we won't think this is a type.  The C struct hack doesn't
4103              go through namespaces.  */
4104           if (TREE_CODE (x) == NAMESPACE_DECL)
4105             set_identifier_type_value_with_scope (name, NULL_TREE,
4106                                                   current_binding_level);
4107
4108           if (oldlocal)
4109             {
4110               tree d = oldlocal;
4111
4112               while (oldlocal
4113                      && TREE_CODE (oldlocal) == VAR_DECL
4114                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4115                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4116
4117               if (oldlocal == NULL_TREE)
4118                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4119             }
4120
4121           /* If this is an extern function declaration, see if we
4122              have a global definition or declaration for the function.  */
4123           if (oldlocal == NULL_TREE
4124               && DECL_EXTERNAL (x)
4125               && oldglobal != NULL_TREE
4126               && TREE_CODE (x) == FUNCTION_DECL
4127               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4128             {
4129               /* We have one.  Their types must agree.  */
4130               if (decls_match (x, oldglobal))
4131                 /* OK */;
4132               else
4133                 {
4134                   warning ("extern declaration of `%#D' doesn't match", x);
4135                   cp_warning_at ("global declaration `%#D'", oldglobal);
4136                 }
4137             }
4138           /* If we have a local external declaration,
4139              and no file-scope declaration has yet been seen,
4140              then if we later have a file-scope decl it must not be static.  */
4141           if (oldlocal == NULL_TREE
4142               && oldglobal == NULL_TREE
4143               && DECL_EXTERNAL (x)
4144               && TREE_PUBLIC (x))
4145             TREE_PUBLIC (name) = 1;
4146
4147           /* Warn if shadowing an argument at the top level of the body.  */
4148           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4149               /* Inline decls shadow nothing.  */
4150               && !DECL_FROM_INLINE (x)
4151               && TREE_CODE (oldlocal) == PARM_DECL)
4152             {
4153               bool err = false;
4154
4155               /* Don't complain if it's from an enclosing function.  */
4156               if (DECL_CONTEXT (oldlocal) == current_function_decl
4157                   && TREE_CODE (x) != PARM_DECL)
4158                 {
4159                   /* Go to where the parms should be and see if we find
4160                      them there.  */
4161                   struct cp_binding_level *b = current_binding_level->level_chain;
4162
4163                   /* Skip the ctor/dtor cleanup level.  */
4164                   b = b->level_chain;
4165
4166                   /* ARM $8.3 */
4167                   if (b->parm_flag == 1)
4168                     {
4169                       error ("declaration of `%#D' shadows a parameter",
4170                                 name);
4171                       err = true;
4172                     }
4173                 }
4174
4175               if (warn_shadow && !err)
4176                 shadow_warning ("a parameter", name, oldlocal);
4177             }
4178
4179           /* Maybe warn if shadowing something else.  */
4180           else if (warn_shadow && !DECL_EXTERNAL (x)
4181               /* No shadow warnings for internally generated vars.  */
4182               && ! DECL_ARTIFICIAL (x)
4183               /* No shadow warnings for vars made for inlining.  */
4184               && ! DECL_FROM_INLINE (x))
4185             {
4186               if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4187                        && current_class_ptr
4188                        && !TREE_STATIC (name))
4189                 warning ("declaration of `%s' shadows a member of `this'",
4190                             IDENTIFIER_POINTER (name));
4191               else if (oldlocal != NULL_TREE
4192                        && TREE_CODE (oldlocal) == VAR_DECL)
4193                 shadow_warning ("a previous local", name, oldlocal);
4194               else if (oldglobal != NULL_TREE
4195                        && TREE_CODE (oldglobal) == VAR_DECL)
4196                 /* XXX shadow warnings in outer-more namespaces */
4197                 shadow_warning ("a global declaration", name, oldglobal);
4198             }
4199         }
4200
4201       if (TREE_CODE (x) == FUNCTION_DECL)
4202         check_default_args (x);
4203
4204       if (TREE_CODE (x) == VAR_DECL)
4205         maybe_register_incomplete_var (x);
4206     }
4207
4208   if (need_new_binding)
4209     add_decl_to_level (x,
4210                        DECL_NAMESPACE_SCOPE_P (x)
4211                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4212                        : current_binding_level);
4213
4214   return x;
4215 }
4216
4217 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4218    caller to set DECL_CONTEXT properly.  */
4219
4220 static tree
4221 pushdecl_with_scope (x, level)
4222      tree x;
4223      struct cp_binding_level *level;
4224 {
4225   register struct cp_binding_level *b;
4226   tree function_decl = current_function_decl;
4227
4228   current_function_decl = NULL_TREE;
4229   if (level->parm_flag == 2)
4230     {
4231       b = class_binding_level;
4232       class_binding_level = level;
4233       pushdecl_class_level (x);
4234       class_binding_level = b;
4235     }
4236   else
4237     {
4238       b = current_binding_level;
4239       current_binding_level = level;
4240       x = pushdecl (x);
4241       current_binding_level = b;
4242     }
4243   current_function_decl = function_decl;
4244   return x;
4245 }
4246
4247 /* Like pushdecl, only it places X in the current namespace,
4248    if appropriate.  */
4249
4250 tree
4251 pushdecl_namespace_level (x)
4252      tree x;
4253 {
4254   register struct cp_binding_level *b = current_binding_level;
4255   register tree t;
4256
4257   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4258
4259   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4260      what we want.  */
4261   if (TREE_CODE (x) == TYPE_DECL)
4262     {
4263       tree name = DECL_NAME (x);
4264       tree newval;
4265       tree *ptr = (tree *)0;
4266       for (; b != global_binding_level; b = b->level_chain)
4267         {
4268           tree shadowed = b->type_shadowed;
4269           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4270             if (TREE_PURPOSE (shadowed) == name)
4271               {
4272                 ptr = &TREE_VALUE (shadowed);
4273                 /* Can't break out of the loop here because sometimes
4274                    a binding level will have duplicate bindings for
4275                    PT names.  It's gross, but I haven't time to fix it.  */
4276               }
4277         }
4278       newval = TREE_TYPE (x);
4279       if (ptr == (tree *)0)
4280         {
4281           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4282              up here if this is changed to an assertion.  --KR  */
4283           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4284         }
4285       else
4286         {
4287           *ptr = newval;
4288         }
4289     }
4290   return t;
4291 }
4292
4293 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4294    if appropriate.  */
4295
4296 tree
4297 pushdecl_top_level (x)
4298      tree x;
4299 {
4300   push_to_top_level ();
4301   x = pushdecl_namespace_level (x);
4302   pop_from_top_level ();
4303   return x;
4304 }
4305
4306 /* Make the declaration of X appear in CLASS scope.  */
4307
4308 void
4309 pushdecl_class_level (x)
4310      tree x;
4311 {
4312   tree name;
4313
4314   /* Get the name of X.  */
4315   if (TREE_CODE (x) == OVERLOAD)
4316     name = DECL_NAME (get_first_fn (x));
4317   else
4318     name = DECL_NAME (x);
4319
4320   if (name)
4321     {
4322       push_class_level_binding (name, x);
4323       if (TREE_CODE (x) == TYPE_DECL)
4324         set_identifier_type_value (name, TREE_TYPE (x));
4325     }
4326   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4327     {
4328       /* If X is an anonymous aggregate, all of its members are
4329          treated as if they were members of the class containing the
4330          aggregate, for naming purposes.  */
4331       tree f;
4332
4333       for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
4334         pushdecl_class_level (f);
4335     }
4336 }
4337
4338 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4339    DECL, or a modified version thereof.  */
4340
4341 tree
4342 maybe_push_decl (decl)
4343      tree decl;
4344 {
4345   tree type = TREE_TYPE (decl);
4346
4347   /* Add this decl to the current binding level, but not if it comes
4348      from another scope, e.g. a static member variable.  TEM may equal
4349      DECL or it may be a previous decl of the same name.  */
4350   if (decl == error_mark_node
4351       || (TREE_CODE (decl) != PARM_DECL
4352           && DECL_CONTEXT (decl) != NULL_TREE
4353           /* Definitions of namespace members outside their namespace are
4354              possible.  */
4355           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4356       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4357       || TREE_CODE (type) == UNKNOWN_TYPE
4358       /* The declaration of a template specialization does not affect
4359          the functions available for overload resolution, so we do not
4360          call pushdecl.  */
4361       || (TREE_CODE (decl) == FUNCTION_DECL
4362           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4363     return decl;
4364   else
4365     return pushdecl (decl);
4366 }
4367
4368 /* Make the declaration(s) of X appear in CLASS scope
4369    under the name NAME.  */
4370
4371 void
4372 push_class_level_binding (name, x)
4373      tree name;
4374      tree x;
4375 {
4376   tree binding;
4377   /* The class_binding_level will be NULL if x is a template
4378      parameter name in a member template.  */
4379   if (!class_binding_level)
4380     return;
4381
4382   /* Make sure that this new member does not have the same name
4383      as a template parameter.  */
4384   if (TYPE_BEING_DEFINED (current_class_type))
4385     check_template_shadow (x);
4386
4387   /* If this declaration shadows a declaration from an enclosing
4388      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4389      we leave this class.  Record the shadowed declaration here.  */
4390   binding = IDENTIFIER_BINDING (name);
4391   if (binding
4392       && ((TREE_CODE (x) == OVERLOAD
4393            && BINDING_VALUE (binding)
4394            && is_overloaded_fn (BINDING_VALUE (binding)))
4395           || INHERITED_VALUE_BINDING_P (binding)))
4396     {
4397       tree shadow;
4398       tree old_decl;
4399
4400       /* If the old binding was from a base class, and was for a tag
4401          name, slide it over to make room for the new binding.  The
4402          old binding is still visible if explicitly qualified with a
4403          class-key.  */
4404       if (INHERITED_VALUE_BINDING_P (binding)
4405           && BINDING_VALUE (binding)
4406           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4407           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4408           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4409         {
4410           old_decl = BINDING_TYPE (binding);
4411           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4412           BINDING_VALUE (binding) = NULL_TREE;
4413           INHERITED_VALUE_BINDING_P (binding) = 0;
4414         }
4415       else
4416         old_decl = BINDING_VALUE (binding);
4417
4418       /* Find the previous binding of name on the class-shadowed
4419          list, and update it.  */
4420       for (shadow = class_binding_level->class_shadowed;
4421            shadow;
4422            shadow = TREE_CHAIN (shadow))
4423         if (TREE_PURPOSE (shadow) == name
4424             && TREE_TYPE (shadow) == old_decl)
4425           {
4426             BINDING_VALUE (binding) = x;
4427             INHERITED_VALUE_BINDING_P (binding) = 0;
4428             TREE_TYPE (shadow) = x;
4429             IDENTIFIER_CLASS_VALUE (name) = x;
4430             return;
4431           }
4432     }
4433
4434   /* If we didn't replace an existing binding, put the binding on the
4435      stack of bindings for the identifier, and update the shadowed list.  */
4436   if (push_class_binding (name, x))
4437     {
4438       class_binding_level->class_shadowed
4439         = tree_cons (name, NULL,
4440                      class_binding_level->class_shadowed);
4441       /* Record the value we are binding NAME to so that we can know
4442          what to pop later.  */
4443       TREE_TYPE (class_binding_level->class_shadowed) = x;
4444     }
4445 }
4446
4447 /* Insert another USING_DECL into the current binding level, returning
4448    this declaration. If this is a redeclaration, do nothing, and
4449    return NULL_TREE if this not in namespace scope (in namespace
4450    scope, a using decl might extend any previous bindings).  */
4451
4452 tree
4453 push_using_decl (scope, name)
4454      tree scope;
4455      tree name;
4456 {
4457   tree decl;
4458
4459   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4460   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4461   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4462     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4463       break;
4464   if (decl)
4465     return namespace_bindings_p () ? decl : NULL_TREE;
4466   decl = build_lang_decl (USING_DECL, name, void_type_node);
4467   DECL_INITIAL (decl) = scope;
4468   TREE_CHAIN (decl) = current_binding_level->usings;
4469   current_binding_level->usings = decl;
4470   return decl;
4471 }
4472
4473 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4474    changed (i.e. there was already a directive), or the fresh
4475    TREE_LIST otherwise.  */
4476
4477 tree
4478 push_using_directive (used)
4479      tree used;
4480 {
4481   tree ud = current_binding_level->using_directives;
4482   tree iter, ancestor;
4483
4484   /* Check if we already have this.  */
4485   if (purpose_member (used, ud) != NULL_TREE)
4486     return NULL_TREE;
4487
4488   /* Recursively add all namespaces used.  */
4489   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4490     push_using_directive (TREE_PURPOSE (iter));
4491
4492   ancestor = namespace_ancestor (current_decl_namespace (), used);
4493   ud = current_binding_level->using_directives;
4494   ud = tree_cons (used, ancestor, ud);
4495   current_binding_level->using_directives = ud;
4496   return ud;
4497 }
4498
4499 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4500    other definitions already in place.  We get around this by making
4501    the value of the identifier point to a list of all the things that
4502    want to be referenced by that name.  It is then up to the users of
4503    that name to decide what to do with that list.
4504
4505    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4506    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4507
4508    FLAGS is a bitwise-or of the following values:
4509      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4510                  namespace scope.
4511      PUSH_USING: DECL is being pushed as the result of a using
4512                  declaration.
4513
4514    The value returned may be a previous declaration if we guessed wrong
4515    about what language DECL should belong to (C or C++).  Otherwise,
4516    it's always DECL (and never something that's not a _DECL).  */
4517
4518 tree
4519 push_overloaded_decl (decl, flags)
4520      tree decl;
4521      int flags;
4522 {
4523   tree name = DECL_NAME (decl);
4524   tree old;
4525   tree new_binding;
4526   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4527
4528   if (doing_global)
4529     old = namespace_binding (name, DECL_CONTEXT (decl));
4530   else
4531     old = lookup_name_current_level (name);
4532
4533   if (old)
4534     {
4535       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4536         {
4537           tree t = TREE_TYPE (old);
4538           if (IS_AGGR_TYPE (t) && warn_shadow
4539               && (! DECL_IN_SYSTEM_HEADER (decl)
4540                   || ! DECL_IN_SYSTEM_HEADER (old)))
4541             warning ("`%#D' hides constructor for `%#T'", decl, t);
4542           old = NULL_TREE;
4543         }
4544       else if (is_overloaded_fn (old))
4545         {
4546           tree tmp;
4547
4548           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4549             {
4550               tree fn = OVL_CURRENT (tmp);
4551
4552               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4553                   && !(flags & PUSH_USING)
4554                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4555                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4556                 error ("`%#D' conflicts with previous using declaration `%#D'",
4557                           decl, fn);
4558
4559               if (duplicate_decls (decl, fn))
4560                 return fn;
4561             }
4562         }
4563       else if (old == error_mark_node)
4564         /* Ignore the undefined symbol marker.  */
4565         old = NULL_TREE;
4566       else
4567         {
4568           cp_error_at ("previous non-function declaration `%#D'", old);
4569           error ("conflicts with function declaration `%#D'", decl);
4570           return decl;
4571         }
4572     }
4573
4574   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4575     {
4576       if (old && TREE_CODE (old) != OVERLOAD)
4577         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4578       else
4579         new_binding = ovl_cons (decl, old);
4580       if (flags & PUSH_USING)
4581         OVL_USED (new_binding) = 1;
4582     }
4583   else
4584     /* NAME is not ambiguous.  */
4585     new_binding = decl;
4586
4587   if (doing_global)
4588     set_namespace_binding (name, current_namespace, new_binding);
4589   else
4590     {
4591       /* We only create an OVERLOAD if there was a previous binding at
4592          this level, or if decl is a template. In the former case, we
4593          need to remove the old binding and replace it with the new
4594          binding.  We must also run through the NAMES on the binding
4595          level where the name was bound to update the chain.  */
4596
4597       if (TREE_CODE (new_binding) == OVERLOAD && old)
4598         {
4599           tree *d;
4600
4601           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4602                *d;
4603                d = &TREE_CHAIN (*d))
4604             if (*d == old
4605                 || (TREE_CODE (*d) == TREE_LIST
4606                     && TREE_VALUE (*d) == old))
4607               {
4608                 if (TREE_CODE (*d) == TREE_LIST)
4609                   /* Just replace the old binding with the new.  */
4610                   TREE_VALUE (*d) = new_binding;
4611                 else
4612                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4613                   *d = tree_cons (NULL_TREE, new_binding,
4614                                   TREE_CHAIN (*d));
4615
4616                 /* And update the CPLUS_BINDING node.  */
4617                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4618                   = new_binding;
4619                 return decl;
4620               }
4621
4622           /* We should always find a previous binding in this case.  */
4623           abort ();
4624         }
4625
4626       /* Install the new binding.  */
4627       push_local_binding (name, new_binding, flags);
4628     }
4629
4630   return decl;
4631 }
4632 \f
4633 /* Generate an implicit declaration for identifier FUNCTIONID
4634    as a function of type int ().  Print a warning if appropriate.  */
4635
4636 tree
4637 implicitly_declare (functionid)
4638      tree functionid;
4639 {
4640   register tree decl;
4641
4642   /* We used to reuse an old implicit decl here,
4643      but this loses with inline functions because it can clobber
4644      the saved decl chains.  */
4645   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4646
4647   DECL_EXTERNAL (decl) = 1;
4648   TREE_PUBLIC (decl) = 1;
4649
4650   /* ISO standard says implicit declarations are in the innermost block.
4651      So we record the decl in the standard fashion.  */
4652   pushdecl (decl);
4653   rest_of_decl_compilation (decl, NULL, 0, 0);
4654
4655   if (warn_implicit
4656       /* Only one warning per identifier.  */
4657       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4658     {
4659       pedwarn ("implicit declaration of function `%#D'", decl);
4660     }
4661
4662   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4663
4664   return decl;
4665 }
4666
4667 /* Return zero if the declaration NEWDECL is valid
4668    when the declaration OLDDECL (assumed to be for the same name)
4669    has already been seen.
4670    Otherwise return an error message format string with a %s
4671    where the identifier should go.  */
4672
4673 static const char *
4674 redeclaration_error_message (newdecl, olddecl)
4675      tree newdecl, olddecl;
4676 {
4677   if (TREE_CODE (newdecl) == TYPE_DECL)
4678     {
4679       /* Because C++ can put things into name space for free,
4680          constructs like "typedef struct foo { ... } foo"
4681          would look like an erroneous redeclaration.  */
4682       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4683         return 0;
4684       else
4685         return "redefinition of `%#D'";
4686     }
4687   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4688     {
4689       /* If this is a pure function, its olddecl will actually be
4690          the original initialization to `0' (which we force to call
4691          abort()).  Don't complain about redefinition in this case.  */
4692       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4693         return 0;
4694
4695       /* If both functions come from different namespaces, this is not
4696          a redeclaration - this is a conflict with a used function.  */
4697       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4698           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4699         return "`%D' conflicts with used function";
4700
4701       /* We'll complain about linkage mismatches in
4702          warn_extern_redeclared_static.  */
4703
4704       /* Defining the same name twice is no good.  */
4705       if (DECL_INITIAL (olddecl) != NULL_TREE
4706           && DECL_INITIAL (newdecl) != NULL_TREE)
4707         {
4708           if (DECL_NAME (olddecl) == NULL_TREE)
4709             return "`%#D' not declared in class";
4710           else
4711             return "redefinition of `%#D'";
4712         }
4713       return 0;
4714     }
4715   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4716     {
4717       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4718            && (DECL_TEMPLATE_RESULT (newdecl)
4719                != DECL_TEMPLATE_RESULT (olddecl))
4720            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4721            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4722           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4723               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4724               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4725         return "redefinition of `%#D'";
4726       return 0;
4727     }
4728   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4729     {
4730       /* Objects declared at top level:  */
4731       /* If at least one is a reference, it's ok.  */
4732       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4733         return 0;
4734       /* Reject two definitions.  */
4735       return "redefinition of `%#D'";
4736     }
4737   else
4738     {
4739       /* Objects declared with block scope:  */
4740       /* Reject two definitions, and reject a definition
4741          together with an external reference.  */
4742       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4743         return "redeclaration of `%#D'";
4744       return 0;
4745     }
4746 }
4747 \f
4748 /* Create a new label, named ID.  */
4749
4750 static tree
4751 make_label_decl (id, local_p)
4752      tree id;
4753      int local_p;
4754 {
4755   tree decl;
4756
4757   decl = build_decl (LABEL_DECL, id, void_type_node);
4758   if (expanding_p)
4759     /* Make sure every label has an rtx.  */
4760     label_rtx (decl);
4761
4762   DECL_CONTEXT (decl) = current_function_decl;
4763   DECL_MODE (decl) = VOIDmode;
4764   C_DECLARED_LABEL_FLAG (decl) = local_p;
4765
4766   /* Say where one reference is to the label, for the sake of the
4767      error if it is not defined.  */
4768   DECL_SOURCE_LINE (decl) = lineno;
4769   DECL_SOURCE_FILE (decl) = input_filename;
4770
4771   /* Record the fact that this identifier is bound to this label.  */
4772   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4773
4774   return decl;
4775 }
4776
4777 /* Record this label on the list of used labels so that we can check
4778    at the end of the function to see whether or not the label was
4779    actually defined, and so we can check when the label is defined whether
4780    this use is valid.  */
4781
4782 static void
4783 use_label (decl)
4784      tree decl;
4785 {
4786   if (named_label_uses == NULL
4787       || named_label_uses->names_in_scope != current_binding_level->names
4788       || named_label_uses->label_decl != decl)
4789     {
4790       struct named_label_use_list *new_ent;
4791       new_ent = ((struct named_label_use_list *)
4792                  ggc_alloc (sizeof (struct named_label_use_list)));
4793       new_ent->label_decl = decl;
4794       new_ent->names_in_scope = current_binding_level->names;
4795       new_ent->binding_level = current_binding_level;
4796       new_ent->lineno_o_goto = lineno;
4797       new_ent->filename_o_goto = input_filename;
4798       new_ent->next = named_label_uses;
4799       named_label_uses = new_ent;
4800     }
4801 }
4802
4803 /* Look for a label named ID in the current function.  If one cannot
4804    be found, create one.  (We keep track of used, but undefined,
4805    labels, and complain about them at the end of a function.)  */
4806
4807 tree
4808 lookup_label (id)
4809      tree id;
4810 {
4811   tree decl;
4812   struct named_label_list *ent;
4813
4814   /* You can't use labels at global scope.  */
4815   if (current_function_decl == NULL_TREE)
4816     {
4817       error ("label `%s' referenced outside of any function",
4818              IDENTIFIER_POINTER (id));
4819       return NULL_TREE;
4820     }
4821
4822   /* See if we've already got this label.  */
4823   decl = IDENTIFIER_LABEL_VALUE (id);
4824   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4825     return decl;
4826
4827   /* Record this label on the list of labels used in this function.
4828      We do this before calling make_label_decl so that we get the
4829      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4830   ent = ((struct named_label_list *)
4831          ggc_alloc_cleared (sizeof (struct named_label_list)));
4832   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4833   ent->next = named_labels;
4834   named_labels = ent;
4835
4836   /* We need a new label.  */
4837   decl = make_label_decl (id, /*local_p=*/0);
4838
4839   /* Now fill in the information we didn't have before.  */
4840   ent->label_decl = decl;
4841
4842   return decl;
4843 }
4844
4845 /* Declare a local label named ID.  */
4846
4847 tree
4848 declare_local_label (id)
4849      tree id;
4850 {
4851   tree decl;
4852
4853   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4854      this scope we can restore the old value of
4855      IDENTIFIER_TYPE_VALUE.  */
4856   current_binding_level->shadowed_labels
4857     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4858                  current_binding_level->shadowed_labels);
4859   /* Look for the label.  */
4860   decl = make_label_decl (id, /*local_p=*/1);
4861   /* Now fill in the information we didn't have before.  */
4862   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4863
4864   return decl;
4865 }
4866
4867 /* Returns nonzero if it is ill-formed to jump past the declaration of
4868    DECL.  Returns 2 if it's also a real problem.  */
4869
4870 static int
4871 decl_jump_unsafe (decl)
4872      tree decl;
4873 {
4874   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4875     return 0;
4876
4877   if (DECL_INITIAL (decl) == NULL_TREE
4878       && pod_type_p (TREE_TYPE (decl)))
4879     return 0;
4880
4881   /* This is really only important if we're crossing an initialization.
4882      The POD stuff is just pedantry; why should it matter if the class
4883      contains a field of pointer to member type?  */
4884   if (DECL_INITIAL (decl)
4885       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4886     return 2;
4887   return 1;
4888 }
4889
4890 /* Check that a single previously seen jump to a newly defined label
4891    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4892    the jump context; NAMES are the names in scope in LEVEL at the jump
4893    context; FILE and LINE are the source position of the jump or 0.  */
4894
4895 static void
4896 check_previous_goto_1 (decl, level, names, file, line)
4897      tree decl;
4898      struct cp_binding_level *level;
4899      tree names;
4900      const char *file;
4901      int line;
4902 {
4903   int identified = 0;
4904   int saw_eh = 0;
4905   struct cp_binding_level *b = current_binding_level;
4906   for (; b; b = b->level_chain)
4907     {
4908       tree new_decls = b->names;
4909       tree old_decls = (b == level ? names : NULL_TREE);
4910       for (; new_decls != old_decls;
4911            new_decls = TREE_CHAIN (new_decls))
4912         {
4913           int problem = decl_jump_unsafe (new_decls);
4914           if (! problem)
4915             continue;
4916
4917           if (! identified)
4918             {
4919               if (decl)
4920                 pedwarn ("jump to label `%D'", decl);
4921               else
4922                 pedwarn ("jump to case label");
4923
4924               if (file)
4925                 pedwarn_with_file_and_line (file, line, "  from here");
4926               identified = 1;
4927             }
4928
4929           if (problem > 1)
4930             cp_error_at ("  crosses initialization of `%#D'",
4931                          new_decls);
4932           else
4933             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4934                            new_decls);
4935         }
4936
4937       if (b == level)
4938         break;
4939       if ((b->is_try_scope || b->is_catch_scope) && ! saw_eh)
4940         {
4941           if (! identified)
4942             {
4943               if (decl)
4944                 pedwarn ("jump to label `%D'", decl);
4945               else
4946                 pedwarn ("jump to case label");
4947
4948               if (file)
4949                 pedwarn_with_file_and_line (file, line, "  from here");
4950               identified = 1;
4951             }
4952           if (b->is_try_scope)
4953             error ("  enters try block");
4954           else
4955             error ("  enters catch block");
4956           saw_eh = 1;
4957         }
4958     }
4959 }
4960
4961 static void
4962 check_previous_goto (use)
4963      struct named_label_use_list *use;
4964 {
4965   check_previous_goto_1 (use->label_decl, use->binding_level,
4966                          use->names_in_scope, use->filename_o_goto,
4967                          use->lineno_o_goto);
4968 }
4969
4970 static void
4971 check_switch_goto (level)
4972      struct cp_binding_level *level;
4973 {
4974   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
4975 }
4976
4977 /* Check that any previously seen jumps to a newly defined label DECL
4978    are OK.  Called by define_label.  */
4979
4980 static void
4981 check_previous_gotos (decl)
4982      tree decl;
4983 {
4984   struct named_label_use_list **usep;
4985
4986   if (! TREE_USED (decl))
4987     return;
4988
4989   for (usep = &named_label_uses; *usep; )
4990     {
4991       struct named_label_use_list *use = *usep;
4992       if (use->label_decl == decl)
4993         {
4994           check_previous_goto (use);
4995           *usep = use->next;
4996         }
4997       else
4998         usep = &(use->next);
4999     }
5000 }
5001
5002 /* Check that a new jump to a label DECL is OK.  Called by
5003    finish_goto_stmt.  */
5004
5005 void
5006 check_goto (decl)
5007      tree decl;
5008 {
5009   int identified = 0;
5010   tree bad;
5011   struct named_label_list *lab;
5012
5013   /* We can't know where a computed goto is jumping.  So we assume
5014      that it's OK.  */
5015   if (! DECL_P (decl))
5016     return;
5017
5018   /* If the label hasn't been defined yet, defer checking.  */
5019   if (! DECL_INITIAL (decl))
5020     {
5021       use_label (decl);
5022       return;
5023     }
5024
5025   for (lab = named_labels; lab; lab = lab->next)
5026     if (decl == lab->label_decl)
5027       break;
5028
5029   /* If the label is not on named_labels it's a gcc local label, so
5030      it must be in an outer scope, so jumping to it is always OK.  */
5031   if (lab == 0)
5032     return;
5033
5034   if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
5035       && !identified)
5036     {
5037       cp_pedwarn_at ("jump to label `%D'", decl);
5038       pedwarn ("  from here");
5039       identified = 1;
5040     }
5041
5042   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5043     {
5044       tree b = TREE_VALUE (bad);
5045       int u = decl_jump_unsafe (b);
5046
5047       if (u > 1 && DECL_ARTIFICIAL (b))
5048         /* Can't skip init of __exception_info.  */
5049         cp_error_at ("  enters catch block", b);
5050       else if (u > 1)
5051         cp_error_at ("  skips initialization of `%#D'", b);
5052       else
5053         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5054     }
5055
5056   if (lab->in_try_scope)
5057     error ("  enters try block");
5058   else if (lab->in_catch_scope)
5059     error ("  enters catch block");
5060 }
5061
5062 /* Define a label, specifying the location in the source file.
5063    Return the LABEL_DECL node for the label, if the definition is valid.
5064    Otherwise return 0.  */
5065
5066 tree
5067 define_label (filename, line, name)
5068      const char *filename;
5069      int line;
5070      tree name;
5071 {
5072   tree decl = lookup_label (name);
5073   struct named_label_list *ent;
5074   register struct cp_binding_level *p;
5075
5076   for (ent = named_labels; ent; ent = ent->next)
5077     if (ent->label_decl == decl)
5078       break;
5079
5080   /* After labels, make any new cleanups in the function go into their
5081      own new (temporary) binding contour.  */
5082   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5083     p->more_cleanups_ok = 0;
5084
5085   if (name == get_identifier ("wchar_t"))
5086     pedwarn ("label named wchar_t");
5087
5088   if (DECL_INITIAL (decl) != NULL_TREE)
5089     {
5090       error ("duplicate label `%D'", decl);
5091       return 0;
5092     }
5093   else
5094     {
5095       /* Mark label as having been defined.  */
5096       DECL_INITIAL (decl) = error_mark_node;
5097       /* Say where in the source.  */
5098       DECL_SOURCE_FILE (decl) = filename;
5099       DECL_SOURCE_LINE (decl) = line;
5100       if (ent)
5101         {
5102           ent->names_in_scope = current_binding_level->names;
5103           ent->binding_level = current_binding_level;
5104         }
5105       check_previous_gotos (decl);
5106       return decl;
5107     }
5108 }
5109
5110 struct cp_switch
5111 {
5112   struct cp_binding_level *level;
5113   struct cp_switch *next;
5114   /* The SWITCH_STMT being built.  */
5115   tree switch_stmt;
5116   /* A splay-tree mapping the low element of a case range to the high
5117      element, or NULL_TREE if there is no high element.  Used to
5118      determine whether or not a new case label duplicates an old case
5119      label.  We need a tree, rather than simply a hash table, because
5120      of the GNU case range extension.  */
5121   splay_tree cases;
5122 };
5123
5124 /* A stack of the currently active switch statements.  The innermost
5125    switch statement is on the top of the stack.  There is no need to
5126    mark the stack for garbage collection because it is only active
5127    during the processing of the body of a function, and we never
5128    collect at that point.  */
5129
5130 static struct cp_switch *switch_stack;
5131
5132 /* Called right after a switch-statement condition is parsed.
5133    SWITCH_STMT is the switch statement being parsed.  */
5134
5135 void
5136 push_switch (switch_stmt)
5137      tree switch_stmt;
5138 {
5139   struct cp_switch *p
5140     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5141   p->level = current_binding_level;
5142   p->next = switch_stack;
5143   p->switch_stmt = switch_stmt;
5144   p->cases = splay_tree_new (case_compare, NULL, NULL);
5145   switch_stack = p;
5146 }
5147
5148 void
5149 pop_switch ()
5150 {
5151   struct cp_switch *cs;
5152
5153   cs = switch_stack;
5154   splay_tree_delete (cs->cases);
5155   switch_stack = switch_stack->next;
5156   free (cs);
5157 }
5158
5159 /* Note that we've seen a definition of a case label, and complain if this
5160    is a bad place for one.  */
5161
5162 tree
5163 finish_case_label (low_value, high_value)
5164      tree low_value;
5165      tree high_value;
5166 {
5167   tree cond, r;
5168   register struct cp_binding_level *p;
5169
5170   if (! switch_stack)
5171     {
5172       if (high_value)
5173         error ("case label not within a switch statement");
5174       else if (low_value)
5175         error ("case label `%E' not within a switch statement",
5176                   low_value);
5177       else
5178         error ("`default' label not within a switch statement");
5179       return NULL_TREE;
5180     }
5181
5182   if (processing_template_decl)
5183     {
5184       tree label;
5185
5186       /* For templates, just add the case label; we'll do semantic
5187          analysis at instantiation-time.  */
5188       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5189       return add_stmt (build_case_label (low_value, high_value, label));
5190     }
5191
5192   /* Find the condition on which this switch statement depends.  */
5193   cond = SWITCH_COND (switch_stack->switch_stmt);
5194   if (cond && TREE_CODE (cond) == TREE_LIST)
5195     cond = TREE_VALUE (cond);
5196
5197   r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5198   if (r == error_mark_node)
5199     r = NULL_TREE;
5200
5201   check_switch_goto (switch_stack->level);
5202
5203   /* After labels, make any new cleanups in the function go into their
5204      own new (temporary) binding contour.  */
5205   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5206     p->more_cleanups_ok = 0;
5207
5208   return r;
5209 }
5210 \f
5211 /* Return the list of declarations of the current level.
5212    Note that this list is in reverse order unless/until
5213    you nreverse it; and when you do nreverse it, you must
5214    store the result back using `storedecls' or you will lose.  */
5215
5216 tree
5217 getdecls ()
5218 {
5219   return current_binding_level->names;
5220 }
5221
5222 /* Return the list of type-tags (for structs, etc) of the current level.  */
5223
5224 tree
5225 gettags ()
5226 {
5227   return current_binding_level->tags;
5228 }
5229
5230 /* Store the list of declarations of the current level.
5231    This is done for the parameter declarations of a function being defined,
5232    after they are modified in the light of any missing parameters.  */
5233
5234 static void
5235 storedecls (decls)
5236      tree decls;
5237 {
5238   current_binding_level->names = decls;
5239 }
5240
5241 /* Similarly, store the list of tags of the current level.  */
5242
5243 void
5244 storetags (tags)
5245      tree tags;
5246 {
5247   current_binding_level->tags = tags;
5248 }
5249 \f
5250 /* Return the type that should be used when TYPE's name is preceded
5251    by a tag such as 'struct' or 'union', or null if the name cannot
5252    be used in this way.
5253
5254    For example, when processing the third line of:
5255
5256         struct A;
5257         typedef struct A A;
5258         struct A;
5259
5260    lookup of A will find the typedef.  Given A's typedef, this function
5261    will return the type associated with "struct A".  For the tag to be
5262    anything other than TYPE, TYPE must be a typedef whose original type
5263    has the same name and context as TYPE itself.
5264
5265    It is not valid for a typedef of an anonymous type to be used with
5266    an explicit tag:
5267
5268        typedef struct { ... } B;
5269        struct B;
5270
5271    Return null for this case.  */
5272
5273 static tree
5274 follow_tag_typedef (type)
5275      tree type;
5276 {
5277   tree original;
5278
5279   original = original_type (type);
5280   if (! TYPE_NAME (original))
5281     return NULL_TREE;
5282   if (TYPE_IDENTIFIER (original) == TYPE_IDENTIFIER (type)
5283       && (CP_DECL_CONTEXT (TYPE_NAME (original))
5284           == CP_DECL_CONTEXT (TYPE_NAME (type)))
5285       && !(CLASS_TYPE_P (original) && TYPE_WAS_ANONYMOUS (original)))
5286     return original;
5287   else
5288     return NULL_TREE;
5289 }
5290
5291 /* Given NAME, an IDENTIFIER_NODE,
5292    return the structure (or union or enum) definition for that name.
5293    Searches binding levels from BINDING_LEVEL up to the global level.
5294    If THISLEVEL_ONLY is nonzero, searches only the specified context
5295    (but skips any tag-transparent contexts to find one that is
5296    meaningful for tags).
5297    FORM says which kind of type the caller wants;
5298    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5299    If the wrong kind of type is found, and it's not a template, an error is
5300    reported.  */
5301
5302 static tree
5303 lookup_tag (form, name, binding_level, thislevel_only)
5304      enum tree_code form;
5305      tree name;
5306      struct cp_binding_level *binding_level;
5307      int thislevel_only;
5308 {
5309   register struct cp_binding_level *level;
5310   /* Nonzero if, we should look past a template parameter level, even
5311      if THISLEVEL_ONLY.  */
5312   int allow_template_parms_p = 1;
5313
5314   for (level = binding_level; level; level = level->level_chain)
5315     {
5316       register tree tail;
5317       if (ANON_AGGRNAME_P (name))
5318         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5319           {
5320             /* There's no need for error checking here, because
5321                anon names are unique throughout the compilation.  */
5322             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5323               return TREE_VALUE (tail);
5324           }
5325       else if (level->namespace_p)
5326         /* Do namespace lookup.  */
5327         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5328           {
5329             tree old = binding_for_name (name, tail);
5330
5331             /* If we just skipped past a template parameter level,
5332                even though THISLEVEL_ONLY, and we find a template
5333                class declaration, then we use the _TYPE node for the
5334                template.  See the example below.  */
5335             if (thislevel_only && !allow_template_parms_p
5336                 && old && BINDING_VALUE (old)
5337                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5338               old = TREE_TYPE (BINDING_VALUE (old));
5339             else
5340               old = BINDING_TYPE (old);
5341
5342             if (old)
5343               {
5344                 /* We've found something at this binding level.  If it is
5345                    a typedef, extract the tag it refers to.  Lookup fails
5346                    if the typedef doesn't refer to a taggable type.  */
5347                 old = follow_tag_typedef (old);
5348                 if (!old)
5349                   return NULL_TREE;
5350                 if (TREE_CODE (old) != form
5351                     && (form == ENUMERAL_TYPE
5352                         || TREE_CODE (old) == ENUMERAL_TYPE))
5353                   {
5354                     error ("`%#D' redeclared as %C", old, form);
5355                     return NULL_TREE;
5356                   }
5357                 return old;
5358               }
5359             if (thislevel_only || tail == global_namespace)
5360               return NULL_TREE;
5361           }
5362       else
5363         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5364           {
5365             if (TREE_PURPOSE (tail) == name)
5366               {
5367                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5368
5369                 if (code != form
5370                     && (form == ENUMERAL_TYPE || code == ENUMERAL_TYPE))
5371                   {
5372                     /* Definition isn't the kind we were looking for.  */
5373                     error ("`%#D' redeclared as %C", TREE_VALUE (tail), form);
5374                     return NULL_TREE;
5375                   }
5376                 return TREE_VALUE (tail);
5377               }
5378           }
5379       if (thislevel_only && ! level->tag_transparent)
5380         {
5381           if (level->template_parms_p && allow_template_parms_p)
5382             {
5383               /* We must deal with cases like this:
5384
5385                    template <class T> struct S;
5386                    template <class T> struct S {};
5387
5388                  When looking up `S', for the second declaration, we
5389                  would like to find the first declaration.  But, we
5390                  are in the pseudo-global level created for the
5391                  template parameters, rather than the (surrounding)
5392                  namespace level.  Thus, we keep going one more level,
5393                  even though THISLEVEL_ONLY is nonzero.  */
5394               allow_template_parms_p = 0;
5395               continue;
5396             }
5397           else
5398             return NULL_TREE;
5399         }
5400     }
5401   return NULL_TREE;
5402 }
5403
5404 #if 0
5405 void
5406 set_current_level_tags_transparency (tags_transparent)
5407      int tags_transparent;
5408 {
5409   current_binding_level->tag_transparent = tags_transparent;
5410 }
5411 #endif
5412
5413 /* Given a type, find the tag that was defined for it and return the tag name.
5414    Otherwise return 0.  However, the value can never be 0
5415    in the cases in which this is used.
5416
5417    C++: If NAME is nonzero, this is the new name to install.  This is
5418    done when replacing anonymous tags with real tag names.  */
5419
5420 static tree
5421 lookup_tag_reverse (type, name)
5422      tree type;
5423      tree name;
5424 {
5425   register struct cp_binding_level *level;
5426
5427   for (level = current_binding_level; level; level = level->level_chain)
5428     {
5429       register tree tail;
5430       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5431         {
5432           if (TREE_VALUE (tail) == type)
5433             {
5434               if (name)
5435                 TREE_PURPOSE (tail) = name;
5436               return TREE_PURPOSE (tail);
5437             }
5438         }
5439     }
5440   return NULL_TREE;
5441 }
5442 \f
5443 /* Look up NAME in the NAMESPACE.  */
5444
5445 tree
5446 lookup_namespace_name (namespace, name)
5447      tree namespace, name;
5448 {
5449   tree val;
5450   tree template_id = NULL_TREE;
5451
5452   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5453
5454   if (TREE_CODE (name) == NAMESPACE_DECL)
5455     /* This happens for A::B<int> when B is a namespace.  */
5456     return name;
5457   else if (TREE_CODE (name) == TEMPLATE_DECL)
5458     {
5459       /* This happens for A::B where B is a template, and there are no
5460          template arguments.  */
5461       error ("invalid use of `%D'", name);
5462       return error_mark_node;
5463     }
5464
5465   namespace = ORIGINAL_NAMESPACE (namespace);
5466
5467   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5468     {
5469       template_id = name;
5470       name = TREE_OPERAND (name, 0);
5471       if (TREE_CODE (name) == OVERLOAD)
5472         name = DECL_NAME (OVL_CURRENT (name));
5473       else if (DECL_P (name))
5474         name = DECL_NAME (name);
5475     }
5476
5477   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5478
5479   val = make_node (CPLUS_BINDING);
5480   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5481     return error_mark_node;
5482
5483   if (BINDING_VALUE (val))
5484     {
5485       val = BINDING_VALUE (val);
5486
5487       if (template_id)
5488         {
5489           if (DECL_CLASS_TEMPLATE_P (val))
5490             val = lookup_template_class (val,
5491                                          TREE_OPERAND (template_id, 1),
5492                                          /*in_decl=*/NULL_TREE,
5493                                          /*context=*/NULL_TREE,
5494                                          /*entering_scope=*/0,
5495                                          tf_error | tf_warning);
5496           else if (DECL_FUNCTION_TEMPLATE_P (val)
5497                    || TREE_CODE (val) == OVERLOAD)
5498             val = lookup_template_function (val,
5499                                             TREE_OPERAND (template_id, 1));
5500           else
5501             {
5502               error ("`%D::%D' is not a template",
5503                         namespace, name);
5504               return error_mark_node;
5505             }
5506         }
5507
5508       /* If we have a single function from a using decl, pull it out.  */
5509       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5510         val = OVL_FUNCTION (val);
5511
5512       /* Ignore built-in functions that haven't been prototyped yet.  */
5513       if (!val || !DECL_P(val)
5514           || !DECL_LANG_SPECIFIC(val)
5515           || !DECL_ANTICIPATED (val))
5516         return val;
5517     }
5518
5519   error ("`%D' undeclared in namespace `%D'", name, namespace);
5520   return error_mark_node;
5521 }
5522
5523 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5524
5525 static hashval_t
5526 typename_hash (k)
5527      const void * k;
5528 {
5529   hashval_t hash;
5530   tree t = (tree) k;
5531
5532   hash = (htab_hash_pointer (TYPE_CONTEXT (t))
5533           ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
5534
5535   return hash;
5536 }
5537
5538 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5539
5540 static int
5541 typename_compare (k1, k2)
5542      const void * k1;
5543      const void * k2;
5544 {
5545   tree t1;
5546   tree t2;
5547   tree d1;
5548   tree d2;
5549
5550   t1 = (tree) k1;
5551   t2 = (tree) k2;
5552   d1 = TYPE_NAME (t1);
5553   d2 = TYPE_NAME (t2);
5554
5555   return (DECL_NAME (d1) == DECL_NAME (d2)
5556           && TYPE_CONTEXT (t1) == TYPE_CONTEXT (t2)
5557           && ((TREE_TYPE (t1) != NULL_TREE)
5558               == (TREE_TYPE (t2) != NULL_TREE))
5559           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5560           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5561 }
5562
5563 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5564    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5565    is non-NULL, this type is being created by the implicit typename
5566    extension, and BASE_TYPE is a type named `t' in some base class of
5567    `T' which depends on template parameters.
5568
5569    Returns the new TYPENAME_TYPE.  */
5570
5571 static GTY ((param_is (union tree_node))) htab_t typename_htab;
5572
5573 tree
5574 build_typename_type (context, name, fullname, base_type)
5575      tree context;
5576      tree name;
5577      tree fullname;
5578      tree base_type;
5579 {
5580   tree t;
5581   tree d;
5582   PTR *e;
5583
5584   if (typename_htab == NULL)
5585     {
5586       typename_htab = htab_create_ggc (61, &typename_hash,
5587                                        &typename_compare, NULL);
5588     }
5589
5590   /* Build the TYPENAME_TYPE.  */
5591   t = make_aggr_type (TYPENAME_TYPE);
5592   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5593   TYPENAME_TYPE_FULLNAME (t) = fullname;
5594   TREE_TYPE (t) = base_type;
5595
5596   /* Build the corresponding TYPE_DECL.  */
5597   d = build_decl (TYPE_DECL, name, t);
5598   TYPE_NAME (TREE_TYPE (d)) = d;
5599   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5600   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5601   DECL_ARTIFICIAL (d) = 1;
5602
5603   /* See if we already have this type.  */
5604   e = htab_find_slot (typename_htab, t, INSERT);
5605   if (*e)
5606     t = (tree) *e;
5607   else
5608     *e = t;
5609
5610   return t;
5611 }
5612
5613 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5614    unless an error occurs, in which case error_mark_node is returned.
5615    If we locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is
5616    set, we return that, rather than the _TYPE it corresponds to, in
5617    other cases we look through the type decl.  If TF_ERROR is set,
5618    complain about errors, otherwise be quiet.  */
5619
5620 tree
5621 make_typename_type (context, name, complain)
5622      tree context, name;
5623      tsubst_flags_t complain;
5624 {
5625   tree fullname;
5626
5627   if (TYPE_P (name))
5628     {
5629       if (!(TYPE_LANG_SPECIFIC (name)
5630             && (CLASSTYPE_IS_TEMPLATE (name)
5631                 || CLASSTYPE_USE_TEMPLATE (name))))
5632         name = TYPE_IDENTIFIER (name);
5633       else
5634         /* Create a TEMPLATE_ID_EXPR for the type.  */
5635         name = build_nt (TEMPLATE_ID_EXPR,
5636                          CLASSTYPE_TI_TEMPLATE (name),
5637                          CLASSTYPE_TI_ARGS (name));
5638     }
5639   else if (TREE_CODE (name) == TYPE_DECL)
5640     name = DECL_NAME (name);
5641
5642   fullname = name;
5643
5644   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5645     {
5646       name = TREE_OPERAND (name, 0);
5647       if (TREE_CODE (name) == TEMPLATE_DECL)
5648         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5649     }
5650   if (TREE_CODE (name) == TEMPLATE_DECL)
5651     {
5652       error ("`%D' used without template parameters", name);
5653       return error_mark_node;
5654     }
5655   if (TREE_CODE (name) != IDENTIFIER_NODE)
5656     abort ();
5657
5658   if (TREE_CODE (context) == NAMESPACE_DECL)
5659     {
5660       /* We can get here from typename_sub0 in the explicit_template_type
5661          expansion.  Just fail.  */
5662       if (complain & tf_error)
5663         error ("no class template named `%#T' in `%#T'",
5664                   name, context);
5665       return error_mark_node;
5666     }
5667
5668   if (! uses_template_parms (context)
5669       || currently_open_class (context))
5670     {
5671       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5672         {
5673           tree tmpl = NULL_TREE;
5674           if (IS_AGGR_TYPE (context))
5675             tmpl = lookup_field (context, name, 0, 0);
5676           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5677             {
5678               if (complain & tf_error)
5679                 error ("no class template named `%#T' in `%#T'",
5680                           name, context);
5681               return error_mark_node;
5682             }
5683
5684           if (complain & tf_parsing)
5685             type_access_control (context, tmpl);
5686           else
5687             enforce_access (context, tmpl);
5688
5689           return lookup_template_class (tmpl,
5690                                         TREE_OPERAND (fullname, 1),
5691                                         NULL_TREE, context,
5692                                         /*entering_scope=*/0,
5693                                         tf_error | tf_warning);
5694         }
5695       else
5696         {
5697           tree t;
5698
5699           if (!IS_AGGR_TYPE (context))
5700             {
5701               if (complain & tf_error)
5702                 error ("no type named `%#T' in `%#T'", name, context);
5703               return error_mark_node;
5704             }
5705
5706           t = lookup_field (context, name, 0, 1);
5707           if (t)
5708             {
5709               if (TREE_CODE (t) != TYPE_DECL)
5710                 {
5711                   if (complain & tf_error)
5712                     error ("no type named `%#T' in `%#T'", name, context);
5713                   return error_mark_node;
5714                 }
5715
5716               if (complain & tf_parsing)
5717                 type_access_control (context, t);
5718               else
5719                 enforce_access (context, t);
5720
5721               if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
5722                 t = TREE_TYPE (t);
5723               if (IMPLICIT_TYPENAME_P (t))
5724                 {
5725                   /* Lookup found an implicit typename that we had
5726                      injected into the current scope. Doing things
5727                      properly would have located the exact same type,
5728                      so there is no error here.  We must remove the
5729                      implicitness so that we do not warn about it.  */
5730                   t = copy_node (t);
5731                   TREE_TYPE (t) = NULL_TREE;
5732                 }
5733
5734               return t;
5735             }
5736         }
5737     }
5738
5739   /* If the CONTEXT is not a template type, then either the field is
5740      there now or its never going to be.  */
5741   if (!uses_template_parms (context))
5742     {
5743       if (complain & tf_error)
5744         error ("no type named `%#T' in `%#T'", name, context);
5745       return error_mark_node;
5746     }
5747
5748   return build_typename_type (context, name, fullname,  NULL_TREE);
5749 }
5750
5751 /* Resolve `CONTEXT::template NAME'.  Returns an appropriate type,
5752    unless an error occurs, in which case error_mark_node is returned.
5753    If we locate a TYPE_DECL, we return that, rather than the _TYPE it
5754    corresponds to.  If COMPLAIN zero, don't complain about any errors
5755    that occur.  */
5756
5757 tree
5758 make_unbound_class_template (context, name, complain)
5759      tree context, name;
5760      tsubst_flags_t complain;
5761 {
5762   tree t;
5763   tree d;
5764
5765   if (TYPE_P (name))
5766     name = TYPE_IDENTIFIER (name);
5767   else if (DECL_P (name))
5768     name = DECL_NAME (name);
5769   if (TREE_CODE (name) != IDENTIFIER_NODE)
5770     abort ();
5771
5772   if (!uses_template_parms (context)
5773       || currently_open_class (context))
5774     {
5775       tree tmpl = NULL_TREE;
5776
5777       if (IS_AGGR_TYPE (context))
5778         tmpl = lookup_field (context, name, 0, 0);
5779
5780       if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5781         {
5782           if (complain & tf_error)
5783             error ("no class template named `%#T' in `%#T'", name, context);
5784           return error_mark_node;
5785         }
5786
5787       if (complain & tf_parsing)
5788         type_access_control (context, tmpl);
5789       else
5790         enforce_access (context, tmpl);
5791
5792       return tmpl;
5793     }
5794
5795   /* Build the UNBOUND_CLASS_TEMPLATE.  */
5796   t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
5797   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5798   TREE_TYPE (t) = NULL_TREE;
5799
5800   /* Build the corresponding TEMPLATE_DECL.  */
5801   d = build_decl (TEMPLATE_DECL, name, t);
5802   TYPE_NAME (TREE_TYPE (d)) = d;
5803   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5804   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5805   DECL_ARTIFICIAL (d) = 1;
5806
5807   return t;
5808 }
5809
5810 /* Select the right _DECL from multiple choices.  */
5811
5812 static tree
5813 select_decl (binding, flags)
5814      tree binding;
5815      int flags;
5816 {
5817   tree val;
5818   val = BINDING_VALUE (binding);
5819
5820   if (LOOKUP_NAMESPACES_ONLY (flags))
5821     {
5822       /* We are not interested in types.  */
5823       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5824         return val;
5825       return NULL_TREE;
5826     }
5827
5828   /* If we could have a type and
5829      we have nothing or we need a type and have none.  */
5830   if (BINDING_TYPE (binding)
5831       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5832                    && TREE_CODE (val) != TYPE_DECL)))
5833     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5834   /* Don't return non-types if we really prefer types.  */
5835   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5836            && (TREE_CODE (val) != TEMPLATE_DECL
5837                || !DECL_CLASS_TEMPLATE_P (val)))
5838     val = NULL_TREE;
5839
5840   return val;
5841 }
5842
5843 /* Unscoped lookup of a global: iterate over current namespaces,
5844    considering using-directives.  If SPACESP is non-NULL, store a list
5845    of the namespaces we've considered in it.  */
5846
5847 tree
5848 unqualified_namespace_lookup (name, flags, spacesp)
5849      tree name;
5850      int flags;
5851      tree *spacesp;
5852 {
5853   tree b = make_node (CPLUS_BINDING);
5854   tree initial = current_decl_namespace ();
5855   tree scope = initial;
5856   tree siter;
5857   struct cp_binding_level *level;
5858   tree val = NULL_TREE;
5859
5860   if (spacesp)
5861     *spacesp = NULL_TREE;
5862
5863   for (; !val; scope = CP_DECL_CONTEXT (scope))
5864     {
5865       if (spacesp)
5866         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5867       val = binding_for_name (name, scope);
5868
5869       /* Ignore anticipated built-in functions.  */
5870       if (val && BINDING_VALUE (val)
5871           && DECL_P (BINDING_VALUE (val))
5872           && DECL_LANG_SPECIFIC (BINDING_VALUE (val))
5873           && DECL_ANTICIPATED (BINDING_VALUE (val)))
5874         {
5875           BINDING_VALUE (b) = NULL_TREE;
5876           BINDING_TYPE (b) = NULL_TREE;
5877         }
5878       else
5879         {
5880           /* Initialize binding for this context.  */
5881           BINDING_VALUE (b) = BINDING_VALUE (val);
5882           BINDING_TYPE (b) = BINDING_TYPE (val);
5883         }
5884
5885       /* Add all _DECLs seen through local using-directives.  */
5886       for (level = current_binding_level;
5887            !level->namespace_p;
5888            level = level->level_chain)
5889         if (!lookup_using_namespace (name, b, level->using_directives,
5890                                      scope, flags, spacesp))
5891           /* Give up because of error.  */
5892           return error_mark_node;
5893
5894       /* Add all _DECLs seen through global using-directives.  */
5895       /* XXX local and global using lists should work equally.  */
5896       siter = initial;
5897       while (1)
5898         {
5899           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5900                                        scope, flags, spacesp))
5901             /* Give up because of error.  */
5902             return error_mark_node;
5903           if (siter == scope) break;
5904           siter = CP_DECL_CONTEXT (siter);
5905         }
5906
5907       val = select_decl (b, flags);
5908       if (scope == global_namespace)
5909         break;
5910     }
5911   return val;
5912 }
5913
5914 /* Combine prefer_type and namespaces_only into flags.  */
5915
5916 static int
5917 lookup_flags (prefer_type, namespaces_only)
5918   int prefer_type, namespaces_only;
5919 {
5920   if (namespaces_only)
5921     return LOOKUP_PREFER_NAMESPACES;
5922   if (prefer_type > 1)
5923     return LOOKUP_PREFER_TYPES;
5924   if (prefer_type > 0)
5925     return LOOKUP_PREFER_BOTH;
5926   return 0;
5927 }
5928
5929 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5930    ignore it or not.  Subroutine of lookup_name_real.  */
5931
5932 static tree
5933 qualify_lookup (val, flags)
5934      tree val;
5935      int flags;
5936 {
5937   if (val == NULL_TREE)
5938     return val;
5939   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5940     return val;
5941   if ((flags & LOOKUP_PREFER_TYPES)
5942       && (TREE_CODE (val) == TYPE_DECL
5943           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5944               && DECL_CLASS_TEMPLATE_P (val))))
5945     return val;
5946   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5947     return NULL_TREE;
5948   return val;
5949 }
5950
5951 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5952    that.  */
5953
5954 static void
5955 warn_about_implicit_typename_lookup (typename, binding)
5956      tree typename;
5957      tree binding;
5958 {
5959   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5960   tree name = DECL_NAME (typename);
5961
5962   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5963          && CLASSTYPE_TEMPLATE_INFO (subtype)
5964          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5965       && ! (TREE_CODE (binding) == TYPE_DECL
5966             && same_type_p (TREE_TYPE (binding), subtype)))
5967     {
5968       warning ("lookup of `%D' finds `%#D'",
5969                   name, binding);
5970       warning ("  instead of `%D' from dependent base class",
5971                   typename);
5972       warning ("  (use `typename %T::%D' if that's what you meant)",
5973                   constructor_name (current_class_type), name);
5974     }
5975 }
5976
5977 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
5978    or a class TYPE).  If IS_TYPE_P is TRUE, then ignore non-type
5979    bindings.
5980
5981    Returns a DECL (or OVERLOAD, or BASELINK) representing the
5982    declaration found.  */
5983
5984 tree
5985 lookup_qualified_name (tree scope, tree name, bool is_type_p, int flags)
5986 {
5987   if (TREE_CODE (scope) == NAMESPACE_DECL)
5988     {
5989       tree val;
5990
5991       val = make_node (CPLUS_BINDING);
5992       flags |= LOOKUP_COMPLAIN;
5993       if (is_type_p)
5994         flags |= LOOKUP_PREFER_TYPES;
5995       if (!qualified_lookup_using_namespace (name, scope, val, flags))
5996         return NULL_TREE;
5997       return select_decl (val, flags);
5998     }
5999   else
6000     return lookup_member (scope, name, 0, is_type_p);
6001 }
6002
6003 /* Check to see whether or not DECL is a variable that would have been
6004    in scope under the ARM, but is not in scope under the ANSI/ISO
6005    standard.  If so, issue an error message.  If name lookup would
6006    work in both cases, but return a different result, this function
6007    returns the result of ANSI/ISO lookup.  Otherwise, it returns
6008    DECL.  */
6009
6010 tree
6011 check_for_out_of_scope_variable (tree decl)
6012 {
6013   tree shadowed;
6014
6015   /* We only care about out of scope variables.  */
6016   if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
6017     return decl;
6018
6019   shadowed = DECL_SHADOWED_FOR_VAR (decl);
6020   while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
6021          && DECL_DEAD_FOR_LOCAL (shadowed))
6022     shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
6023   if (!shadowed)
6024     shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
6025   if (shadowed)
6026     {
6027       if (!DECL_ERROR_REPORTED (decl))
6028         {
6029           warning ("name lookup of `%D' changed",
6030                       DECL_NAME (decl));
6031           cp_warning_at ("  matches this `%D' under ISO standard rules",
6032                          shadowed);
6033           cp_warning_at ("  matches this `%D' under old rules", decl);
6034           DECL_ERROR_REPORTED (decl) = 1;
6035         }
6036       return shadowed;
6037     }
6038
6039   /* If we have already complained about this declaration, there's no
6040      need to do it again.  */
6041   if (DECL_ERROR_REPORTED (decl))
6042     return decl;
6043
6044   DECL_ERROR_REPORTED (decl) = 1;
6045   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
6046     {
6047       error ("name lookup of `%D' changed for new ISO `for' scoping",
6048              DECL_NAME (decl));
6049       cp_error_at ("  cannot use obsolete binding at `%D' because it has a destructor", decl);
6050       return error_mark_node;
6051     }
6052   else
6053     {
6054       pedwarn ("name lookup of `%D' changed for new ISO `for' scoping",
6055                DECL_NAME (decl));
6056       cp_pedwarn_at ("  using obsolete binding at `%D'", decl);
6057     }
6058
6059   return decl;
6060 }
6061
6062 /* Look up NAME in the current binding level and its superiors in the
6063    namespace of variables, functions and typedefs.  Return a ..._DECL
6064    node of some kind representing its definition if there is only one
6065    such declaration, or return a TREE_LIST with all the overloaded
6066    definitions if there are many, or return 0 if it is undefined.
6067
6068    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
6069    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
6070    Otherwise we prefer non-TYPE_DECLs.
6071
6072    If NONCLASS is nonzero, we don't look for the NAME in class scope,
6073    using IDENTIFIER_CLASS_VALUE.  */
6074
6075 tree
6076 lookup_name_real (tree name,
6077                   int prefer_type,
6078                   int nonclass,
6079                   int namespaces_only,
6080                   int flags)
6081 {
6082   tree t;
6083   tree val = NULL_TREE;
6084   int yylex = 0;
6085   int val_is_implicit_typename = 0;
6086
6087   /* Conversion operators are handled specially because ordinary
6088      unqualified name lookup will not find template conversion
6089      operators.  */
6090   if (IDENTIFIER_TYPENAME_P (name))
6091     {
6092       struct cp_binding_level *level;
6093
6094       for (level = current_binding_level;
6095            level && !level->namespace_p;
6096            level = level->level_chain)
6097         {
6098           tree class_type;
6099           tree operators;
6100
6101           /* A conversion operator can only be declared in a class
6102              scope.  */
6103           if (level->parm_flag != 2)
6104             continue;
6105
6106           /* Lookup the conversion operator in the class.  */
6107           class_type = level->this_class;
6108           operators = lookup_fnfields (class_type, name, /*protect=*/0);
6109           if (operators)
6110             return operators;
6111         }
6112
6113       return NULL_TREE;
6114     }
6115
6116   /* Hack: copy flag set by parser, if set. */
6117   if (only_namespace_names)
6118     namespaces_only = 1;
6119
6120   flags |= lookup_flags (prefer_type, namespaces_only);
6121
6122   /* First, look in non-namespace scopes.  */
6123
6124   if (current_class_type == NULL_TREE)
6125     nonclass = 1;
6126
6127   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
6128     {
6129       tree binding;
6130
6131       if (!LOCAL_BINDING_P (t) && nonclass)
6132         /* We're not looking for class-scoped bindings, so keep going.  */
6133         continue;
6134
6135       /* If this is the kind of thing we're looking for, we're done.  */
6136       if (qualify_lookup (BINDING_VALUE (t), flags))
6137         binding = BINDING_VALUE (t);
6138       else if ((flags & LOOKUP_PREFER_TYPES)
6139                && qualify_lookup (BINDING_TYPE (t), flags))
6140         binding = BINDING_TYPE (t);
6141       else
6142         binding = NULL_TREE;
6143
6144       if (binding
6145           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
6146         {
6147           if (val_is_implicit_typename && !yylex)
6148             warn_about_implicit_typename_lookup (val, binding);
6149           val = binding;
6150           val_is_implicit_typename
6151             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
6152           if (!val_is_implicit_typename)
6153             break;
6154         }
6155     }
6156
6157   /* Now lookup in namespace scopes.  */
6158   if (!val || val_is_implicit_typename)
6159     {
6160       t = unqualified_namespace_lookup (name, flags, 0);
6161       if (t)
6162         {
6163           if (val_is_implicit_typename && !yylex)
6164             warn_about_implicit_typename_lookup (val, t);
6165           val = t;
6166         }
6167     }
6168
6169   if (val)
6170     {
6171       /* If we have a single function from a using decl, pull it out.  */
6172       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6173         val = OVL_FUNCTION (val);
6174     }
6175
6176   return val;
6177 }
6178
6179 tree
6180 lookup_name_nonclass (name)
6181      tree name;
6182 {
6183   return lookup_name_real (name, 0, 1, 0, LOOKUP_COMPLAIN);
6184 }
6185
6186 tree
6187 lookup_function_nonclass (name, args)
6188      tree name;
6189      tree args;
6190 {
6191   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6192 }
6193
6194 tree
6195 lookup_name_namespace_only (name)
6196      tree name;
6197 {
6198   /* type-or-namespace, nonclass, namespace_only */
6199   return lookup_name_real (name, 1, 1, 1, LOOKUP_COMPLAIN);
6200 }
6201
6202 tree
6203 lookup_name (name, prefer_type)
6204      tree name;
6205      int prefer_type;
6206 {
6207   return lookup_name_real (name, prefer_type, 0, 0, LOOKUP_COMPLAIN);
6208 }
6209
6210 /* Similar to `lookup_name' but look only in the innermost non-class
6211    binding level.  */
6212
6213 tree
6214 lookup_name_current_level (name)
6215      tree name;
6216 {
6217   struct cp_binding_level *b;
6218   tree t = NULL_TREE;
6219
6220   b = current_binding_level;
6221   while (b->parm_flag == 2)
6222     b = b->level_chain;
6223
6224   if (b->namespace_p)
6225     {
6226       t = IDENTIFIER_NAMESPACE_VALUE (name);
6227
6228       /* extern "C" function() */
6229       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6230         t = TREE_VALUE (t);
6231     }
6232   else if (IDENTIFIER_BINDING (name)
6233            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6234     {
6235       while (1)
6236         {
6237           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6238             return IDENTIFIER_VALUE (name);
6239
6240           if (b->keep == 2)
6241             b = b->level_chain;
6242           else
6243             break;
6244         }
6245     }
6246
6247   return t;
6248 }
6249
6250 /* Like lookup_name_current_level, but for types.  */
6251
6252 tree
6253 lookup_type_current_level (name)
6254      tree name;
6255 {
6256   register tree t = NULL_TREE;
6257
6258   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6259
6260   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6261       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6262     {
6263       struct cp_binding_level *b = current_binding_level;
6264       while (1)
6265         {
6266           if (purpose_member (name, b->type_shadowed))
6267             return REAL_IDENTIFIER_TYPE_VALUE (name);
6268           if (b->keep == 2)
6269             b = b->level_chain;
6270           else
6271             break;
6272         }
6273     }
6274
6275   return t;
6276 }
6277
6278 void
6279 begin_only_namespace_names ()
6280 {
6281   only_namespace_names = 1;
6282 }
6283
6284 void
6285 end_only_namespace_names ()
6286 {
6287   only_namespace_names = 0;
6288 }
6289 \f
6290 /* Push the declarations of builtin types into the namespace.
6291    RID_INDEX is the index of the builtin type
6292    in the array RID_POINTERS.  NAME is the name used when looking
6293    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6294
6295 void
6296 record_builtin_type (rid_index, name, type)
6297      enum rid rid_index;
6298      const char *name;
6299      tree type;
6300 {
6301   tree rname = NULL_TREE, tname = NULL_TREE;
6302   tree tdecl = NULL_TREE;
6303
6304   if ((int) rid_index < (int) RID_MAX)
6305     rname = ridpointers[(int) rid_index];
6306   if (name)
6307     tname = get_identifier (name);
6308
6309   TYPE_BUILT_IN (type) = 1;
6310
6311   if (tname)
6312     {
6313       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6314       set_identifier_type_value (tname, NULL_TREE);
6315       if ((int) rid_index < (int) RID_MAX)
6316         /* Built-in types live in the global namespace.  */
6317         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6318     }
6319   if (rname != NULL_TREE)
6320     {
6321       if (tname != NULL_TREE)
6322         {
6323           set_identifier_type_value (rname, NULL_TREE);
6324           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6325         }
6326       else
6327         {
6328           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6329           set_identifier_type_value (rname, NULL_TREE);
6330         }
6331     }
6332 }
6333
6334 /* Record one of the standard Java types.
6335  * Declare it as having the given NAME.
6336  * If SIZE > 0, it is the size of one of the integral types;
6337  * otherwise it is the negative of the size of one of the other types.  */
6338
6339 static tree
6340 record_builtin_java_type (name, size)
6341      const char *name;
6342      int size;
6343 {
6344   tree type, decl;
6345   if (size > 0)
6346     type = make_signed_type (size);
6347   else if (size > -32)
6348     { /* "__java_char" or ""__java_boolean".  */
6349       type = make_unsigned_type (-size);
6350       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6351     }
6352   else
6353     { /* "__java_float" or ""__java_double".  */
6354       type = make_node (REAL_TYPE);
6355       TYPE_PRECISION (type) = - size;
6356       layout_type (type);
6357     }
6358   record_builtin_type (RID_MAX, name, type);
6359   decl = TYPE_NAME (type);
6360
6361   /* Suppress generate debug symbol entries for these types,
6362      since for normal C++ they are just clutter.
6363      However, push_lang_context undoes this if extern "Java" is seen.  */
6364   DECL_IGNORED_P (decl) = 1;
6365
6366   TYPE_FOR_JAVA (type) = 1;
6367   return type;
6368 }
6369
6370 /* Push a type into the namespace so that the back-ends ignore it.  */
6371
6372 static void
6373 record_unknown_type (type, name)
6374      tree type;
6375      const char *name;
6376 {
6377   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6378   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6379   DECL_IGNORED_P (decl) = 1;
6380   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6381   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6382   TYPE_ALIGN (type) = 1;
6383   TYPE_USER_ALIGN (type) = 0;
6384   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6385 }
6386
6387 /* An string for which we should create an IDENTIFIER_NODE at
6388    startup.  */
6389
6390 typedef struct predefined_identifier
6391 {
6392   /* The name of the identifier.  */
6393   const char *const name;
6394   /* The place where the IDENTIFIER_NODE should be stored.  */
6395   tree *const node;
6396   /* Nonzero if this is the name of a constructor or destructor.  */
6397   const int ctor_or_dtor_p;
6398 } predefined_identifier;
6399
6400 /* Create all the predefined identifiers.  */
6401
6402 static void
6403 initialize_predefined_identifiers ()
6404 {
6405   const predefined_identifier *pid;
6406
6407   /* A table of identifiers to create at startup.  */
6408   static const predefined_identifier predefined_identifiers[] = {
6409     { "C++", &lang_name_cplusplus, 0 },
6410     { "C", &lang_name_c, 0 },
6411     { "Java", &lang_name_java, 0 },
6412     { CTOR_NAME, &ctor_identifier, 1 },
6413     { "__base_ctor", &base_ctor_identifier, 1 },
6414     { "__comp_ctor", &complete_ctor_identifier, 1 },
6415     { DTOR_NAME, &dtor_identifier, 1 },
6416     { "__comp_dtor", &complete_dtor_identifier, 1 },
6417     { "__base_dtor", &base_dtor_identifier, 1 },
6418     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6419     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6420     { "nelts", &nelts_identifier, 0 },
6421     { THIS_NAME, &this_identifier, 0 },
6422     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6423     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6424     { "_vptr", &vptr_identifier, 0 },
6425     { "__vtt_parm", &vtt_parm_identifier, 0 },
6426     { "std", &std_identifier, 0 },
6427     { NULL, NULL, 0 }
6428   };
6429
6430   for (pid = predefined_identifiers; pid->name; ++pid)
6431     {
6432       *pid->node = get_identifier (pid->name);
6433       if (pid->ctor_or_dtor_p)
6434         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6435     }
6436 }
6437
6438 /* Create the predefined scalar types of C,
6439    and some nodes representing standard constants (0, 1, (void *)0).
6440    Initialize the global binding level.
6441    Make definitions for built-in primitive functions.  */
6442
6443 void
6444 cxx_init_decl_processing ()
6445 {
6446   tree void_ftype;
6447   tree void_ftype_ptr;
6448
6449   /* Create all the identifiers we need.  */
6450   initialize_predefined_identifiers ();
6451
6452   /* Fill in back-end hooks.  */
6453   lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
6454
6455   /* Create the global variables.  */
6456   push_to_top_level ();
6457
6458   /* Enter the global namespace.  */
6459   my_friendly_assert (global_namespace == NULL_TREE, 375);
6460   push_namespace (get_identifier ("::"));
6461   global_namespace = current_namespace;
6462   current_lang_name = NULL_TREE;
6463
6464   /* Adjust various flags based on command-line settings.  */
6465   if (! flag_permissive && ! pedantic)
6466     flag_pedantic_errors = 1;
6467   if (!flag_no_inline)
6468     {
6469       flag_inline_trees = 1;
6470       flag_no_inline = 1;
6471     }
6472   if (flag_inline_functions)
6473     {
6474       flag_inline_trees = 2;
6475       flag_inline_functions = 0;
6476     }
6477
6478   /* Force minimum function alignment if using the least significant
6479      bit of function pointers to store the virtual bit.  */
6480   if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
6481       && force_align_functions_log < 1)
6482     force_align_functions_log = 1;
6483
6484   /* Initially, C.  */
6485   current_lang_name = lang_name_c;
6486
6487   current_function_decl = NULL_TREE;
6488   current_binding_level = NULL_BINDING_LEVEL;
6489   free_binding_level = NULL_BINDING_LEVEL;
6490
6491   build_common_tree_nodes (flag_signed_char);
6492
6493   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6494   TREE_TYPE (error_mark_list) = error_mark_node;
6495
6496   /* Make the binding_level structure for global names.  */
6497   pushlevel (0);
6498   global_binding_level = current_binding_level;
6499   /* The global level is the namespace level of ::.  */
6500   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6501   declare_namespace_level ();
6502
6503   /* Create the `std' namespace.  */
6504   push_namespace (std_identifier);
6505   std_node = current_namespace;
6506   pop_namespace ();
6507
6508   c_common_nodes_and_builtins ();
6509
6510   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6511   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6512   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6513   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6514   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6515   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6516   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6517   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6518
6519   integer_two_node = build_int_2 (2, 0);
6520   TREE_TYPE (integer_two_node) = integer_type_node;
6521   integer_three_node = build_int_2 (3, 0);
6522   TREE_TYPE (integer_three_node) = integer_type_node;
6523
6524   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6525   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6526   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6527   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6528   TYPE_PRECISION (boolean_type_node) = 1;
6529   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6530   boolean_false_node = build_int_2 (0, 0);
6531   TREE_TYPE (boolean_false_node) = boolean_type_node;
6532   boolean_true_node = build_int_2 (1, 0);
6533   TREE_TYPE (boolean_true_node) = boolean_type_node;
6534
6535   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6536
6537 #if 0
6538   record_builtin_type (RID_MAX, NULL, string_type_node);
6539 #endif
6540
6541   delta_type_node = ptrdiff_type_node;
6542   vtable_index_type = ptrdiff_type_node;
6543
6544   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6545   void_ftype = build_function_type (void_type_node, void_list_node);
6546   void_ftype_ptr = build_function_type (void_type_node,
6547                                         tree_cons (NULL_TREE,
6548                                                    ptr_type_node,
6549                                                    void_list_node));
6550   void_ftype_ptr
6551     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6552
6553   /* C++ extensions */
6554
6555   unknown_type_node = make_node (UNKNOWN_TYPE);
6556   record_unknown_type (unknown_type_node, "unknown type");
6557
6558   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6559   TREE_TYPE (unknown_type_node) = unknown_type_node;
6560
6561   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6562      result.  */
6563   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6564   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6565
6566   {
6567     /* Make sure we get a unique function type, so we can give
6568        its pointer type a name.  (This wins for gdb.) */
6569     tree vfunc_type = make_node (FUNCTION_TYPE);
6570     TREE_TYPE (vfunc_type) = integer_type_node;
6571     TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6572     layout_type (vfunc_type);
6573
6574     vtable_entry_type = build_pointer_type (vfunc_type);
6575   }
6576   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6577
6578   vtbl_type_node
6579     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6580   layout_type (vtbl_type_node);
6581   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6582   record_builtin_type (RID_MAX, NULL, vtbl_type_node);
6583   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6584   layout_type (vtbl_ptr_type_node);
6585   record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
6586
6587   push_namespace (get_identifier ("__cxxabiv1"));
6588   abi_node = current_namespace;
6589   pop_namespace ();
6590
6591   global_type_node = make_node (LANG_TYPE);
6592   record_unknown_type (global_type_node, "global type");
6593
6594   /* Now, C++.  */
6595   current_lang_name = lang_name_cplusplus;
6596
6597   {
6598     tree bad_alloc_type_node, newtype, deltype;
6599     tree ptr_ftype_sizetype;
6600
6601     push_namespace (std_identifier);
6602     bad_alloc_type_node
6603       = xref_tag (class_type, get_identifier ("bad_alloc"),
6604                   /*attributes=*/NULL_TREE, 1);
6605     pop_namespace ();
6606     ptr_ftype_sizetype
6607       = build_function_type (ptr_type_node,
6608                              tree_cons (NULL_TREE,
6609                                         size_type_node,
6610                                         void_list_node));
6611     newtype = build_exception_variant
6612       (ptr_ftype_sizetype, add_exception_specifier
6613        (NULL_TREE, bad_alloc_type_node, -1));
6614     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6615     push_cp_library_fn (NEW_EXPR, newtype);
6616     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6617     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6618     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6619   }
6620
6621   abort_fndecl
6622     = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
6623
6624   /* Perform other language dependent initializations.  */
6625   init_class_processing ();
6626   init_search_processing ();
6627   init_rtti_processing ();
6628
6629   if (flag_exceptions)
6630     init_exception_processing ();
6631
6632   if (! supports_one_only ())
6633     flag_weak = 0;
6634
6635   make_fname_decl = cp_make_fname_decl;
6636   start_fname_decls ();
6637
6638   /* Show we use EH for cleanups.  */
6639   using_eh_for_cleanups ();
6640
6641   /* Maintain consistency.  Perhaps we should just complain if they
6642      say -fwritable-strings?  */
6643   if (flag_writable_strings)
6644     flag_const_strings = 0;
6645 }
6646
6647 /* Generate an initializer for a function naming variable from
6648    NAME. NAME may be NULL, in which case we generate a special
6649    ERROR_MARK node which should be replaced later.  */
6650
6651 tree
6652 cp_fname_init (name)
6653      const char *name;
6654 {
6655   tree domain = NULL_TREE;
6656   tree type;
6657   tree init = NULL_TREE;
6658   size_t length = 0;
6659
6660   if (name)
6661     {
6662       length = strlen (name);
6663       domain = build_index_type (size_int (length));
6664       init = build_string (length + 1, name);
6665     }
6666
6667   type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
6668   type = build_cplus_array_type (type, domain);
6669
6670   if (init)
6671     TREE_TYPE (init) = type;
6672   else
6673     /* We don't know the value until instantiation time. Make
6674        something which will be digested now, but replaced later.  */
6675     init = build (ERROR_MARK, type);
6676
6677   return init;
6678 }
6679
6680 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6681    decl, NAME is the initialization string and TYPE_DEP indicates whether
6682    NAME depended on the type of the function. We make use of that to detect
6683    __PRETTY_FUNCTION__ inside a template fn. This is being done
6684    lazily at the point of first use, so we musn't push the decl now.  */
6685
6686 static tree
6687 cp_make_fname_decl (id, type_dep)
6688      tree id;
6689      int type_dep;
6690 {
6691   const char *const name = (type_dep && processing_template_decl
6692                       ? NULL : fname_as_string (type_dep));
6693   tree init = cp_fname_init (name);
6694   tree decl = build_decl (VAR_DECL, id, TREE_TYPE (init));
6695
6696   /* As we don't push the decl here, we must set the context.  */
6697   DECL_CONTEXT (decl) = current_function_decl;
6698   DECL_PRETTY_FUNCTION_P (decl) = type_dep;
6699
6700   TREE_STATIC (decl) = 1;
6701   TREE_READONLY (decl) = 1;
6702   DECL_ARTIFICIAL (decl) = 1;
6703   DECL_INITIAL (decl) = init;
6704
6705   TREE_USED (decl) = 1;
6706
6707   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6708
6709   return decl;
6710 }
6711
6712 /* Make a definition for a builtin function named NAME in the current
6713    namespace, whose data type is TYPE and whose context is CONTEXT.
6714    TYPE should be a function type with argument types.
6715
6716    CLASS and CODE tell later passes how to compile calls to this function.
6717    See tree.h for possible values.
6718
6719    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6720    the name to be called if we can't opencode the function.
6721    If ATTRS is nonzero, use that for the function's attribute
6722    list.  */
6723
6724 static tree
6725 builtin_function_1 (name, type, context, code, class, libname, attrs)
6726      const char *name;
6727      tree type;
6728      tree context;
6729      int code;
6730      enum built_in_class class;
6731      const char *libname;
6732      tree attrs;
6733 {
6734   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6735   DECL_BUILT_IN_CLASS (decl) = class;
6736   DECL_FUNCTION_CODE (decl) = code;
6737   DECL_CONTEXT (decl) = context;
6738
6739   pushdecl (decl);
6740
6741   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6742      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6743      function in the namespace.  */
6744   if (libname)
6745     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
6746   make_decl_rtl (decl, NULL);
6747
6748   /* Warn if a function in the namespace for users
6749      is used without an occasion to consider it declared.  */
6750   if (name[0] != '_' || name[1] != '_')
6751     DECL_ANTICIPATED (decl) = 1;
6752
6753   /* Possibly apply some default attributes to this built-in function.  */
6754   if (attrs)
6755     decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
6756   else
6757     decl_attributes (&decl, NULL_TREE, 0);
6758
6759   return decl;
6760 }
6761
6762 /* Entry point for the benefit of c_common_nodes_and_builtins.
6763
6764    Make a defintion for a builtin function named NAME and whose data type
6765    is TYPE.  TYPE should be a function type with argument types.  This
6766    function places the anticipated declaration in the global namespace
6767    and additionally in the std namespace if appropriate.
6768
6769    CLASS and CODE tell later passes how to compile calls to this function.
6770    See tree.h for possible values.
6771
6772    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6773    the name to be called if we can't opencode the function.
6774
6775    If ATTRS is nonzero, use that for the function's attribute
6776    list.  */
6777
6778 tree
6779 builtin_function (name, type, code, class, libname, attrs)
6780      const char *name;
6781      tree type;
6782      int code;
6783      enum built_in_class class;
6784      const char *libname;
6785      tree attrs;
6786 {
6787   /* All builtins that don't begin with an '_' should additionally
6788      go in the 'std' namespace.  */
6789   if (name[0] != '_')
6790     {
6791       push_namespace (std_identifier);
6792       builtin_function_1 (name, type, std_node, code, class, libname, attrs);
6793       pop_namespace ();
6794     }
6795
6796   return builtin_function_1 (name, type, NULL_TREE, code,
6797                              class, libname, attrs);
6798 }
6799
6800 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6801    function.  Not called directly.  */
6802
6803 static tree
6804 build_library_fn_1 (name, operator_code, type)
6805      tree name;
6806      enum tree_code operator_code;
6807      tree type;
6808 {
6809   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6810   DECL_EXTERNAL (fn) = 1;
6811   TREE_PUBLIC (fn) = 1;
6812   DECL_ARTIFICIAL (fn) = 1;
6813   TREE_NOTHROW (fn) = 1;
6814   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6815   SET_DECL_LANGUAGE (fn, lang_c);
6816   return fn;
6817 }
6818
6819 /* Returns the _DECL for a library function with C linkage.
6820    We assume that such functions never throw; if this is incorrect,
6821    callers should unset TREE_NOTHROW.  */
6822
6823 tree
6824 build_library_fn (name, type)
6825      tree name;
6826      tree type;
6827 {
6828   return build_library_fn_1 (name, ERROR_MARK, type);
6829 }
6830
6831 /* Returns the _DECL for a library function with C++ linkage.  */
6832
6833 static tree
6834 build_cp_library_fn (name, operator_code, type)
6835      tree name;
6836      enum tree_code operator_code;
6837      tree type;
6838 {
6839   tree fn = build_library_fn_1 (name, operator_code, type);
6840   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6841   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6842   SET_DECL_LANGUAGE (fn, lang_cplusplus);
6843   set_mangled_name_for_decl (fn);
6844   return fn;
6845 }
6846
6847 /* Like build_library_fn, but takes a C string instead of an
6848    IDENTIFIER_NODE.  */
6849
6850 tree
6851 build_library_fn_ptr (name, type)
6852      const char *name;
6853      tree type;
6854 {
6855   return build_library_fn (get_identifier (name), type);
6856 }
6857
6858 /* Like build_cp_library_fn, but takes a C string instead of an
6859    IDENTIFIER_NODE.  */
6860
6861 tree
6862 build_cp_library_fn_ptr (name, type)
6863      const char *name;
6864      tree type;
6865 {
6866   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6867 }
6868
6869 /* Like build_library_fn, but also pushes the function so that we will
6870    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6871
6872 tree
6873 push_library_fn (name, type)
6874      tree name, type;
6875 {
6876   tree fn = build_library_fn (name, type);
6877   pushdecl_top_level (fn);
6878   return fn;
6879 }
6880
6881 /* Like build_cp_library_fn, but also pushes the function so that it
6882    will be found by normal lookup.  */
6883
6884 static tree
6885 push_cp_library_fn (operator_code, type)
6886      enum tree_code operator_code;
6887      tree type;
6888 {
6889   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6890                                  operator_code,
6891                                  type);
6892   pushdecl (fn);
6893   return fn;
6894 }
6895
6896 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6897    a FUNCTION_TYPE.  */
6898
6899 tree
6900 push_void_library_fn (name, parmtypes)
6901      tree name, parmtypes;
6902 {
6903   tree type = build_function_type (void_type_node, parmtypes);
6904   return push_library_fn (name, type);
6905 }
6906
6907 /* Like push_library_fn, but also note that this function throws
6908    and does not return.  Used for __throw_foo and the like.  */
6909
6910 tree
6911 push_throw_library_fn (name, type)
6912      tree name, type;
6913 {
6914   tree fn = push_library_fn (name, type);
6915   TREE_THIS_VOLATILE (fn) = 1;
6916   TREE_NOTHROW (fn) = 0;
6917   return fn;
6918 }
6919
6920 /* Apply default attributes to a function, if a system function with default
6921    attributes.  */
6922
6923 void
6924 cxx_insert_default_attributes (decl)
6925      tree decl;
6926 {
6927   if (!DECL_EXTERN_C_FUNCTION_P (decl))
6928     return;
6929   if (!TREE_PUBLIC (decl))
6930     return;
6931   c_common_insert_default_attributes (decl);
6932 }
6933 \f
6934 /* When we call finish_struct for an anonymous union, we create
6935    default copy constructors and such.  But, an anonymous union
6936    shouldn't have such things; this function undoes the damage to the
6937    anonymous union type T.
6938
6939    (The reason that we create the synthesized methods is that we don't
6940    distinguish `union { int i; }' from `typedef union { int i; } U'.
6941    The first is an anonymous union; the second is just an ordinary
6942    union type.)  */
6943
6944 void
6945 fixup_anonymous_aggr (t)
6946      tree t;
6947 {
6948   tree *q;
6949
6950   /* Wipe out memory of synthesized methods */
6951   TYPE_HAS_CONSTRUCTOR (t) = 0;
6952   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6953   TYPE_HAS_INIT_REF (t) = 0;
6954   TYPE_HAS_CONST_INIT_REF (t) = 0;
6955   TYPE_HAS_ASSIGN_REF (t) = 0;
6956   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6957
6958   /* Splice the implicitly generated functions out of the TYPE_METHODS
6959      list.  */
6960   q = &TYPE_METHODS (t);
6961   while (*q)
6962     {
6963       if (DECL_ARTIFICIAL (*q))
6964         *q = TREE_CHAIN (*q);
6965       else
6966         q = &TREE_CHAIN (*q);
6967     }
6968
6969   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6970   if (TYPE_METHODS (t))
6971     cp_error_at ("an anonymous union cannot have function members", t);
6972
6973   /* Anonymous aggregates cannot have fields with ctors, dtors or complex
6974      assignment operators (because they cannot have these methods themselves).
6975      For anonymous unions this is already checked because they are not allowed
6976      in any union, otherwise we have to check it.  */
6977   if (TREE_CODE (t) != UNION_TYPE)
6978     {
6979       tree field, type;
6980
6981       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
6982         if (TREE_CODE (field) == FIELD_DECL)
6983           {
6984             type = TREE_TYPE (field);
6985             if (CLASS_TYPE_P (type))
6986               {
6987                 if (TYPE_NEEDS_CONSTRUCTING (type))
6988                   cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
6989                                field);
6990                 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6991                   cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
6992                                field);
6993                 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
6994                   cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
6995                                field);
6996               }
6997           }
6998     }
6999 }
7000
7001 /* Make sure that a declaration with no declarator is well-formed, i.e.
7002    just declares a tagged type or anonymous union.
7003
7004    Returns the type declared; or NULL_TREE if none.  */
7005
7006 tree
7007 check_tag_decl (declspecs)
7008      tree declspecs;
7009 {
7010   int found_type = 0;
7011   int saw_friend = 0;
7012   int saw_typedef = 0;
7013   tree ob_modifier = NULL_TREE;
7014   register tree link;
7015   /* If a class, struct, or enum type is declared by the DECLSPECS
7016      (i.e, if a class-specifier, enum-specifier, or non-typename
7017      elaborated-type-specifier appears in the DECLSPECS),
7018      DECLARED_TYPE is set to the corresponding type.  */
7019   tree declared_type = NULL_TREE;
7020   bool error_p = false;
7021
7022   for (link = declspecs; link; link = TREE_CHAIN (link))
7023     {
7024       tree value = TREE_VALUE (link);
7025
7026       if (TYPE_P (value)
7027           || TREE_CODE (value) == TYPE_DECL
7028           || (TREE_CODE (value) == IDENTIFIER_NODE
7029               && IDENTIFIER_GLOBAL_VALUE (value)
7030               && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value)) == TYPE_DECL))
7031         {
7032           ++found_type;
7033
7034           if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
7035             {
7036               if (! in_system_header)
7037                 pedwarn ("redeclaration of C++ built-in type `%T'", value);
7038               return NULL_TREE;
7039             }
7040
7041           if (TYPE_P (value)
7042               && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
7043                   || TREE_CODE (value) == ENUMERAL_TYPE))
7044             {
7045               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
7046               declared_type = value;
7047             }
7048         }
7049       else if (value == ridpointers[(int) RID_TYPEDEF])
7050         saw_typedef = 1;
7051       else if (value == ridpointers[(int) RID_FRIEND])
7052         {
7053           if (current_class_type == NULL_TREE
7054               || current_scope () != current_class_type)
7055             ob_modifier = value;
7056           else
7057             saw_friend = 1;
7058         }
7059       else if (value == ridpointers[(int) RID_STATIC]
7060                || value == ridpointers[(int) RID_EXTERN]
7061                || value == ridpointers[(int) RID_AUTO]
7062                || value == ridpointers[(int) RID_REGISTER]
7063                || value == ridpointers[(int) RID_INLINE]
7064                || value == ridpointers[(int) RID_VIRTUAL]
7065                || value == ridpointers[(int) RID_CONST]
7066                || value == ridpointers[(int) RID_VOLATILE]
7067                || value == ridpointers[(int) RID_EXPLICIT]
7068                || value == ridpointers[(int) RID_THREAD])
7069         ob_modifier = value;
7070       else if (value == error_mark_node)
7071         error_p = true;
7072     }
7073
7074   if (found_type > 1)
7075     error ("multiple types in one declaration");
7076
7077   if (declared_type == NULL_TREE && ! saw_friend && !error_p)
7078     pedwarn ("declaration does not declare anything");
7079   /* Check for an anonymous union.  */
7080   else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type))
7081            && TYPE_ANONYMOUS_P (declared_type))
7082     {
7083       /* 7/3 In a simple-declaration, the optional init-declarator-list
7084          can be omitted only when declaring a class (clause 9) or
7085          enumeration (7.2), that is, when the decl-specifier-seq contains
7086          either a class-specifier, an elaborated-type-specifier with
7087          a class-key (9.1), or an enum-specifier.  In these cases and
7088          whenever a class-specifier or enum-specifier is present in the
7089          decl-specifier-seq, the identifiers in these specifiers are among
7090          the names being declared by the declaration (as class-name,
7091          enum-names, or enumerators, depending on the syntax).  In such
7092          cases, and except for the declaration of an unnamed bit-field (9.6),
7093          the decl-specifier-seq shall introduce one or more names into the
7094          program, or shall redeclare a name introduced by a previous
7095          declaration.  [Example:
7096              enum { };            // ill-formed
7097              typedef class { };   // ill-formed
7098          --end example]  */
7099       if (saw_typedef)
7100         {
7101           error ("missing type-name in typedef-declaration");
7102           return NULL_TREE;
7103         }
7104       /* Anonymous unions are objects, so they can have specifiers.  */;
7105       SET_ANON_AGGR_TYPE_P (declared_type);
7106
7107       if (TREE_CODE (declared_type) != UNION_TYPE && pedantic
7108           && !in_system_header)
7109         pedwarn ("ISO C++ prohibits anonymous structs");
7110     }
7111
7112   else if (ob_modifier)
7113     {
7114       if (ob_modifier == ridpointers[(int) RID_INLINE]
7115           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7116         error ("`%D' can only be specified for functions", ob_modifier);
7117       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7118         error ("`%D' can only be specified inside a class", ob_modifier);
7119       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7120         error ("`%D' can only be specified for constructors",
7121                   ob_modifier);
7122       else
7123         error ("`%D' can only be specified for objects and functions",
7124                   ob_modifier);
7125     }
7126
7127   return declared_type;
7128 }
7129
7130 /* Called when a declaration is seen that contains no names to declare.
7131    If its type is a reference to a structure, union or enum inherited
7132    from a containing scope, shadow that tag name for the current scope
7133    with a forward reference.
7134    If its type defines a new named structure or union
7135    or defines an enum, it is valid but we need not do anything here.
7136    Otherwise, it is an error.
7137
7138    C++: may have to grok the declspecs to learn about static,
7139    complain for anonymous unions.
7140
7141    Returns the TYPE declared -- or NULL_TREE if none.  */
7142
7143 tree
7144 shadow_tag (declspecs)
7145      tree declspecs;
7146 {
7147   tree t = check_tag_decl (declspecs);
7148
7149   if (!t)
7150     return NULL_TREE;
7151
7152   maybe_process_partial_specialization (t);
7153
7154   /* This is where the variables in an anonymous union are
7155      declared.  An anonymous union declaration looks like:
7156      union { ... } ;
7157      because there is no declarator after the union, the parser
7158      sends that declaration here.  */
7159   if (ANON_AGGR_TYPE_P (t))
7160     {
7161       fixup_anonymous_aggr (t);
7162
7163       if (TYPE_FIELDS (t))
7164         {
7165           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7166                                       NULL);
7167           finish_anon_union (decl);
7168         }
7169     }
7170
7171   return t;
7172 }
7173 \f
7174 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7175
7176 tree
7177 groktypename (typename)
7178      tree typename;
7179 {
7180   tree specs, attrs;
7181   tree type;
7182   if (TREE_CODE (typename) != TREE_LIST)
7183     return typename;
7184   split_specs_attrs (TREE_PURPOSE (typename), &specs, &attrs);
7185   type = grokdeclarator (TREE_VALUE (typename), specs,
7186                          TYPENAME, 0, &attrs);
7187   if (attrs)
7188     cplus_decl_attributes (&type, attrs, 0);
7189   return type;
7190 }
7191
7192 /* Decode a declarator in an ordinary declaration or data definition.
7193    This is called as soon as the type information and variable name
7194    have been parsed, before parsing the initializer if any.
7195    Here we create the ..._DECL node, fill in its type,
7196    and put it on the list of decls for the current context.
7197    The ..._DECL node is returned as the value.
7198
7199    Exception: for arrays where the length is not specified,
7200    the type is left null, to be filled in by `cp_finish_decl'.
7201
7202    Function definitions do not come here; they go to start_function
7203    instead.  However, external and forward declarations of functions
7204    do go through here.  Structure field declarations are done by
7205    grokfield and not through here.  */
7206
7207 tree
7208 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7209      tree declarator, declspecs;
7210      int initialized;
7211      tree attributes, prefix_attributes;
7212 {
7213   tree decl;
7214   register tree type, tem;
7215   tree context;
7216
7217 #if 0
7218   /* See code below that used this.  */
7219   int init_written = initialized;
7220 #endif
7221
7222   /* This should only be done once on the top most decl.  */
7223   if (have_extern_spec)
7224     {
7225       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7226                              declspecs);
7227       have_extern_spec = false;
7228     }
7229
7230   /* An object declared as __attribute__((deprecated)) suppresses
7231      warnings of uses of other deprecated items.  */
7232   if (lookup_attribute ("deprecated", attributes))
7233     deprecated_state = DEPRECATED_SUPPRESS;
7234
7235   attributes = chainon (attributes, prefix_attributes);
7236
7237   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7238                          &attributes);
7239
7240   deprecated_state = DEPRECATED_NORMAL;
7241
7242   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7243     return NULL_TREE;
7244
7245   type = TREE_TYPE (decl);
7246
7247   if (type == error_mark_node)
7248     return NULL_TREE;
7249
7250   context = DECL_CONTEXT (decl);
7251
7252   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7253       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7254     {
7255       /* When parsing the initializer, lookup should use the object's
7256          namespace.  */
7257       push_decl_namespace (context);
7258     }
7259
7260   /* We are only interested in class contexts, later.  */
7261   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7262     context = NULL_TREE;
7263
7264   if (initialized)
7265     /* Is it valid for this decl to have an initializer at all?
7266        If not, set INITIALIZED to zero, which will indirectly
7267        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7268     switch (TREE_CODE (decl))
7269       {
7270       case TYPE_DECL:
7271         error ("typedef `%D' is initialized (use __typeof__ instead)", decl);
7272         initialized = 0;
7273         break;
7274
7275       case FUNCTION_DECL:
7276         error ("function `%#D' is initialized like a variable", decl);
7277         initialized = 0;
7278         break;
7279
7280       default:
7281         break;
7282       }
7283
7284   if (initialized)
7285     {
7286       if (! toplevel_bindings_p ()
7287           && DECL_EXTERNAL (decl))
7288         warning ("declaration of `%#D' has `extern' and is initialized",
7289                     decl);
7290       DECL_EXTERNAL (decl) = 0;
7291       if (toplevel_bindings_p ())
7292         TREE_STATIC (decl) = 1;
7293
7294       /* Tell `pushdecl' this is an initialized decl
7295          even though we don't yet have the initializer expression.
7296          Also tell `cp_finish_decl' it may store the real initializer.  */
7297       DECL_INITIAL (decl) = error_mark_node;
7298     }
7299
7300   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7301   cplus_decl_attributes (&decl, attributes, 0);
7302
7303   /* If #pragma weak was used, mark the decl weak now.  */
7304   if (current_binding_level == global_binding_level)
7305     maybe_apply_pragma_weak (decl);
7306
7307   if (TREE_CODE (decl) == FUNCTION_DECL
7308       && DECL_DECLARED_INLINE_P (decl)
7309       && DECL_UNINLINABLE (decl)
7310       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
7311     warning_with_decl (decl,
7312                        "inline function `%s' given attribute noinline");
7313
7314   if (context && COMPLETE_TYPE_P (complete_type (context)))
7315     {
7316       push_nested_class (context, 2);
7317
7318       if (TREE_CODE (decl) == VAR_DECL)
7319         {
7320           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7321           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7322             error ("`%#D' is not a static member of `%#T'", decl, context);
7323           else
7324             {
7325               if (DECL_CONTEXT (field) != context)
7326                 {
7327                   if (!same_type_p (DECL_CONTEXT (field), context))
7328                     pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7329                              DECL_CONTEXT (field), DECL_NAME (decl),
7330                              context, DECL_NAME (decl));
7331                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7332                 }
7333               /* Static data member are tricky; an in-class initialization
7334                  still doesn't provide a definition, so the in-class
7335                  declaration will have DECL_EXTERNAL set, but will have an
7336                  initialization.  Thus, duplicate_decls won't warn
7337                  about this situation, and so we check here.  */
7338               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7339                 error ("duplicate initialization of %D", decl);
7340               if (duplicate_decls (decl, field))
7341                 decl = field;
7342             }
7343         }
7344       else
7345         {
7346           tree field = check_classfn (context, decl);
7347           if (field && duplicate_decls (decl, field))
7348             decl = field;
7349         }
7350
7351       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7352       DECL_IN_AGGR_P (decl) = 0;
7353       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7354           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7355         {
7356           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7357           /* [temp.expl.spec] An explicit specialization of a static data
7358              member of a template is a definition if the declaration
7359              includes an initializer; otherwise, it is a declaration.
7360
7361              We check for processing_specialization so this only applies
7362              to the new specialization syntax.  */
7363           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7364             DECL_EXTERNAL (decl) = 1;
7365         }
7366
7367       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7368         pedwarn ("declaration of `%#D' outside of class is not definition",
7369                     decl);
7370     }
7371
7372   /* Enter this declaration into the symbol table.  */
7373   tem = maybe_push_decl (decl);
7374
7375   if (processing_template_decl)
7376     tem = push_template_decl (tem);
7377
7378 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7379   /* Tell the back-end to use or not use .common as appropriate.  If we say
7380      -fconserve-space, we want this to save .data space, at the expense of
7381      wrong semantics.  If we say -fno-conserve-space, we want this to
7382      produce errors about redefs; to do this we force variables into the
7383      data segment.  */
7384   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7385 #endif
7386
7387   if (! processing_template_decl)
7388     start_decl_1 (tem);
7389
7390   return tem;
7391 }
7392
7393 void
7394 start_decl_1 (decl)
7395      tree decl;
7396 {
7397   tree type = TREE_TYPE (decl);
7398   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7399
7400   if (type == error_mark_node)
7401     return;
7402
7403   maybe_push_cleanup_level (type);
7404
7405   if (initialized)
7406     /* Is it valid for this decl to have an initializer at all?
7407        If not, set INITIALIZED to zero, which will indirectly
7408        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7409     {
7410       /* Don't allow initializations for incomplete types except for
7411          arrays which might be completed by the initialization.  */
7412       if (COMPLETE_TYPE_P (complete_type (type)))
7413         ;                       /* A complete type is ok.  */
7414       else if (TREE_CODE (type) != ARRAY_TYPE)
7415         {
7416           error ("variable `%#D' has initializer but incomplete type",
7417                     decl);
7418           initialized = 0;
7419           type = TREE_TYPE (decl) = error_mark_node;
7420         }
7421       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7422         {
7423           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7424             error ("elements of array `%#D' have incomplete type", decl);
7425           /* else we already gave an error in start_decl.  */
7426           initialized = 0;
7427         }
7428     }
7429
7430   if (!initialized
7431       && TREE_CODE (decl) != TYPE_DECL
7432       && TREE_CODE (decl) != TEMPLATE_DECL
7433       && type != error_mark_node
7434       && IS_AGGR_TYPE (type)
7435       && ! DECL_EXTERNAL (decl))
7436     {
7437       if ((! processing_template_decl || ! uses_template_parms (type))
7438           && !COMPLETE_TYPE_P (complete_type (type)))
7439         {
7440           error ("aggregate `%#D' has incomplete type and cannot be defined",
7441                  decl);
7442           /* Change the type so that assemble_variable will give
7443              DECL an rtl we can live with: (mem (const_int 0)).  */
7444           type = TREE_TYPE (decl) = error_mark_node;
7445         }
7446       else
7447         {
7448           /* If any base type in the hierarchy of TYPE needs a constructor,
7449              then we set initialized to 1.  This way any nodes which are
7450              created for the purposes of initializing this aggregate
7451              will live as long as it does.  This is necessary for global
7452              aggregates which do not have their initializers processed until
7453              the end of the file.  */
7454           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7455         }
7456     }
7457
7458   if (! initialized)
7459     DECL_INITIAL (decl) = NULL_TREE;
7460 }
7461
7462 /* Handle initialization of references.
7463    These three arguments are from `cp_finish_decl', and have the
7464    same meaning here that they do there.
7465
7466    Quotes on semantics can be found in ARM 8.4.3.  */
7467
7468 static tree
7469 grok_reference_init (decl, type, init)
7470      tree decl, type, init;
7471 {
7472   tree tmp;
7473
7474   if (init == NULL_TREE)
7475     {
7476       if ((DECL_LANG_SPECIFIC (decl) == 0
7477            || DECL_IN_AGGR_P (decl) == 0)
7478           && ! DECL_THIS_EXTERN (decl))
7479         error ("`%D' declared as reference but not initialized", decl);
7480       return NULL_TREE;
7481     }
7482
7483   if (TREE_CODE (init) == CONSTRUCTOR)
7484     {
7485       error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7486       return NULL_TREE;
7487     }
7488
7489   if (TREE_CODE (init) == TREE_LIST)
7490     init = build_compound_expr (init);
7491
7492   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7493     init = convert_from_reference (init);
7494
7495   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7496       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7497     {
7498       /* Note: default conversion is only called in very special cases.  */
7499       init = default_conversion (init);
7500     }
7501
7502   /* Convert INIT to the reference type TYPE.  This may involve the
7503      creation of a temporary, whose lifetime must be the same as that
7504      of the reference.  If so, a DECL_STMT for the temporary will be
7505      added just after the DECL_STMT for DECL.  That's why we don't set
7506      DECL_INITIAL for local references (instead assigning to them
7507      explicitly); we need to allow the temporary to be initialized
7508      first.  */
7509   tmp = convert_to_reference
7510     (type, init, CONV_IMPLICIT,
7511      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7512      decl);
7513
7514   if (tmp == error_mark_node)
7515     return NULL_TREE;
7516   else if (tmp == NULL_TREE)
7517     {
7518       error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7519       return NULL_TREE;
7520     }
7521
7522   if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
7523     return tmp;
7524
7525   DECL_INITIAL (decl) = tmp;
7526
7527   return NULL_TREE;
7528 }
7529
7530 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7531    array until we finish parsing the initializer.  If that's the
7532    situation we're in, update DECL accordingly.  */
7533
7534 static void
7535 maybe_deduce_size_from_array_init (decl, init)
7536      tree decl;
7537      tree init;
7538 {
7539   tree type = TREE_TYPE (decl);
7540
7541   if (TREE_CODE (type) == ARRAY_TYPE
7542       && TYPE_DOMAIN (type) == NULL_TREE
7543       && TREE_CODE (decl) != TYPE_DECL)
7544     {
7545       /* do_default is really a C-ism to deal with tentative definitions.
7546          But let's leave it here to ease the eventual merge.  */
7547       int do_default = !DECL_EXTERNAL (decl);
7548       tree initializer = init ? init : DECL_INITIAL (decl);
7549       int failure = complete_array_type (type, initializer, do_default);
7550
7551       if (failure == 1)
7552         error ("initializer fails to determine size of `%D'", decl);
7553
7554       if (failure == 2)
7555         {
7556           if (do_default)
7557             error ("array size missing in `%D'", decl);
7558           /* If a `static' var's size isn't known, make it extern as
7559              well as static, so it does not get allocated.  If it's not
7560              `static', then don't mark it extern; finish_incomplete_decl
7561              will give it a default size and it will get allocated.  */
7562           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7563             DECL_EXTERNAL (decl) = 1;
7564         }
7565
7566       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7567           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7568                               integer_zero_node))
7569         error ("zero-size array `%D'", decl);
7570
7571       layout_decl (decl, 0);
7572     }
7573 }
7574
7575 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7576    any appropriate error messages regarding the layout.  */
7577
7578 static void
7579 layout_var_decl (decl)
7580      tree decl;
7581 {
7582   tree type = TREE_TYPE (decl);
7583 #if 0
7584   tree ttype = target_type (type);
7585 #endif
7586
7587   /* If we haven't already layed out this declaration, do so now.
7588      Note that we must not call complete type for an external object
7589      because it's type might involve templates that we are not
7590      supposed to isntantiate yet.  (And it's perfectly valid to say
7591      `extern X x' for some incomplete type `X'.)  */
7592   if (!DECL_EXTERNAL (decl))
7593     complete_type (type);
7594   if (!DECL_SIZE (decl)
7595       && TREE_TYPE (decl) != error_mark_node
7596       && (COMPLETE_TYPE_P (type)
7597           || (TREE_CODE (type) == ARRAY_TYPE
7598               && !TYPE_DOMAIN (type)
7599               && COMPLETE_TYPE_P (TREE_TYPE (type)))))
7600     layout_decl (decl, 0);
7601
7602   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7603     {
7604       /* An automatic variable with an incomplete type: that is an error.
7605          Don't talk about array types here, since we took care of that
7606          message in grokdeclarator.  */
7607       error ("storage size of `%D' isn't known", decl);
7608       TREE_TYPE (decl) = error_mark_node;
7609     }
7610 #if 0
7611   /* Keep this code around in case we later want to control debug info
7612      based on whether a type is "used".  (jason 1999-11-11) */
7613
7614   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7615     /* Let debugger know it should output info for this type.  */
7616     note_debug_info_needed (ttype);
7617
7618   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7619     note_debug_info_needed (DECL_CONTEXT (decl));
7620 #endif
7621
7622   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7623       && DECL_SIZE (decl) != NULL_TREE
7624       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7625     {
7626       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7627         constant_expression_warning (DECL_SIZE (decl));
7628       else
7629         error ("storage size of `%D' isn't constant", decl);
7630     }
7631
7632   if (TREE_STATIC (decl)
7633       && !DECL_ARTIFICIAL (decl)
7634       && current_function_decl
7635       && DECL_CONTEXT (decl) == current_function_decl)
7636     push_local_name (decl);
7637 }
7638
7639 /* If a local static variable is declared in an inline function, or if
7640    we have a weak definition, we must endeavor to create only one
7641    instance of the variable at link-time.  */
7642
7643 static void
7644 maybe_commonize_var (decl)
7645      tree decl;
7646 {
7647   /* Static data in a function with comdat linkage also has comdat
7648      linkage.  */
7649   if (TREE_STATIC (decl)
7650       /* Don't mess with __FUNCTION__.  */
7651       && ! DECL_ARTIFICIAL (decl)
7652       && current_function_decl
7653       && DECL_CONTEXT (decl) == current_function_decl
7654       && (DECL_DECLARED_INLINE_P (current_function_decl)
7655           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7656       && TREE_PUBLIC (current_function_decl))
7657     {
7658       /* If flag_weak, we don't need to mess with this, as we can just
7659          make the function weak, and let it refer to its unique local
7660          copy.  This works because we don't allow the function to be
7661          inlined.  */
7662       if (! flag_weak)
7663         {
7664           if (DECL_INTERFACE_KNOWN (current_function_decl))
7665             {
7666               TREE_PUBLIC (decl) = 1;
7667               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7668             }
7669           else if (DECL_INITIAL (decl) == NULL_TREE
7670                    || DECL_INITIAL (decl) == error_mark_node)
7671             {
7672               TREE_PUBLIC (decl) = 1;
7673               DECL_COMMON (decl) = 1;
7674             }
7675           /* else we lose. We can only do this if we can use common,
7676              which we can't if it has been initialized.  */
7677
7678           if (!TREE_PUBLIC (decl))
7679             {
7680               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7681               cp_warning_at ("  you can work around this by removing the initializer", decl);
7682             }
7683         }
7684       else
7685         comdat_linkage (decl);
7686     }
7687   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7688     /* Set it up again; we might have set DECL_INITIAL since the last
7689        time.  */
7690     comdat_linkage (decl);
7691 }
7692
7693 /* Issue an error message if DECL is an uninitialized const variable.  */
7694
7695 static void
7696 check_for_uninitialized_const_var (decl)
7697      tree decl;
7698 {
7699   tree type = TREE_TYPE (decl);
7700
7701   /* ``Unless explicitly declared extern, a const object does not have
7702      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7703      7.1.6 */
7704   if (TREE_CODE (decl) == VAR_DECL
7705       && TREE_CODE (type) != REFERENCE_TYPE
7706       && CP_TYPE_CONST_P (type)
7707       && !TYPE_NEEDS_CONSTRUCTING (type)
7708       && !DECL_INITIAL (decl))
7709     error ("uninitialized const `%D'", decl);
7710 }
7711
7712 /* FIELD is a FIELD_DECL or NULL.  In the former case, the value
7713    returned is the next FIELD_DECL (possibly FIELD itself) that can be
7714    initialized.  If there are no more such fields, the return value
7715    will be NULL.  */
7716
7717 static tree
7718 next_initializable_field (tree field)
7719 {
7720   while (field
7721          && (TREE_CODE (field) != FIELD_DECL
7722              || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
7723              || DECL_ARTIFICIAL (field)))
7724     field = TREE_CHAIN (field);
7725
7726   return field;
7727 }
7728
7729 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
7730    brace-enclosed aggregate initializer.
7731
7732    *INITP is one of a list of initializers describing a brace-enclosed
7733    initializer for an entity of the indicated aggregate TYPE.  It may
7734    not presently match the shape of the TYPE; for example:
7735
7736      struct S { int a; int b; };
7737      struct S a[] = { 1, 2, 3, 4 };
7738
7739    Here *INITP will point to TREE_LIST of four elements, rather than a
7740    list of two elements, each itself a list of two elements.  This
7741    routine transforms INIT from the former form into the latter.  The
7742    revised initializer is returned.  */
7743
7744 static tree
7745 reshape_init (tree type, tree *initp)
7746 {
7747   tree inits;
7748   tree old_init;
7749   tree old_init_value;
7750   tree new_init;
7751   bool brace_enclosed_p;
7752
7753   old_init = *initp;
7754   old_init_value = (TREE_CODE (*initp) == TREE_LIST
7755                     ? TREE_VALUE (*initp) : old_init);
7756
7757   /* For some parse errors, OLD_INIT_VALUE may be NULL.  */
7758   if (!old_init_value)
7759     {
7760       my_friendly_assert (TREE_CODE (old_init) == TREE_LIST, 20021202);
7761       TREE_VALUE (old_init) = error_mark_node;
7762       return old_init;
7763     }
7764
7765   /* If the initializer is brace-enclosed, pull initializers from the
7766      enclosed elements.  Advance past the brace-enclosed initializer
7767      now.  */
7768   if (TREE_CODE (old_init_value) == CONSTRUCTOR
7769       && TREE_HAS_CONSTRUCTOR (old_init_value))
7770     {
7771       *initp = TREE_CHAIN (old_init);
7772       TREE_CHAIN (old_init) = NULL_TREE;
7773       inits = CONSTRUCTOR_ELTS (old_init_value);
7774       initp = &inits;
7775       brace_enclosed_p = true;
7776     }
7777   else
7778     {
7779       inits = NULL_TREE;
7780       brace_enclosed_p = false;
7781     }
7782
7783   /* A non-aggregate type is always initialized with a single
7784      initializer.  */
7785   if (!CP_AGGREGATE_TYPE_P (type))
7786       {
7787         *initp = TREE_CHAIN (old_init);
7788         TREE_CHAIN (old_init) = NULL_TREE;
7789         /* It is invalid to initialize a non-aggregate type with a
7790            brace-enclosed initializer.  */
7791         if (brace_enclosed_p)
7792           {
7793             error ("brace-enclosed initializer used to initialize `%T'",
7794                    type);
7795             if (TREE_CODE (old_init) == TREE_LIST)
7796               TREE_VALUE (old_init) = error_mark_node;
7797             else
7798               old_init = error_mark_node;
7799           }
7800
7801         return old_init;
7802       }
7803
7804   /* [dcl.init.aggr]
7805
7806      All implicit type conversions (clause _conv_) are considered when
7807      initializing the aggregate member with an initializer from an
7808      initializer-list.  If the initializer can initialize a member,
7809      the member is initialized.  Otherwise, if the member is itself a
7810      non-empty subaggregate, brace elision is assumed and the
7811      initializer is considered for the initialization of the first
7812      member of the subaggregate.  */
7813   if (CLASS_TYPE_P (type)
7814       && !brace_enclosed_p
7815       && can_convert_arg (type, TREE_TYPE (old_init_value), old_init_value))
7816     {
7817       *initp = TREE_CHAIN (old_init);
7818       TREE_CHAIN (old_init) = NULL_TREE;
7819       return old_init;
7820     }
7821
7822   if (TREE_CODE (old_init_value) == STRING_CST
7823       && TREE_CODE (type) == ARRAY_TYPE
7824       && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
7825     {
7826       /* [dcl.init.string]
7827
7828          A char array (whether plain char, signed char, or unsigned char)
7829          can be initialized by a string-literal (optionally enclosed in
7830          braces); a wchar_t array can be initialized by a wide
7831          string-literal (optionally enclosed in braces).  */
7832       new_init = old_init;
7833       /* Move past the initializer.  */
7834       *initp = TREE_CHAIN (old_init);
7835       TREE_CHAIN (old_init) = NULL_TREE;
7836     }
7837   else
7838     {
7839       /* Build a CONSTRUCTOR to hold the contents of the aggregate.  */
7840       new_init = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
7841       TREE_HAS_CONSTRUCTOR (new_init) = 1;
7842
7843       if (CLASS_TYPE_P (type))
7844         {
7845           tree field;
7846
7847           field = next_initializable_field (TYPE_FIELDS (type));
7848
7849           if (!field)
7850             {
7851               /* [dcl.init.aggr]
7852
7853                  An initializer for an aggregate member that is an
7854                  empty class shall have the form of an empty
7855                  initializer-list {}.  */
7856               if (!brace_enclosed_p)
7857                 error ("initializer for `%T' must be brace-enclosed",
7858                        type);
7859             }
7860           else
7861             {
7862               /* Loop through the initializable fields, gathering
7863                  initializers.  */
7864               while (*initp && field)
7865                 {
7866                   tree field_init;
7867
7868                   field_init = reshape_init (TREE_TYPE (field), initp);
7869                   TREE_CHAIN (field_init) = CONSTRUCTOR_ELTS (new_init);
7870                   CONSTRUCTOR_ELTS (new_init) = field_init;
7871                   /* [dcl.init.aggr]
7872
7873                      When a union  is  initialized with a brace-enclosed
7874                      initializer, the braces shall only contain an
7875                      initializer for the first member of the union.  */
7876                   if (TREE_CODE (type) == UNION_TYPE)
7877                     break;
7878                   if (TREE_PURPOSE (field_init))
7879                     field = TREE_PURPOSE (field_init);
7880                   field = next_initializable_field (TREE_CHAIN (field));
7881                 }
7882             }
7883         }
7884       else if (TREE_CODE (type) == ARRAY_TYPE)
7885         {
7886           tree index;
7887           tree max_index;
7888
7889           /* If the bound of the array is known, take no more initializers
7890              than are allowed.  */
7891           max_index = (TYPE_DOMAIN (type)
7892                        ? array_type_nelts (type) : NULL_TREE);
7893           /* Loop through the array elements, gathering initializers.  */
7894           for (index = size_zero_node;
7895                *initp && (!max_index || !tree_int_cst_lt (max_index, index));
7896                index = size_binop (PLUS_EXPR, index, size_one_node))
7897             {
7898               tree element_init;
7899
7900               element_init = reshape_init (TREE_TYPE (type), initp);
7901               TREE_CHAIN (element_init) = CONSTRUCTOR_ELTS (new_init);
7902               CONSTRUCTOR_ELTS (new_init) = element_init;
7903               if (TREE_PURPOSE (element_init))
7904                 index = TREE_PURPOSE (element_init);
7905             }
7906         }
7907       else
7908         abort ();
7909
7910       /* The initializers were placed in reverse order in the
7911          CONSTRUCTOR.  */
7912       CONSTRUCTOR_ELTS (new_init) = nreverse (CONSTRUCTOR_ELTS (new_init));
7913
7914       if (TREE_CODE (old_init) == TREE_LIST)
7915         new_init = build_tree_list (TREE_PURPOSE (old_init), new_init);
7916     }
7917
7918   /* If this was a brace-enclosed initializer and all of the
7919      initializers were not used up, there is a problem.  */
7920   if (brace_enclosed_p && *initp)
7921     error ("too many initializers for `%T'", type);
7922
7923   return new_init;
7924 }
7925
7926 /* Verify INIT (the initializer for DECL), and record the
7927    initialization in DECL_INITIAL, if appropriate.
7928
7929    If the return value is non-NULL, it is an expression that must be
7930    evaluated dynamically to initialize DECL.  */
7931
7932 static tree
7933 check_initializer (tree decl, tree init, int flags)
7934 {
7935   tree type = TREE_TYPE (decl);
7936
7937   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7938   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7939     init = NULL_TREE;
7940
7941   /* If an initializer is present, DECL_INITIAL has been
7942      error_mark_node, to indicate that an as-of-yet unevaluated
7943      initialization will occur.  From now on, DECL_INITIAL reflects
7944      the static initialization -- if any -- of DECL.  */
7945   DECL_INITIAL (decl) = NULL_TREE;
7946
7947   /* Things that are going to be initialized need to have complete
7948      type.  */
7949   TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7950
7951   if (type == error_mark_node)
7952     /* We will have already complained.  */
7953     init = NULL_TREE;
7954   else if (init && COMPLETE_TYPE_P (type)
7955            && !TREE_CONSTANT (TYPE_SIZE (type)))
7956     {
7957       error ("variable-sized object `%D' may not be initialized", decl);
7958       init = NULL_TREE;
7959     }
7960   else if (TREE_CODE (type) == ARRAY_TYPE
7961            && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7962     {
7963       error ("elements of array `%#D' have incomplete type", decl);
7964       init = NULL_TREE;
7965     }
7966   else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
7967     {
7968       error ("`%D' has incomplete type", decl);
7969       TREE_TYPE (decl) = error_mark_node;
7970       init = NULL_TREE;
7971     }
7972
7973   if (TREE_CODE (decl) == CONST_DECL)
7974     {
7975       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7976
7977       DECL_INITIAL (decl) = init;
7978
7979       my_friendly_assert (init != NULL_TREE, 149);
7980       init = NULL_TREE;
7981     }
7982   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7983     init = grok_reference_init (decl, type, init);
7984   else if (init)
7985     {
7986       if (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))
7987         {
7988           /* [dcl.init] paragraph 13,
7989              If T is a scalar type, then a declaration of the form
7990              T x = { a };
7991              is equivalent to
7992              T x = a;
7993
7994              reshape_init will complain about the extra braces,
7995              and doesn't do anything useful in the case where TYPE is
7996              scalar, so just don't call it.  */
7997           if (CP_AGGREGATE_TYPE_P (type))
7998             init = reshape_init (type, &init);
7999         }
8000
8001       /* If DECL has an array type without a specific bound, deduce the
8002          array size from the initializer.  */
8003       maybe_deduce_size_from_array_init (decl, init);
8004       type = TREE_TYPE (decl);
8005       if (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))
8006         TREE_TYPE (init) = type;
8007
8008       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
8009         {
8010           if (TREE_CODE (type) == ARRAY_TYPE)
8011             goto initialize_aggr;
8012           else if (TREE_CODE (init) == CONSTRUCTOR
8013                    && TREE_HAS_CONSTRUCTOR (init))
8014             {
8015               if (TYPE_NON_AGGREGATE_CLASS (type))
8016                 {
8017                   error ("`%D' must be initialized by constructor, not by `{...}'",
8018                          decl);
8019                   init = error_mark_node;
8020                 }
8021               else
8022                 goto dont_use_constructor;
8023             }
8024           else
8025             {
8026               int saved_stmts_are_full_exprs_p;
8027
8028             initialize_aggr:
8029               saved_stmts_are_full_exprs_p = 0;
8030               if (building_stmt_tree ())
8031                 {
8032                   saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
8033                   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
8034                 }
8035               init = build_aggr_init (decl, init, flags);
8036               if (building_stmt_tree ())
8037                 current_stmt_tree ()->stmts_are_full_exprs_p =
8038                   saved_stmts_are_full_exprs_p;
8039               return init;
8040             }
8041         }
8042       else
8043         {
8044         dont_use_constructor:
8045           if (TREE_CODE (init) != TREE_VEC)
8046             init = store_init_value (decl, init);
8047         }
8048     }
8049   else if (DECL_EXTERNAL (decl))
8050     ;
8051   else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
8052     goto initialize_aggr;
8053   else if (IS_AGGR_TYPE (type))
8054     {
8055       tree core_type = strip_array_types (type);
8056
8057       if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
8058         error ("structure `%D' with uninitialized const members", decl);
8059       if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
8060         error ("structure `%D' with uninitialized reference members",
8061                decl);
8062
8063       check_for_uninitialized_const_var (decl);
8064     }
8065   else
8066     check_for_uninitialized_const_var (decl);
8067
8068   if (init && init != error_mark_node)
8069     init = build (INIT_EXPR, type, decl, init);
8070
8071   return init;
8072 }
8073
8074 /* If DECL is not a local variable, give it RTL.  */
8075
8076 static void
8077 make_rtl_for_nonlocal_decl (decl, init, asmspec)
8078      tree decl;
8079      tree init;
8080      const char *asmspec;
8081 {
8082   int toplev = toplevel_bindings_p ();
8083   int defer_p;
8084
8085   /* Handle non-variables up front.  */
8086   if (TREE_CODE (decl) != VAR_DECL)
8087     {
8088       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
8089       return;
8090     }
8091
8092   /* If we see a class member here, it should be a static data
8093      member.  */
8094   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
8095     {
8096       my_friendly_assert (TREE_STATIC (decl), 19990828);
8097       /* An in-class declaration of a static data member should be
8098          external; it is only a declaration, and not a definition.  */
8099       if (init == NULL_TREE)
8100         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
8101     }
8102
8103   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
8104   if (asmspec)
8105     {
8106       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8107       /* The `register' keyword, when used together with an
8108          asm-specification, indicates that the variable should be
8109          placed in a particular register.  */
8110       if (DECL_REGISTER (decl))
8111         DECL_C_HARD_REGISTER (decl) = 1;
8112     }
8113
8114   /* We don't create any RTL for local variables.  */
8115   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
8116     return;
8117
8118   /* We defer emission of local statics until the corresponding
8119      DECL_STMT is expanded.  */
8120   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
8121
8122   /* We try to defer namespace-scope static constants so that they are
8123      not emitted into the object file unnecessarily.  */
8124   if (!DECL_VIRTUAL_P (decl)
8125       && TREE_READONLY (decl)
8126       && DECL_INITIAL (decl) != NULL_TREE
8127       && DECL_INITIAL (decl) != error_mark_node
8128       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
8129       && toplev
8130       && !TREE_PUBLIC (decl))
8131     {
8132       /* Fool with the linkage of static consts according to #pragma
8133          interface.  */
8134       if (!interface_unknown && !TREE_PUBLIC (decl))
8135         {
8136           TREE_PUBLIC (decl) = 1;
8137           DECL_EXTERNAL (decl) = interface_only;
8138         }
8139
8140       defer_p = 1;
8141     }
8142   /* Likewise for template instantiations.  */
8143   else if (DECL_COMDAT (decl))
8144     defer_p = 1;
8145
8146   /* If we're deferring the variable, we only need to make RTL if
8147      there's an ASMSPEC.  Otherwise, we'll lazily create it later when
8148      we need it.  (There's no way to lazily create RTL for things that
8149      have assembly specs because the information about the specifier
8150      isn't stored in the tree, yet)  */
8151   if (defer_p && asmspec)
8152     make_decl_rtl (decl, asmspec);
8153   /* If we're not deferring, go ahead and assemble the variable.  */
8154   else if (!defer_p)
8155     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
8156 }
8157
8158 /* The old ARM scoping rules injected variables declared in the
8159    initialization statement of a for-statement into the surrounding
8160    scope.  We support this usage, in order to be backward-compatible.
8161    DECL is a just-declared VAR_DECL; if necessary inject its
8162    declaration into the surrounding scope.  */
8163
8164 void
8165 maybe_inject_for_scope_var (decl)
8166      tree decl;
8167 {
8168   if (!DECL_NAME (decl))
8169     return;
8170
8171   /* Declarations of __FUNCTION__ and its ilk appear magically when
8172      the variable is first used.  If that happens to be inside a
8173      for-loop, we don't want to do anything special.  */
8174   if (DECL_PRETTY_FUNCTION_P (decl))
8175     return;
8176
8177   if (current_binding_level->is_for_scope)
8178     {
8179       struct cp_binding_level *outer
8180         = current_binding_level->level_chain;
8181
8182       /* Check to see if the same name is already bound at the outer
8183          level, either because it was directly declared, or because a
8184          dead for-decl got preserved.  In either case, the code would
8185          not have been valid under the ARM scope rules, so clear
8186          is_for_scope for the current_binding_level.
8187
8188          Otherwise, we need to preserve the temp slot for decl to last
8189          into the outer binding level.  */
8190
8191       tree outer_binding
8192         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
8193
8194       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
8195           && (TREE_CODE (BINDING_VALUE (outer_binding))
8196               == VAR_DECL)
8197           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
8198         {
8199           BINDING_VALUE (outer_binding)
8200             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
8201           current_binding_level->is_for_scope = 0;
8202         }
8203       else if (DECL_IN_MEMORY_P (decl))
8204         preserve_temp_slots (DECL_RTL (decl));
8205     }
8206 }
8207
8208 /* Generate code to initialize DECL (a local variable).  */
8209
8210 static void
8211 initialize_local_var (decl, init)
8212      tree decl;
8213      tree init;
8214 {
8215   tree type = TREE_TYPE (decl);
8216
8217   my_friendly_assert (TREE_CODE (decl) == VAR_DECL
8218                       || TREE_CODE (decl) == RESULT_DECL,
8219                       20021010);
8220   my_friendly_assert (!TREE_STATIC (decl), 20021010);
8221
8222   if (DECL_SIZE (decl) == NULL_TREE)
8223     {
8224       /* If we used it already as memory, it must stay in memory.  */
8225       DECL_INITIAL (decl) = NULL_TREE;
8226       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
8227     }
8228
8229   if (DECL_SIZE (decl) && type != error_mark_node)
8230     {
8231       int already_used;
8232
8233       /* Compute and store the initial value.  */
8234       already_used = TREE_USED (decl) || TREE_USED (type);
8235
8236       /* Perform the initialization.  */
8237       if (init)
8238         {
8239           int saved_stmts_are_full_exprs_p;
8240
8241           my_friendly_assert (building_stmt_tree (), 20000906);
8242           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
8243           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
8244           finish_expr_stmt (init);
8245           current_stmt_tree ()->stmts_are_full_exprs_p =
8246             saved_stmts_are_full_exprs_p;
8247         }
8248
8249       /* Set this to 0 so we can tell whether an aggregate which was
8250          initialized was ever used.  Don't do this if it has a
8251          destructor, so we don't complain about the 'resource
8252          allocation is initialization' idiom.  Now set
8253          attribute((unused)) on types so decls of that type will be
8254          marked used. (see TREE_USED, above.)  */
8255       if (TYPE_NEEDS_CONSTRUCTING (type)
8256           && ! already_used
8257           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
8258           && DECL_NAME (decl))
8259         TREE_USED (decl) = 0;
8260       else if (already_used)
8261         TREE_USED (decl) = 1;
8262     }
8263
8264   /* Generate a cleanup, if necessary.  */
8265   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8266     {
8267       tree cleanup;
8268
8269       /* Compute the cleanup.  */
8270       cleanup = cxx_maybe_build_cleanup (decl);
8271
8272       /* Record the cleanup required for this declaration.  */
8273       if (DECL_SIZE (decl) && cleanup)
8274         finish_decl_cleanup (decl, cleanup);
8275     }
8276 }
8277
8278 /* Finish processing of a declaration;
8279    install its line number and initial value.
8280    If the length of an array type is not known before,
8281    it must be determined now, from the initial value, or it is an error.
8282
8283    INIT holds the value of an initializer that should be allowed to escape
8284    the normal rules.
8285
8286    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8287    if the (init) syntax was used.  */
8288
8289 void
8290 cp_finish_decl (decl, init, asmspec_tree, flags)
8291      tree decl, init;
8292      tree asmspec_tree;
8293      int flags;
8294 {
8295   register tree type;
8296   tree ttype = NULL_TREE;
8297   const char *asmspec = NULL;
8298   int was_readonly = 0;
8299
8300   if (! decl)
8301     {
8302       if (init)
8303         error ("assignment (not initialization) in declaration");
8304       return;
8305     }
8306
8307   /* If a name was specified, get the string.  */
8308   if (current_binding_level == global_binding_level)
8309     asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
8310   if (asmspec_tree)
8311     asmspec = TREE_STRING_POINTER (asmspec_tree);
8312
8313   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8314     {
8315       error ("cannot initialize `%D' to namespace `%D'",
8316                 decl, init);
8317       init = NULL_TREE;
8318     }
8319
8320   if (current_class_type
8321       && CP_DECL_CONTEXT (decl) == current_class_type
8322       && TYPE_BEING_DEFINED (current_class_type)
8323       && (DECL_INITIAL (decl) || init))
8324     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
8325
8326   if (TREE_CODE (decl) == VAR_DECL
8327       && DECL_CONTEXT (decl)
8328       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8329       && DECL_CONTEXT (decl) != current_namespace
8330       && init)
8331     {
8332       /* Leave the namespace of the object.  */
8333       pop_decl_namespace ();
8334     }
8335
8336   type = TREE_TYPE (decl);
8337
8338   if (type == error_mark_node)
8339     return;
8340
8341   if (TYPE_HAS_MUTABLE_P (type))
8342     TREE_READONLY (decl) = 0;
8343
8344   if (processing_template_decl)
8345     {
8346       /* Add this declaration to the statement-tree.  */
8347       if (at_function_scope_p ()
8348           && TREE_CODE (decl) != RESULT_DECL)
8349         add_decl_stmt (decl);
8350
8351       if (init && DECL_INITIAL (decl))
8352         DECL_INITIAL (decl) = init;
8353       goto finish_end0;
8354     }
8355
8356   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8357   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8358
8359   /* Take care of TYPE_DECLs up front.  */
8360   if (TREE_CODE (decl) == TYPE_DECL)
8361     {
8362       if (type != error_mark_node
8363           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8364         {
8365           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8366             warning ("shadowing previous type declaration of `%#D'", decl);
8367           set_identifier_type_value (DECL_NAME (decl), type);
8368           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8369         }
8370
8371       /* If we have installed this as the canonical typedef for this
8372          type, and that type has not been defined yet, delay emitting
8373          the debug information for it, as we will emit it later.  */
8374       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8375           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8376         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8377
8378       rest_of_decl_compilation (decl, NULL,
8379                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8380       goto finish_end;
8381     }
8382
8383   if (TREE_CODE (decl) != FUNCTION_DECL)
8384     ttype = target_type (type);
8385
8386   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8387       && TYPE_NEEDS_CONSTRUCTING (type))
8388     {
8389       /* Currently, GNU C++ puts constants in text space, making them
8390          impossible to initialize.  In the future, one would hope for
8391          an operating system which understood the difference between
8392          initialization and the running of a program.  */
8393       was_readonly = 1;
8394       TREE_READONLY (decl) = 0;
8395     }
8396
8397   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8398     {
8399       /* This must override the asm specifier which was placed by
8400          grokclassfn.  Lay this out fresh.  */
8401       SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
8402       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8403       make_decl_rtl (decl, asmspec);
8404     }
8405   else if (TREE_CODE (decl) == RESULT_DECL)
8406     init = check_initializer (decl, init, flags);
8407   else if (TREE_CODE (decl) == VAR_DECL)
8408     {
8409       /* Only PODs can have thread-local storage.  Other types may require
8410          various kinds of non-trivial initialization.  */
8411       if (DECL_THREAD_LOCAL (decl) && !pod_type_p (TREE_TYPE (decl)))
8412         error ("`%D' cannot be thread-local because it has non-POD type `%T'",
8413                decl, TREE_TYPE (decl));
8414       /* Convert the initializer to the type of DECL, if we have not
8415          already initialized DECL.  */
8416       if (!DECL_INITIALIZED_P (decl)
8417           /* If !DECL_EXTERNAL then DECL is being defined.  In the
8418              case of a static data member initialized inside the
8419              class-specifier, there can be an initializer even if DECL
8420              is *not* defined.  */
8421           && (!DECL_EXTERNAL (decl) || init))
8422         {
8423           init = check_initializer (decl, init, flags);
8424           /* Thread-local storage cannot be dynamically initialized.  */
8425           if (DECL_THREAD_LOCAL (decl) && init)
8426             {
8427               error ("`%D' is thread-local and so cannot be dynamically "
8428                      "initialized", decl);
8429               init = NULL_TREE;
8430             }
8431           /* Handle:
8432
8433              [dcl.init]
8434
8435              The memory occupied by any object of static storage
8436              duration is zero-initialized at program startup before
8437              any other initialization takes place.
8438
8439              We cannot create an appropriate initializer until after
8440              the type of DECL is finalized.  If DECL_INITIAL is set,
8441              then the DECL is statically initialized, and any
8442              necessary zero-initialization has already been performed.  */
8443           if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
8444             DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
8445                                                    /*static_storage_p=*/true);
8446           /* Remember that the initialization for this variable has
8447              taken place.  */
8448           DECL_INITIALIZED_P (decl) = 1;
8449         }
8450       /* If the variable has an array type, lay out the type, even if
8451          there is no initializer.  It is valid to index through the
8452          array, and we must get TYPE_ALIGN set correctly on the array
8453          type.  */
8454       else if (TREE_CODE (type) == ARRAY_TYPE)
8455         layout_type (type);
8456     }
8457
8458   /* Add this declaration to the statement-tree.  This needs to happen
8459      after the call to check_initializer so that the DECL_STMT for a
8460      reference temp is added before the DECL_STMT for the reference itself.  */
8461   if (building_stmt_tree ()
8462       && at_function_scope_p ()
8463       && TREE_CODE (decl) != RESULT_DECL)
8464     add_decl_stmt (decl);
8465
8466   if (TREE_CODE (decl) == VAR_DECL)
8467     layout_var_decl (decl);
8468
8469   /* Output the assembler code and/or RTL code for variables and functions,
8470      unless the type is an undefined structure or union.
8471      If not, it will get done when the type is completed.  */
8472   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8473       || TREE_CODE (decl) == RESULT_DECL)
8474     {
8475       if (TREE_CODE (decl) == VAR_DECL)
8476         maybe_commonize_var (decl);
8477
8478       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8479
8480       if (TREE_CODE (type) == FUNCTION_TYPE
8481           || TREE_CODE (type) == METHOD_TYPE)
8482         abstract_virtuals_error (decl,
8483                                  strip_array_types (TREE_TYPE (type)));
8484       else
8485         abstract_virtuals_error (decl, strip_array_types (type));
8486
8487       if (TREE_CODE (decl) == FUNCTION_DECL
8488           || TREE_TYPE (decl) == error_mark_node)
8489         /* No initialization required.  */
8490         ;
8491       else if (DECL_EXTERNAL (decl)
8492                && ! (DECL_LANG_SPECIFIC (decl)
8493                      && DECL_NOT_REALLY_EXTERN (decl)))
8494         {
8495           if (init)
8496             DECL_INITIAL (decl) = init;
8497         }
8498       else
8499         {
8500           /* A variable definition.  */
8501           if (DECL_FUNCTION_SCOPE_P (decl))
8502             {
8503               /* This is a local declaration.  */
8504               if (doing_semantic_analysis_p ())
8505                 maybe_inject_for_scope_var (decl);
8506               /* Initialize the local variable.  */
8507               if (processing_template_decl)
8508                 {
8509                   if (init || DECL_INITIAL (decl) == error_mark_node)
8510                     DECL_INITIAL (decl) = init;
8511                 }
8512               else if (!TREE_STATIC (decl))
8513                 initialize_local_var (decl, init);
8514             }
8515
8516           if (TREE_STATIC (decl))
8517             expand_static_init (decl, init);
8518         }
8519     finish_end0:
8520
8521       /* Undo call to `pushclass' that was done in `start_decl'
8522          due to initialization of qualified member variable.
8523          I.e., Foo::x = 10;  */
8524       {
8525         tree context = CP_DECL_CONTEXT (decl);
8526         if (context
8527             && TYPE_P (context)
8528             && (TREE_CODE (decl) == VAR_DECL
8529                 /* We also have a pushclass done that we need to undo here
8530                    if we're at top level and declare a method.  */
8531                 || TREE_CODE (decl) == FUNCTION_DECL)
8532             /* If size hasn't been set, we're still defining it,
8533                and therefore inside the class body; don't pop
8534                the binding level..  */
8535             && COMPLETE_TYPE_P (context)
8536             && context == current_class_type)
8537           pop_nested_class ();
8538       }
8539     }
8540
8541  finish_end:
8542
8543   if (was_readonly)
8544     TREE_READONLY (decl) = 1;
8545 }
8546
8547 /* This is here for a midend callback from c-common.c */
8548
8549 void
8550 finish_decl (decl, init, asmspec_tree)
8551      tree decl, init;
8552      tree asmspec_tree;
8553 {
8554   cp_finish_decl (decl, init, asmspec_tree, 0);
8555 }
8556
8557 /* Returns a declaration for a VAR_DECL as if:
8558
8559      extern "C" TYPE NAME;
8560
8561    had been seen.  Used to create compiler-generated global
8562    variables.  */
8563
8564 tree
8565 declare_global_var (name, type)
8566      tree name;
8567      tree type;
8568 {
8569   tree decl;
8570
8571   push_to_top_level ();
8572   decl = build_decl (VAR_DECL, name, type);
8573   TREE_PUBLIC (decl) = 1;
8574   DECL_EXTERNAL (decl) = 1;
8575   DECL_ARTIFICIAL (decl) = 1;
8576   pushdecl (decl);
8577   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8578   pop_from_top_level ();
8579
8580   return decl;
8581 }
8582
8583 /* Returns a pointer to the `atexit' function.  Note that if
8584    FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
8585    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8586
8587 static tree
8588 get_atexit_node ()
8589 {
8590   tree atexit_fndecl;
8591   tree arg_types;
8592   tree fn_type;
8593   tree fn_ptr_type;
8594   const char *name;
8595
8596   if (atexit_node)
8597     return atexit_node;
8598
8599   if (flag_use_cxa_atexit)
8600     {
8601       /* The declaration for `__cxa_atexit' is:
8602
8603            int __cxa_atexit (void (*)(void *), void *, void *)
8604
8605          We build up the argument types and then then function type
8606          itself.  */
8607
8608       /* First, build the pointer-to-function type for the first
8609          argument.  */
8610       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8611       fn_type = build_function_type (void_type_node, arg_types);
8612       fn_ptr_type = build_pointer_type (fn_type);
8613       /* Then, build the rest of the argument types.  */
8614       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8615       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8616       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8617       /* And the final __cxa_atexit type.  */
8618       fn_type = build_function_type (integer_type_node, arg_types);
8619       fn_ptr_type = build_pointer_type (fn_type);
8620       name = "__cxa_atexit";
8621     }
8622   else
8623     {
8624       /* The declaration for `atexit' is:
8625
8626            int atexit (void (*)());
8627
8628          We build up the argument types and then then function type
8629          itself.  */
8630       fn_type = build_function_type (void_type_node, void_list_node);
8631       fn_ptr_type = build_pointer_type (fn_type);
8632       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8633       /* Build the final atexit type.  */
8634       fn_type = build_function_type (integer_type_node, arg_types);
8635       name = "atexit";
8636     }
8637
8638   /* Now, build the function declaration.  */
8639   push_lang_context (lang_name_c);
8640   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8641   mark_used (atexit_fndecl);
8642   pop_lang_context ();
8643   atexit_node = default_conversion (atexit_fndecl);
8644
8645   return atexit_node;
8646 }
8647
8648 /* Returns the __dso_handle VAR_DECL.  */
8649
8650 static tree
8651 get_dso_handle_node ()
8652 {
8653   if (dso_handle_node)
8654     return dso_handle_node;
8655
8656   /* Declare the variable.  */
8657   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8658                                         ptr_type_node);
8659
8660   return dso_handle_node;
8661 }
8662
8663 /* Begin a new function with internal linkage whose job will be simply
8664    to destroy some particular variable.  */
8665
8666 static tree
8667 start_cleanup_fn ()
8668 {
8669   static int counter = 0;
8670   int old_interface_only = interface_only;
8671   int old_interface_unknown = interface_unknown;
8672   char name[32];
8673   tree parmtypes;
8674   tree fntype;
8675   tree fndecl;
8676
8677   push_to_top_level ();
8678
8679   /* No need to mangle this.  */
8680   push_lang_context (lang_name_c);
8681
8682   interface_only = 0;
8683   interface_unknown = 1;
8684
8685   /* Build the parameter-types.  */
8686   parmtypes = void_list_node;
8687   /* Functions passed to __cxa_atexit take an additional parameter.
8688      We'll just ignore it.  After we implement the new calling
8689      convention for destructors, we can eliminate the use of
8690      additional cleanup functions entirely in the -fnew-abi case.  */
8691   if (flag_use_cxa_atexit)
8692     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8693   /* Build the function type itself.  */
8694   fntype = build_function_type (void_type_node, parmtypes);
8695   /* Build the name of the function.  */
8696   sprintf (name, "__tcf_%d", counter++);
8697   /* Build the function declaration.  */
8698   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8699   /* It's a function with internal linkage, generated by the
8700      compiler.  */
8701   TREE_PUBLIC (fndecl) = 0;
8702   DECL_ARTIFICIAL (fndecl) = 1;
8703   /* Make the function `inline' so that it is only emitted if it is
8704      actually needed.  It is unlikely that it will be inlined, since
8705      it is only called via a function pointer, but we avoid unnecessary
8706      emissions this way.  */
8707   DECL_INLINE (fndecl) = 1;
8708   /* Build the parameter.  */
8709   if (flag_use_cxa_atexit)
8710     {
8711       tree parmdecl;
8712
8713       parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
8714       DECL_CONTEXT (parmdecl) = fndecl;
8715       TREE_USED (parmdecl) = 1;
8716       DECL_ARGUMENTS (fndecl) = parmdecl;
8717     }
8718
8719   pushdecl (fndecl);
8720   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8721
8722   interface_unknown = old_interface_unknown;
8723   interface_only = old_interface_only;
8724
8725   pop_lang_context ();
8726
8727   return current_function_decl;
8728 }
8729
8730 /* Finish the cleanup function begun by start_cleanup_fn.  */
8731
8732 static void
8733 end_cleanup_fn ()
8734 {
8735   expand_body (finish_function (0));
8736
8737   pop_from_top_level ();
8738 }
8739
8740 /* Generate code to handle the destruction of DECL, an object with
8741    static storage duration.  */
8742
8743 void
8744 register_dtor_fn (decl)
8745      tree decl;
8746 {
8747   tree cleanup;
8748   tree compound_stmt;
8749   tree args;
8750   tree fcall;
8751   int saved_flag_access_control;
8752
8753   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8754     return;
8755
8756   /* Call build_cleanup before we enter the anonymous function so that
8757      any access checks will be done relative to the current scope,
8758      rather than the scope of the anonymous function.  */
8759   build_cleanup (decl);
8760
8761   /* Now start the function.  */
8762   cleanup = start_cleanup_fn ();
8763
8764   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8765      to the original function, rather than the anonymous one.  That
8766      will make the back-end think that nested functions are in use,
8767      which causes confusion.  */
8768   saved_flag_access_control = flag_access_control;
8769   scope_chain->check_access = flag_access_control = 0;
8770   fcall = build_cleanup (decl);
8771   scope_chain->check_access = flag_access_control = saved_flag_access_control;
8772
8773   /* Create the body of the anonymous function.  */
8774   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8775   finish_expr_stmt (fcall);
8776   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8777   end_cleanup_fn ();
8778
8779   /* Call atexit with the cleanup function.  */
8780   cxx_mark_addressable (cleanup);
8781   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8782   if (flag_use_cxa_atexit)
8783     {
8784       args = tree_cons (NULL_TREE,
8785                         build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
8786                         NULL_TREE);
8787       args = tree_cons (NULL_TREE, null_pointer_node, args);
8788       args = tree_cons (NULL_TREE, cleanup, args);
8789     }
8790   else
8791     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8792   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8793 }
8794
8795 /* DECL is a VAR_DECL with static storage duration.  INIT, if present,
8796    is its initializer.  Generate code to handle the construction
8797    and destruction of DECL.  */
8798
8799 static void
8800 expand_static_init (decl, init)
8801      tree decl;
8802      tree init;
8803 {
8804   tree oldstatic;
8805
8806   my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 20021010);
8807   my_friendly_assert (TREE_STATIC (decl), 20021010);
8808
8809   /* Some variables require no initialization.  */
8810   if (!init
8811       && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8812       && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8813     return;
8814
8815   oldstatic = value_member (decl, static_aggregates);
8816
8817   if (oldstatic)
8818     {
8819       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8820         error ("multiple initializations given for `%D'", decl);
8821     }
8822   else if (! toplevel_bindings_p ())
8823     {
8824       /* Emit code to perform this initialization but once.  */
8825       tree if_stmt;
8826       tree then_clause;
8827       tree assignment;
8828       tree guard;
8829       tree guard_init;
8830
8831       /* Emit code to perform this initialization but once.  This code
8832          looks like:
8833
8834            static int guard = 0;
8835            if (!guard) {
8836              // Do initialization.
8837              guard = 1;
8838              // Register variable for destruction at end of program.
8839            }
8840
8841          Note that the `temp' variable is only set to 1 *after* the
8842          initialization is complete.  This ensures that an exception,
8843          thrown during the construction, will cause the variable to
8844          reinitialized when we pass through this code again, as per:
8845
8846            [stmt.dcl]
8847
8848            If the initialization exits by throwing an exception, the
8849            initialization is not complete, so it will be tried again
8850            the next time control enters the declaration.
8851
8852          In theory, this process should be thread-safe, too; multiple
8853          threads should not be able to initialize the variable more
8854          than once.  We don't yet attempt to ensure thread-safety.  */
8855
8856       /* Create the guard variable.  */
8857       guard = get_guard (decl);
8858
8859       /* Begin the conditional initialization.  */
8860       if_stmt = begin_if_stmt ();
8861       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8862       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8863
8864       /* Do the initialization itself.  */
8865       assignment = init ? init : NULL_TREE;
8866
8867       /* Once the assignment is complete, set TEMP to 1.  Since the
8868          construction of the static object is complete at this point,
8869          we want to make sure TEMP is set to 1 even if a temporary
8870          constructed during the initialization throws an exception
8871          when it is destroyed.  So, we combine the initialization and
8872          the assignment to TEMP into a single expression, ensuring
8873          that when we call finish_expr_stmt the cleanups will not be
8874          run until after TEMP is set to 1.  */
8875       guard_init = set_guard (guard);
8876       if (assignment)
8877         {
8878           assignment = tree_cons (NULL_TREE, assignment,
8879                                   build_tree_list (NULL_TREE,
8880                                                    guard_init));
8881           assignment = build_compound_expr (assignment);
8882         }
8883       else
8884         assignment = guard_init;
8885       finish_expr_stmt (assignment);
8886
8887       /* Use atexit to register a function for destroying this static
8888          variable.  */
8889       register_dtor_fn (decl);
8890
8891       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8892       finish_then_clause (if_stmt);
8893       finish_if_stmt ();
8894     }
8895   else
8896     static_aggregates = tree_cons (init, decl, static_aggregates);
8897 }
8898
8899 /* Finish the declaration of a catch-parameter.  */
8900
8901 tree
8902 start_handler_parms (declspecs, declarator)
8903      tree declspecs;
8904      tree declarator;
8905 {
8906   tree decl;
8907   if (declspecs)
8908     {
8909       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8910                              1, NULL);
8911       if (decl == NULL_TREE)
8912         error ("invalid catch parameter");
8913     }
8914   else
8915     decl = NULL_TREE;
8916
8917   return decl;
8918 }
8919
8920 \f
8921 /* Make TYPE a complete type based on INITIAL_VALUE.
8922    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8923    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8924
8925 int
8926 complete_array_type (type, initial_value, do_default)
8927      tree type, initial_value;
8928      int do_default;
8929 {
8930   register tree maxindex = NULL_TREE;
8931   int value = 0;
8932
8933   if (initial_value)
8934     {
8935       /* An array of character type can be initialized from a
8936          brace-enclosed string constant.  */
8937       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8938           && TREE_CODE (initial_value) == CONSTRUCTOR
8939           && CONSTRUCTOR_ELTS (initial_value)
8940           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8941               == STRING_CST)
8942           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8943         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8944
8945       /* Note MAXINDEX is really the maximum index, one less than the
8946          size.  */
8947       if (TREE_CODE (initial_value) == STRING_CST)
8948         {
8949           int eltsize
8950             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8951           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8952                                    / eltsize) - 1, 0);
8953         }
8954       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8955         {
8956           tree elts = CONSTRUCTOR_ELTS (initial_value);
8957
8958           maxindex = ssize_int (-1);
8959           for (; elts; elts = TREE_CHAIN (elts))
8960             {
8961               if (TREE_PURPOSE (elts))
8962                 maxindex = TREE_PURPOSE (elts);
8963               else
8964                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8965             }
8966           maxindex = copy_node (maxindex);
8967         }
8968       else
8969         {
8970           /* Make an error message unless that happened already.  */
8971           if (initial_value != error_mark_node)
8972             value = 1;
8973           else
8974             initial_value = NULL_TREE;
8975
8976           /* Prevent further error messages.  */
8977           maxindex = build_int_2 (0, 0);
8978         }
8979     }
8980
8981   if (!maxindex)
8982     {
8983       if (do_default)
8984         maxindex = build_int_2 (0, 0);
8985       value = 2;
8986     }
8987
8988   if (maxindex)
8989     {
8990       tree itype;
8991       tree domain;
8992
8993       domain = build_index_type (maxindex);
8994       TYPE_DOMAIN (type) = domain;
8995
8996       if (! TREE_TYPE (maxindex))
8997         TREE_TYPE (maxindex) = domain;
8998       if (initial_value)
8999         itype = TREE_TYPE (initial_value);
9000       else
9001         itype = NULL;
9002       if (itype && !TYPE_DOMAIN (itype))
9003         TYPE_DOMAIN (itype) = domain;
9004       /* The type of the main variant should never be used for arrays
9005          of different sizes.  It should only ever be completed with the
9006          size of the array.  */
9007       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
9008         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
9009     }
9010
9011   /* Lay out the type now that we can get the real answer.  */
9012
9013   layout_type (type);
9014
9015   return value;
9016 }
9017 \f
9018 /* Return zero if something is declared to be a member of type
9019    CTYPE when in the context of CUR_TYPE.  STRING is the error
9020    message to print in that case.  Otherwise, quietly return 1.  */
9021
9022 static int
9023 member_function_or_else (ctype, cur_type, flags)
9024      tree ctype, cur_type;
9025      enum overload_flags flags;
9026 {
9027   if (ctype && ctype != cur_type)
9028     {
9029       if (flags == DTOR_FLAG)
9030         error ("destructor for alien class `%T' cannot be a member",
9031                   ctype);
9032       else
9033         error ("constructor for alien class `%T' cannot be a member",
9034                   ctype);
9035       return 0;
9036     }
9037   return 1;
9038 }
9039 \f
9040 /* Subroutine of `grokdeclarator'.  */
9041
9042 /* Generate errors possibly applicable for a given set of specifiers.
9043    This is for ARM $7.1.2.  */
9044
9045 static void
9046 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
9047      tree object;
9048      const char *type;
9049      int virtualp, quals, friendp, raises, inlinep;
9050 {
9051   if (virtualp)
9052     error ("`%D' declared as a `virtual' %s", object, type);
9053   if (inlinep)
9054     error ("`%D' declared as an `inline' %s", object, type);
9055   if (quals)
9056     error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
9057               object, type);
9058   if (friendp)
9059     cp_error_at ("`%D' declared as a friend", object);
9060   if (raises
9061       && (TREE_CODE (object) == TYPE_DECL
9062           || (!TYPE_PTRFN_P (TREE_TYPE (object))
9063               && !TYPE_REFFN_P (TREE_TYPE (object))
9064               && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
9065     cp_error_at ("`%D' declared with an exception specification", object);
9066 }
9067
9068 /* CTYPE is class type, or null if non-class.
9069    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
9070    or METHOD_TYPE.
9071    DECLARATOR is the function's name.
9072    VIRTUALP is truthvalue of whether the function is virtual or not.
9073    FLAGS are to be passed through to `grokclassfn'.
9074    QUALS are qualifiers indicating whether the function is `const'
9075    or `volatile'.
9076    RAISES is a list of exceptions that this function can raise.
9077    CHECK is 1 if we must find this method in CTYPE, 0 if we should
9078    not look, and -1 if we should not call `grokclassfn' at all.
9079
9080    Returns `NULL_TREE' if something goes wrong, after issuing
9081    applicable error messages.  */
9082
9083 static tree
9084 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
9085             raises, check, friendp, publicp, inlinep, funcdef_flag,
9086             template_count, in_namespace)
9087      tree ctype, type;
9088      tree declarator;
9089      tree orig_declarator;
9090      int virtualp;
9091      enum overload_flags flags;
9092      tree quals, raises;
9093      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
9094      tree in_namespace;
9095 {
9096   tree decl;
9097   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
9098   int has_default_arg = 0;
9099   tree t;
9100
9101   if (raises)
9102     type = build_exception_variant (type, raises);
9103
9104   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
9105   /* Propagate volatile out from type to decl.  */
9106   if (TYPE_VOLATILE (type))
9107     TREE_THIS_VOLATILE (decl) = 1;
9108
9109   /* If this decl has namespace scope, set that up.  */
9110   if (in_namespace)
9111     set_decl_namespace (decl, in_namespace, friendp);
9112   else if (!ctype)
9113     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
9114
9115   /* `main' and builtins have implicit 'C' linkage.  */
9116   if ((MAIN_NAME_P (declarator)
9117        || (IDENTIFIER_LENGTH (declarator) > 10
9118            && IDENTIFIER_POINTER (declarator)[0] == '_'
9119            && IDENTIFIER_POINTER (declarator)[1] == '_'
9120            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
9121       && current_lang_name == lang_name_cplusplus
9122       && ctype == NULL_TREE
9123       /* NULL_TREE means global namespace.  */
9124       && DECL_CONTEXT (decl) == NULL_TREE)
9125     SET_DECL_LANGUAGE (decl, lang_c);
9126
9127   /* Should probably propagate const out from type to decl I bet (mrs).  */
9128   if (staticp)
9129     {
9130       DECL_STATIC_FUNCTION_P (decl) = 1;
9131       DECL_CONTEXT (decl) = ctype;
9132     }
9133
9134   if (ctype)
9135     DECL_CONTEXT (decl) = ctype;
9136
9137   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
9138     {
9139       if (processing_template_decl)
9140         error ("cannot declare `::main' to be a template");
9141       if (inlinep)
9142         error ("cannot declare `::main' to be inline");
9143       if (!publicp)
9144         error ("cannot declare `::main' to be static");
9145       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
9146                         integer_type_node))
9147         error ("`main' must return `int'");
9148       inlinep = 0;
9149       publicp = 1;
9150     }
9151
9152   /* Members of anonymous types and local classes have no linkage; make
9153      them internal.  */
9154   /* FIXME what if it gets a name from typedef?  */
9155   if (ctype && (TYPE_ANONYMOUS_P (ctype)
9156                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
9157     publicp = 0;
9158
9159   if (publicp)
9160     {
9161       /* [basic.link]: A name with no linkage (notably, the name of a class
9162          or enumeration declared in a local scope) shall not be used to
9163          declare an entity with linkage.
9164
9165          Only check this for public decls for now.  */
9166       t = no_linkage_check (TREE_TYPE (decl));
9167       if (t)
9168         {
9169           if (TYPE_ANONYMOUS_P (t))
9170             {
9171               if (DECL_EXTERN_C_P (decl))
9172                 /* Allow this; it's pretty common in C.  */;
9173               else
9174                 {
9175                   pedwarn ("non-local function `%#D' uses anonymous type",
9176                               decl);
9177                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
9178                     cp_pedwarn_at ("\
9179 `%#D' does not refer to the unqualified type, so it is not used for linkage",
9180                                 TYPE_NAME (t));
9181                 }
9182             }
9183           else
9184             pedwarn ("non-local function `%#D' uses local type `%T'",
9185                         decl, t);
9186         }
9187     }
9188
9189   TREE_PUBLIC (decl) = publicp;
9190   if (! publicp)
9191     {
9192       DECL_INTERFACE_KNOWN (decl) = 1;
9193       DECL_NOT_REALLY_EXTERN (decl) = 1;
9194     }
9195
9196   /* If the declaration was declared inline, mark it as such.  */
9197   if (inlinep)
9198     DECL_DECLARED_INLINE_P (decl) = 1;
9199   /* We inline functions that are explicitly declared inline, or, when
9200      the user explicitly asks us to, all functions.  */
9201   if (DECL_DECLARED_INLINE_P (decl) || flag_inline_trees == 2)
9202     DECL_INLINE (decl) = 1;
9203
9204   DECL_EXTERNAL (decl) = 1;
9205   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
9206     {
9207       error ("%smember function `%D' cannot have `%T' method qualifier",
9208                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
9209       quals = NULL_TREE;
9210     }
9211
9212   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
9213     grok_op_properties (decl, friendp);
9214
9215   if (ctype && decl_function_context (decl))
9216     DECL_NO_STATIC_CHAIN (decl) = 1;
9217
9218   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
9219     if (TREE_PURPOSE (t)
9220         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
9221       {
9222         has_default_arg = 1;
9223         break;
9224       }
9225
9226   if (friendp
9227       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
9228     {
9229       if (funcdef_flag)
9230         error
9231           ("defining explicit specialization `%D' in friend declaration",
9232            orig_declarator);
9233       else
9234         {
9235           tree fns = TREE_OPERAND (orig_declarator, 0);
9236           tree args = TREE_OPERAND (orig_declarator, 1);
9237
9238           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
9239             {
9240               /* Something like `template <class T> friend void f<T>()'.  */
9241               error ("invalid use of template-id `%D' in declaration of primary template",
9242                         orig_declarator);
9243               return NULL_TREE;
9244             }
9245
9246
9247           /* A friend declaration of the form friend void f<>().  Record
9248              the information in the TEMPLATE_ID_EXPR.  */
9249           SET_DECL_IMPLICIT_INSTANTIATION (decl);
9250
9251           if (TREE_CODE (fns) == COMPONENT_REF)
9252             {
9253               /* Due to bison parser ickiness, we will have already looked
9254                  up an operator_name or PFUNCNAME within the current class
9255                  (see template_id in parse.y). If the current class contains
9256                  such a name, we'll get a COMPONENT_REF here. Undo that.  */
9257
9258               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
9259                                   == current_class_type, 20001120);
9260               fns = TREE_OPERAND (fns, 1);
9261             }
9262           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
9263                               || TREE_CODE (fns) == LOOKUP_EXPR
9264                               || TREE_CODE (fns) == OVERLOAD, 20001120);
9265           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
9266
9267           if (has_default_arg)
9268             {
9269               error ("default arguments are not allowed in declaration of friend template specialization `%D'",
9270                         decl);
9271               return NULL_TREE;
9272             }
9273
9274           if (inlinep)
9275             {
9276               error ("`inline' is not allowed in declaration of friend template specialization `%D'",
9277                         decl);
9278               return NULL_TREE;
9279             }
9280         }
9281     }
9282
9283   if (funcdef_flag)
9284     /* Make the init_value nonzero so pushdecl knows this is not
9285        tentative.  error_mark_node is replaced later with the BLOCK.  */
9286     DECL_INITIAL (decl) = error_mark_node;
9287
9288   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
9289     TREE_NOTHROW (decl) = 1;
9290
9291   /* Caller will do the rest of this.  */
9292   if (check < 0)
9293     return decl;
9294
9295   if (flags == NO_SPECIAL && ctype && constructor_name_p (declarator, ctype))
9296     DECL_CONSTRUCTOR_P (decl) = 1;
9297
9298   /* Function gets the ugly name, field gets the nice one.  This call
9299      may change the type of the function (because of default
9300      parameters)!  */
9301   if (ctype != NULL_TREE)
9302     grokclassfn (ctype, decl, flags, quals);
9303
9304   decl = check_explicit_specialization (orig_declarator, decl,
9305                                         template_count,
9306                                         2 * (funcdef_flag != 0) +
9307                                         4 * (friendp != 0));
9308   if (decl == error_mark_node)
9309     return NULL_TREE;
9310
9311   if (ctype != NULL_TREE
9312       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9313       && check)
9314     {
9315       tree old_decl;
9316
9317       old_decl = check_classfn (ctype, decl);
9318
9319       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9320         /* Because grokfndecl is always supposed to return a
9321            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9322            here.  We depend on our callers to figure out that its
9323            really a template that's being returned.  */
9324         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9325
9326       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9327           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9328         {
9329           /* Remove the `this' parm added by grokclassfn.
9330              XXX Isn't this done in start_function, too?  */
9331           revert_static_member_fn (decl);
9332           last_function_parms = TREE_CHAIN (last_function_parms);
9333         }
9334       if (old_decl && DECL_ARTIFICIAL (old_decl))
9335         error ("definition of implicitly-declared `%D'", old_decl);
9336
9337       if (old_decl)
9338         {
9339           /* Since we've smashed OLD_DECL to its
9340              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9341           if (TREE_CODE (decl) == TEMPLATE_DECL)
9342             decl = DECL_TEMPLATE_RESULT (decl);
9343
9344           /* Attempt to merge the declarations.  This can fail, in
9345              the case of some invalid specialization declarations.  */
9346           if (!duplicate_decls (decl, old_decl))
9347             error ("no `%#D' member function declared in class `%T'",
9348                       decl, ctype);
9349           return old_decl;
9350         }
9351     }
9352
9353   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9354     return NULL_TREE;
9355
9356   if (ctype == NULL_TREE || check)
9357     return decl;
9358
9359   if (virtualp)
9360     DECL_VIRTUAL_P (decl) = 1;
9361
9362   return decl;
9363 }
9364
9365 /* Create a VAR_DECL named NAME with the indicated TYPE.
9366
9367    If SCOPE is non-NULL, it is the class type or namespace containing
9368    the variable.  If SCOPE is NULL, the variable should is created in
9369    the innermost enclosings scope.  */
9370
9371 static tree
9372 grokvardecl (type, name, specbits_in, initialized, constp, scope)
9373      tree type;
9374      tree name;
9375      RID_BIT_TYPE *specbits_in;
9376      int initialized;
9377      int constp;
9378      tree scope;
9379 {
9380   tree decl;
9381   RID_BIT_TYPE specbits;
9382
9383   my_friendly_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE,
9384                       20020808);
9385
9386   specbits = *specbits_in;
9387
9388   /* Compute the scope in which to place the variable.  */
9389   if (!scope)
9390     {
9391       /* An explicit "extern" specifier indicates a namespace-scope
9392          variable.  */
9393       if (RIDBIT_SETP (RID_EXTERN, specbits))
9394         scope = current_namespace;
9395       else if (!at_function_scope_p ())
9396         {
9397           scope = current_scope ();
9398           if (!scope)
9399             scope = current_namespace;
9400         }
9401     }
9402
9403   if (scope
9404       && (/* If the variable is a namespace-scope variable declared in a
9405              template, we need DECL_LANG_SPECIFIC.  */
9406           (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
9407           /* Similarly for namespace-scope variables with language linkage
9408              other than C++.  */
9409           || (TREE_CODE (scope) == NAMESPACE_DECL
9410               && current_lang_name != lang_name_cplusplus)
9411           /* Similarly for static data members.  */
9412           || TYPE_P (scope)))
9413     decl = build_lang_decl (VAR_DECL, name, type);
9414   else
9415     decl = build_decl (VAR_DECL, name, type);
9416
9417   if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
9418     set_decl_namespace (decl, scope, 0);
9419   else
9420     DECL_CONTEXT (decl) = scope;
9421
9422   if (name && scope && current_lang_name != lang_name_c)
9423     /* We can't mangle lazily here because we don't have any
9424        way to recover whether or not a variable was `extern
9425        "C"' later.  */
9426     mangle_decl (decl);
9427
9428   if (RIDBIT_SETP (RID_EXTERN, specbits))
9429     {
9430       DECL_THIS_EXTERN (decl) = 1;
9431       DECL_EXTERNAL (decl) = !initialized;
9432     }
9433
9434   /* In class context, static means one per class,
9435      public access, and static storage.  */
9436   if (DECL_CLASS_SCOPE_P (decl))
9437     {
9438       TREE_PUBLIC (decl) = 1;
9439       TREE_STATIC (decl) = 1;
9440       DECL_EXTERNAL (decl) = 0;
9441     }
9442   /* At top level, either `static' or no s.c. makes a definition
9443      (perhaps tentative), and absence of `static' makes it public.  */
9444   else if (toplevel_bindings_p ())
9445     {
9446       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9447                             && (DECL_THIS_EXTERN (decl) || ! constp));
9448       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9449     }
9450   /* Not at top level, only `static' makes a static definition.  */
9451   else
9452     {
9453       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9454       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9455     }
9456
9457   if (RIDBIT_SETP (RID_THREAD, specbits))
9458     {
9459       if (targetm.have_tls)
9460         DECL_THREAD_LOCAL (decl) = 1;
9461       else
9462         /* A mere warning is sure to result in improper semantics
9463            at runtime.  Don't bother to allow this to compile.  */
9464         error ("thread-local storage not supported for this target");
9465     }
9466
9467   if (TREE_PUBLIC (decl))
9468     {
9469       /* [basic.link]: A name with no linkage (notably, the name of a class
9470          or enumeration declared in a local scope) shall not be used to
9471          declare an entity with linkage.
9472
9473          Only check this for public decls for now.  */
9474       tree t = no_linkage_check (TREE_TYPE (decl));
9475       if (t)
9476         {
9477           if (TYPE_ANONYMOUS_P (t))
9478             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9479           else
9480             pedwarn ("non-local variable `%#D' uses local type `%T'",
9481                         decl, t);
9482         }
9483     }
9484
9485   return decl;
9486 }
9487
9488 /* Create and return a canonical pointer to member function type, for
9489    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9490
9491 tree
9492 build_ptrmemfunc_type (type)
9493      tree type;
9494 {
9495   tree field, fields;
9496   tree t;
9497   tree unqualified_variant = NULL_TREE;
9498
9499   if (type == error_mark_node)
9500     return type;
9501
9502   /* If a canonical type already exists for this type, use it.  We use
9503      this method instead of type_hash_canon, because it only does a
9504      simple equality check on the list of field members.  */
9505
9506   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9507     return t;
9508
9509   /* Make sure that we always have the unqualified pointer-to-member
9510      type first.  */
9511   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9512     unqualified_variant
9513       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9514
9515   t = make_aggr_type (RECORD_TYPE);
9516   /* Let the front-end know this is a pointer to member function...  */
9517   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9518   /* ... and not really an aggregate.  */
9519   SET_IS_AGGR_TYPE (t, 0);
9520
9521   field = build_decl (FIELD_DECL, pfn_identifier, type);
9522   fields = field;
9523
9524   field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
9525   TREE_CHAIN (field) = fields;
9526   fields = field;
9527
9528   finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
9529
9530   /* Zap out the name so that the back-end will give us the debugging
9531      information for this anonymous RECORD_TYPE.  */
9532   TYPE_NAME (t) = NULL_TREE;
9533
9534   /* If this is not the unqualified form of this pointer-to-member
9535      type, set the TYPE_MAIN_VARIANT for this type to be the
9536      unqualified type.  Since they are actually RECORD_TYPEs that are
9537      not variants of each other, we must do this manually.  */
9538   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9539     {
9540       t = build_qualified_type (t, cp_type_quals (type));
9541       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9542       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9543       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9544     }
9545
9546   /* Cache this pointer-to-member type so that we can find it again
9547      later.  */
9548   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9549
9550   /* Seems to be wanted.  */
9551   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9552
9553   return t;
9554 }
9555
9556 /* Create and return a pointer to data member type.  */
9557
9558 tree
9559 build_ptrmem_type (tree class_type, tree member_type)
9560 {
9561   return build_pointer_type (build_offset_type (class_type, member_type));
9562 }
9563
9564 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9565    Check to see that the definition is valid.  Issue appropriate error
9566    messages.  Return 1 if the definition is particularly bad, or 0
9567    otherwise.  */
9568
9569 int
9570 check_static_variable_definition (decl, type)
9571      tree decl;
9572      tree type;
9573 {
9574   /* Motion 10 at San Diego: If a static const integral data member is
9575      initialized with an integral constant expression, the initializer
9576      may appear either in the declaration (within the class), or in
9577      the definition, but not both.  If it appears in the class, the
9578      member is a member constant.  The file-scope definition is always
9579      required.  */
9580   if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
9581     {
9582       error ("invalid in-class initialization of static data member of non-integral type `%T'",
9583              type);
9584       /* If we just return the declaration, crashes will sometimes
9585          occur.  We therefore return void_type_node, as if this was a
9586          friend declaration, to cause callers to completely ignore
9587          this declaration.  */
9588       return 1;
9589     }
9590   else if (!CP_TYPE_CONST_P (type))
9591     error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9592               decl);
9593   else if (pedantic && !INTEGRAL_TYPE_P (type))
9594     pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9595
9596   return 0;
9597 }
9598
9599 /* Given the SIZE (i.e., number of elements) in an array, compute an
9600    appropriate index type for the array.  If non-NULL, NAME is the
9601    name of the thing being declared.  */
9602
9603 tree
9604 compute_array_index_type (name, size)
9605      tree name;
9606      tree size;
9607 {
9608   tree itype;
9609
9610   /* If this involves a template parameter, it will be a constant at
9611      instantiation time, but we don't know what the value is yet.
9612      Even if no template parameters are involved, we may an expression
9613      that is not a constant; we don't even simplify `1 + 2' when
9614      processing a template.  */
9615   if (processing_template_decl)
9616     {
9617       /* Resolve a qualified reference to an enumerator or static
9618          const data member of ours.  */
9619       if (TREE_CODE (size) == SCOPE_REF
9620           && TREE_OPERAND (size, 0) == current_class_type)
9621         {
9622           tree t = lookup_field (current_class_type,
9623                                  TREE_OPERAND (size, 1), 0, 0);
9624           if (t)
9625             size = t;
9626         }
9627
9628       return build_index_type (build_min (MINUS_EXPR, sizetype,
9629                                           size, integer_one_node));
9630     }
9631
9632   /* The size might be the result of a cast.  */
9633   STRIP_TYPE_NOPS (size);
9634
9635   /* It might be a const variable or enumeration constant.  */
9636   size = decl_constant_value (size);
9637
9638   /* The array bound must be an integer type.  */
9639   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9640       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9641       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9642     {
9643       if (name)
9644         error ("size of array `%D' has non-integer type", name);
9645       else
9646         error ("size of array has non-integer type");
9647       size = integer_one_node;
9648     }
9649
9650   /* Normally, the array-bound will be a constant.  */
9651   if (TREE_CODE (size) == INTEGER_CST)
9652     {
9653       /* Check to see if the array bound overflowed.  Make that an
9654          error, no matter how generous we're being.  */
9655       int old_flag_pedantic_errors = flag_pedantic_errors;
9656       int old_pedantic = pedantic;
9657       pedantic = flag_pedantic_errors = 1;
9658       constant_expression_warning (size);
9659       pedantic = old_pedantic;
9660       flag_pedantic_errors = old_flag_pedantic_errors;
9661
9662       /* An array must have a positive number of elements.  */
9663       if (INT_CST_LT (size, integer_zero_node))
9664         {
9665           if (name)
9666             error ("size of array `%D' is negative", name);
9667           else
9668             error ("size of array is negative");
9669           size = integer_one_node;
9670         }
9671       /* Except that an extension we allow zero-sized arrays.  We
9672          always allow them in system headers because glibc uses
9673          them.  */
9674       else if (integer_zerop (size) && pedantic && !in_system_header)
9675         {
9676           if (name)
9677             pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9678           else
9679             pedwarn ("ISO C++ forbids zero-size array");
9680         }
9681     }
9682   else if (TREE_CONSTANT (size))
9683     {
9684       /* `(int) &fn' is not a valid array bound.  */
9685       if (name)
9686         error ("size of array `%D' is not an integral constant-expression",
9687                   name);
9688       else
9689         error ("size of array is not an integral constant-expression");
9690     }
9691
9692   /* Compute the index of the largest element in the array.  It is
9693      one less than the number of elements in the array.  */
9694   itype
9695     = fold (cp_build_binary_op (MINUS_EXPR,
9696                                 cp_convert (ssizetype, size),
9697                                 cp_convert (ssizetype,
9698                                             integer_one_node)));
9699
9700   /* Check for variable-sized arrays.  We allow such things as an
9701      extension, even though they are not allowed in ANSI/ISO C++.  */
9702   if (!TREE_CONSTANT (itype))
9703     {
9704       if (pedantic)
9705         {
9706           if (name)
9707             pedwarn ("ISO C++ forbids variable-size array `%D'",
9708                         name);
9709           else
9710             pedwarn ("ISO C++ forbids variable-size array");
9711         }
9712
9713       /* Create a variable-sized array index type.  */
9714       itype = variable_size (itype);
9715     }
9716   /* Make sure that there was no overflow when creating to a signed
9717      index type.  (For example, on a 32-bit machine, an array with
9718      size 2^32 - 1 is too big.)  */
9719   else if (TREE_OVERFLOW (itype))
9720     {
9721       error ("overflow in array dimension");
9722       TREE_OVERFLOW (itype) = 0;
9723     }
9724
9725   /* Create and return the appropriate index type.  */
9726   return build_index_type (itype);
9727 }
9728
9729 /* Returns the scope (if any) in which the entity declared by
9730    DECLARATOR will be located.  If the entity was declared with an
9731    unqualified name, NULL_TREE is returned.  */
9732
9733 tree
9734 get_scope_of_declarator (declarator)
9735      tree declarator;
9736 {
9737   if (!declarator)
9738     return NULL_TREE;
9739
9740   switch (TREE_CODE (declarator))
9741     {
9742     case CALL_EXPR:
9743     case ARRAY_REF:
9744     case INDIRECT_REF:
9745     case ADDR_EXPR:
9746       /* For any of these, the main declarator is the first operand.  */
9747       return get_scope_of_declarator (TREE_OPERAND
9748                                       (declarator, 0));
9749
9750     case SCOPE_REF:
9751       /* For a pointer-to-member, continue descending.  */
9752       if (TREE_CODE (TREE_OPERAND (declarator, 1))
9753           == INDIRECT_REF)
9754         return get_scope_of_declarator (TREE_OPERAND
9755                                         (declarator, 1));
9756       /* Otherwise, if the declarator-id is a SCOPE_REF, the scope in
9757          which the declaration occurs is the first operand.  */
9758       return TREE_OPERAND (declarator, 0);
9759
9760     case TREE_LIST:
9761       /* Attributes to be applied. The declarator is TREE_VALUE.  */
9762       return get_scope_of_declarator (TREE_VALUE (declarator));
9763
9764     default:
9765       /* Otherwise, we have a declarator-id which is not a qualified
9766          name; the entity will be declared in the current scope.  */
9767       return NULL_TREE;
9768     }
9769 }
9770
9771 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9772    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9773    with this type.  */
9774
9775 static tree
9776 create_array_type_for_decl (name, type, size)
9777      tree name;
9778      tree type;
9779      tree size;
9780 {
9781   tree itype = NULL_TREE;
9782   const char* error_msg;
9783
9784   /* If things have already gone awry, bail now.  */
9785   if (type == error_mark_node || size == error_mark_node)
9786     return error_mark_node;
9787
9788   /* Assume that everything will go OK.  */
9789   error_msg = NULL;
9790
9791   /* There are some types which cannot be array elements.  */
9792   switch (TREE_CODE (type))
9793     {
9794     case VOID_TYPE:
9795       error_msg = "array of void";
9796       break;
9797
9798     case FUNCTION_TYPE:
9799       error_msg = "array of functions";
9800       break;
9801
9802     case REFERENCE_TYPE:
9803       error_msg = "array of references";
9804       break;
9805
9806     case OFFSET_TYPE:
9807       error_msg = "array of data members";
9808       break;
9809
9810     case METHOD_TYPE:
9811       error_msg = "array of function members";
9812       break;
9813
9814     default:
9815       break;
9816     }
9817
9818   /* If something went wrong, issue an error-message and return.  */
9819   if (error_msg)
9820     {
9821       if (name)
9822         error ("declaration of `%D' as %s", name, error_msg);
9823       else
9824         error ("creating %s", error_msg);
9825
9826       return error_mark_node;
9827     }
9828
9829   /* [dcl.array]
9830
9831      The constant expressions that specify the bounds of the arrays
9832      can be omitted only for the first member of the sequence.  */
9833   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9834     {
9835       if (name)
9836         error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9837                   name);
9838       else
9839         error ("multidimensional array must have bounds for all dimensions except the first");
9840
9841       return error_mark_node;
9842     }
9843
9844   /* Figure out the index type for the array.  */
9845   if (size)
9846     itype = compute_array_index_type (name, size);
9847
9848   return build_cplus_array_type (type, itype);
9849 }
9850
9851 /* Check that it's OK to declare a function with the indicated TYPE.
9852    SFK indicates the kind of special function (if any) that this
9853    function is.  OPTYPE is the type given in a conversion operator
9854    declaration.  Returns the actual return type of the function; that
9855    may be different than TYPE if an error occurs, or for certain
9856    special functions.  */
9857
9858 static tree
9859 check_special_function_return_type (sfk, type, optype)
9860      special_function_kind sfk;
9861      tree type;
9862      tree optype;
9863 {
9864   switch (sfk)
9865     {
9866     case sfk_constructor:
9867       if (type)
9868         error ("return type specification for constructor invalid");
9869
9870       type = void_type_node;
9871       break;
9872
9873     case sfk_destructor:
9874       if (type)
9875         error ("return type specification for destructor invalid");
9876       type = void_type_node;
9877       break;
9878
9879     case sfk_conversion:
9880       if (type && !same_type_p (type, optype))
9881         error ("operator `%T' declared to return `%T'", optype, type);
9882       else if (type)
9883         pedwarn ("return type specified for `operator %T'",  optype);
9884       type = optype;
9885       break;
9886
9887     default:
9888       abort ();
9889       break;
9890     }
9891
9892   return type;
9893 }
9894
9895 /* Given declspecs and a declarator (abstract or otherwise), determine
9896    the name and type of the object declared and construct a DECL node
9897    for it.
9898
9899    DECLSPECS is a chain of tree_list nodes whose value fields
9900     are the storage classes and type specifiers.
9901
9902    DECL_CONTEXT says which syntactic context this declaration is in:
9903      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9904      FUNCDEF for a function definition.  Like NORMAL but a few different
9905       error messages in each case.  Return value may be zero meaning
9906       this definition is too screwy to try to parse.
9907      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9908       handle member functions (which have FIELD context).
9909       Return value may be zero meaning this definition is too screwy to
9910       try to parse.
9911      PARM for a parameter declaration (either within a function prototype
9912       or before a function body).  Make a PARM_DECL, or return void_type_node.
9913      CATCHPARM for a parameter declaration before a catch clause.
9914      TYPENAME if for a typename (in a cast or sizeof).
9915       Don't make a DECL node; just return the ..._TYPE node.
9916      FIELD for a struct or union field; make a FIELD_DECL.
9917      BITFIELD for a field with specified width.
9918    INITIALIZED is 1 if the decl has an initializer.
9919
9920    ATTRLIST is a pointer to the list of attributes, which may be NULL
9921    if there are none; *ATTRLIST may be modified if attributes from inside
9922    the declarator should be applied to the declaration.
9923
9924    When this function is called, scoping variables (such as
9925    CURRENT_CLASS_TYPE) should reflect the scope in which the
9926    declaration occurs, not the scope in which the new declaration will
9927    be placed.  For example, on:
9928
9929      void S::f() { ... }
9930
9931    when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
9932    should not be `S'.  */
9933
9934 tree
9935 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9936      tree declspecs;
9937      tree declarator;
9938      enum decl_context decl_context;
9939      int initialized;
9940      tree *attrlist;
9941 {
9942   RID_BIT_TYPE specbits;
9943   int nclasses = 0;
9944   tree spec;
9945   tree type = NULL_TREE;
9946   int longlong = 0;
9947   int type_quals;
9948   int virtualp, explicitp, friendp, inlinep, staticp;
9949   int explicit_int = 0;
9950   int explicit_char = 0;
9951   int defaulted_int = 0;
9952   int extern_langp = 0;
9953   tree dependant_name = NULL_TREE;
9954
9955   tree typedef_decl = NULL_TREE;
9956   const char *name;
9957   tree typedef_type = NULL_TREE;
9958   int funcdef_flag = 0;
9959   enum tree_code innermost_code = ERROR_MARK;
9960   int bitfield = 0;
9961 #if 0
9962   /* See the code below that used this.  */
9963   tree decl_attr = NULL_TREE;
9964 #endif
9965   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9966      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9967   tree init = NULL_TREE;
9968
9969   /* Keep track of what sort of function is being processed
9970      so that we can warn about default return values, or explicit
9971      return values which do not match prescribed defaults.  */
9972   special_function_kind sfk = sfk_none;
9973
9974   tree dname = NULL_TREE;
9975   tree ctype = current_class_type;
9976   tree ctor_return_type = NULL_TREE;
9977   enum overload_flags flags = NO_SPECIAL;
9978   tree quals = NULL_TREE;
9979   tree raises = NULL_TREE;
9980   int template_count = 0;
9981   tree in_namespace = NULL_TREE;
9982   tree returned_attrs = NULL_TREE;
9983   tree scope = NULL_TREE;
9984
9985   RIDBIT_RESET_ALL (specbits);
9986   if (decl_context == FUNCDEF)
9987     funcdef_flag = 1, decl_context = NORMAL;
9988   else if (decl_context == MEMFUNCDEF)
9989     funcdef_flag = -1, decl_context = FIELD;
9990   else if (decl_context == BITFIELD)
9991     bitfield = 1, decl_context = FIELD;
9992
9993   /* Look inside a declarator for the name being declared
9994      and get it as a string, for an error message.  */
9995   {
9996     tree *next = &declarator;
9997     register tree decl;
9998     name = NULL;
9999
10000     while (next && *next)
10001       {
10002         decl = *next;
10003         switch (TREE_CODE (decl))
10004           {
10005           case TREE_LIST:
10006             /* For attributes.  */
10007             next = &TREE_VALUE (decl);
10008             break;
10009
10010           case COND_EXPR:
10011             ctype = NULL_TREE;
10012             next = &TREE_OPERAND (decl, 0);
10013             break;
10014
10015           case BIT_NOT_EXPR:    /* For C++ destructors!  */
10016             {
10017               tree name = TREE_OPERAND (decl, 0);
10018               tree rename = NULL_TREE;
10019
10020               my_friendly_assert (flags == NO_SPECIAL, 152);
10021               flags = DTOR_FLAG;
10022               sfk = sfk_destructor;
10023               if (TYPE_P (name))
10024                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
10025               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
10026               if (ctype == NULL_TREE)
10027                 {
10028                   if (current_class_type == NULL_TREE)
10029                     {
10030                       error ("destructors must be member functions");
10031                       flags = NO_SPECIAL;
10032                     }
10033                   else
10034                     {
10035                       tree t = constructor_name (current_class_type);
10036                       if (t != name)
10037                         rename = t;
10038                     }
10039                 }
10040               else
10041                 {
10042                   tree t = constructor_name (ctype);
10043                   if (t != name)
10044                     rename = t;
10045                 }
10046
10047               if (rename)
10048                 {
10049                   error ("destructor `%T' must match class name `%T'",
10050                             name, rename);
10051                   TREE_OPERAND (decl, 0) = rename;
10052                 }
10053               next = &name;
10054             }
10055             break;
10056
10057           case ADDR_EXPR:       /* C++ reference declaration */
10058             /* Fall through.  */
10059           case ARRAY_REF:
10060           case INDIRECT_REF:
10061             ctype = NULL_TREE;
10062             innermost_code = TREE_CODE (decl);
10063             next = &TREE_OPERAND (decl, 0);
10064             break;
10065
10066           case CALL_EXPR:
10067             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
10068               {
10069                 /* This is actually a variable declaration using
10070                    constructor syntax.  We need to call start_decl and
10071                    cp_finish_decl so we can get the variable
10072                    initialized...  */
10073
10074                 tree attributes;
10075
10076                 if (decl_context != NORMAL)
10077                   {
10078                     error ("variable declaration is not allowed here");
10079                     return error_mark_node;
10080                   }
10081
10082                 *next = TREE_OPERAND (decl, 0);
10083                 init = CALL_DECLARATOR_PARMS (decl);
10084
10085                 if (attrlist)
10086                   {
10087                     attributes = *attrlist;
10088                   }
10089                 else
10090                   {
10091                     attributes = NULL_TREE;
10092                   }
10093
10094                 decl = start_decl (declarator, declspecs, 1,
10095                                    attributes, NULL_TREE);
10096                 decl_type_access_control (decl);
10097                 if (decl)
10098                   {
10099                     /* Look for __unused__ attribute */
10100                     if (TREE_USED (TREE_TYPE (decl)))
10101                       TREE_USED (decl) = 1;
10102                     finish_decl (decl, init, NULL_TREE);
10103                   }
10104                 else
10105                   error ("invalid declarator");
10106                 return NULL_TREE;
10107               }
10108             innermost_code = TREE_CODE (decl);
10109             if (decl_context == FIELD && ctype == NULL_TREE)
10110               ctype = current_class_type;
10111             if (ctype
10112                 && TREE_OPERAND (decl, 0)
10113                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
10114                     && constructor_name_p (DECL_NAME (TREE_OPERAND (decl, 0)),
10115                                            ctype)))
10116               TREE_OPERAND (decl, 0) = constructor_name (ctype);
10117             next = &TREE_OPERAND (decl, 0);
10118             decl = *next;
10119             if (ctype != NULL_TREE
10120                 && decl != NULL_TREE && flags != DTOR_FLAG
10121                 && constructor_name_p (decl, ctype))
10122               {
10123                 sfk = sfk_constructor;
10124                 ctor_return_type = ctype;
10125               }
10126             ctype = NULL_TREE;
10127             break;
10128
10129           case TEMPLATE_ID_EXPR:
10130               {
10131                 tree fns = TREE_OPERAND (decl, 0);
10132
10133                 if (TREE_CODE (fns) == LOOKUP_EXPR)
10134                   fns = TREE_OPERAND (fns, 0);
10135
10136                 dname = fns;
10137                 if (TREE_CODE (dname) == COMPONENT_REF)
10138                   dname = TREE_OPERAND (dname, 1);
10139                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
10140                   {
10141                     my_friendly_assert (is_overloaded_fn (dname),
10142                                         19990331);
10143                     dname = DECL_NAME (get_first_fn (dname));
10144                   }
10145               }
10146           /* Fall through.  */
10147
10148           case IDENTIFIER_NODE:
10149             if (TREE_CODE (decl) == IDENTIFIER_NODE)
10150               dname = decl;
10151
10152             next = 0;
10153
10154             if (C_IS_RESERVED_WORD (dname))
10155               {
10156                 error ("declarator-id missing; using reserved word `%D'",
10157                           dname);
10158                 name = IDENTIFIER_POINTER (dname);
10159               }
10160             else if (!IDENTIFIER_TYPENAME_P (dname))
10161               name = IDENTIFIER_POINTER (dname);
10162             else
10163               {
10164                 my_friendly_assert (flags == NO_SPECIAL, 154);
10165                 flags = TYPENAME_FLAG;
10166                 ctor_return_type = TREE_TYPE (dname);
10167                 sfk = sfk_conversion;
10168                 if (IDENTIFIER_GLOBAL_VALUE (dname)
10169                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
10170                         == TYPE_DECL))
10171                   name = IDENTIFIER_POINTER (dname);
10172                 else
10173                   name = "<invalid operator>";
10174               }
10175             break;
10176
10177             /* C++ extension */
10178           case SCOPE_REF:
10179             {
10180               /* Perform error checking, and decide on a ctype.  */
10181               tree cname = TREE_OPERAND (decl, 0);
10182               if (cname == NULL_TREE)
10183                 ctype = NULL_TREE;
10184               else if (TREE_CODE (cname) == NAMESPACE_DECL)
10185                 {
10186                   ctype = NULL_TREE;
10187                   in_namespace = TREE_OPERAND (decl, 0);
10188                 }
10189               else if (! is_aggr_type (cname, 1))
10190                 ctype = NULL_TREE;
10191               /* Must test TREE_OPERAND (decl, 1), in case user gives
10192                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
10193               else if (TREE_OPERAND (decl, 1)
10194                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
10195                 ctype = cname;
10196               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
10197                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
10198                 {
10199                   /* This might be declaring a member of a template
10200                      parm to be a friend.  */
10201                   ctype = cname;
10202                   dependant_name = TREE_OPERAND (decl, 1);
10203                 }
10204               else if (ctype == NULL_TREE)
10205                 ctype = cname;
10206               else if (TREE_COMPLEXITY (decl) == current_class_depth)
10207                 ;
10208               else
10209                 {
10210                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
10211                     {
10212                       error ("type `%T' is not derived from type `%T'",
10213                                 cname, ctype);
10214                       ctype = NULL_TREE;
10215                     }
10216                   else
10217                     ctype = cname;
10218                 }
10219
10220               /* It is valid to write:
10221
10222                    class C { void f(); };
10223                    typedef C D;
10224                    void D::f();
10225
10226                  The standard is not clear about whether `typedef const C D' is
10227                  legal; as of 2002-09-15 the committee is considering
10228                  that question.  EDG 3.0 allows that syntax.
10229                  Therefore, we do as well.  */
10230               if (ctype)
10231                 ctype = TYPE_MAIN_VARIANT (ctype);
10232               /* Update the declarator so that when we process it
10233                  again the correct type is present.  */
10234               TREE_OPERAND (decl, 0) = ctype;
10235
10236               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
10237                   && constructor_name_p (DECL_NAME (TREE_OPERAND (decl, 1)),
10238                                          ctype))
10239                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
10240               next = &TREE_OPERAND (decl, 1);
10241               decl = *next;
10242               if (ctype)
10243                 {
10244                   if (TREE_CODE (decl) == IDENTIFIER_NODE
10245                       && constructor_name_p (decl, ctype))
10246                     {
10247                       sfk = sfk_constructor;
10248                       ctor_return_type = ctype;
10249                     }
10250                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
10251                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
10252                            && constructor_name_p (TREE_OPERAND (decl, 0),
10253                                                   ctype))
10254                     {
10255                       sfk = sfk_destructor;
10256                       ctor_return_type = ctype;
10257                       flags = DTOR_FLAG;
10258                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
10259                       next = &TREE_OPERAND (decl, 0);
10260                     }
10261                 }
10262             }
10263             break;
10264
10265           case ERROR_MARK:
10266             next = 0;
10267             break;
10268
10269           case TYPE_DECL:
10270             /* Parse error puts this typespec where
10271                a declarator should go.  */
10272             error ("`%T' specified as declarator-id", DECL_NAME (decl));
10273             if (TREE_TYPE (decl) == current_class_type)
10274               error ("  perhaps you want `%T' for a constructor",
10275                         current_class_name);
10276             dname = DECL_NAME (decl);
10277             name = IDENTIFIER_POINTER (dname);
10278
10279             /* Avoid giving two errors for this.  */
10280             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
10281
10282             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
10283             *next = dname;
10284             next = 0;
10285             break;
10286
10287           case BASELINK:
10288             next = &BASELINK_FUNCTIONS (decl);
10289             break;
10290
10291           case TEMPLATE_DECL:
10292             /* Sometimes, we see a template-name used as part of a
10293                decl-specifier like in
10294                   std::allocator alloc;
10295                Handle that gracefully.  */
10296             error ("invalid use of template-name '%E' in a declarator", decl);
10297             return error_mark_node;
10298             break;
10299
10300           default:
10301             my_friendly_assert (0, 20020917);
10302           }
10303       }
10304   }
10305
10306   /* A function definition's declarator must have the form of
10307      a function declarator.  */
10308
10309   if (funcdef_flag && innermost_code != CALL_EXPR)
10310     return 0;
10311
10312   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
10313       && innermost_code != CALL_EXPR
10314       && ! (ctype && declspecs == NULL_TREE))
10315     {
10316       error ("declaration of `%D' as non-function", dname);
10317       return void_type_node;
10318     }
10319
10320   /* Anything declared one level down from the top level
10321      must be one of the parameters of a function
10322      (because the body is at least two levels down).  */
10323
10324   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10325      by not allowing C++ class definitions to specify their parameters
10326      with xdecls (must be spec.d in the parmlist).
10327
10328      Since we now wait to push a class scope until we are sure that
10329      we are in a legitimate method context, we must set oldcname
10330      explicitly (since current_class_name is not yet alive).
10331
10332      We also want to avoid calling this a PARM if it is in a namespace.  */
10333
10334   if (decl_context == NORMAL && !toplevel_bindings_p ())
10335     {
10336       struct cp_binding_level *b = current_binding_level;
10337       current_binding_level = b->level_chain;
10338       if (current_binding_level != 0 && toplevel_bindings_p ())
10339         decl_context = PARM;
10340       current_binding_level = b;
10341     }
10342
10343   if (name == NULL)
10344     name = decl_context == PARM ? "parameter" : "type name";
10345
10346   /* Look through the decl specs and record which ones appear.
10347      Some typespecs are defined as built-in typenames.
10348      Others, the ones that are modifiers of other types,
10349      are represented by bits in SPECBITS: set the bits for
10350      the modifiers that appear.  Storage class keywords are also in SPECBITS.
10351
10352      If there is a typedef name or a type, store the type in TYPE.
10353      This includes builtin typedefs such as `int'.
10354
10355      Set EXPLICIT_INT if the type is `int' or `char' and did not
10356      come from a user typedef.
10357
10358      Set LONGLONG if `long' is mentioned twice.
10359
10360      For C++, constructors and destructors have their own fast treatment.  */
10361
10362   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10363     {
10364       register int i;
10365       register tree id;
10366
10367       /* Certain parse errors slip through.  For example,
10368          `int class;' is not caught by the parser. Try
10369          weakly to recover here.  */
10370       if (TREE_CODE (spec) != TREE_LIST)
10371         return 0;
10372
10373       id = TREE_VALUE (spec);
10374
10375       /* If the entire declaration is itself tagged as deprecated then
10376          suppress reports of deprecated items.  */
10377       if (!adding_implicit_members && id && TREE_DEPRECATED (id))
10378         {
10379           if (deprecated_state != DEPRECATED_SUPPRESS)
10380             warn_deprecated_use (id);
10381         }
10382
10383       if (TREE_CODE (id) == IDENTIFIER_NODE)
10384         {
10385           if (id == ridpointers[(int) RID_INT]
10386               || id == ridpointers[(int) RID_CHAR]
10387               || id == ridpointers[(int) RID_BOOL]
10388               || id == ridpointers[(int) RID_WCHAR])
10389             {
10390               if (type)
10391                 {
10392                   if (id == ridpointers[(int) RID_BOOL])
10393                     error ("`bool' is now a keyword");
10394                   else
10395                     error ("extraneous `%T' ignored", id);
10396                 }
10397               else
10398                 {
10399                   if (id == ridpointers[(int) RID_INT])
10400                     explicit_int = 1;
10401                   else if (id == ridpointers[(int) RID_CHAR])
10402                     explicit_char = 1;
10403                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10404                 }
10405               goto found;
10406             }
10407           /* C++ aggregate types.  */
10408           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10409             {
10410               if (type)
10411                 error ("multiple declarations `%T' and `%T'", type, id);
10412               else
10413                 type = IDENTIFIER_TYPE_VALUE (id);
10414               goto found;
10415             }
10416
10417           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10418             {
10419               if (ridpointers[i] == id)
10420                 {
10421                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10422                     {
10423                       if (pedantic && ! in_system_header && warn_long_long)
10424                         pedwarn ("ISO C++ does not support `long long'");
10425                       if (longlong)
10426                         error ("`long long long' is too long for GCC");
10427                       else
10428                         longlong = 1;
10429                     }
10430                   else if (RIDBIT_SETP (i, specbits))
10431                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10432
10433                   /* Diagnose "__thread extern" or "__thread static".  */
10434                   if (RIDBIT_SETP (RID_THREAD, specbits))
10435                     {
10436                       if (i == (int)RID_EXTERN)
10437                         error ("`__thread' before `extern'");
10438                       else if (i == (int)RID_STATIC)
10439                         error ("`__thread' before `static'");
10440                     }
10441
10442                   if (i == (int)RID_EXTERN
10443                       && TREE_PURPOSE (spec) == error_mark_node)
10444                     /* This extern was part of a language linkage.  */
10445                     extern_langp = 1;
10446
10447                   RIDBIT_SET (i, specbits);
10448                   goto found;
10449                 }
10450             }
10451         }
10452       else if (TREE_CODE (id) == TYPE_DECL)
10453         {
10454           if (type)
10455             error ("multiple declarations `%T' and `%T'", type,
10456                       TREE_TYPE (id));
10457           else
10458             {
10459               type = TREE_TYPE (id);
10460               TREE_VALUE (spec) = type;
10461               typedef_decl = id;
10462             }
10463           goto found;
10464         }
10465       if (type)
10466         error ("two or more data types in declaration of `%s'", name);
10467       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10468         {
10469           register tree t = lookup_name (id, 1);
10470           if (!t || TREE_CODE (t) != TYPE_DECL)
10471             error ("`%s' fails to be a typedef or built in type",
10472                    IDENTIFIER_POINTER (id));
10473           else
10474             {
10475               type = TREE_TYPE (t);
10476               typedef_decl = t;
10477             }
10478         }
10479       else if (id != error_mark_node)
10480         /* Can't change CLASS nodes into RECORD nodes here!  */
10481         type = id;
10482
10483     found: ;
10484     }
10485
10486 #if 0
10487   /* See the code below that used this.  */
10488   if (typedef_decl)
10489     decl_attr = DECL_ATTRIBUTES (typedef_decl);
10490 #endif
10491   typedef_type = type;
10492
10493   /* No type at all: default to `int', and set DEFAULTED_INT
10494      because it was not a user-defined typedef.  */
10495
10496   if (type == NULL_TREE
10497       && (RIDBIT_SETP (RID_SIGNED, specbits)
10498           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10499           || RIDBIT_SETP (RID_LONG, specbits)
10500           || RIDBIT_SETP (RID_SHORT, specbits)))
10501     {
10502       /* These imply 'int'.  */
10503       type = integer_type_node;
10504       defaulted_int = 1;
10505     }
10506
10507   if (sfk != sfk_none)
10508     type = check_special_function_return_type (sfk, type,
10509                                                ctor_return_type);
10510   else if (type == NULL_TREE)
10511     {
10512       int is_main;
10513
10514       explicit_int = -1;
10515
10516       /* We handle `main' specially here, because 'main () { }' is so
10517          common.  With no options, it is allowed.  With -Wreturn-type,
10518          it is a warning.  It is only an error with -pedantic-errors.  */
10519       is_main = (funcdef_flag
10520                  && dname && MAIN_NAME_P (dname)
10521                  && ctype == NULL_TREE
10522                  && in_namespace == NULL_TREE
10523                  && current_namespace == global_namespace);
10524
10525       if (in_system_header || flag_ms_extensions)
10526         /* Allow it, sigh.  */;
10527       else if (pedantic || ! is_main)
10528         pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10529                     name);
10530       else if (warn_return_type)
10531         warning ("ISO C++ forbids declaration of `%s' with no type",
10532                     name);
10533
10534       type = integer_type_node;
10535     }
10536
10537   if (type && IMPLICIT_TYPENAME_P (type))
10538     {
10539       /* The implicit typename extension is deprecated and will be
10540          removed.  Warn about its use now.  */
10541       warning ("`%T' is implicitly a typename", type);
10542       cp_deprecated ("implicit typename");
10543
10544       /* Now remove its implicitness, so that we don't warn again.
10545          For instance this might be a typedef, and we do not want to
10546          warn on uses of the typedef itself.  Simply clearing the
10547          TREE_TYPE is insufficient.  */
10548       type = copy_node (type);
10549       TREE_TYPE (type) = NULL_TREE;
10550     }
10551
10552   ctype = NULL_TREE;
10553
10554   /* Now process the modifiers that were specified
10555      and check for invalid combinations.  */
10556
10557   /* Long double is a special combination.  */
10558
10559   if (RIDBIT_SETP (RID_LONG, specbits)
10560       && TYPE_MAIN_VARIANT (type) == double_type_node)
10561     {
10562       RIDBIT_RESET (RID_LONG, specbits);
10563       type = build_qualified_type (long_double_type_node,
10564                                    cp_type_quals (type));
10565     }
10566
10567   /* Check all other uses of type modifiers.  */
10568
10569   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10570       || RIDBIT_SETP (RID_SIGNED, specbits)
10571       || RIDBIT_SETP (RID_LONG, specbits)
10572       || RIDBIT_SETP (RID_SHORT, specbits))
10573     {
10574       int ok = 0;
10575
10576       if (TREE_CODE (type) == REAL_TYPE)
10577         error ("short, signed or unsigned invalid for `%s'", name);
10578       else if (TREE_CODE (type) != INTEGER_TYPE)
10579         error ("long, short, signed or unsigned invalid for `%s'", name);
10580       else if (RIDBIT_SETP (RID_LONG, specbits)
10581                && RIDBIT_SETP (RID_SHORT, specbits))
10582         error ("long and short specified together for `%s'", name);
10583       else if ((RIDBIT_SETP (RID_LONG, specbits)
10584                 || RIDBIT_SETP (RID_SHORT, specbits))
10585                && explicit_char)
10586         error ("long or short specified with char for `%s'", name);
10587       else if ((RIDBIT_SETP (RID_LONG, specbits)
10588                 || RIDBIT_SETP (RID_SHORT, specbits))
10589                && TREE_CODE (type) == REAL_TYPE)
10590         error ("long or short specified with floating type for `%s'", name);
10591       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10592                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10593         error ("signed and unsigned given together for `%s'", name);
10594       else
10595         {
10596           ok = 1;
10597           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10598             {
10599               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10600                        name);
10601               if (flag_pedantic_errors)
10602                 ok = 0;
10603             }
10604         }
10605
10606       /* Discard the type modifiers if they are invalid.  */
10607       if (! ok)
10608         {
10609           RIDBIT_RESET (RID_UNSIGNED, specbits);
10610           RIDBIT_RESET (RID_SIGNED, specbits);
10611           RIDBIT_RESET (RID_LONG, specbits);
10612           RIDBIT_RESET (RID_SHORT, specbits);
10613           longlong = 0;
10614         }
10615     }
10616
10617   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10618       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10619     {
10620       error ("complex invalid for `%s'", name);
10621       RIDBIT_RESET (RID_COMPLEX, specbits);
10622     }
10623
10624   /* Decide whether an integer type is signed or not.
10625      Optionally treat bitfields as signed by default.  */
10626   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10627       /* [class.bit]
10628
10629          It is implementation-defined whether a plain (neither
10630          explicitly signed or unsigned) char, short, int, or long
10631          bit-field is signed or unsigned.
10632
10633          Naturally, we extend this to long long as well.  Note that
10634          this does not include wchar_t.  */
10635       || (bitfield && !flag_signed_bitfields
10636           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10637           /* A typedef for plain `int' without `signed' can be
10638              controlled just like plain `int', but a typedef for
10639              `signed int' cannot be so controlled.  */
10640           && !(typedef_decl
10641                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10642           && (TREE_CODE (type) == INTEGER_TYPE
10643               || TREE_CODE (type) == CHAR_TYPE)
10644           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10645     {
10646       if (longlong)
10647         type = long_long_unsigned_type_node;
10648       else if (RIDBIT_SETP (RID_LONG, specbits))
10649         type = long_unsigned_type_node;
10650       else if (RIDBIT_SETP (RID_SHORT, specbits))
10651         type = short_unsigned_type_node;
10652       else if (type == char_type_node)
10653         type = unsigned_char_type_node;
10654       else if (typedef_decl)
10655         type = c_common_unsigned_type (type);
10656       else
10657         type = unsigned_type_node;
10658     }
10659   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10660            && type == char_type_node)
10661     type = signed_char_type_node;
10662   else if (longlong)
10663     type = long_long_integer_type_node;
10664   else if (RIDBIT_SETP (RID_LONG, specbits))
10665     type = long_integer_type_node;
10666   else if (RIDBIT_SETP (RID_SHORT, specbits))
10667     type = short_integer_type_node;
10668
10669   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10670     {
10671       /* If we just have "complex", it is equivalent to
10672          "complex double", but if any modifiers at all are specified it is
10673          the complex form of TYPE.  E.g, "complex short" is
10674          "complex short int".  */
10675
10676       if (defaulted_int && ! longlong
10677           && ! (RIDBIT_SETP (RID_LONG, specbits)
10678                 || RIDBIT_SETP (RID_SHORT, specbits)
10679                 || RIDBIT_SETP (RID_SIGNED, specbits)
10680                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10681         type = complex_double_type_node;
10682       else if (type == integer_type_node)
10683         type = complex_integer_type_node;
10684       else if (type == float_type_node)
10685         type = complex_float_type_node;
10686       else if (type == double_type_node)
10687         type = complex_double_type_node;
10688       else if (type == long_double_type_node)
10689         type = complex_long_double_type_node;
10690       else
10691         type = build_complex_type (type);
10692     }
10693
10694   type_quals = TYPE_UNQUALIFIED;
10695   if (RIDBIT_SETP (RID_CONST, specbits))
10696     type_quals |= TYPE_QUAL_CONST;
10697   if (RIDBIT_SETP (RID_VOLATILE, specbits))
10698     type_quals |= TYPE_QUAL_VOLATILE;
10699   if (RIDBIT_SETP (RID_RESTRICT, specbits))
10700     type_quals |= TYPE_QUAL_RESTRICT;
10701   if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
10702     error ("qualifiers are not allowed on declaration of `operator %T'",
10703               ctor_return_type);
10704
10705   type_quals |= cp_type_quals (type);
10706   type = cp_build_qualified_type_real
10707     (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
10708                          ? tf_ignore_bad_quals : 0) | tf_error | tf_warning));
10709   /* We might have ignored or rejected some of the qualifiers.  */
10710   type_quals = cp_type_quals (type);
10711
10712   staticp = 0;
10713   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10714   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10715   RIDBIT_RESET (RID_VIRTUAL, specbits);
10716   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10717   RIDBIT_RESET (RID_EXPLICIT, specbits);
10718
10719   if (RIDBIT_SETP (RID_STATIC, specbits))
10720     staticp = 1 + (decl_context == FIELD);
10721
10722   if (virtualp && staticp == 2)
10723     {
10724       error ("member `%D' cannot be declared both virtual and static",
10725                 dname);
10726       staticp = 0;
10727     }
10728   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10729   RIDBIT_RESET (RID_FRIEND, specbits);
10730
10731   if (dependant_name && !friendp)
10732     {
10733       error ("`%T::%D' is not a valid declarator", ctype, dependant_name);
10734       return void_type_node;
10735     }
10736
10737   /* Warn if two storage classes are given. Default to `auto'.  */
10738
10739   if (RIDBIT_ANY_SET (specbits))
10740     {
10741       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10742       if (RIDBIT_SETP (RID_EXTERN, specbits) && !extern_langp) nclasses++;
10743       if (RIDBIT_SETP (RID_THREAD, specbits)) nclasses++;
10744       if (decl_context == PARM && nclasses > 0)
10745         error ("storage class specifiers invalid in parameter declarations");
10746       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10747         {
10748           if (decl_context == PARM)
10749             error ("typedef declaration invalid in parameter declaration");
10750           nclasses++;
10751         }
10752       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10753       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10754       if (!nclasses && !friendp && extern_langp)
10755         nclasses++;
10756     }
10757
10758   /* Give error if `virtual' is used outside of class declaration.  */
10759   if (virtualp
10760       && (current_class_name == NULL_TREE || decl_context != FIELD))
10761     {
10762       error ("virtual outside class declaration");
10763       virtualp = 0;
10764     }
10765
10766   /* Static anonymous unions are dealt with here.  */
10767   if (staticp && decl_context == TYPENAME
10768       && TREE_CODE (declspecs) == TREE_LIST
10769       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10770     decl_context = FIELD;
10771
10772   /* Warn about storage classes that are invalid for certain
10773      kinds of declarations (parameters, typenames, etc.).  */
10774
10775   /* "static __thread" and "extern __thread" are allowed.  */
10776   if (nclasses == 2
10777       && RIDBIT_SETP (RID_THREAD, specbits)
10778       && (RIDBIT_SETP (RID_EXTERN, specbits)
10779           || RIDBIT_SETP (RID_STATIC, specbits)))
10780     nclasses = 1;
10781
10782   if (nclasses > 1)
10783     error ("multiple storage classes in declaration of `%s'", name);
10784   else if (decl_context != NORMAL && nclasses > 0)
10785     {
10786       if ((decl_context == PARM || decl_context == CATCHPARM)
10787           && (RIDBIT_SETP (RID_REGISTER, specbits)
10788               || RIDBIT_SETP (RID_AUTO, specbits)))
10789         ;
10790       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10791         ;
10792       else if (decl_context == FIELD
10793                /* C++ allows static class elements  */
10794                && RIDBIT_SETP (RID_STATIC, specbits))
10795         /* C++ also allows inlines and signed and unsigned elements,
10796            but in those cases we don't come in here.  */
10797         ;
10798       else
10799         {
10800           if (decl_context == FIELD)
10801             {
10802               tree tmp = NULL_TREE;
10803               register int op = 0;
10804
10805               if (declarator)
10806                 {
10807                   /* Avoid trying to get an operand off an identifier node.  */
10808                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10809                     tmp = declarator;
10810                   else
10811                     tmp = TREE_OPERAND (declarator, 0);
10812                   op = IDENTIFIER_OPNAME_P (tmp);
10813                   if (IDENTIFIER_TYPENAME_P (tmp))
10814                     {
10815                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10816                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10817                               == TYPE_DECL))
10818                         name = IDENTIFIER_POINTER (tmp);
10819                       else
10820                         name = "<invalid operator>";
10821                     }
10822                 }
10823               error ("storage class specified for %s `%s'",
10824                      op ? "member operator" : "field",
10825                      name);
10826             }
10827           else
10828             {
10829               if (decl_context == PARM || decl_context == CATCHPARM)
10830                 error ("storage class specified for parameter `%s'", name);
10831               else
10832                 error ("storage class specified for typename");
10833             }
10834           RIDBIT_RESET (RID_REGISTER, specbits);
10835           RIDBIT_RESET (RID_AUTO, specbits);
10836           RIDBIT_RESET (RID_EXTERN, specbits);
10837           RIDBIT_RESET (RID_THREAD, specbits);
10838         }
10839     }
10840   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10841     {
10842       if (toplevel_bindings_p ())
10843         {
10844           /* It's common practice (and completely valid) to have a const
10845              be initialized and declared extern.  */
10846           if (!(type_quals & TYPE_QUAL_CONST))
10847             warning ("`%s' initialized and declared `extern'", name);
10848         }
10849       else
10850         error ("`%s' has both `extern' and initializer", name);
10851     }
10852   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10853            && ! toplevel_bindings_p ())
10854     error ("nested function `%s' declared `extern'", name);
10855   else if (toplevel_bindings_p ())
10856     {
10857       if (RIDBIT_SETP (RID_AUTO, specbits))
10858         error ("top-level declaration of `%s' specifies `auto'", name);
10859     }
10860   else if (RIDBIT_SETP (RID_THREAD, specbits)
10861            && !RIDBIT_SETP (RID_EXTERN, specbits)
10862            && !RIDBIT_SETP (RID_STATIC, specbits))
10863     {
10864       error ("function-scope `%s' implicitly auto and declared `__thread'",
10865              name);
10866       RIDBIT_RESET (RID_THREAD, specbits);
10867     }
10868
10869   if (nclasses > 0 && friendp)
10870     error ("storage class specifiers invalid in friend function declarations");
10871
10872   scope = get_scope_of_declarator (declarator);
10873
10874   /* Now figure out the structure of the declarator proper.
10875      Descend through it, creating more complex types, until we reach
10876      the declared identifier (or NULL_TREE, in an abstract declarator).  */
10877
10878   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10879          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10880     {
10881       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10882          an INDIRECT_REF (for *...),
10883          a CALL_EXPR (for ...(...)),
10884          an identifier (for the name being declared)
10885          or a null pointer (for the place in an absolute declarator
10886          where the name was omitted).
10887          For the last two cases, we have just exited the loop.
10888
10889          For C++ it could also be
10890          a SCOPE_REF (for class :: ...).  In this case, we have converted
10891          sensible names to types, and those are the values we use to
10892          qualify the member name.
10893          an ADDR_EXPR (for &...),
10894          a BIT_NOT_EXPR (for destructors)
10895
10896          At this point, TYPE is the type of elements of an array,
10897          or for a function to return, or for a pointer to point to.
10898          After this sequence of ifs, TYPE is the type of the
10899          array or function or pointer, and DECLARATOR has had its
10900          outermost layer removed.  */
10901
10902       if (type == error_mark_node)
10903         {
10904           if (TREE_CODE (declarator) == SCOPE_REF)
10905             declarator = TREE_OPERAND (declarator, 1);
10906           else
10907             declarator = TREE_OPERAND (declarator, 0);
10908           continue;
10909         }
10910       if (quals != NULL_TREE
10911           && (declarator == NULL_TREE
10912               || TREE_CODE (declarator) != SCOPE_REF))
10913         {
10914           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10915             ctype = TYPE_METHOD_BASETYPE (type);
10916           if (ctype != NULL_TREE)
10917             {
10918               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10919               grok_method_quals (ctype, dummy, quals);
10920               type = TREE_TYPE (dummy);
10921               quals = NULL_TREE;
10922             }
10923         }
10924
10925       switch (TREE_CODE (declarator))
10926         {
10927         case TREE_LIST:
10928           {
10929             /* We encode a declarator with embedded attributes using
10930                a TREE_LIST.  */
10931             tree attrs = TREE_PURPOSE (declarator);
10932             tree inner_decl;
10933             int attr_flags;
10934
10935             declarator = TREE_VALUE (declarator);
10936             inner_decl = declarator;
10937             while (inner_decl != NULL_TREE
10938                    && TREE_CODE (inner_decl) == TREE_LIST)
10939               inner_decl = TREE_VALUE (inner_decl);
10940             attr_flags = 0;
10941             if (inner_decl == NULL_TREE
10942                 || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
10943               attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
10944             if (TREE_CODE (inner_decl) == CALL_EXPR)
10945               attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
10946             if (TREE_CODE (inner_decl) == ARRAY_REF)
10947               attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
10948             returned_attrs = decl_attributes (&type,
10949                                               chainon (returned_attrs, attrs),
10950                                               attr_flags);
10951           }
10952           break;
10953
10954         case ARRAY_REF:
10955           {
10956             register tree size;
10957
10958             size = TREE_OPERAND (declarator, 1);
10959
10960             /* VC++ spells a zero-sized array with [].  */
10961             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10962                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10963               size = integer_zero_node;
10964
10965             declarator = TREE_OPERAND (declarator, 0);
10966
10967             type = create_array_type_for_decl (dname, type, size);
10968
10969             ctype = NULL_TREE;
10970           }
10971           break;
10972
10973         case CALL_EXPR:
10974           {
10975             tree arg_types;
10976             int funcdecl_p;
10977             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10978             tree inner_decl = TREE_OPERAND (declarator, 0);
10979
10980             /* Declaring a function type.
10981                Make sure we have a valid type for the function to return.  */
10982
10983             /* We now know that the TYPE_QUALS don't apply to the
10984                decl, but to its return type.  */
10985             type_quals = TYPE_UNQUALIFIED;
10986
10987             /* Warn about some types functions can't return.  */
10988
10989             if (TREE_CODE (type) == FUNCTION_TYPE)
10990               {
10991                 error ("`%s' declared as function returning a function", name);
10992                 type = integer_type_node;
10993               }
10994             if (TREE_CODE (type) == ARRAY_TYPE)
10995               {
10996                 error ("`%s' declared as function returning an array", name);
10997                 type = integer_type_node;
10998               }
10999
11000             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
11001               inner_decl = TREE_OPERAND (inner_decl, 1);
11002
11003             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
11004               inner_decl = dname;
11005
11006             /* Pick up type qualifiers which should be applied to `this'.  */
11007             quals = CALL_DECLARATOR_QUALS (declarator);
11008
11009             /* Pick up the exception specifications.  */
11010             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
11011
11012             /* Say it's a definition only for the CALL_EXPR
11013                closest to the identifier.  */
11014             funcdecl_p
11015               = inner_decl
11016               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
11017                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
11018                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
11019
11020             if (ctype == NULL_TREE
11021                 && decl_context == FIELD
11022                 && funcdecl_p
11023                 && (friendp == 0 || dname == current_class_name))
11024               ctype = current_class_type;
11025
11026             if (ctype && sfk == sfk_conversion)
11027               TYPE_HAS_CONVERSION (ctype) = 1;
11028             if (ctype && constructor_name_p (dname, ctype))
11029               {
11030                 /* We are within a class's scope. If our declarator name
11031                    is the same as the class name, and we are defining
11032                    a function, then it is a constructor/destructor, and
11033                    therefore returns a void type.  */
11034
11035                 if (flags == DTOR_FLAG)
11036                   {
11037                     /* ISO C++ 12.4/2.  A destructor may not be
11038                        declared const or volatile.  A destructor may
11039                        not be static.  */
11040                     if (staticp == 2)
11041                       error ("destructor cannot be static member function");
11042                     if (quals)
11043                       {
11044                         error ("destructors may not be `%s'",
11045                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
11046                         quals = NULL_TREE;
11047                       }
11048                     if (decl_context == FIELD)
11049                       {
11050                         if (! member_function_or_else (ctype,
11051                                                        current_class_type,
11052                                                        flags))
11053                           return void_type_node;
11054                       }
11055                   }
11056                 else            /* It's a constructor.  */
11057                   {
11058                     if (explicitp == 1)
11059                       explicitp = 2;
11060                     /* ISO C++ 12.1.  A constructor may not be
11061                        declared const or volatile.  A constructor may
11062                        not be virtual.  A constructor may not be
11063                        static.  */
11064                     if (staticp == 2)
11065                       error ("constructor cannot be static member function");
11066                     if (virtualp)
11067                       {
11068                         pedwarn ("constructors cannot be declared virtual");
11069                         virtualp = 0;
11070                       }
11071                     if (quals)
11072                       {
11073                         error ("constructors may not be `%s'",
11074                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
11075                         quals = NULL_TREE;
11076                       }
11077                     {
11078                       RID_BIT_TYPE tmp_bits;
11079                       memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
11080                       RIDBIT_RESET (RID_INLINE, tmp_bits);
11081                       RIDBIT_RESET (RID_STATIC, tmp_bits);
11082                       if (RIDBIT_ANY_SET (tmp_bits))
11083                         error ("return value type specifier for constructor ignored");
11084                     }
11085                     if (decl_context == FIELD)
11086                       {
11087                         if (! member_function_or_else (ctype,
11088                                                        current_class_type,
11089                                                        flags))
11090                           return void_type_node;
11091                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
11092                         if (sfk != sfk_constructor)
11093                           return NULL_TREE;
11094                       }
11095                   }
11096                 if (decl_context == FIELD)
11097                   staticp = 0;
11098               }
11099             else if (friendp)
11100               {
11101                 if (initialized)
11102                   error ("can't initialize friend function `%s'", name);
11103                 if (virtualp)
11104                   {
11105                     /* Cannot be both friend and virtual.  */
11106                     error ("virtual functions cannot be friends");
11107                     RIDBIT_RESET (RID_FRIEND, specbits);
11108                     friendp = 0;
11109                   }
11110                 if (decl_context == NORMAL)
11111                   error ("friend declaration not in class definition");
11112                 if (current_function_decl && funcdef_flag)
11113                   error ("can't define friend function `%s' in a local class definition",
11114                             name);
11115               }
11116
11117             /* Construct the function type and go to the next
11118                inner layer of declarator.  */
11119
11120             declarator = TREE_OPERAND (declarator, 0);
11121
11122             /* FIXME: This is where default args should be fully
11123                processed.  */
11124
11125             arg_types = grokparms (inner_parms);
11126
11127             if (declarator && flags == DTOR_FLAG)
11128               {
11129                 /* A destructor declared in the body of a class will
11130                    be represented as a BIT_NOT_EXPR.  But, we just
11131                    want the underlying IDENTIFIER.  */
11132                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
11133                   declarator = TREE_OPERAND (declarator, 0);
11134
11135                 if (arg_types != void_list_node)
11136                   {
11137                     error ("destructors may not have parameters");
11138                     arg_types = void_list_node;
11139                     last_function_parms = NULL_TREE;
11140                   }
11141               }
11142
11143             /* ANSI says that `const int foo ();'
11144                does not make the function foo const.  */
11145             type = build_function_type (type, arg_types);
11146           }
11147           break;
11148
11149         case ADDR_EXPR:
11150         case INDIRECT_REF:
11151           /* Filter out pointers-to-references and references-to-references.
11152              We can get these if a TYPE_DECL is used.  */
11153
11154           if (TREE_CODE (type) == REFERENCE_TYPE)
11155             {
11156               error (TREE_CODE (declarator) == ADDR_EXPR
11157                      ? "cannot declare reference to `%#T'"
11158                      : "cannot declare pointer to `%#T'", type);
11159               type = TREE_TYPE (type);
11160             }
11161           else if (VOID_TYPE_P (type)
11162                    && (ctype || TREE_CODE (declarator) == ADDR_EXPR))
11163             error (ctype ? "cannot declare pointer to `%#T' member"
11164                      : "cannot declare reference to `%#T'", type);
11165
11166           /* Merge any constancy or volatility into the target type
11167              for the pointer.  */
11168
11169           /* We now know that the TYPE_QUALS don't apply to the decl,
11170              but to the target of the pointer.  */
11171           type_quals = TYPE_UNQUALIFIED;
11172
11173           if (TREE_CODE (declarator) == ADDR_EXPR)
11174             {
11175               if (!VOID_TYPE_P (type))
11176                 type = build_reference_type (type);
11177             }
11178           else if (TREE_CODE (type) == METHOD_TYPE)
11179             type = build_ptrmemfunc_type (build_pointer_type (type));
11180           else if (ctype)
11181             type = build_ptrmem_type (ctype, type);
11182           else
11183             type = build_pointer_type (type);
11184
11185           /* Process a list of type modifier keywords (such as
11186              const or volatile) that were given inside the `*' or `&'.  */
11187
11188           if (TREE_TYPE (declarator))
11189             {
11190               register tree typemodlist;
11191               int erred = 0;
11192               int constp = 0;
11193               int volatilep = 0;
11194               int restrictp = 0;
11195
11196               for (typemodlist = TREE_TYPE (declarator); typemodlist;
11197                    typemodlist = TREE_CHAIN (typemodlist))
11198                 {
11199                   tree qualifier = TREE_VALUE (typemodlist);
11200
11201                   if (qualifier == ridpointers[(int) RID_CONST])
11202                     {
11203                       constp++;
11204                       type_quals |= TYPE_QUAL_CONST;
11205                     }
11206                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
11207                     {
11208                       volatilep++;
11209                       type_quals |= TYPE_QUAL_VOLATILE;
11210                     }
11211                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
11212                     {
11213                       restrictp++;
11214                       type_quals |= TYPE_QUAL_RESTRICT;
11215                     }
11216                   else if (!erred)
11217                     {
11218                       erred = 1;
11219                       error ("invalid type modifier within pointer declarator");
11220                     }
11221                 }
11222               if (constp > 1)
11223                 pedwarn ("duplicate `const'");
11224               if (volatilep > 1)
11225                 pedwarn ("duplicate `volatile'");
11226               if (restrictp > 1)
11227                 pedwarn ("duplicate `restrict'");
11228               type = cp_build_qualified_type (type, type_quals);
11229               type_quals = cp_type_quals (type);
11230             }
11231           declarator = TREE_OPERAND (declarator, 0);
11232           ctype = NULL_TREE;
11233           break;
11234
11235         case SCOPE_REF:
11236           {
11237             /* We have converted type names to NULL_TREE if the
11238                name was bogus, or to a _TYPE node, if not.
11239
11240                The variable CTYPE holds the type we will ultimately
11241                resolve to.  The code here just needs to build
11242                up appropriate member types.  */
11243             tree sname = TREE_OPERAND (declarator, 1);
11244             tree t;
11245
11246             /* Destructors can have their visibilities changed as well.  */
11247             if (TREE_CODE (sname) == BIT_NOT_EXPR)
11248               sname = TREE_OPERAND (sname, 0);
11249
11250             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
11251               {
11252                 /* We had a reference to a global decl, or
11253                    perhaps we were given a non-aggregate typedef,
11254                    in which case we cleared this out, and should just
11255                    keep going as though it wasn't there.  */
11256                 declarator = sname;
11257                 continue;
11258               }
11259             ctype = TREE_OPERAND (declarator, 0);
11260
11261             t = ctype;
11262             while (t != NULL_TREE && CLASS_TYPE_P (t))
11263               {
11264                 /* You're supposed to have one `template <...>'
11265                    for every template class, but you don't need one
11266                    for a full specialization.  For example:
11267
11268                      template <class T> struct S{};
11269                      template <> struct S<int> { void f(); };
11270                      void S<int>::f () {}
11271
11272                    is correct; there shouldn't be a `template <>' for
11273                    the definition of `S<int>::f'.  */
11274                 if (CLASSTYPE_TEMPLATE_INFO (t)
11275                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
11276                         || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
11277                     && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
11278                   template_count += 1;
11279
11280                 t = TYPE_MAIN_DECL (t);
11281                 t = DECL_CONTEXT (t);
11282               }
11283
11284             if (sname == NULL_TREE)
11285               goto done_scoping;
11286
11287             if (TREE_CODE (sname) == IDENTIFIER_NODE)
11288               {
11289                 /* This is the `standard' use of the scoping operator:
11290                    basetype :: member .  */
11291
11292                 if (ctype == current_class_type)
11293                   {
11294                     /* class A {
11295                          void A::f ();
11296                        };
11297
11298                        Is this ill-formed?  */
11299
11300                     if (pedantic)
11301                       pedwarn ("extra qualification `%T::' on member `%s' ignored",
11302                                   ctype, name);
11303                   }
11304                 else if (TREE_CODE (type) == FUNCTION_TYPE)
11305                   {
11306                     if (current_class_type == NULL_TREE || friendp)
11307                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11308                                                       TYPE_ARG_TYPES (type));
11309                     else
11310                       {
11311                         error ("cannot declare member function `%T::%s' within `%T'",
11312                                   ctype, name, current_class_type);
11313                         return error_mark_node;
11314                       }
11315                   }
11316                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
11317                          || COMPLETE_TYPE_P (complete_type (ctype)))
11318                   {
11319                     /* Have to move this code elsewhere in this function.
11320                        this code is used for i.e., typedef int A::M; M *pm;
11321
11322                        It is?  How? jason 10/2/94 */
11323
11324                     if (current_class_type)
11325                       {
11326                         error ("cannot declare member `%T::%s' within `%T'",
11327                                   ctype, name, current_class_type);
11328                         return void_type_node;
11329                       }
11330                   }
11331                 else
11332                   {
11333                     cxx_incomplete_type_error (NULL_TREE, ctype);
11334                     return error_mark_node;
11335                   }
11336
11337                 declarator = sname;
11338               }
11339             else if (TREE_CODE (sname) == SCOPE_REF)
11340               abort ();
11341             else
11342               {
11343               done_scoping:
11344                 declarator = TREE_OPERAND (declarator, 1);
11345                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
11346                   /* In this case, we will deal with it later.  */
11347                   ;
11348                 else if (TREE_CODE (type) == FUNCTION_TYPE)
11349                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11350                                                   TYPE_ARG_TYPES (type));
11351               }
11352           }
11353           break;
11354
11355         case BIT_NOT_EXPR:
11356           declarator = TREE_OPERAND (declarator, 0);
11357           break;
11358
11359         case BASELINK:
11360           declarator = BASELINK_FUNCTIONS (declarator);
11361           break;
11362
11363         case RECORD_TYPE:
11364         case UNION_TYPE:
11365         case ENUMERAL_TYPE:
11366           declarator = NULL_TREE;
11367           break;
11368
11369         case ERROR_MARK:
11370           declarator = NULL_TREE;
11371           break;
11372
11373         default:
11374           abort ();
11375         }
11376     }
11377
11378   if (returned_attrs)
11379     {
11380       if (attrlist)
11381         *attrlist = chainon (returned_attrs, *attrlist);
11382       else
11383         attrlist = &returned_attrs;
11384     }
11385
11386   /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq that refer
11387      to ctype.  They couldn't be resolved earlier because we hadn't
11388      pushed into the class yet.
11389
11390      For example, consider:
11391
11392        template <typename T>
11393        struct S {
11394          typedef T X;
11395          X f();
11396        };
11397
11398        template <typename T>
11399        typename S<T>::X f() {}
11400
11401        When parsing the decl-specifier-seq for the definition of `f',
11402        we construct a TYPENAME_TYPE for `S<T>::X'.  By substituting
11403        here, we resolve it to the correct type.  */
11404   if (scope && CLASS_TYPE_P (scope)
11405       && current_template_parms
11406       && uses_template_parms (scope))
11407     {
11408       tree args = current_template_args ();
11409       push_scope (scope);
11410       type = tsubst (type, args, tf_error | tf_warning,
11411                      NULL_TREE);
11412       pop_scope (scope);
11413     }
11414
11415   /* Now TYPE has the actual type.  */
11416
11417   /* Did array size calculations overflow?  */
11418
11419   if (TREE_CODE (type) == ARRAY_TYPE
11420       && COMPLETE_TYPE_P (type)
11421       && TREE_OVERFLOW (TYPE_SIZE (type)))
11422     {
11423       error ("size of array `%s' is too large", name);
11424       /* If we proceed with the array type as it is, we'll eventually
11425          crash in tree_low_cst().  */
11426       type = error_mark_node;
11427     }
11428
11429   if (decl_context == FIELD
11430       && !processing_template_decl
11431       && variably_modified_type_p (type))
11432     {
11433       error ("data member may not have variably modified type `%T'", type);
11434       type = error_mark_node;
11435     }
11436
11437   if (explicitp == 1 || (explicitp && friendp))
11438     {
11439       /* [dcl.fct.spec] The explicit specifier shall only be used in
11440          declarations of constructors within a class definition.  */
11441       error ("only declarations of constructors can be `explicit'");
11442       explicitp = 0;
11443     }
11444
11445   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11446     {
11447       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11448         {
11449           error ("non-member `%s' cannot be declared `mutable'", name);
11450           RIDBIT_RESET (RID_MUTABLE, specbits);
11451         }
11452       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11453         {
11454           error ("non-object member `%s' cannot be declared `mutable'", name);
11455           RIDBIT_RESET (RID_MUTABLE, specbits);
11456         }
11457       else if (TREE_CODE (type) == FUNCTION_TYPE
11458                || TREE_CODE (type) == METHOD_TYPE)
11459         {
11460           error ("function `%s' cannot be declared `mutable'", name);
11461           RIDBIT_RESET (RID_MUTABLE, specbits);
11462         }
11463       else if (staticp)
11464         {
11465           error ("static `%s' cannot be declared `mutable'", name);
11466           RIDBIT_RESET (RID_MUTABLE, specbits);
11467         }
11468       else if (type_quals & TYPE_QUAL_CONST)
11469         {
11470           error ("const `%s' cannot be declared `mutable'", name);
11471           RIDBIT_RESET (RID_MUTABLE, specbits);
11472         }
11473     }
11474
11475   if (declarator == NULL_TREE
11476       || TREE_CODE (declarator) == IDENTIFIER_NODE
11477       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11478           && (TREE_CODE (type) == FUNCTION_TYPE
11479               || TREE_CODE (type) == METHOD_TYPE)))
11480     /* OK */;
11481   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11482     {
11483       error ("template-id `%D' used as a declarator", declarator);
11484       declarator = dname;
11485     }
11486   else
11487     /* Unexpected declarator format.  */
11488     abort ();
11489
11490   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11491
11492   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11493     {
11494       tree decl;
11495
11496       /* Note that the grammar rejects storage classes
11497          in typenames, fields or parameters.  */
11498       if (current_lang_name == lang_name_java)
11499         TYPE_FOR_JAVA (type) = 1;
11500
11501       if (decl_context == FIELD)
11502         {
11503           if (constructor_name_p (declarator, current_class_type))
11504             pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11505                         declarator);
11506           decl = build_lang_decl (TYPE_DECL, declarator, type);
11507         }
11508       else
11509         {
11510           decl = build_decl (TYPE_DECL, declarator, type);
11511           if (in_namespace || ctype)
11512             cp_error_at ("typedef name may not be a nested-name-specifier",
11513                          decl);
11514           if (!current_function_decl)
11515             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11516         }
11517
11518       /* If the user declares "typedef struct {...} foo" then the
11519          struct will have an anonymous name.  Fill that name in now.
11520          Nothing can refer to it, so nothing needs know about the name
11521          change.  */
11522       if (type != error_mark_node
11523           && declarator
11524           && TYPE_NAME (type)
11525           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11526           && TYPE_ANONYMOUS_P (type)
11527           /* Don't do this if there are attributes.  */
11528           && (!attrlist || !*attrlist)
11529           && cp_type_quals (type) == TYPE_UNQUALIFIED)
11530         {
11531           tree oldname = TYPE_NAME (type);
11532           tree t;
11533
11534           /* Replace the anonymous name with the real name everywhere.  */
11535           lookup_tag_reverse (type, declarator);
11536           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11537             if (TYPE_NAME (t) == oldname)
11538               TYPE_NAME (t) = decl;
11539
11540           if (TYPE_LANG_SPECIFIC (type))
11541             TYPE_WAS_ANONYMOUS (type) = 1;
11542
11543           /* If this is a typedef within a template class, the nested
11544              type is a (non-primary) template.  The name for the
11545              template needs updating as well.  */
11546           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11547             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11548               = TYPE_IDENTIFIER (type);
11549
11550           /* FIXME remangle member functions; member functions of a
11551              type with external linkage have external linkage.  */
11552         }
11553
11554       if (quals)
11555         {
11556           if (ctype == NULL_TREE)
11557             {
11558               if (TREE_CODE (type) != METHOD_TYPE)
11559                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11560               else
11561                 ctype = TYPE_METHOD_BASETYPE (type);
11562             }
11563           if (ctype != NULL_TREE)
11564             grok_method_quals (ctype, decl, quals);
11565         }
11566
11567       if (RIDBIT_SETP (RID_SIGNED, specbits)
11568           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11569         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11570
11571       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11572                       inlinep, friendp, raises != NULL_TREE);
11573
11574       return decl;
11575     }
11576
11577   /* Detect the case of an array type of unspecified size
11578      which came, as such, direct from a typedef name.
11579      We must copy the type, so that the array's domain can be
11580      individually set by the object's initializer.  */
11581
11582   if (type && typedef_type
11583       && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
11584       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
11585     type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
11586
11587   /* Detect where we're using a typedef of function type to declare a
11588      function. last_function_parms will not be set, so we must create
11589      it now.  */
11590
11591   if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
11592     {
11593       tree decls = NULL_TREE;
11594       tree args;
11595
11596       for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
11597         {
11598           tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
11599
11600           TREE_CHAIN (decl) = decls;
11601           decls = decl;
11602         }
11603
11604       last_function_parms = nreverse (decls);
11605     }
11606
11607   /* If this is a type name (such as, in a cast or sizeof),
11608      compute the type and return it now.  */
11609
11610   if (decl_context == TYPENAME)
11611     {
11612       /* Note that the grammar rejects storage classes
11613          in typenames, fields or parameters.  */
11614       if (type_quals != TYPE_UNQUALIFIED)
11615         type_quals = TYPE_UNQUALIFIED;
11616
11617       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11618       if (friendp)
11619         {
11620           if (type_quals != TYPE_UNQUALIFIED)
11621             {
11622               error ("type qualifiers specified for friend class declaration");
11623               type_quals = TYPE_UNQUALIFIED;
11624             }
11625           if (inlinep)
11626             {
11627               error ("`inline' specified for friend class declaration");
11628               inlinep = 0;
11629             }
11630
11631           if (!current_aggr)
11632             {
11633               /* Don't allow friend declaration without a class-key.  */
11634               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11635                 pedwarn ("template parameters cannot be friends");
11636               else if (TREE_CODE (type) == TYPENAME_TYPE)
11637                 pedwarn ("friend declaration requires class-key, "
11638                          "i.e. `friend class %T::%D'",
11639                          TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
11640               else
11641                 pedwarn ("friend declaration requires class-key, "
11642                          "i.e. `friend %#T'",
11643                          type);
11644             }
11645
11646           /* Only try to do this stuff if we didn't already give up.  */
11647           if (type != integer_type_node)
11648             {
11649               decl_type_access_control (TYPE_NAME (type));
11650
11651               /* A friendly class?  */
11652               if (current_class_type)
11653                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11654               else
11655                 error ("trying to make class `%T' a friend of global scope",
11656                           type);
11657
11658               type = void_type_node;
11659             }
11660         }
11661       else if (quals)
11662         {
11663           if (ctype == NULL_TREE)
11664             {
11665               if (TREE_CODE (type) != METHOD_TYPE)
11666                 error ("invalid qualifiers on non-member function type");
11667               else
11668                 ctype = TYPE_METHOD_BASETYPE (type);
11669             }
11670           if (ctype)
11671             {
11672               tree dummy = build_decl (TYPE_DECL, declarator, type);
11673               grok_method_quals (ctype, dummy, quals);
11674               type = TREE_TYPE (dummy);
11675             }
11676         }
11677
11678       return type;
11679     }
11680   else if (declarator == NULL_TREE && decl_context != PARM
11681            && decl_context != CATCHPARM
11682            && TREE_CODE (type) != UNION_TYPE
11683            && ! bitfield)
11684     {
11685       error ("abstract declarator `%T' used as declaration", type);
11686       declarator = make_anon_name ();
11687     }
11688
11689   /* `void' at top level (not within pointer)
11690      is allowed only in typedefs or type names.
11691      We don't complain about parms either, but that is because
11692      a better error message can be made later.  */
11693
11694   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11695     {
11696       if (! declarator)
11697         error ("unnamed variable or field declared void");
11698       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11699         {
11700           if (IDENTIFIER_OPNAME_P (declarator))
11701             abort ();
11702           else
11703             error ("variable or field `%s' declared void", name);
11704         }
11705       else
11706         error ("variable or field declared void");
11707       type = integer_type_node;
11708     }
11709
11710   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11711      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11712
11713   if (decl_context == PARM || decl_context == CATCHPARM)
11714     {
11715       if (ctype || in_namespace)
11716         error ("cannot use `::' in parameter declaration");
11717
11718       /* A parameter declared as an array of T is really a pointer to T.
11719          One declared as a function is really a pointer to a function.
11720          One declared as a member is really a pointer to member.  */
11721
11722       if (TREE_CODE (type) == ARRAY_TYPE)
11723         {
11724           /* Transfer const-ness of array into that of type pointed to.  */
11725           type = build_pointer_type (TREE_TYPE (type));
11726           type_quals = TYPE_UNQUALIFIED;
11727         }
11728       else if (TREE_CODE (type) == FUNCTION_TYPE)
11729         type = build_pointer_type (type);
11730       else if (TREE_CODE (type) == OFFSET_TYPE)
11731         type = build_pointer_type (type);
11732     }
11733
11734   {
11735     register tree decl;
11736
11737     if (decl_context == PARM)
11738       {
11739         decl = cp_build_parm_decl (declarator, type);
11740
11741         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11742                         inlinep, friendp, raises != NULL_TREE);
11743       }
11744     else if (decl_context == FIELD)
11745       {
11746         if (type == error_mark_node)
11747           {
11748             /* Happens when declaring arrays of sizes which
11749                are error_mark_node, for example.  */
11750             decl = NULL_TREE;
11751           }
11752         else if (in_namespace && !friendp)
11753           {
11754             /* Something like struct S { int N::j; };  */
11755             error ("invalid use of `::'");
11756             decl = NULL_TREE;
11757           }
11758         else if (TREE_CODE (type) == FUNCTION_TYPE)
11759           {
11760             int publicp = 0;
11761             tree function_context;
11762
11763             /* We catch the others as conflicts with the builtin
11764                typedefs.  */
11765             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11766               {
11767                 error ("function `%D' cannot be declared friend",
11768                           declarator);
11769                 friendp = 0;
11770               }
11771
11772             if (friendp == 0)
11773               {
11774                 if (ctype == NULL_TREE)
11775                   ctype = current_class_type;
11776
11777                 if (ctype == NULL_TREE)
11778                   {
11779                     error ("can't make `%D' into a method -- not in a class",
11780                               declarator);
11781                     return void_type_node;
11782                   }
11783
11784                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11785                    ARM 9.5 */
11786                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11787                   {
11788                     error ("function `%D' declared virtual inside a union",
11789                               declarator);
11790                     return void_type_node;
11791                   }
11792
11793                 if (declarator == ansi_opname (NEW_EXPR)
11794                     || declarator == ansi_opname (VEC_NEW_EXPR)
11795                     || declarator == ansi_opname (DELETE_EXPR)
11796                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11797                   {
11798                     if (virtualp)
11799                       {
11800                         error ("`%D' cannot be declared virtual, since it is always static",
11801                                   declarator);
11802                         virtualp = 0;
11803                       }
11804                   }
11805                 else if (staticp < 2)
11806                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11807                                                   TYPE_ARG_TYPES (type));
11808               }
11809
11810             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11811             function_context = (ctype != NULL_TREE) ?
11812               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11813             publicp = (! friendp || ! staticp)
11814               && function_context == NULL_TREE;
11815             decl = grokfndecl (ctype, type,
11816                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11817                                ? declarator : dname,
11818                                declarator,
11819                                virtualp, flags, quals, raises,
11820                                friendp ? -1 : 0, friendp, publicp, inlinep,
11821                                funcdef_flag, template_count, in_namespace);
11822             if (decl == NULL_TREE)
11823               return decl;
11824 #if 0
11825             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11826             /* The decl and setting of decl_attr is also turned off.  */
11827             decl = build_decl_attribute_variant (decl, decl_attr);
11828 #endif
11829
11830             /* [class.conv.ctor]
11831
11832                A constructor declared without the function-specifier
11833                explicit that can be called with a single parameter
11834                specifies a conversion from the type of its first
11835                parameter to the type of its class.  Such a constructor
11836                is called a converting constructor.  */
11837             if (explicitp == 2)
11838               DECL_NONCONVERTING_P (decl) = 1;
11839             else if (DECL_CONSTRUCTOR_P (decl))
11840               {
11841                 /* The constructor can be called with exactly one
11842                    parameter if there is at least one parameter, and
11843                    any subsequent parameters have default arguments.
11844                    Ignore any compiler-added parms.  */
11845                 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
11846
11847                 if (arg_types == void_list_node
11848                     || (arg_types
11849                         && TREE_CHAIN (arg_types)
11850                         && TREE_CHAIN (arg_types) != void_list_node
11851                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11852                   DECL_NONCONVERTING_P (decl) = 1;
11853               }
11854           }
11855         else if (TREE_CODE (type) == METHOD_TYPE)
11856           {
11857             /* We only get here for friend declarations of
11858                members of other classes.  */
11859             /* All method decls are public, so tell grokfndecl to set
11860                TREE_PUBLIC, also.  */
11861             decl = grokfndecl (ctype, type, declarator, declarator,
11862                                virtualp, flags, quals, raises,
11863                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11864                                template_count, in_namespace);
11865             if (decl == NULL_TREE)
11866               return NULL_TREE;
11867           }
11868         else if (!staticp && ! processing_template_decl
11869                  && !COMPLETE_TYPE_P (complete_type (type))
11870                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11871           {
11872             if (declarator)
11873               error ("field `%D' has incomplete type", declarator);
11874             else
11875               error ("name `%T' has incomplete type", type);
11876
11877             /* If we're instantiating a template, tell them which
11878                instantiation made the field's type be incomplete.  */
11879             if (current_class_type
11880                 && TYPE_NAME (current_class_type)
11881                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11882                 && declspecs && TREE_VALUE (declspecs)
11883                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11884               error ("  in instantiation of template `%T'",
11885                         current_class_type);
11886
11887             type = error_mark_node;
11888             decl = NULL_TREE;
11889           }
11890         else
11891           {
11892             if (friendp)
11893               {
11894                 error ("`%s' is neither function nor member function; cannot be declared friend",
11895                        IDENTIFIER_POINTER (declarator));
11896                 friendp = 0;
11897               }
11898             decl = NULL_TREE;
11899           }
11900
11901         if (friendp)
11902           {
11903             /* Friends are treated specially.  */
11904             if (ctype == current_class_type)
11905               warning ("member functions are implicitly friends of their class");
11906             else
11907               {
11908                 tree t = NULL_TREE;
11909                 if (decl && DECL_NAME (decl))
11910                   {
11911                     if (template_class_depth (current_class_type) == 0)
11912                       {
11913                         decl
11914                           = check_explicit_specialization
11915                           (declarator, decl,
11916                            template_count, 2 * (funcdef_flag != 0) + 4);
11917                         if (decl == error_mark_node)
11918                           return error_mark_node;
11919                       }
11920
11921                     t = do_friend (ctype, declarator, decl,
11922                                    last_function_parms, *attrlist,
11923                                    flags, quals, funcdef_flag);
11924                   }
11925                 if (t && funcdef_flag)
11926                   return t;
11927
11928                 return void_type_node;
11929               }
11930           }
11931
11932         /* Structure field.  It may not be a function, except for C++ */
11933
11934         if (decl == NULL_TREE)
11935           {
11936             if (initialized)
11937               {
11938                 if (!staticp)
11939                   {
11940                     /* An attempt is being made to initialize a non-static
11941                        member.  But, from [class.mem]:
11942
11943                        4 A member-declarator can contain a
11944                        constant-initializer only if it declares a static
11945                        member (_class.static_) of integral or enumeration
11946                        type, see _class.static.data_.
11947
11948                        This used to be relatively common practice, but
11949                        the rest of the compiler does not correctly
11950                        handle the initialization unless the member is
11951                        static so we make it static below.  */
11952                     pedwarn ("ISO C++ forbids initialization of member `%D'",
11953                                 declarator);
11954                     pedwarn ("making `%D' static", declarator);
11955                     staticp = 1;
11956                   }
11957
11958                 if (uses_template_parms (type))
11959                   /* We'll check at instantiation time.  */
11960                   ;
11961                 else if (check_static_variable_definition (declarator,
11962                                                            type))
11963                   /* If we just return the declaration, crashes
11964                      will sometimes occur.  We therefore return
11965                      void_type_node, as if this was a friend
11966                      declaration, to cause callers to completely
11967                      ignore this declaration.  */
11968                   return void_type_node;
11969               }
11970
11971             /* 9.2p13 [class.mem] */
11972             if (constructor_name_p (declarator, current_class_type)
11973                 /* The standard does not allow non-static data members
11974                    here either, but we agreed at the 10/99 meeting
11975                    to change that in TC 1 so that they are allowed in
11976                    classes with no user-defined constructors.  */
11977                 && staticp)
11978               pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11979                           declarator);
11980
11981             if (staticp)
11982               {
11983                 /* C++ allows static class members.  All other work
11984                    for this is done by grokfield.  */
11985                 decl = build_lang_decl (VAR_DECL, declarator, type);
11986                 TREE_STATIC (decl) = 1;
11987                 /* In class context, 'static' means public access.  */
11988                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11989               }
11990             else
11991               {
11992                 decl = build_decl (FIELD_DECL, declarator, type);
11993                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11994                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11995                   {
11996                     DECL_MUTABLE_P (decl) = 1;
11997                     RIDBIT_RESET (RID_MUTABLE, specbits);
11998                   }
11999               }
12000
12001             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
12002                             inlinep, friendp, raises != NULL_TREE);
12003           }
12004       }
12005     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
12006       {
12007         tree original_name;
12008         int publicp = 0;
12009
12010         if (! declarator)
12011           return NULL_TREE;
12012
12013         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
12014           original_name = dname;
12015         else
12016           original_name = declarator;
12017
12018         if (RIDBIT_SETP (RID_AUTO, specbits))
12019           error ("storage class `auto' invalid for function `%s'", name);
12020         else if (RIDBIT_SETP (RID_REGISTER, specbits))
12021           error ("storage class `register' invalid for function `%s'", name);
12022         else if (RIDBIT_SETP (RID_THREAD, specbits))
12023           error ("storage class `__thread' invalid for function `%s'", name);
12024
12025         /* Function declaration not at top level.
12026            Storage classes other than `extern' are not allowed
12027            and `extern' makes no difference.  */
12028         if (! toplevel_bindings_p ()
12029             && (RIDBIT_SETP (RID_STATIC, specbits)
12030                 || RIDBIT_SETP (RID_INLINE, specbits))
12031             && pedantic)
12032           {
12033             if (RIDBIT_SETP (RID_STATIC, specbits))
12034               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
12035             else
12036               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
12037           }
12038
12039         if (ctype == NULL_TREE)
12040           {
12041             if (virtualp)
12042               {
12043                 error ("virtual non-class function `%s'", name);
12044                 virtualp = 0;
12045               }
12046           }
12047         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
12048           type = build_cplus_method_type (ctype, TREE_TYPE (type),
12049                                           TYPE_ARG_TYPES (type));
12050
12051         /* Record presence of `static'.  */
12052         publicp = (ctype != NULL_TREE
12053                    || RIDBIT_SETP (RID_EXTERN, specbits)
12054                    || !RIDBIT_SETP (RID_STATIC, specbits));
12055
12056         decl = grokfndecl (ctype, type, original_name, declarator,
12057                            virtualp, flags, quals, raises,
12058                            1, friendp,
12059                            publicp, inlinep, funcdef_flag,
12060                            template_count, in_namespace);
12061         if (decl == NULL_TREE)
12062           return NULL_TREE;
12063
12064         if (staticp == 1)
12065           {
12066             int invalid_static = 0;
12067
12068             /* Don't allow a static member function in a class, and forbid
12069                declaring main to be static.  */
12070             if (TREE_CODE (type) == METHOD_TYPE)
12071               {
12072                 pedwarn ("cannot declare member function `%D' to have static linkage", decl);
12073                 invalid_static = 1;
12074               }
12075             else if (current_function_decl)
12076               {
12077                 /* FIXME need arm citation */
12078                 error ("cannot declare static function inside another function");
12079                 invalid_static = 1;
12080               }
12081
12082             if (invalid_static)
12083               {
12084                 staticp = 0;
12085                 RIDBIT_RESET (RID_STATIC, specbits);
12086               }
12087           }
12088       }
12089     else
12090       {
12091         /* It's a variable.  */
12092
12093         /* An uninitialized decl with `extern' is a reference.  */
12094         decl = grokvardecl (type, declarator, &specbits,
12095                             initialized,
12096                             (type_quals & TYPE_QUAL_CONST) != 0,
12097                             ctype ? ctype : in_namespace);
12098         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
12099                         inlinep, friendp, raises != NULL_TREE);
12100
12101         if (ctype)
12102           {
12103             DECL_CONTEXT (decl) = ctype;
12104             if (staticp == 1)
12105               {
12106                 pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
12107                 staticp = 0;
12108                 RIDBIT_RESET (RID_STATIC, specbits);
12109               }
12110             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
12111               {
12112                 error ("static member `%D' declared `register'", decl);
12113                 RIDBIT_RESET (RID_REGISTER, specbits);
12114               }
12115             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
12116               {
12117                 pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
12118                             decl);
12119                 RIDBIT_RESET (RID_EXTERN, specbits);
12120               }
12121           }
12122       }
12123
12124     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
12125
12126     /* Record `register' declaration for warnings on &
12127        and in case doing stupid register allocation.  */
12128
12129     if (RIDBIT_SETP (RID_REGISTER, specbits))
12130       DECL_REGISTER (decl) = 1;
12131
12132     if (RIDBIT_SETP (RID_EXTERN, specbits))
12133       DECL_THIS_EXTERN (decl) = 1;
12134
12135     if (RIDBIT_SETP (RID_STATIC, specbits))
12136       DECL_THIS_STATIC (decl) = 1;
12137
12138     /* Record constancy and volatility.  There's no need to do this
12139        when processing a template; we'll do this for the instantiated
12140        declaration based on the type of DECL.  */
12141     if (!processing_template_decl)
12142       c_apply_type_quals_to_decl (type_quals, decl);
12143
12144     return decl;
12145   }
12146 }
12147 \f
12148 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
12149    An empty exprlist is a parmlist.  An exprlist which
12150    contains only identifiers at the global level
12151    is a parmlist.  Otherwise, it is an exprlist.  */
12152
12153 int
12154 parmlist_is_exprlist (exprs)
12155      tree exprs;
12156 {
12157   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
12158     return 0;
12159
12160   if (toplevel_bindings_p ())
12161     {
12162       /* At the global level, if these are all identifiers,
12163          then it is a parmlist.  */
12164       while (exprs)
12165         {
12166           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
12167             return 1;
12168           exprs = TREE_CHAIN (exprs);
12169         }
12170       return 0;
12171     }
12172   return 1;
12173 }
12174
12175 /* Subroutine of start_function.  Ensure that each of the parameter
12176    types (as listed in PARMS) is complete, as is required for a
12177    function definition.  */
12178
12179 static void
12180 require_complete_types_for_parms (parms)
12181      tree parms;
12182 {
12183   for (; parms; parms = TREE_CHAIN (parms))
12184     {
12185       if (VOID_TYPE_P (TREE_TYPE (parms)))
12186         /* grokparms will have already issued an error */
12187         TREE_TYPE (parms) = error_mark_node;
12188       else if (complete_type_or_else (TREE_TYPE (parms), parms))
12189         layout_decl (parms, 0);
12190       else
12191         TREE_TYPE (parms) = error_mark_node;
12192     }
12193 }
12194
12195 /* Returns nonzero if T is a local variable.  */
12196
12197 int
12198 local_variable_p (t)
12199      tree t;
12200 {
12201   if ((TREE_CODE (t) == VAR_DECL
12202        /* A VAR_DECL with a context that is a _TYPE is a static data
12203           member.  */
12204        && !TYPE_P (CP_DECL_CONTEXT (t))
12205        /* Any other non-local variable must be at namespace scope.  */
12206        && !DECL_NAMESPACE_SCOPE_P (t))
12207       || (TREE_CODE (t) == PARM_DECL))
12208     return 1;
12209
12210   return 0;
12211 }
12212
12213 /* Returns nonzero if T is an automatic local variable or a label.
12214    (These are the declarations that need to be remapped when the code
12215    containing them is duplicated.)  */
12216
12217 int
12218 nonstatic_local_decl_p (t)
12219      tree t;
12220 {
12221   return ((local_variable_p (t) && !TREE_STATIC (t))
12222           || TREE_CODE (t) == LABEL_DECL
12223           || TREE_CODE (t) == RESULT_DECL);
12224 }
12225
12226 /* Like local_variable_p, but suitable for use as a tree-walking
12227    function.  */
12228
12229 static tree
12230 local_variable_p_walkfn (tp, walk_subtrees, data)
12231      tree *tp;
12232      int *walk_subtrees ATTRIBUTE_UNUSED;
12233      void *data ATTRIBUTE_UNUSED;
12234 {
12235   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
12236           ? *tp : NULL_TREE);
12237 }
12238
12239 /* Check that ARG, which is a default-argument expression for a
12240    parameter DECL, is valid.  Returns ARG, or ERROR_MARK_NODE, if
12241    something goes wrong.  DECL may also be a _TYPE node, rather than a
12242    DECL, if there is no DECL available.  */
12243
12244 tree
12245 check_default_argument (decl, arg)
12246      tree decl;
12247      tree arg;
12248 {
12249   tree var;
12250   tree decl_type;
12251
12252   if (TREE_CODE (arg) == DEFAULT_ARG)
12253     /* We get a DEFAULT_ARG when looking at an in-class declaration
12254        with a default argument.  Ignore the argument for now; we'll
12255        deal with it after the class is complete.  */
12256     return arg;
12257
12258   if (processing_template_decl || uses_template_parms (arg))
12259     /* We don't do anything checking until instantiation-time.  Note
12260        that there may be uninstantiated arguments even for an
12261        instantiated function, since default arguments are not
12262        instantiated until they are needed.  */
12263     return arg;
12264
12265   if (TYPE_P (decl))
12266     {
12267       decl_type = decl;
12268       decl = NULL_TREE;
12269     }
12270   else
12271     decl_type = TREE_TYPE (decl);
12272
12273   if (arg == error_mark_node
12274       || decl == error_mark_node
12275       || TREE_TYPE (arg) == error_mark_node
12276       || decl_type == error_mark_node)
12277     /* Something already went wrong.  There's no need to check
12278        further.  */
12279     return error_mark_node;
12280
12281   /* [dcl.fct.default]
12282
12283      A default argument expression is implicitly converted to the
12284      parameter type.  */
12285   if (!TREE_TYPE (arg)
12286       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
12287     {
12288       if (decl)
12289         error ("default argument for `%#D' has type `%T'",
12290                   decl, TREE_TYPE (arg));
12291       else
12292         error ("default argument for parameter of type `%T' has type `%T'",
12293                   decl_type, TREE_TYPE (arg));
12294
12295       return error_mark_node;
12296     }
12297
12298   /* [dcl.fct.default]
12299
12300      Local variables shall not be used in default argument
12301      expressions.
12302
12303      The keyword `this' shall not be used in a default argument of a
12304      member function.  */
12305   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
12306                                       NULL);
12307   if (var)
12308     {
12309       error ("default argument `%E' uses local variable `%D'",
12310                 arg, var);
12311       return error_mark_node;
12312     }
12313
12314   /* All is well.  */
12315   return arg;
12316 }
12317
12318 /* Decode the list of parameter types for a function type.
12319    Given the list of things declared inside the parens,
12320    return a list of types.
12321
12322    We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
12323    flag. If unset, we append void_list_node. A parmlist declared
12324    as `(void)' is accepted as the empty parmlist.
12325
12326    Also set last_function_parms to the chain of PARM_DECLs.  */
12327
12328 static tree
12329 grokparms (first_parm)
12330      tree first_parm;
12331 {
12332   tree result = NULL_TREE;
12333   tree decls = NULL_TREE;
12334   int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
12335   tree parm, chain;
12336   int any_error = 0;
12337
12338   my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
12339
12340   for (parm = first_parm; parm != NULL_TREE; parm = chain)
12341     {
12342       tree type = NULL_TREE;
12343       tree decl = TREE_VALUE (parm);
12344       tree init = TREE_PURPOSE (parm);
12345       tree specs, attrs;
12346
12347       chain = TREE_CHAIN (parm);
12348       /* @@ weak defense against parse errors.  */
12349       if (TREE_CODE (decl) != VOID_TYPE
12350           && TREE_CODE (decl) != TREE_LIST)
12351         {
12352           /* Give various messages as the need arises.  */
12353           if (TREE_CODE (decl) == STRING_CST)
12354             error ("invalid string constant `%E'", decl);
12355           else if (TREE_CODE (decl) == INTEGER_CST)
12356             error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12357           continue;
12358         }
12359
12360       if (parm == void_list_node)
12361         break;
12362
12363       split_specs_attrs (TREE_PURPOSE (decl), &specs, &attrs);
12364       decl = grokdeclarator (TREE_VALUE (decl), specs,
12365                              PARM, init != NULL_TREE, &attrs);
12366       if (! decl || TREE_TYPE (decl) == error_mark_node)
12367         continue;
12368
12369       if (attrs)
12370         cplus_decl_attributes (&decl, attrs, 0);
12371
12372       type = TREE_TYPE (decl);
12373       if (VOID_TYPE_P (type))
12374         {
12375           if (same_type_p (type, void_type_node)
12376               && !DECL_NAME (decl) && !result && !chain && !ellipsis)
12377             /* this is a parmlist of `(void)', which is ok.  */
12378             break;
12379           cxx_incomplete_type_error (decl, type);
12380           /* It's not a good idea to actually create parameters of
12381              type `void'; other parts of the compiler assume that a
12382              void type terminates the parameter list.  */
12383           type = error_mark_node;
12384           TREE_TYPE (decl) = error_mark_node;
12385         }
12386
12387       if (type != error_mark_node)
12388         {
12389           /* Top-level qualifiers on the parameters are
12390              ignored for function types.  */
12391           type = TYPE_MAIN_VARIANT (type);
12392           if (TREE_CODE (type) == METHOD_TYPE)
12393             {
12394               error ("parameter `%D' invalidly declared method type", decl);
12395               type = build_pointer_type (type);
12396               TREE_TYPE (decl) = type;
12397             }
12398           else if (TREE_CODE (type) == OFFSET_TYPE)
12399             {
12400               error ("parameter `%D' invalidly declared offset type", decl);
12401               type = build_pointer_type (type);
12402               TREE_TYPE (decl) = type;
12403             }
12404           else if (abstract_virtuals_error (decl, type))
12405             any_error = 1;  /* Seems like a good idea.  */
12406           else if (POINTER_TYPE_P (type))
12407             {
12408               /* [dcl.fct]/6, parameter types cannot contain pointers
12409                  (references) to arrays of unknown bound.  */
12410               tree t = TREE_TYPE (type);
12411               int ptr = TYPE_PTR_P (type);
12412
12413               while (1)
12414                 {
12415                   if (TYPE_PTR_P (t))
12416                     ptr = 1;
12417                   else if (TREE_CODE (t) != ARRAY_TYPE)
12418                     break;
12419                   else if (!TYPE_DOMAIN (t))
12420                     break;
12421                   t = TREE_TYPE (t);
12422                 }
12423               if (TREE_CODE (t) == ARRAY_TYPE)
12424                 error ("parameter `%D' includes %s to array of unknown bound `%T'",
12425                           decl, ptr ? "pointer" : "reference", t);
12426             }
12427
12428           if (!any_error && init)
12429             init = check_default_argument (decl, init);
12430           else
12431             init = NULL_TREE;
12432         }
12433
12434       TREE_CHAIN (decl) = decls;
12435       decls = decl;
12436       result = tree_cons (init, type, result);
12437     }
12438   decls = nreverse (decls);
12439   result = nreverse (result);
12440   if (!ellipsis)
12441     result = chainon (result, void_list_node);
12442   last_function_parms = decls;
12443
12444   return result;
12445 }
12446
12447 \f
12448 /* D is a constructor or overloaded `operator='.
12449
12450    Let T be the class in which D is declared. Then, this function
12451    returns:
12452
12453    -1 if D's is an ill-formed constructor or copy assignment operator
12454       whose first parameter is of type `T'.
12455    0  if D is not a copy constructor or copy assignment
12456       operator.
12457    1  if D is a copy constructor or copy assignment operator whose
12458       first parameter is a reference to const qualified T.
12459    2  if D is a copy constructor or copy assignment operator whose
12460       first parameter is a reference to non-const qualified T.
12461
12462    This function can be used as a predicate. Positive values indicate
12463    a copy constructor and nonzero values indicate a copy assignment
12464    operator.  */
12465
12466 int
12467 copy_fn_p (d)
12468      tree d;
12469 {
12470   tree args;
12471   tree arg_type;
12472   int result = 1;
12473
12474   my_friendly_assert (DECL_FUNCTION_MEMBER_P (d), 20011208);
12475
12476   if (DECL_TEMPLATE_INFO (d) && is_member_template (DECL_TI_TEMPLATE (d)))
12477     /* Instantiations of template member functions are never copy
12478        functions.  Note that member functions of templated classes are
12479        represented as template functions internally, and we must
12480        accept those as copy functions.  */
12481     return 0;
12482
12483   args = FUNCTION_FIRST_USER_PARMTYPE (d);
12484   if (!args)
12485     return 0;
12486
12487   arg_type = TREE_VALUE (args);
12488
12489   if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
12490     {
12491       /* Pass by value copy assignment operator.  */
12492       result = -1;
12493     }
12494   else if (TREE_CODE (arg_type) == REFERENCE_TYPE
12495            && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
12496     {
12497       if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
12498         result = 2;
12499     }
12500   else
12501     return 0;
12502
12503   args = TREE_CHAIN (args);
12504
12505   if (args && args != void_list_node && !TREE_PURPOSE (args))
12506     /* There are more non-optional args.  */
12507     return 0;
12508
12509   return result;
12510 }
12511
12512 /* Remember any special properties of member function DECL.  */
12513
12514 void grok_special_member_properties (decl)
12515      tree decl;
12516 {
12517   if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl))
12518     ; /* Not special.  */
12519   else if (DECL_CONSTRUCTOR_P (decl))
12520     {
12521       int ctor = copy_fn_p (decl);
12522
12523       if (ctor > 0)
12524         {
12525           /* [class.copy]
12526
12527              A non-template constructor for class X is a copy
12528              constructor if its first parameter is of type X&, const
12529              X&, volatile X& or const volatile X&, and either there
12530              are no other parameters or else all other parameters have
12531              default arguments.  */
12532           TYPE_HAS_INIT_REF (DECL_CONTEXT (decl)) = 1;
12533           if (ctor > 1)
12534             TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl)) = 1;
12535         }
12536       else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
12537         TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl)) = 1;
12538     }
12539   else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
12540     {
12541       /* [class.copy]
12542
12543          A non-template assignment operator for class X is a copy
12544          assignment operator if its parameter is of type X, X&, const
12545          X&, volatile X& or const volatile X&.  */
12546
12547       int assop = copy_fn_p (decl);
12548
12549       if (assop)
12550         {
12551           TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12552           if (assop != 1)
12553             TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12554           if (DECL_PURE_VIRTUAL_P (decl))
12555             TYPE_HAS_ABSTRACT_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12556         }
12557     }
12558 }
12559
12560 /* Check a constructor DECL has the correct form.  Complains
12561    if the class has a constructor of the form X(X).  */
12562
12563 int
12564 grok_ctor_properties (ctype, decl)
12565      tree ctype, decl;
12566 {
12567   int ctor_parm = copy_fn_p (decl);
12568
12569   if (ctor_parm < 0)
12570     {
12571       /* [class.copy]
12572
12573          A declaration of a constructor for a class X is ill-formed if
12574          its first parameter is of type (optionally cv-qualified) X
12575          and either there are no other parameters or else all other
12576          parameters have default arguments.
12577
12578          We *don't* complain about member template instantiations that
12579          have this form, though; they can occur as we try to decide
12580          what constructor to use during overload resolution.  Since
12581          overload resolution will never prefer such a constructor to
12582          the non-template copy constructor (which is either explicitly
12583          or implicitly defined), there's no need to worry about their
12584          existence.  Theoretically, they should never even be
12585          instantiated, but that's hard to forestall.  */
12586       error ("invalid constructor; you probably meant `%T (const %T&)'",
12587                 ctype, ctype);
12588       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12589       return 0;
12590     }
12591
12592   return 1;
12593 }
12594
12595 /* An operator with this code is unary, but can also be binary.  */
12596
12597 static int
12598 ambi_op_p (code)
12599      enum tree_code code;
12600 {
12601   return (code == INDIRECT_REF
12602           || code == ADDR_EXPR
12603           || code == CONVERT_EXPR
12604           || code == NEGATE_EXPR
12605           || code == PREINCREMENT_EXPR
12606           || code == PREDECREMENT_EXPR);
12607 }
12608
12609 /* An operator with this name can only be unary.  */
12610
12611 static int
12612 unary_op_p (code)
12613      enum tree_code code;
12614 {
12615   return (code == TRUTH_NOT_EXPR
12616           || code == BIT_NOT_EXPR
12617           || code == COMPONENT_REF
12618           || code == TYPE_EXPR);
12619 }
12620
12621 /* Do a little sanity-checking on how they declared their operator.  */
12622
12623 void
12624 grok_op_properties (decl, friendp)
12625      tree decl;
12626      int friendp;
12627 {
12628   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12629   tree argtype;
12630   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12631   tree name = DECL_NAME (decl);
12632   enum tree_code operator_code;
12633   int arity;
12634
12635   /* Count the number of arguments.  */
12636   for (argtype = argtypes, arity = 0;
12637        argtype && argtype != void_list_node;
12638        argtype = TREE_CHAIN (argtype))
12639     ++arity;
12640
12641   if (current_class_type == NULL_TREE)
12642     friendp = 1;
12643
12644   if (DECL_CONV_FN_P (decl))
12645     operator_code = TYPE_EXPR;
12646   else
12647     do
12648       {
12649 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)       \
12650         if (ansi_opname (CODE) == name)                         \
12651           {                                                     \
12652             operator_code = (CODE);                             \
12653             break;                                              \
12654           }                                                     \
12655         else if (ansi_assopname (CODE) == name)                 \
12656           {                                                     \
12657             operator_code = (CODE);                             \
12658             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;              \
12659             break;                                              \
12660           }
12661
12662 #include "operators.def"
12663 #undef DEF_OPERATOR
12664
12665         abort ();
12666       }
12667     while (0);
12668   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12669   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12670
12671   if (! friendp)
12672     {
12673       switch (operator_code)
12674         {
12675         case CALL_EXPR:
12676           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12677           break;
12678
12679         case ARRAY_REF:
12680           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12681           break;
12682
12683         case COMPONENT_REF:
12684         case MEMBER_REF:
12685           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12686           break;
12687
12688         case NEW_EXPR:
12689           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12690           break;
12691
12692         case DELETE_EXPR:
12693           TYPE_GETS_DELETE (current_class_type) |= 1;
12694           break;
12695
12696         case VEC_NEW_EXPR:
12697           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12698           break;
12699
12700         case VEC_DELETE_EXPR:
12701           TYPE_GETS_DELETE (current_class_type) |= 2;
12702           break;
12703
12704         default:
12705           break;
12706         }
12707     }
12708
12709   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12710     {
12711       /* When the compiler encounters the definition of A::operator new, it
12712          doesn't look at the class declaration to find out if it's static.  */
12713       if (methodp)
12714         revert_static_member_fn (decl);
12715
12716       TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12717     }
12718   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12719     {
12720       if (methodp)
12721         revert_static_member_fn (decl);
12722
12723       TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12724     }
12725   else
12726     {
12727       /* An operator function must either be a non-static member function
12728          or have at least one parameter of a class, a reference to a class,
12729          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12730       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12731         {
12732           if (operator_code == TYPE_EXPR
12733               || operator_code == CALL_EXPR
12734               || operator_code == COMPONENT_REF
12735               || operator_code == ARRAY_REF
12736               || operator_code == NOP_EXPR)
12737             error ("`%D' must be a nonstatic member function", decl);
12738           else
12739             {
12740               tree p = argtypes;
12741
12742               if (DECL_STATIC_FUNCTION_P (decl))
12743                 error ("`%D' must be either a non-static member function or a non-member function", decl);
12744
12745               if (p)
12746                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12747                   {
12748                     tree arg = TREE_VALUE (p);
12749                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12750                       arg = TREE_TYPE (arg);
12751
12752                     /* This lets bad template code slip through.  */
12753                     if (IS_AGGR_TYPE (arg)
12754                         || TREE_CODE (arg) == ENUMERAL_TYPE
12755                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12756                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12757                       goto foundaggr;
12758                   }
12759               error
12760                 ("`%D' must have an argument of class or enumerated type",
12761                  decl);
12762             foundaggr:
12763               ;
12764             }
12765         }
12766
12767       if (operator_code == CALL_EXPR)
12768         return;                 /* No restrictions on args.  */
12769
12770       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12771         {
12772           tree t = TREE_TYPE (name);
12773           if (! friendp)
12774             {
12775               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12776               const char *what = 0;
12777
12778               if (ref)
12779                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12780
12781               if (TREE_CODE (t) == VOID_TYPE)
12782                 what = "void";
12783               else if (t == current_class_type)
12784                 what = "the same type";
12785               /* Don't force t to be complete here.  */
12786               else if (IS_AGGR_TYPE (t)
12787                        && COMPLETE_TYPE_P (t)
12788                        && DERIVED_FROM_P (t, current_class_type))
12789                 what = "a base class";
12790
12791               if (what)
12792                 warning ("conversion to %s%s will never use a type conversion operator",
12793                          ref ? "a reference to " : "", what);
12794             }
12795         }
12796       if (operator_code == COND_EXPR)
12797         {
12798           /* 13.4.0.3 */
12799           error ("ISO C++ prohibits overloading operator ?:");
12800         }
12801       else if (ambi_op_p (operator_code))
12802         {
12803           if (arity == 1)
12804             /* We pick the one-argument operator codes by default, so
12805                we don't have to change anything.  */
12806             ;
12807           else if (arity == 2)
12808             {
12809               /* If we thought this was a unary operator, we now know
12810                  it to be a binary operator.  */
12811               switch (operator_code)
12812                 {
12813                 case INDIRECT_REF:
12814                   operator_code = MULT_EXPR;
12815                   break;
12816
12817                 case ADDR_EXPR:
12818                   operator_code = BIT_AND_EXPR;
12819                   break;
12820
12821                 case CONVERT_EXPR:
12822                   operator_code = PLUS_EXPR;
12823                   break;
12824
12825                 case NEGATE_EXPR:
12826                   operator_code = MINUS_EXPR;
12827                   break;
12828
12829                 case PREINCREMENT_EXPR:
12830                   operator_code = POSTINCREMENT_EXPR;
12831                   break;
12832
12833                 case PREDECREMENT_EXPR:
12834                   operator_code = POSTDECREMENT_EXPR;
12835                   break;
12836
12837                 default:
12838                   abort ();
12839                 }
12840
12841               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12842
12843               if ((operator_code == POSTINCREMENT_EXPR
12844                    || operator_code == POSTDECREMENT_EXPR)
12845                   && ! processing_template_decl
12846                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12847                 {
12848                   if (methodp)
12849                     error ("postfix `%D' must take `int' as its argument",
12850                               decl);
12851                   else
12852                     error
12853                       ("postfix `%D' must take `int' as its second argument",
12854                        decl);
12855                 }
12856             }
12857           else
12858             {
12859               if (methodp)
12860                 error ("`%D' must take either zero or one argument", decl);
12861               else
12862                 error ("`%D' must take either one or two arguments", decl);
12863             }
12864
12865           /* More Effective C++ rule 6.  */
12866           if (warn_ecpp
12867               && (operator_code == POSTINCREMENT_EXPR
12868                   || operator_code == POSTDECREMENT_EXPR
12869                   || operator_code == PREINCREMENT_EXPR
12870                   || operator_code == PREDECREMENT_EXPR))
12871             {
12872               tree arg = TREE_VALUE (argtypes);
12873               tree ret = TREE_TYPE (TREE_TYPE (decl));
12874               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12875                 arg = TREE_TYPE (arg);
12876               arg = TYPE_MAIN_VARIANT (arg);
12877               if (operator_code == PREINCREMENT_EXPR
12878                   || operator_code == PREDECREMENT_EXPR)
12879                 {
12880                   if (TREE_CODE (ret) != REFERENCE_TYPE
12881                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12882                                        arg))
12883                     warning ("prefix `%D' should return `%T'", decl,
12884                                 build_reference_type (arg));
12885                 }
12886               else
12887                 {
12888                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12889                     warning ("postfix `%D' should return `%T'", decl, arg);
12890                 }
12891             }
12892         }
12893       else if (unary_op_p (operator_code))
12894         {
12895           if (arity != 1)
12896             {
12897               if (methodp)
12898                 error ("`%D' must take `void'", decl);
12899               else
12900                 error ("`%D' must take exactly one argument", decl);
12901             }
12902         }
12903       else /* if (binary_op_p (operator_code)) */
12904         {
12905           if (arity != 2)
12906             {
12907               if (methodp)
12908                 error ("`%D' must take exactly one argument", decl);
12909               else
12910                 error ("`%D' must take exactly two arguments", decl);
12911             }
12912
12913           /* More Effective C++ rule 7.  */
12914           if (warn_ecpp
12915               && (operator_code == TRUTH_ANDIF_EXPR
12916                   || operator_code == TRUTH_ORIF_EXPR
12917                   || operator_code == COMPOUND_EXPR))
12918             warning ("user-defined `%D' always evaluates both arguments",
12919                         decl);
12920         }
12921
12922       /* Effective C++ rule 23.  */
12923       if (warn_ecpp
12924           && arity == 2
12925           && !DECL_ASSIGNMENT_OPERATOR_P (decl)
12926           && (operator_code == PLUS_EXPR
12927               || operator_code == MINUS_EXPR
12928               || operator_code == TRUNC_DIV_EXPR
12929               || operator_code == MULT_EXPR
12930               || operator_code == TRUNC_MOD_EXPR)
12931           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12932         warning ("`%D' should return by value", decl);
12933
12934       /* [over.oper]/8 */
12935       for (; argtypes && argtypes != void_list_node;
12936           argtypes = TREE_CHAIN (argtypes))
12937         if (TREE_PURPOSE (argtypes))
12938           {
12939             TREE_PURPOSE (argtypes) = NULL_TREE;
12940             if (operator_code == POSTINCREMENT_EXPR
12941                 || operator_code == POSTDECREMENT_EXPR)
12942               {
12943                 if (pedantic)
12944                   pedwarn ("`%D' cannot have default arguments", decl);
12945               }
12946             else
12947               error ("`%D' cannot have default arguments", decl);
12948           }
12949
12950     }
12951 }
12952 \f
12953 static const char *
12954 tag_name (code)
12955      enum tag_types code;
12956 {
12957   switch (code)
12958     {
12959     case record_type:
12960       return "struct";
12961     case class_type:
12962       return "class";
12963     case union_type:
12964       return "union ";
12965     case enum_type:
12966       return "enum";
12967     default:
12968       abort ();
12969     }
12970 }
12971
12972 /* Get the struct, enum or union (CODE says which) with tag NAME.
12973    Define the tag as a forward-reference if it is not defined.
12974
12975    C++: If a class derivation is given, process it here, and report
12976    an error if multiple derivation declarations are not identical.
12977
12978    If this is a definition, come in through xref_tag and only look in
12979    the current frame for the name (since C++ allows new names in any
12980    scope.)  */
12981
12982 tree
12983 xref_tag (enum tag_types tag_code, tree name, tree attributes,
12984           bool globalize)
12985 {
12986   enum tree_code code;
12987   register tree ref, t;
12988   struct cp_binding_level *b = current_binding_level;
12989   tree context = NULL_TREE;
12990
12991   switch (tag_code)
12992     {
12993     case record_type:
12994     case class_type:
12995       code = RECORD_TYPE;
12996       break;
12997     case union_type:
12998       code = UNION_TYPE;
12999       break;
13000     case enum_type:
13001       code = ENUMERAL_TYPE;
13002       break;
13003     default:
13004       abort ();
13005     }
13006
13007   /* If a cross reference is requested, look up the type
13008      already defined for this tag and return it.  */
13009   if (TYPE_P (name))
13010     {
13011       t = name;
13012       name = TYPE_IDENTIFIER (t);
13013     }
13014   else
13015     t = IDENTIFIER_TYPE_VALUE (name);
13016
13017   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
13018   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
13019     {
13020       static int explained;
13021       tree shadowed;
13022
13023       warning ("`%s %T' declares a new type at namespace scope",
13024                   tag_name (tag_code), name);
13025       if (!explained++)
13026         warning ("  names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'",
13027                     tag_name (tag_code),
13028                     constructor_name (current_class_type),
13029                     TYPE_IDENTIFIER (t));
13030
13031       /* We need to remove the class scope binding for the
13032          TYPENAME_TYPE as otherwise poplevel_class gets confused.  */
13033       for (shadowed = b->class_shadowed;
13034            shadowed;
13035            shadowed = TREE_CHAIN (shadowed))
13036         if (TREE_TYPE (shadowed) == TYPE_NAME (t))
13037           {
13038             TREE_PURPOSE (shadowed) = NULL_TREE;
13039             break;
13040           }
13041     }
13042
13043   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
13044       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
13045     t = NULL_TREE;
13046
13047   if (! globalize)
13048     {
13049       /* If we know we are defining this tag, only look it up in
13050          this scope and don't try to find it as a type.  */
13051       ref = lookup_tag (code, name, b, 1);
13052     }
13053   else
13054     {
13055       if (t)
13056         {
13057           ref = follow_tag_typedef (t);
13058
13059           /* [dcl.type.elab] If the identifier resolves to a
13060              typedef-name or a template type-parameter, the
13061              elaborated-type-specifier is ill-formed.  */
13062           if (!ref)
13063             {
13064               pedwarn ("using typedef-name `%D' after `%s'",
13065                        TYPE_NAME (t), tag_name (tag_code));
13066               ref = t;
13067             }
13068           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
13069             error ("using template type parameter `%T' after `%s'",
13070                    t, tag_name (tag_code));
13071         }
13072       else
13073         ref = lookup_tag (code, name, b, 0);
13074
13075       if (! ref)
13076         {
13077           /* Try finding it as a type declaration.  If that wins,
13078              use it.  */
13079           ref = lookup_name (name, 1);
13080
13081           if (ref != NULL_TREE
13082               && processing_template_decl
13083               && DECL_CLASS_TEMPLATE_P (ref)
13084               && template_class_depth (current_class_type) == 0)
13085             /* Since GLOBALIZE is true, we're declaring a global
13086                template, so we want this type.  */
13087             ref = DECL_TEMPLATE_RESULT (ref);
13088
13089           if (ref && TREE_CODE (ref) == TYPE_DECL
13090               && TREE_CODE (TREE_TYPE (ref)) == code)
13091             ref = TREE_TYPE (ref);
13092           else
13093             ref = NULL_TREE;
13094         }
13095
13096       if (ref && current_class_type
13097           && template_class_depth (current_class_type)
13098           && PROCESSING_REAL_TEMPLATE_DECL_P ())
13099         {
13100           /* Since GLOBALIZE is nonzero, we are not looking at a
13101              definition of this tag.  Since, in addition, we are currently
13102              processing a (member) template declaration of a template
13103              class, we must be very careful; consider:
13104
13105                template <class X>
13106                struct S1
13107
13108                template <class U>
13109                struct S2
13110                { template <class V>
13111                friend struct S1; };
13112
13113              Here, the S2::S1 declaration should not be confused with the
13114              outer declaration.  In particular, the inner version should
13115              have a template parameter of level 2, not level 1.  This
13116              would be particularly important if the member declaration
13117              were instead:
13118
13119                template <class V = U> friend struct S1;
13120
13121              say, when we should tsubst into `U' when instantiating
13122              S2.  On the other hand, when presented with:
13123
13124                  template <class T>
13125                  struct S1 {
13126                    template <class U>
13127                    struct S2 {};
13128                    template <class U>
13129                    friend struct S2;
13130                  };
13131
13132               we must find the inner binding eventually.  We
13133               accomplish this by making sure that the new type we
13134               create to represent this declaration has the right
13135               TYPE_CONTEXT.  */
13136           context = TYPE_CONTEXT (ref);
13137           ref = NULL_TREE;
13138         }
13139     }
13140
13141   if (! ref)
13142     {
13143       /* If no such tag is yet defined, create a forward-reference node
13144          and record it as the "definition".
13145          When a real declaration of this type is found,
13146          the forward-reference will be altered into a real type.  */
13147       if (code == ENUMERAL_TYPE)
13148         {
13149           error ("use of enum `%#D' without previous declaration", name);
13150
13151           ref = make_node (ENUMERAL_TYPE);
13152
13153           /* Give the type a default layout like unsigned int
13154              to avoid crashing if it does not get defined.  */
13155           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
13156           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
13157           TYPE_USER_ALIGN (ref) = 0;
13158           TREE_UNSIGNED (ref) = 1;
13159           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
13160           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
13161           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
13162
13163           /* Enable us to recognize when a type is created in class context.
13164              To do nested classes correctly, this should probably be cleared
13165              out when we leave this classes scope.  Currently this in only
13166              done in `start_enum'.  */
13167
13168           pushtag (name, ref, globalize);
13169         }
13170       else
13171         {
13172           struct cp_binding_level *old_b = class_binding_level;
13173
13174           ref = make_aggr_type (code);
13175           TYPE_CONTEXT (ref) = context;
13176
13177 #ifdef NONNESTED_CLASSES
13178           /* Class types don't nest the way enums do.  */
13179           class_binding_level = (struct cp_binding_level *)0;
13180 #endif
13181           pushtag (name, ref, globalize);
13182           class_binding_level = old_b;
13183         }
13184     }
13185   else
13186     {
13187       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
13188         redeclare_class_template (ref, current_template_parms);
13189     }
13190
13191   TYPE_ATTRIBUTES (ref) = attributes;
13192
13193   return ref;
13194 }
13195
13196 tree
13197 xref_tag_from_type (old, id, globalize)
13198      tree old, id;
13199      int globalize;
13200 {
13201   enum tag_types tag_kind;
13202
13203   if (TREE_CODE (old) == RECORD_TYPE)
13204     tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
13205   else
13206     tag_kind  = union_type;
13207
13208   if (id == NULL_TREE)
13209     id = TYPE_IDENTIFIER (old);
13210
13211   return xref_tag (tag_kind, id, /*attributes=*/NULL_TREE, globalize);
13212 }
13213
13214 /* REF is a type (named NAME), for which we have just seen some
13215    baseclasses.  BINFO is a list of those baseclasses; the
13216    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
13217    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
13218    struct, or union.  */
13219
13220 void
13221 xref_basetypes (ref, binfo)
13222      tree ref;
13223      tree binfo;
13224 {
13225   /* In the declaration `A : X, Y, ... Z' we mark all the types
13226      (A, X, Y, ..., Z) so we can check for duplicates.  */
13227   tree binfos;
13228   tree base;
13229
13230   int i, len;
13231   enum tag_types tag_code;
13232
13233   if (TREE_CODE (ref) == UNION_TYPE)
13234     {
13235       error ("derived union `%T' invalid", ref);
13236       return;
13237     }
13238
13239   tag_code = (CLASSTYPE_DECLARED_CLASS (ref) ? class_type : record_type);
13240
13241   len = list_length (binfo);
13242
13243   /* First, make sure that any templates in base-classes are
13244      instantiated.  This ensures that if we call ourselves recursively
13245      we do not get confused about which classes are marked and which
13246      are not.  */
13247   for (base = binfo; base; base = TREE_CHAIN (base))
13248     complete_type (TREE_VALUE (base));
13249
13250   SET_CLASSTYPE_MARKED (ref);
13251   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
13252
13253   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
13254     {
13255       /* The base of a derived struct is public by default.  */
13256       int via_public
13257         = (TREE_PURPOSE (binfo) == access_public_node
13258            || TREE_PURPOSE (binfo) == access_public_virtual_node
13259            || (tag_code != class_type
13260                && (TREE_PURPOSE (binfo) == access_default_node
13261                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
13262       int via_protected
13263         = (TREE_PURPOSE (binfo) == access_protected_node
13264            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
13265       int via_virtual
13266         = (TREE_PURPOSE (binfo) == access_private_virtual_node
13267            || TREE_PURPOSE (binfo) == access_protected_virtual_node
13268            || TREE_PURPOSE (binfo) == access_public_virtual_node
13269            || TREE_PURPOSE (binfo) == access_default_virtual_node);
13270       tree basetype = TREE_VALUE (binfo);
13271       tree base_binfo;
13272
13273       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
13274         basetype = TREE_TYPE (basetype);
13275       if (!basetype
13276           || (TREE_CODE (basetype) != RECORD_TYPE
13277               && TREE_CODE (basetype) != TYPENAME_TYPE
13278               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
13279               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
13280         {
13281           error ("base type `%T' fails to be a struct or class type",
13282                     TREE_VALUE (binfo));
13283           continue;
13284         }
13285
13286       /* This code replaces similar code in layout_basetypes.
13287          We put the complete_type first for implicit `typename'.  */
13288       if (!COMPLETE_TYPE_P (basetype)
13289           && ! (current_template_parms && uses_template_parms (basetype)))
13290         {
13291           error ("base class `%T' has incomplete type", basetype);
13292           continue;
13293         }
13294       else
13295         {
13296           if (CLASSTYPE_MARKED (basetype))
13297             {
13298               if (basetype == ref)
13299                 error ("recursive type `%T' undefined", basetype);
13300               else
13301                 error ("duplicate base type `%T' invalid", basetype);
13302               continue;
13303             }
13304
13305           if (TYPE_FOR_JAVA (basetype)
13306               && (current_lang_depth () == 0))
13307             TYPE_FOR_JAVA (ref) = 1;
13308
13309           /* Note that the BINFO records which describe individual
13310              inheritances are *not* shared in the lattice!  They
13311              cannot be shared because a given baseclass may be
13312              inherited with different `accessibility' by different
13313              derived classes.  (Each BINFO record describing an
13314              individual inheritance contains flags which say what
13315              the `accessibility' of that particular inheritance is.)  */
13316
13317           base_binfo
13318             = make_binfo (size_zero_node, basetype,
13319                           CLASS_TYPE_P (basetype)
13320                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13321                           CLASS_TYPE_P (basetype)
13322                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13323
13324           TREE_VEC_ELT (binfos, i) = base_binfo;
13325           TREE_VIA_PUBLIC (base_binfo) = via_public;
13326           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13327           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13328           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13329
13330           /* We need to unshare the binfos now so that lookups during class
13331              definition work.  */
13332           unshare_base_binfos (base_binfo);
13333
13334           SET_CLASSTYPE_MARKED (basetype);
13335
13336           /* We are free to modify these bits because they are meaningless
13337              at top level, and BASETYPE is a top-level type.  */
13338           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13339             {
13340               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13341               /* Converting to a virtual base class requires looking
13342                  up the offset of the virtual base.  */
13343               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13344             }
13345
13346           if (CLASS_TYPE_P (basetype))
13347             {
13348               TYPE_HAS_NEW_OPERATOR (ref)
13349                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13350               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13351                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13352               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13353               /* If the base-class uses multiple inheritance, so do we.  */
13354               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13355                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13356               /* Likewise, if converting to a base of the base may require
13357                  code, then we may need to generate code to convert to a
13358                  base as well.  */
13359               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13360                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13361             }
13362
13363           i += 1;
13364         }
13365     }
13366   if (i)
13367     TREE_VEC_LENGTH (binfos) = i;
13368   else
13369     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13370
13371   if (i > 1)
13372     {
13373       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13374       /* If there is more than one non-empty they cannot be at the same
13375          address.  */
13376       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13377     }
13378
13379   /* Unmark all the types.  */
13380   while (--i >= 0)
13381     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13382   CLEAR_CLASSTYPE_MARKED (ref);
13383
13384   /* Now that we know all the base-classes, set up the list of virtual
13385      bases.  */
13386   get_vbase_types (ref);
13387 }
13388
13389 \f
13390 /* Begin compiling the definition of an enumeration type.
13391    NAME is its name (or null if anonymous).
13392    Returns the type object, as yet incomplete.
13393    Also records info about it so that build_enumerator
13394    may be used to declare the individual values as they are read.  */
13395
13396 tree
13397 start_enum (name)
13398      tree name;
13399 {
13400   register tree enumtype = NULL_TREE;
13401   struct cp_binding_level *b = current_binding_level;
13402
13403   /* If this is the real definition for a previous forward reference,
13404      fill in the contents in the same object that used to be the
13405      forward reference.  */
13406
13407   if (name != NULL_TREE)
13408     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13409
13410   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13411     {
13412       error ("multiple definition of `%#T'", enumtype);
13413       cp_error_at ("previous definition here", enumtype);
13414       /* Clear out TYPE_VALUES, and start again.  */
13415       TYPE_VALUES (enumtype) = NULL_TREE;
13416     }
13417   else
13418     {
13419       enumtype = make_node (ENUMERAL_TYPE);
13420       pushtag (name, enumtype, 0);
13421     }
13422
13423   return enumtype;
13424 }
13425
13426 /* After processing and defining all the values of an enumeration type,
13427    install their decls in the enumeration type and finish it off.
13428    ENUMTYPE is the type object and VALUES a list of name-value pairs.  */
13429
13430 void
13431 finish_enum (enumtype)
13432      tree enumtype;
13433 {
13434   tree pair;
13435   tree minnode;
13436   tree maxnode;
13437   tree t;
13438   bool unsignedp;
13439   int lowprec;
13440   int highprec;
13441   int precision;
13442
13443   /* We built up the VALUES in reverse order.  */
13444   TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
13445
13446   /* [dcl.enum]
13447
13448      Following the closing brace of an enum-specifier, each
13449      enumerator has the type of its enumeration.  Prior to the
13450      closing brace, the type of each enumerator is the type of
13451      its initializing value.  */
13452   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13453     TREE_TYPE (TREE_VALUE (pair)) = enumtype;
13454
13455   /* For an enum defined in a template, all further processing is
13456      postponed until the template is instantiated.  */
13457   if (processing_template_decl)
13458     {
13459       if (at_function_scope_p ())
13460         add_stmt (build_min (TAG_DEFN, enumtype));
13461       return;
13462     }
13463
13464   /* Figure out what the minimum and maximum values of the enumerators
13465      are.  */
13466   if (TYPE_VALUES (enumtype))
13467     {
13468       minnode = maxnode = NULL_TREE;
13469
13470       for (pair = TYPE_VALUES (enumtype);
13471            pair;
13472            pair = TREE_CHAIN (pair))
13473         {
13474           tree value;
13475
13476           value = DECL_INITIAL (TREE_VALUE (pair));
13477
13478           if (!minnode)
13479             minnode = maxnode = value;
13480           else if (tree_int_cst_lt (maxnode, value))
13481             maxnode = value;
13482           else if (tree_int_cst_lt (value, minnode))
13483             minnode = value;
13484         }
13485     }
13486   else
13487     minnode = maxnode = integer_zero_node;
13488
13489   /* Compute the number of bits require to represent all values of the
13490      enumeration.  We must do this before the type of MINNODE and
13491      MAXNODE are transformed, since min_precision relies on the
13492      TREE_TYPE of the value it is passed.  */
13493   unsignedp = tree_int_cst_sgn (minnode) >= 0;
13494   lowprec = min_precision (minnode, unsignedp);
13495   highprec = min_precision (maxnode, unsignedp);
13496   precision = MAX (lowprec, highprec);
13497
13498   /* Set the TREE_TYPE for the values as well.  That's so that when we
13499      call decl_constant_value we get an entity of the right type (but
13500      with the constant value).  In addition, transform the TYPE_VALUES
13501      list to contain the values, rather than the CONST_DECLs for them.  */
13502   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13503     {
13504       tree value = DECL_INITIAL (TREE_VALUE (pair));
13505
13506       TREE_TYPE (value) = enumtype;
13507       TREE_VALUE (pair) = value;
13508     }
13509
13510   /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13511   TYPE_SIZE (enumtype) = NULL_TREE;
13512   TYPE_PRECISION (enumtype) = precision;
13513   if (unsignedp)
13514     fixup_unsigned_type (enumtype);
13515   else
13516     fixup_signed_type (enumtype);
13517
13518   if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13519     /* Use the width of the narrowest normal C type which is wide
13520        enough.  */
13521     TYPE_PRECISION (enumtype) = TYPE_PRECISION (c_common_type_for_size
13522                                                 (precision, 1));
13523   else
13524     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13525
13526   TYPE_SIZE (enumtype) = NULL_TREE;
13527   layout_type (enumtype);
13528
13529   /* Fix up all variant types of this enum type.  */
13530   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13531     {
13532       TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13533       TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
13534       TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
13535       TYPE_SIZE (t) = TYPE_SIZE (enumtype);
13536       TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
13537       TYPE_MODE (t) = TYPE_MODE (enumtype);
13538       TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
13539       TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
13540       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
13541       TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype);
13542     }
13543
13544   /* Finish debugging output for this type.  */
13545   rest_of_type_compilation (enumtype, namespace_bindings_p ());
13546 }
13547
13548 /* Build and install a CONST_DECL for an enumeration constant of the
13549    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13550    Assignment of sequential values by default is handled here.  */
13551
13552 void
13553 build_enumerator (name, value, enumtype)
13554      tree name;
13555      tree value;
13556      tree enumtype;
13557 {
13558   tree decl;
13559   tree context;
13560   tree type;
13561   tree values;
13562
13563   /* Remove no-op casts from the value.  */
13564   if (value)
13565     STRIP_TYPE_NOPS (value);
13566
13567   if (! processing_template_decl)
13568     {
13569       /* Validate and default VALUE.  */
13570       if (value != NULL_TREE)
13571         {
13572           value = decl_constant_value (value);
13573
13574           if (TREE_CODE (value) == INTEGER_CST)
13575             {
13576               value = default_conversion (value);
13577               constant_expression_warning (value);
13578             }
13579           else
13580             {
13581               error ("enumerator value for `%D' not integer constant", name);
13582               value = NULL_TREE;
13583             }
13584         }
13585
13586       /* Default based on previous value.  */
13587       if (value == NULL_TREE && ! processing_template_decl)
13588         {
13589           tree prev_value;
13590
13591           if (TYPE_VALUES (enumtype))
13592             {
13593               /* The next value is the previous value ...  */
13594               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13595               /* ... plus one.  */
13596               value = cp_build_binary_op (PLUS_EXPR,
13597                                           prev_value,
13598                                           integer_one_node);
13599
13600               if (tree_int_cst_lt (value, prev_value))
13601                 error ("overflow in enumeration values at `%D'", name);
13602             }
13603           else
13604             value = integer_zero_node;
13605         }
13606
13607       /* Remove no-op casts from the value.  */
13608       if (value)
13609         STRIP_TYPE_NOPS (value);
13610 #if 0
13611       /* To fix MAX_VAL enum consts. (bkoz)  */
13612       TREE_TYPE (value) = integer_type_node;
13613 #endif
13614     }
13615
13616   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13617      Even in other cases, we will later (in finish_enum) be setting
13618      the type of VALUE.  But, we don't need to make a copy if this
13619      VALUE is one of the enumeration constants for this same
13620      enumeration type.  */
13621   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13622     if (TREE_VALUE (values) == value)
13623       break;
13624   /* If we didn't break out of the loop, then we do need a copy.  */
13625   if (!values && value)
13626     value = copy_node (value);
13627
13628   /* C++ associates enums with global, function, or class declarations.  */
13629   context = current_scope ();
13630
13631   /* Build the actual enumeration constant.  Note that the enumeration
13632     constants have the type of their initializers until the
13633     enumeration is complete:
13634
13635       [ dcl.enum ]
13636
13637       Following the closing brace of an enum-specifier, each enumer-
13638       ator has the type of its enumeration.  Prior to the closing
13639       brace, the type of each enumerator is the type of its
13640       initializing value.
13641
13642     In finish_enum we will reset the type.  Of course, if we're
13643     processing a template, there may be no value.  */
13644   type = value ? TREE_TYPE (value) : NULL_TREE;
13645
13646   if (context && context == current_class_type)
13647     /* This enum declaration is local to the class.  We need the full
13648        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13649     decl = build_lang_decl (CONST_DECL, name, type);
13650   else
13651     /* It's a global enum, or it's local to a function.  (Note local to
13652       a function could mean local to a class method.  */
13653     decl = build_decl (CONST_DECL, name, type);
13654
13655   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13656   DECL_INITIAL (decl) = value;
13657   TREE_READONLY (decl) = 1;
13658
13659   if (context && context == current_class_type)
13660     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13661       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13662       things like `S::i' later.)  */
13663     finish_member_declaration (decl);
13664   else
13665     pushdecl (decl);
13666
13667   /* Add this enumeration constant to the list for this type.  */
13668   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13669 }
13670
13671 \f
13672 /* We're defining DECL.  Make sure that it's type is OK.  */
13673
13674 static void
13675 check_function_type (decl, current_function_parms)
13676      tree decl;
13677      tree current_function_parms;
13678 {
13679   tree fntype = TREE_TYPE (decl);
13680   tree return_type = complete_type (TREE_TYPE (fntype));
13681
13682   /* In a function definition, arg types must be complete.  */
13683   require_complete_types_for_parms (current_function_parms);
13684
13685   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13686     {
13687       error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13688
13689       /* Make it return void instead, but don't change the
13690          type of the DECL_RESULT, in case we have a named return value.  */
13691       if (TREE_CODE (fntype) == METHOD_TYPE)
13692         {
13693           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13694           TREE_TYPE (decl)
13695             = build_cplus_method_type (ctype,
13696                                        void_type_node,
13697                                        FUNCTION_ARG_CHAIN (decl));
13698         }
13699       else
13700         TREE_TYPE (decl)
13701           = build_function_type (void_type_node,
13702                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13703       TREE_TYPE (decl)
13704         = build_exception_variant (fntype,
13705                                    TYPE_RAISES_EXCEPTIONS (fntype));
13706     }
13707   else
13708     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13709 }
13710
13711 /* Create the FUNCTION_DECL for a function definition.
13712    DECLSPECS and DECLARATOR are the parts of the declaration;
13713    they describe the function's name and the type it returns,
13714    but twisted together in a fashion that parallels the syntax of C.
13715
13716    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13717    DECLARATOR is really the DECL for the function we are about to
13718    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13719    indicating that the function is an inline defined in-class.
13720
13721    This function creates a binding context for the function body
13722    as well as setting up the FUNCTION_DECL in current_function_decl.
13723
13724    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13725    (it defines a datum instead), we return 0, which tells
13726    yyparse to report a parse error.
13727
13728    For C++, we must first check whether that datum makes any sense.
13729    For example, "class A local_a(1,2);" means that variable local_a
13730    is an aggregate of type A, which should have a constructor
13731    applied to it with the argument list [1, 2].  */
13732
13733 int
13734 start_function (declspecs, declarator, attrs, flags)
13735      tree declspecs, declarator, attrs;
13736      int flags;
13737 {
13738   tree decl1;
13739   tree ctype = NULL_TREE;
13740   tree fntype;
13741   tree restype;
13742   int doing_friend = 0;
13743   struct cp_binding_level *bl;
13744   tree current_function_parms;
13745
13746   /* Sanity check.  */
13747   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13748   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13749
13750   /* This should only be done once on the top most decl.  */
13751   if (have_extern_spec)
13752     {
13753       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13754       have_extern_spec = false;
13755     }
13756
13757   if (flags & SF_PRE_PARSED)
13758     {
13759       decl1 = declarator;
13760
13761       fntype = TREE_TYPE (decl1);
13762       if (TREE_CODE (fntype) == METHOD_TYPE)
13763         ctype = TYPE_METHOD_BASETYPE (fntype);
13764
13765       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13766          the (lexical) scope of the class in which it is defined.  */
13767       if (!ctype && DECL_FRIEND_P (decl1))
13768         {
13769           ctype = DECL_FRIEND_CONTEXT (decl1);
13770
13771           /* CTYPE could be null here if we're dealing with a template;
13772              for example, `inline friend float foo()' inside a template
13773              will have no CTYPE set.  */
13774           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13775             ctype = NULL_TREE;
13776           else
13777             doing_friend = 1;
13778         }
13779
13780       last_function_parms = DECL_ARGUMENTS (decl1);
13781     }
13782   else
13783     {
13784       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL);
13785       /* If the declarator is not suitable for a function definition,
13786          cause a syntax error.  */
13787       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
13788         return 0;
13789
13790       cplus_decl_attributes (&decl1, attrs, 0);
13791
13792       /* If #pragma weak was used, mark the decl weak now.  */
13793       if (current_binding_level == global_binding_level)
13794         maybe_apply_pragma_weak (decl1);
13795
13796       fntype = TREE_TYPE (decl1);
13797
13798       restype = TREE_TYPE (fntype);
13799       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13800         {
13801           error ("semicolon missing after declaration of `%#T'", restype);
13802           shadow_tag (build_tree_list (NULL_TREE, restype));
13803           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13804           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13805             fntype = build_function_type (integer_type_node,
13806                                           TYPE_ARG_TYPES (fntype));
13807           else
13808             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13809                                               integer_type_node,
13810                                               TYPE_ARG_TYPES (fntype));
13811           TREE_TYPE (decl1) = fntype;
13812         }
13813
13814       if (TREE_CODE (fntype) == METHOD_TYPE)
13815         ctype = TYPE_METHOD_BASETYPE (fntype);
13816       else if (DECL_MAIN_P (decl1))
13817         {
13818           /* If this doesn't return integer_type, complain.  */
13819           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13820             {
13821               if (pedantic || warn_return_type)
13822                 pedwarn ("return type for `main' changed to `int'");
13823               TREE_TYPE (decl1) = fntype = default_function_type;
13824             }
13825         }
13826     }
13827
13828   if (DECL_DECLARED_INLINE_P (decl1)
13829       && lookup_attribute ("noinline", attrs))
13830     warning_with_decl (decl1,
13831                        "inline function `%s' given attribute noinline");
13832
13833   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13834     /* This is a constructor, we must ensure that any default args
13835        introduced by this definition are propagated to the clones
13836        now. The clones are used directly in overload resolution.  */
13837     adjust_clone_args (decl1);
13838
13839   /* Sometimes we don't notice that a function is a static member, and
13840      build a METHOD_TYPE for it.  Fix that up now.  */
13841   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13842       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13843     {
13844       revert_static_member_fn (decl1);
13845       last_function_parms = TREE_CHAIN (last_function_parms);
13846       ctype = NULL_TREE;
13847     }
13848
13849   /* Warn if function was previously implicitly declared
13850      (but not if we warned then).  */
13851   if (! warn_implicit
13852       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13853     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13854
13855   /* Set up current_class_type, and enter the scope of the class, if
13856      appropriate.  */
13857   if (ctype)
13858     push_nested_class (ctype, 1);
13859   else if (DECL_STATIC_FUNCTION_P (decl1))
13860     push_nested_class (DECL_CONTEXT (decl1), 2);
13861
13862   /* Now that we have entered the scope of the class, we must restore
13863      the bindings for any template parameters surrounding DECL1, if it
13864      is an inline member template.  (Order is important; consider the
13865      case where a template parameter has the same name as a field of
13866      the class.)  It is not until after this point that
13867      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13868   if (flags & SF_INCLASS_INLINE)
13869     maybe_begin_member_template_processing (decl1);
13870
13871   /* Effective C++ rule 15.  */
13872   if (warn_ecpp
13873       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13874       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13875     warning ("`operator=' should return a reference to `*this'");
13876
13877   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13878      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13879   if (!DECL_INITIAL (decl1))
13880     DECL_INITIAL (decl1) = error_mark_node;
13881
13882   /* This function exists in static storage.
13883      (This does not mean `static' in the C sense!)  */
13884   TREE_STATIC (decl1) = 1;
13885
13886   /* We must call push_template_decl after current_class_type is set
13887      up.  (If we are processing inline definitions after exiting a
13888      class scope, current_class_type will be NULL_TREE until set above
13889      by push_nested_class.)  */
13890   if (processing_template_decl)
13891     decl1 = push_template_decl (decl1);
13892
13893   /* We are now in the scope of the function being defined.  */
13894   current_function_decl = decl1;
13895
13896   /* Save the parm names or decls from this function's declarator
13897      where store_parm_decls will find them.  */
13898   current_function_parms = last_function_parms;
13899
13900   /* Make sure the parameter and return types are reasonable.  When
13901      you declare a function, these types can be incomplete, but they
13902      must be complete when you define the function.  */
13903   if (! processing_template_decl)
13904     check_function_type (decl1, current_function_parms);
13905
13906   /* Build the return declaration for the function.  */
13907   restype = TREE_TYPE (fntype);
13908   /* Promote the value to int before returning it.  */
13909   if (c_promoting_integer_type_p (restype))
13910     restype = type_promotes_to (restype);
13911   if (DECL_RESULT (decl1) == NULL_TREE)
13912     {
13913       DECL_RESULT (decl1)
13914         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13915       c_apply_type_quals_to_decl (cp_type_quals (restype),
13916                                   DECL_RESULT (decl1));
13917     }
13918
13919   /* Initialize RTL machinery.  We cannot do this until
13920      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13921      even when processing a template; this is how we get
13922      CFUN set up, and our per-function variables initialized.
13923      FIXME factor out the non-RTL stuff.  */
13924   bl = current_binding_level;
13925   init_function_start (decl1, input_filename, lineno);
13926   current_binding_level = bl;
13927
13928   /* Even though we're inside a function body, we still don't want to
13929      call expand_expr to calculate the size of a variable-sized array.
13930      We haven't necessarily assigned RTL to all variables yet, so it's
13931      not safe to try to expand expressions involving them.  */
13932   immediate_size_expand = 0;
13933   cfun->x_dont_save_pending_sizes_p = 1;
13934
13935   /* Start the statement-tree, start the tree now.  */
13936   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13937
13938   /* Let the user know we're compiling this function.  */
13939   announce_function (decl1);
13940
13941   /* Record the decl so that the function name is defined.
13942      If we already have a decl for this name, and it is a FUNCTION_DECL,
13943      use the old decl.  */
13944   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13945     {
13946       /* A specialization is not used to guide overload resolution.  */
13947       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13948           && ! DECL_FUNCTION_MEMBER_P (decl1))
13949         decl1 = pushdecl (decl1);
13950       else
13951         {
13952           /* We need to set the DECL_CONTEXT.  */
13953           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13954             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13955           /* And make sure we have enough default args.  */
13956           check_default_args (decl1);
13957         }
13958       fntype = TREE_TYPE (decl1);
13959     }
13960
13961   /* Reset these in case the call to pushdecl changed them.  */
13962   current_function_decl = decl1;
13963   cfun->decl = decl1;
13964
13965   /* If we are (erroneously) defining a function that we have already
13966      defined before, wipe out what we knew before.  */
13967   if (!DECL_PENDING_INLINE_P (decl1))
13968     DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13969
13970   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13971     {
13972       /* We know that this was set up by `grokclassfn'.  We do not
13973          wait until `store_parm_decls', since evil parse errors may
13974          never get us to that point.  Here we keep the consistency
13975          between `current_class_type' and `current_class_ptr'.  */
13976       tree t = DECL_ARGUMENTS (decl1);
13977
13978       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13979                           162);
13980       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13981                           19990811);
13982
13983       cp_function_chain->x_current_class_ref
13984         = build_indirect_ref (t, NULL);
13985       cp_function_chain->x_current_class_ptr = t;
13986
13987       /* Constructors and destructors need to know whether they're "in
13988          charge" of initializing virtual base classes.  */
13989       t = TREE_CHAIN (t);
13990       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13991         {
13992           current_in_charge_parm = t;
13993           t = TREE_CHAIN (t);
13994         }
13995       if (DECL_HAS_VTT_PARM_P (decl1))
13996         {
13997           if (DECL_NAME (t) != vtt_parm_identifier)
13998             abort ();
13999           current_vtt_parm = t;
14000         }
14001     }
14002
14003   if (DECL_INTERFACE_KNOWN (decl1))
14004     {
14005       tree ctx = decl_function_context (decl1);
14006
14007       if (DECL_NOT_REALLY_EXTERN (decl1))
14008         DECL_EXTERNAL (decl1) = 0;
14009
14010       if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
14011           && TREE_PUBLIC (ctx))
14012         /* This is a function in a local class in an extern inline
14013            function.  */
14014         comdat_linkage (decl1);
14015     }
14016   /* If this function belongs to an interface, it is public.
14017      If it belongs to someone else's interface, it is also external.
14018      This only affects inlines and template instantiations.  */
14019   else if (interface_unknown == 0
14020            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
14021                || flag_alt_external_templates))
14022     {
14023       if (DECL_DECLARED_INLINE_P (decl1)
14024           || DECL_TEMPLATE_INSTANTIATION (decl1)
14025           || processing_template_decl)
14026         {
14027           DECL_EXTERNAL (decl1)
14028             = (interface_only
14029                || (DECL_DECLARED_INLINE_P (decl1)
14030                    && ! flag_implement_inlines
14031                    && !DECL_VINDEX (decl1)));
14032
14033           /* For WIN32 we also want to put these in linkonce sections.  */
14034           maybe_make_one_only (decl1);
14035         }
14036       else
14037         DECL_EXTERNAL (decl1) = 0;
14038       DECL_NOT_REALLY_EXTERN (decl1) = 0;
14039       DECL_INTERFACE_KNOWN (decl1) = 1;
14040     }
14041   else if (interface_unknown && interface_only
14042            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
14043                || flag_alt_external_templates))
14044     {
14045       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
14046          interface, we will have interface_only set but not
14047          interface_known.  In that case, we don't want to use the normal
14048          heuristics because someone will supply a #pragma implementation
14049          elsewhere, and deducing it here would produce a conflict.  */
14050       comdat_linkage (decl1);
14051       DECL_EXTERNAL (decl1) = 0;
14052       DECL_INTERFACE_KNOWN (decl1) = 1;
14053       DECL_DEFER_OUTPUT (decl1) = 1;
14054     }
14055   else
14056     {
14057       /* This is a definition, not a reference.
14058          So clear DECL_EXTERNAL.  */
14059       DECL_EXTERNAL (decl1) = 0;
14060
14061       if ((DECL_DECLARED_INLINE_P (decl1)
14062            || DECL_TEMPLATE_INSTANTIATION (decl1))
14063           && ! DECL_INTERFACE_KNOWN (decl1)
14064           /* Don't try to defer nested functions for now.  */
14065           && ! decl_function_context (decl1))
14066         DECL_DEFER_OUTPUT (decl1) = 1;
14067       else
14068         DECL_INTERFACE_KNOWN (decl1) = 1;
14069     }
14070
14071   pushlevel (0);
14072   current_binding_level->parm_flag = 1;
14073
14074   ++function_depth;
14075
14076   if (DECL_DESTRUCTOR_P (decl1))
14077     {
14078       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14079       DECL_CONTEXT (dtor_label) = current_function_decl;
14080     }
14081
14082   start_fname_decls ();
14083
14084   store_parm_decls (current_function_parms);
14085
14086   return 1;
14087 }
14088 \f
14089 /* Store the parameter declarations into the current function declaration.
14090    This is called after parsing the parameter declarations, before
14091    digesting the body of the function.
14092
14093    Also install to binding contour return value identifier, if any.  */
14094
14095 static void
14096 store_parm_decls (current_function_parms)
14097      tree current_function_parms;
14098 {
14099   register tree fndecl = current_function_decl;
14100   register tree parm;
14101
14102   /* This is a chain of any other decls that came in among the parm
14103      declarations.  If a parm is declared with  enum {foo, bar} x;
14104      then CONST_DECLs for foo and bar are put here.  */
14105   tree nonparms = NULL_TREE;
14106
14107   if (current_function_parms)
14108     {
14109       /* This case is when the function was defined with an ANSI prototype.
14110          The parms already have decls, so we need not do anything here
14111          except record them as in effect
14112          and complain if any redundant old-style parm decls were written.  */
14113
14114       tree specparms = current_function_parms;
14115       tree next;
14116
14117       /* Must clear this because it might contain TYPE_DECLs declared
14118              at class level.  */
14119       storedecls (NULL_TREE);
14120
14121       /* If we're doing semantic analysis, then we'll call pushdecl
14122              for each of these.  We must do them in reverse order so that
14123              they end in the correct forward order.  */
14124       specparms = nreverse (specparms);
14125
14126       for (parm = specparms; parm; parm = next)
14127         {
14128           next = TREE_CHAIN (parm);
14129           if (TREE_CODE (parm) == PARM_DECL)
14130             {
14131               if (DECL_NAME (parm) == NULL_TREE
14132                   || TREE_CODE (parm) != VOID_TYPE)
14133                 pushdecl (parm);
14134               else
14135                 error ("parameter `%D' declared void", parm);
14136             }
14137           else
14138             {
14139               /* If we find an enum constant or a type tag,
14140                  put it aside for the moment.  */
14141               TREE_CHAIN (parm) = NULL_TREE;
14142               nonparms = chainon (nonparms, parm);
14143             }
14144         }
14145
14146       /* Get the decls in their original chain order and record in the
14147          function.  This is all and only the PARM_DECLs that were
14148          pushed into scope by the loop above.  */
14149       DECL_ARGUMENTS (fndecl) = getdecls ();
14150       storetags (gettags ());
14151     }
14152   else
14153     DECL_ARGUMENTS (fndecl) = NULL_TREE;
14154
14155   /* Now store the final chain of decls for the arguments
14156      as the decl-chain of the current lexical scope.
14157      Put the enumerators in as well, at the front so that
14158      DECL_ARGUMENTS is not modified.  */
14159   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
14160
14161   /* Do the starting of the exception specifications, if we have any.  */
14162   if (flag_exceptions && !processing_template_decl
14163       && flag_enforce_eh_specs
14164       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14165     current_eh_spec_block = begin_eh_spec_block ();
14166 }
14167
14168 \f
14169 /* We have finished doing semantic analysis on DECL, but have not yet
14170    generated RTL for its body.  Save away our current state, so that
14171    when we want to generate RTL later we know what to do.  */
14172
14173 static void
14174 save_function_data (decl)
14175      tree decl;
14176 {
14177   struct language_function *f;
14178
14179   /* Save the language-specific per-function data so that we can
14180      get it back when we really expand this function.  */
14181   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14182                       19990908);
14183
14184   /* Make a copy.  */
14185   f = ((struct language_function *)
14186        ggc_alloc (sizeof (struct language_function)));
14187   memcpy (f, cp_function_chain, sizeof (struct language_function));
14188   DECL_SAVED_FUNCTION_DATA (decl) = f;
14189
14190   /* Clear out the bits we don't need.  */
14191   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
14192   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
14193   f->x_named_label_uses = NULL;
14194   f->bindings = NULL;
14195   f->x_local_names = NULL;
14196
14197   /* When we get back here again, we will be expanding.  */
14198   f->x_expanding_p = 1;
14199
14200   /* If we've already decided that we cannot inline this function, we
14201      must remember that fact when we actually go to expand the
14202      function.  */
14203   if (current_function_cannot_inline)
14204     {
14205       f->cannot_inline = current_function_cannot_inline;
14206       DECL_INLINE (decl) = 0;
14207     }
14208 }
14209
14210 /* Add a note to mark the beginning of the main body of the constructor.
14211    This is used to set up the data structures for the cleanup regions for
14212    fully-constructed bases and members.  */
14213
14214 static void
14215 begin_constructor_body ()
14216 {
14217 }
14218
14219 /* Add a note to mark the end of the main body of the constructor.  This is
14220    used to end the cleanup regions for fully-constructed bases and
14221    members.  */
14222
14223 static void
14224 finish_constructor_body ()
14225 {
14226 }
14227
14228 /* Do all the processing for the beginning of a destructor; set up the
14229    vtable pointers and cleanups for bases and members.  */
14230
14231 static void
14232 begin_destructor_body ()
14233 {
14234   tree if_stmt;
14235   tree compound_stmt;
14236
14237   /* If the dtor is empty, and we know there is not any possible
14238      way we could use any vtable entries, before they are possibly
14239      set by a base class dtor, we don't have to setup the vtables,
14240      as we know that any base class dtor will set up any vtables
14241      it needs.  We avoid MI, because one base class dtor can do a
14242      virtual dispatch to an overridden function that would need to
14243      have a non-related vtable set up, we cannot avoid setting up
14244      vtables in that case.  We could change this to see if there
14245      is just one vtable.
14246
14247      ??? In the destructor for a class, the vtables are set
14248      appropriately for that class.  There will be no non-related
14249      vtables.  jason 2001-12-11.  */
14250   if_stmt = begin_if_stmt ();
14251
14252   /* If it is not safe to avoid setting up the vtables, then
14253      someone will change the condition to be boolean_true_node.
14254      (Actually, for now, we do not have code to set the condition
14255      appropriately, so we just assume that we always need to
14256      initialize the vtables.)  */
14257   finish_if_stmt_cond (boolean_true_node, if_stmt);
14258
14259   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14260
14261   /* Make all virtual function table pointers in non-virtual base
14262      classes point to CURRENT_CLASS_TYPE's virtual function
14263      tables.  */
14264   initialize_vtbl_ptrs (current_class_ptr);
14265
14266   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14267   finish_then_clause (if_stmt);
14268   finish_if_stmt ();
14269
14270   /* And insert cleanups for our bases and members so that they
14271      will be properly destroyed if we throw.  */
14272   push_base_cleanups ();
14273 }
14274
14275 /* At the end of every destructor we generate code to delete the object if
14276    necessary.  Do that now.  */
14277
14278 static void
14279 finish_destructor_body ()
14280 {
14281   tree exprstmt;
14282
14283   /* Any return from a destructor will end up here; that way all base
14284      and member cleanups will be run when the function returns.  */
14285   add_stmt (build_stmt (LABEL_STMT, dtor_label));
14286
14287   /* In a virtual destructor, we must call delete.  */
14288   if (DECL_VIRTUAL_P (current_function_decl))
14289     {
14290       tree if_stmt;
14291       tree virtual_size = cxx_sizeof (current_class_type);
14292
14293       /* [class.dtor]
14294
14295       At the point of definition of a virtual destructor (including
14296       an implicit definition), non-placement operator delete shall
14297       be looked up in the scope of the destructor's class and if
14298       found shall be accessible and unambiguous.  */
14299       exprstmt = build_op_delete_call
14300         (DELETE_EXPR, current_class_ptr, virtual_size,
14301          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14302
14303       if_stmt = begin_if_stmt ();
14304       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14305                                   current_in_charge_parm,
14306                                   integer_one_node),
14307                            if_stmt);
14308       finish_expr_stmt (exprstmt);
14309       finish_then_clause (if_stmt);
14310       finish_if_stmt ();
14311     }
14312 }
14313
14314 /* Do the necessary processing for the beginning of a function body, which
14315    in this case includes member-initializers, but not the catch clauses of
14316    a function-try-block.  Currently, this means opening a binding level
14317    for the member-initializers (in a ctor) and member cleanups (in a dtor).
14318    In other functions, this isn't necessary, but it doesn't hurt.  */
14319
14320 tree
14321 begin_function_body ()
14322 {
14323   tree stmt;
14324
14325   if (processing_template_decl)
14326     /* Do nothing now.  */;
14327   else
14328     /* Always keep the BLOCK node associated with the outermost pair of
14329        curly braces of a function.  These are needed for correct
14330        operation of dwarfout.c.  */
14331     keep_next_level (1);
14332
14333   stmt = begin_compound_stmt (0);
14334   COMPOUND_STMT_BODY_BLOCK (stmt) = 1;
14335
14336   if (processing_template_decl)
14337     /* Do nothing now.  */;
14338   else if (DECL_CONSTRUCTOR_P (current_function_decl))
14339     begin_constructor_body ();
14340   else if (DECL_DESTRUCTOR_P (current_function_decl))
14341     begin_destructor_body ();
14342
14343   return stmt;
14344 }
14345
14346 /* Do the processing for the end of a function body.  Currently, this means
14347    closing out the cleanups for fully-constructed bases and members, and in
14348    the case of the destructor, deleting the object if desired.  Again, this
14349    is only meaningful for [cd]tors, since they are the only functions where
14350    there is a significant distinction between the main body and any
14351    function catch clauses.  Handling, say, main() return semantics here
14352    would be wrong, as flowing off the end of a function catch clause for
14353    main() would also need to return 0.  */
14354
14355 void
14356 finish_function_body (compstmt)
14357      tree compstmt;
14358 {
14359   /* Close the block.  */
14360   finish_compound_stmt (0, compstmt);
14361
14362   if (processing_template_decl)
14363     /* Do nothing now.  */;
14364   else if (DECL_CONSTRUCTOR_P (current_function_decl))
14365     finish_constructor_body ();
14366   else if (DECL_DESTRUCTOR_P (current_function_decl))
14367     finish_destructor_body ();
14368 }
14369
14370 /* Finish up a function declaration and compile that function
14371    all the way to assembler language output.  The free the storage
14372    for the function definition.
14373
14374    FLAGS is a bitwise or of the following values:
14375      2 - INCLASS_INLINE
14376        We just finished processing the body of an in-class inline
14377        function definition.  (This processing will have taken place
14378        after the class definition is complete.)  */
14379
14380 tree
14381 finish_function (flags)
14382      int flags;
14383 {
14384   register tree fndecl = current_function_decl;
14385   tree fntype, ctype = NULL_TREE;
14386   int inclass_inline = (flags & 2) != 0;
14387   int nested;
14388
14389   /* When we get some parse errors, we can end up without a
14390      current_function_decl, so cope.  */
14391   if (fndecl == NULL_TREE)
14392     return error_mark_node;
14393
14394   nested = function_depth > 1;
14395   fntype = TREE_TYPE (fndecl);
14396
14397   /*  TREE_READONLY (fndecl) = 1;
14398       This caused &foo to be of type ptr-to-const-function
14399       which then got a warning when stored in a ptr-to-function variable.  */
14400
14401   my_friendly_assert (building_stmt_tree (), 20000911);
14402
14403   finish_fname_decls ();
14404
14405   /* For a cloned function, we've already got all the code we need;
14406      there's no need to add any extra bits.  */
14407   if (!DECL_CLONED_FUNCTION_P (fndecl))
14408     {
14409       if (DECL_MAIN_P (current_function_decl))
14410         {
14411           /* Make it so that `main' always returns 0 by default.  */
14412 #if VMS_TARGET
14413           finish_return_stmt (integer_one_node);
14414 #else
14415           finish_return_stmt (integer_zero_node);
14416 #endif
14417         }
14418
14419       /* Finish dealing with exception specifiers.  */
14420       if (flag_exceptions && !processing_template_decl
14421           && flag_enforce_eh_specs
14422           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14423         finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14424                               (TREE_TYPE (current_function_decl)),
14425                               current_eh_spec_block);
14426     }
14427
14428   /* If we're saving up tree structure, tie off the function now.  */
14429   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14430
14431   /* This must come after expand_function_end because cleanups might
14432      have declarations (from inline functions) that need to go into
14433      this function's blocks.  */
14434
14435   /* If the current binding level isn't the outermost binding level
14436      for this function, either there is a bug, or we have experienced
14437      syntax errors and the statement tree is malformed.  */
14438   if (current_binding_level->parm_flag != 1)
14439     {
14440       /* Make sure we have already experienced errors.  */
14441       if (errorcount == 0)
14442         abort ();
14443
14444       /* Throw away the broken statement tree and extra binding
14445          levels.  */
14446       DECL_SAVED_TREE (fndecl) = build_stmt (COMPOUND_STMT, NULL_TREE);
14447
14448       while (current_binding_level->parm_flag != 1)
14449         {
14450           if (current_binding_level->parm_flag == 2)
14451             pop_nested_class ();
14452           else
14453             poplevel (0, 0, 0);
14454         }
14455     }
14456   poplevel (1, 0, 1);
14457
14458   /* Set up the named return value optimization, if we can.  Here, we
14459      eliminate the copy from the nrv into the RESULT_DECL and any cleanup
14460      for the nrv.  genrtl_start_function and declare_return_variable
14461      handle making the nrv and RESULT_DECL share space.  */
14462   if (current_function_return_value)
14463     {
14464       tree r = current_function_return_value;
14465       /* This is only worth doing for fns that return in memory--and
14466          simpler, since we don't have to worry about promoted modes.  */
14467       if (r != error_mark_node
14468           && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl))))
14469         {
14470           DECL_ALIGN (r) = DECL_ALIGN (DECL_RESULT (fndecl));
14471           walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl),
14472                                         nullify_returns_r, r);
14473         }
14474       else
14475         /* Clear it so genrtl_start_function and declare_return_variable
14476            know we're not optimizing.  */
14477         current_function_return_value = NULL_TREE;
14478     }
14479
14480   /* Remember that we were in class scope.  */
14481   if (current_class_name)
14482     ctype = current_class_type;
14483
14484   /* Must mark the RESULT_DECL as being in this function.  */
14485   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14486
14487   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14488      to the FUNCTION_DECL node itself.  */
14489   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14490
14491   /* Save away current state, if appropriate.  */
14492   if (!processing_template_decl)
14493     save_function_data (fndecl);
14494
14495   /* If this function calls `setjmp' it cannot be inlined.  When
14496      `longjmp' is called it is not guaranteed to restore the value of
14497      local variables that have been modified since the call to
14498      `setjmp'.  So, if were to inline this function into some caller
14499      `c', then when we `longjmp', we might not restore all variables
14500      in `c'.  (It might seem, at first blush, that there's no way for
14501      this function to modify local variables in `c', but their
14502      addresses may have been stored somewhere accessible to this
14503      function.)  */
14504   if (!processing_template_decl && calls_setjmp_p (fndecl))
14505     DECL_UNINLINABLE (fndecl) = 1;
14506
14507   /* Complain if there's just no return statement.  */
14508   if (warn_return_type
14509       && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
14510       && !current_function_returns_value && !current_function_returns_null
14511       /* Don't complain if we abort or throw.  */
14512       && !current_function_returns_abnormally
14513       && !DECL_NAME (DECL_RESULT (fndecl))
14514       /* Normally, with -Wreturn-type, flow will complain.  Unless we're an
14515          inline function, as we might never be compiled separately.  */
14516       && (DECL_INLINE (fndecl) || processing_template_decl))
14517     warning ("no return statement in function returning non-void");
14518
14519   /* Clear out memory we no longer need.  */
14520   free_after_parsing (cfun);
14521   /* Since we never call rest_of_compilation, we never clear
14522      CFUN.  Do so explicitly.  */
14523   free_after_compilation (cfun);
14524   cfun = NULL;
14525
14526   /* If this is an in-class inline definition, we may have to pop the
14527      bindings for the template parameters that we added in
14528      maybe_begin_member_template_processing when start_function was
14529      called.  */
14530   if (inclass_inline)
14531     maybe_end_member_template_processing ();
14532
14533   /* Leave the scope of the class.  */
14534   if (ctype)
14535     pop_nested_class ();
14536
14537   --function_depth;
14538
14539   /* Clean up.  */
14540   if (! nested)
14541     /* Let the error reporting routines know that we're outside a
14542        function.  For a nested function, this value is used in
14543        cxx_pop_function_context and then reset via pop_function_context.  */
14544     current_function_decl = NULL_TREE;
14545
14546   return fndecl;
14547 }
14548 \f
14549 /* Create the FUNCTION_DECL for a function definition.
14550    DECLSPECS and DECLARATOR are the parts of the declaration;
14551    they describe the return type and the name of the function,
14552    but twisted together in a fashion that parallels the syntax of C.
14553
14554    This function creates a binding context for the function body
14555    as well as setting up the FUNCTION_DECL in current_function_decl.
14556
14557    Returns a FUNCTION_DECL on success.
14558
14559    If the DECLARATOR is not suitable for a function (it defines a datum
14560    instead), we return 0, which tells yyparse to report a parse error.
14561
14562    May return void_type_node indicating that this method is actually
14563    a friend.  See grokfield for more details.
14564
14565    Came here with a `.pushlevel' .
14566
14567    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14568    CHANGES TO CODE IN `grokfield'.  */
14569
14570 tree
14571 start_method (declspecs, declarator, attrlist)
14572      tree declarator, declspecs, attrlist;
14573 {
14574   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14575                                 &attrlist);
14576
14577   if (fndecl == error_mark_node)
14578     return error_mark_node;
14579
14580   if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
14581     {
14582       error ("invalid member function declaration");
14583       return error_mark_node;
14584     }
14585
14586   if (attrlist)
14587     cplus_decl_attributes (&fndecl, attrlist, 0);
14588
14589   /* Pass friends other than inline friend functions back.  */
14590   if (fndecl == void_type_node)
14591     return fndecl;
14592
14593   if (DECL_IN_AGGR_P (fndecl))
14594     {
14595       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14596         {
14597           if (DECL_CONTEXT (fndecl)
14598               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14599             error ("`%D' is already defined in class `%T'", fndecl,
14600                       DECL_CONTEXT (fndecl));
14601         }
14602       return void_type_node;
14603     }
14604
14605   check_template_shadow (fndecl);
14606
14607   DECL_DECLARED_INLINE_P (fndecl) = 1;
14608
14609   if (flag_default_inline)
14610     DECL_INLINE (fndecl) = 1;
14611
14612   /* We process method specializations in finish_struct_1.  */
14613   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14614     fndecl = push_template_decl (fndecl);
14615
14616   if (! DECL_FRIEND_P (fndecl))
14617     {
14618       if (TREE_CHAIN (fndecl))
14619         {
14620           fndecl = copy_node (fndecl);
14621           TREE_CHAIN (fndecl) = NULL_TREE;
14622         }
14623       grok_special_member_properties (fndecl);
14624     }
14625
14626   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14627
14628   /* Make a place for the parms */
14629   pushlevel (0);
14630   current_binding_level->parm_flag = 1;
14631
14632   DECL_IN_AGGR_P (fndecl) = 1;
14633   return fndecl;
14634 }
14635
14636 /* Go through the motions of finishing a function definition.
14637    We don't compile this method until after the whole class has
14638    been processed.
14639
14640    FINISH_METHOD must return something that looks as though it
14641    came from GROKFIELD (since we are defining a method, after all).
14642
14643    This is called after parsing the body of the function definition.
14644    STMTS is the chain of statements that makes up the function body.
14645
14646    DECL is the ..._DECL that `start_method' provided.  */
14647
14648 tree
14649 finish_method (decl)
14650      tree decl;
14651 {
14652   register tree fndecl = decl;
14653   tree old_initial;
14654
14655   register tree link;
14656
14657   if (decl == void_type_node)
14658     return decl;
14659
14660   old_initial = DECL_INITIAL (fndecl);
14661
14662   /* Undo the level for the parms (from start_method).
14663      This is like poplevel, but it causes nothing to be
14664      saved.  Saving information here confuses symbol-table
14665      output routines.  Besides, this information will
14666      be correctly output when this method is actually
14667      compiled.  */
14668
14669   /* Clear out the meanings of the local variables of this level;
14670      also record in each decl which block it belongs to.  */
14671
14672   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14673     {
14674       if (DECL_NAME (link) != NULL_TREE)
14675         pop_binding (DECL_NAME (link), link);
14676       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14677       DECL_CONTEXT (link) = NULL_TREE;
14678     }
14679
14680   poplevel (0, 0, 0);
14681
14682   DECL_INITIAL (fndecl) = old_initial;
14683
14684   /* We used to check if the context of FNDECL was different from
14685      current_class_type as another way to get inside here.  This didn't work
14686      for String.cc in libg++.  */
14687   if (DECL_FRIEND_P (fndecl))
14688     {
14689       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14690         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14691       decl = void_type_node;
14692     }
14693
14694   return decl;
14695 }
14696 \f
14697
14698 /* VAR is a VAR_DECL.  If its type is incomplete, remember VAR so that
14699    we can lay it out later, when and if its type becomes complete.  */
14700
14701 void
14702 maybe_register_incomplete_var (var)
14703      tree var;
14704 {
14705   my_friendly_assert (TREE_CODE (var) == VAR_DECL, 20020406);
14706
14707   /* Keep track of variables with incomplete types.  */
14708   if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
14709       && DECL_EXTERNAL (var))
14710     {
14711       tree inner_type = TREE_TYPE (var);
14712
14713       while (TREE_CODE (inner_type) == ARRAY_TYPE)
14714         inner_type = TREE_TYPE (inner_type);
14715       inner_type = TYPE_MAIN_VARIANT (inner_type);
14716
14717       if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
14718           /* RTTI TD entries are created while defining the type_info.  */
14719           || (TYPE_LANG_SPECIFIC (inner_type)
14720               && TYPE_BEING_DEFINED (inner_type)))
14721         incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
14722     }
14723 }
14724
14725 /* Called when a class type (given by TYPE) is defined.  If there are
14726    any existing VAR_DECLs whose type hsa been completed by this
14727    declaration, update them now.  */
14728
14729 void
14730 complete_vars (type)
14731      tree type;
14732 {
14733   tree *list = &incomplete_vars;
14734
14735   my_friendly_assert (CLASS_TYPE_P (type), 20020406);
14736   while (*list)
14737     {
14738       if (same_type_p (type, TREE_PURPOSE (*list)))
14739         {
14740           tree var = TREE_VALUE (*list);
14741           /* Complete the type of the variable.  The VAR_DECL itself
14742              will be laid out in expand_expr.  */
14743           complete_type (TREE_TYPE (var));
14744           /* Remove this entry from the list.  */
14745           *list = TREE_CHAIN (*list);
14746         }
14747       else
14748         list = &TREE_CHAIN (*list);
14749     }
14750 }
14751
14752 /* If DECL is of a type which needs a cleanup, build that cleanup
14753    here.  */
14754
14755 tree
14756 cxx_maybe_build_cleanup (decl)
14757      tree decl;
14758 {
14759   tree type = TREE_TYPE (decl);
14760
14761   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14762     {
14763       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14764       tree rval;
14765
14766       if (TREE_CODE (type) == ARRAY_TYPE)
14767         rval = decl;
14768       else
14769         {
14770           cxx_mark_addressable (decl);
14771           rval = build_unary_op (ADDR_EXPR, decl, 0);
14772         }
14773
14774       /* Optimize for space over speed here.  */
14775       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14776           || flag_expensive_optimizations)
14777         flags |= LOOKUP_NONVIRTUAL;
14778
14779       rval = build_delete (TREE_TYPE (rval), rval,
14780                            sfk_complete_destructor, flags, 0);
14781
14782       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14783           && ! TYPE_HAS_DESTRUCTOR (type))
14784         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14785                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14786
14787       return rval;
14788     }
14789   return NULL_TREE;
14790 }
14791 \f
14792 /* When a stmt has been parsed, this function is called.  */
14793
14794 void
14795 finish_stmt ()
14796 {
14797   /* Always assume this statement was not an expression statement.  If
14798      it actually was an expression statement, its our callers
14799      responsibility to fix this up.  */
14800   last_expr_type = NULL_TREE;
14801 }
14802
14803 /* DECL was originally constructed as a non-static member function,
14804    but turned out to be static.  Update it accordingly.  */
14805
14806 void
14807 revert_static_member_fn (decl)
14808      tree decl;
14809 {
14810   tree tmp;
14811   tree function = TREE_TYPE (decl);
14812   tree args = TYPE_ARG_TYPES (function);
14813
14814   if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
14815       != TYPE_UNQUALIFIED)
14816     error ("static member function `%#D' declared with type qualifiers",
14817               decl);
14818
14819   args = TREE_CHAIN (args);
14820   tmp = build_function_type (TREE_TYPE (function), args);
14821   tmp = build_qualified_type (tmp, cp_type_quals (function));
14822   tmp = build_exception_variant (tmp,
14823                                  TYPE_RAISES_EXCEPTIONS (function));
14824   TREE_TYPE (decl) = tmp;
14825   if (DECL_ARGUMENTS (decl))
14826     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14827   DECL_STATIC_FUNCTION_P (decl) = 1;
14828 }
14829
14830 /* Initialize the variables used during compilation of a C++
14831    function.  */
14832
14833 void
14834 cxx_push_function_context (f)
14835      struct function *f;
14836 {
14837   struct language_function *p
14838     = ((struct language_function *)
14839        ggc_alloc_cleared (sizeof (struct language_function)));
14840   f->language = p;
14841
14842   /* It takes an explicit call to expand_body to generate RTL for a
14843      function.  */
14844   expanding_p = 0;
14845
14846   /* Whenever we start a new function, we destroy temporaries in the
14847      usual way.  */
14848   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14849 }
14850
14851 /* Free the language-specific parts of F, now that we've finished
14852    compiling the function.  */
14853
14854 void
14855 cxx_pop_function_context (f)
14856      struct function *f;
14857 {
14858   f->language = 0;
14859 }
14860
14861 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
14862    one of the language-independent trees.  */
14863
14864 enum cp_tree_node_structure_enum
14865 cp_tree_node_structure (t)
14866      union lang_tree_node *t;
14867 {
14868   switch (TREE_CODE (&t->generic))
14869     {
14870     case DEFAULT_ARG:           return TS_CP_DEFAULT_ARG;
14871     case IDENTIFIER_NODE:       return TS_CP_IDENTIFIER;
14872     case CPLUS_BINDING:         return TS_CP_BINDING;
14873     case OVERLOAD:              return TS_CP_OVERLOAD;
14874     case TEMPLATE_PARM_INDEX:   return TS_CP_TPI;
14875     case PTRMEM_CST:            return TS_CP_PTRMEM;
14876     case WRAPPER:               return TS_CP_WRAPPER;
14877     case SRCLOC:                return TS_CP_SRCLOC;
14878     default:                    return TS_CP_GENERIC;
14879     }
14880 }
14881
14882 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14883    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
14884
14885 tree
14886 identifier_global_value (t)
14887      tree t;
14888 {
14889   return IDENTIFIER_GLOBAL_VALUE (t);
14890 }
14891
14892 /* Build the void_list_node (void_type_node having been created).  */
14893 tree
14894 build_void_list_node ()
14895 {
14896   tree t = build_tree_list (NULL_TREE, void_type_node);
14897   TREE_PARMLIST (t) = 1;
14898   return t;
14899 }
14900
14901 static int
14902 cp_missing_noreturn_ok_p (decl)
14903      tree decl;
14904 {
14905   /* A missing noreturn is ok for the `main' function.  */
14906   return DECL_MAIN_P (decl);
14907 }
14908
14909 #include "gt-cp-decl.h"
14910 #include "gtype-cp.h"