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, 2003  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 "tm_p.h"
  48 #include "target.h"
  49 #include "c-common.h"
  50 #include "c-pragma.h"
  51 #include "diagnostic.h"
  52 #include "debug.h"
  53 #include "timevar.h"
  54
  55 static tree grokparms (tree);
  56 static const char *redeclaration_error_message (tree, tree);
  57
  58 static void push_binding_level (struct cp_binding_level *, int,
  59                                 int);
  60 static void pop_binding_level (void);
  61 static void suspend_binding_level (void);
  62 static void resume_binding_level (struct cp_binding_level *);
  63 static struct cp_binding_level *make_binding_level (void);
  64 static void declare_namespace_level (void);
  65 static int decl_jump_unsafe (tree);
  66 static void storedecls (tree);
  67 static void require_complete_types_for_parms (tree);
  68 static int ambi_op_p (enum tree_code);
  69 static int unary_op_p (enum tree_code);
  70 static tree store_bindings (tree, tree);
  71 static tree lookup_tag_reverse (tree, tree);
  72 static void push_local_name (tree);
  73 static void warn_extern_redeclared_static (tree, tree);
  74 static tree grok_reference_init (tree, tree, tree);
  75 static tree grokfndecl (tree, tree, tree, tree, int,
  76                         enum overload_flags, tree,
  77                         tree, int, int, int, int, int, int, tree);
  78 static tree grokvardecl (tree, tree, RID_BIT_TYPE *, int, int, tree);
  79 static tree follow_tag_typedef (tree);
  80 static tree lookup_tag (enum tree_code, tree,
  81                         struct cp_binding_level *, int);
  82 static void set_identifier_type_value_with_scope
  83         (tree, tree, struct cp_binding_level *);
  84 static void record_unknown_type (tree, const char *);
  85 static tree builtin_function_1 (const char *, tree, tree, int,
  86                                 enum built_in_class, const char *,
  87                                 tree);
  88 static tree build_library_fn_1 (tree, enum tree_code, tree);
  89 static int member_function_or_else (tree, tree, enum overload_flags);
  90 static void bad_specifiers (tree, const char *, int, int, int, int,
  91                             int);
  92 static tree maybe_process_template_type_declaration
  93         (tree, int, struct cp_binding_level*);
  94 static void check_for_uninitialized_const_var (tree);
  95 static hashval_t typename_hash (const void *);
  96 static int typename_compare (const void *, const void *);
  97 static void push_binding (tree, tree, struct cp_binding_level*);
  98 static int add_binding (tree, tree);
  99 static void pop_binding (tree, tree);
 100 static tree local_variable_p_walkfn (tree *, int *, void *);
 101 static tree find_binding (tree, tree);
 102 static tree select_decl (tree, int);
 103 static int lookup_flags (int, int);
 104 static tree qualify_lookup (tree, int);
 105 static tree record_builtin_java_type (const char *, int);
 106 static const char *tag_name (enum tag_types code);
 107 static void find_class_binding_level (void);
 108 static struct cp_binding_level *innermost_nonclass_level (void);
 109 static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
 110 static int walk_globals_r (tree, void*);
 111 static int walk_vtables_r (tree, void*);
 112 static void add_decl_to_level (tree, struct cp_binding_level *);
 113 static tree make_label_decl (tree, int);
 114 static void use_label (tree);
 115 static void check_previous_goto_1 (tree, struct cp_binding_level *, tree,
 116                                    const char *, int);
 117 static void check_previous_goto (struct named_label_use_list *);
 118 static void check_switch_goto (struct cp_binding_level *);
 119 static void check_previous_gotos (tree);
 120 static void pop_label (tree, tree);
 121 static void pop_labels (tree);
 122 static void maybe_deduce_size_from_array_init (tree, tree);
 123 static void layout_var_decl (tree);
 124 static void maybe_commonize_var (tree);
 125 static tree check_initializer (tree, tree, int);
 126 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
 127 static void save_function_data (tree);
 128 static void check_function_type (tree, tree);
 129 static void begin_constructor_body (void);
 130 static void finish_constructor_body (void);
 131 static void begin_destructor_body (void);
 132 static void finish_destructor_body (void);
 133 static tree create_array_type_for_decl (tree, tree, tree);
 134 static tree get_atexit_node (void);
 135 static tree get_dso_handle_node (void);
 136 static tree start_cleanup_fn (void);
 137 static void end_cleanup_fn (void);
 138 static tree cp_make_fname_decl (tree, int);
 139 static void initialize_predefined_identifiers (void);
 140 static tree check_special_function_return_type
 141         (special_function_kind, tree, tree);
 142 static tree push_cp_library_fn (enum tree_code, tree);
 143 static tree build_cp_library_fn (tree, enum tree_code, tree);
 144 static void store_parm_decls (tree);
 145 static int cp_missing_noreturn_ok_p (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 static tree build_typename_type (tree, tree, tree);
 151
 152 #if defined (DEBUG_BINDING_LEVELS)
 153 static void indent (void);
 154 #endif
 155
 156 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 157 tree error_mark_list;
 158
 159 /* The following symbols are subsumed in the cp_global_trees array, and
 160    listed here individually for documentation purposes.
 161
 162    C++ extensions
 163         tree wchar_decl_node;
 164
 165         tree vtable_entry_type;
 166         tree delta_type_node;
 167         tree __t_desc_type_node;
 168         tree ti_desc_type_node;
 169         tree bltn_desc_type_node, ptr_desc_type_node;
 170         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 171         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 172         tree ptm_desc_type_node;
 173         tree base_desc_type_node;
 174
 175         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 176         tree unknown_type_node;
 177
 178    Array type `vtable_entry_type[]'
 179
 180         tree vtbl_type_node;
 181         tree vtbl_ptr_type_node;
 182
 183    Namespaces,
 184
 185         tree std_node;
 186         tree abi_node;
 187
 188    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 189    one that the user will declare, but sufficient to be called
 190    by routines that want to abort the program.
 191
 192         tree abort_fndecl;
 193
 194    The FUNCTION_DECL for the default `::operator delete'.
 195
 196         tree global_delete_fndecl;
 197
 198    Used by RTTI
 199         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 200         tree tinfo_var_id;
 201
 202 */
 203
 204 tree cp_global_trees[CPTI_MAX];
 205
 206 /* Indicates that there is a type value in some namespace, although
 207    that is not necessarily in scope at the moment.  */
 208
 209 static GTY(()) tree global_type_node;
 210
 211 /* Used only for jumps to as-yet undefined labels, since jumps to
 212    defined labels can have their validity checked immediately.  */
 213
 214 struct named_label_use_list GTY(())
 215 {
 216   struct cp_binding_level *binding_level;
 217   tree names_in_scope;
 218   tree label_decl;
 219   const char *filename_o_goto;
 220   int lineno_o_goto;
 221   struct named_label_use_list *next;
 222 };
 223
 224 #define named_label_uses cp_function_chain->x_named_label_uses
 225
 226 #define local_names cp_function_chain->x_local_names
 227
 228 /* A list of objects which have constructors or destructors
 229    which reside in the global scope.  The decl is stored in
 230    the TREE_VALUE slot and the initializer is stored
 231    in the TREE_PURPOSE slot.  */
 232 tree static_aggregates;
 233
 234 /* -- end of C++ */
 235
 236 /* A node for the integer constants 2, and 3.  */
 237
 238 tree integer_two_node, integer_three_node;
 239
 240 /* Similar, for last_function_parm_tags.  */
 241 tree last_function_parms;
 242
 243 /* A list of all LABEL_DECLs in the function that have names.  Here so
 244    we can clear out their names' definitions at the end of the
 245    function, and so we can check the validity of jumps to these labels.  */
 246
 247 struct named_label_list GTY(())
 248 {
 249   struct cp_binding_level *binding_level;
 250   tree names_in_scope;
 251   tree old_value;
 252   tree label_decl;
 253   tree bad_decls;
 254   struct named_label_list *next;
 255   unsigned int in_try_scope : 1;
 256   unsigned int in_catch_scope : 1;
 257 };
 258
 259 #define named_labels cp_function_chain->x_named_labels
 260 \f
 261 /* The name of the anonymous namespace, throughout this translation
 262    unit.  */
 263 tree anonymous_namespace_name;
 264
 265 /* The number of function bodies which we are currently processing.
 266    (Zero if we are at namespace scope, one inside the body of a
 267    function, two inside the body of a function in a local class, etc.)  */
 268 int function_depth;
 269
 270 /* States indicating how grokdeclarator() should handle declspecs marked
 271    with __attribute__((deprecated)).  An object declared as
 272    __attribute__((deprecated)) suppresses warnings of uses of other
 273    deprecated items.  */
 274
 275 enum deprecated_states {
 276   DEPRECATED_NORMAL,
 277   DEPRECATED_SUPPRESS
 278 };
 279
 280 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
 281
 282 /* Set by add_implicitly_declared_members() to keep those members from
 283    being flagged as deprecated or reported as using deprecated
 284    types.  */
 285 int adding_implicit_members = 0;
 286
 287 /* True if a declaration with an `extern' linkage specifier is being
 288    processed.  */
 289 bool have_extern_spec;
 290
 291 \f
 292 /* For each binding contour we allocate a binding_level structure
 293    which records the names defined in that contour.
 294    Contours include:
 295     0) the global one
 296     1) one for each function definition,
 297        where internal declarations of the parameters appear.
 298     2) one for each compound statement,
 299        to record its declarations.
 300
 301    The current meaning of a name can be found by searching the levels
 302    from the current one out to the global one.
 303
 304    Off to the side, may be the class_binding_level.  This exists only
 305    to catch class-local declarations.  It is otherwise nonexistent.
 306
 307    Also there may be binding levels that catch cleanups that must be
 308    run when exceptions occur.  Thus, to see whether a name is bound in
 309    the current scope, it is not enough to look in the
 310    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 311    instead.  */
 312
 313 /* Note that the information in the `names' component of the global contour
 314    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 315
 316 struct cp_binding_level GTY(())
 317   {
 318     /* A chain of _DECL nodes for all variables, constants, functions,
 319        and typedef types.  These are in the reverse of the order
 320        supplied.  There may be OVERLOADs on this list, too, but they
 321        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 322     tree names;
 323
 324     /* Count of elements in names chain.  */
 325     size_t names_size;
 326
 327     /* A chain of NAMESPACE_DECL nodes.  */
 328     tree namespaces;
 329
 330     /* A chain of VTABLE_DECL nodes.  */
 331     tree vtables;
 332
 333     /* A list of structure, union and enum definitions, for looking up
 334        tag names.
 335        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 336        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 337        or ENUMERAL_TYPE node.
 338
 339        C++: the TREE_VALUE nodes can be simple types for
 340        component_bindings.  */
 341     tree tags;
 342
 343     /* A list of USING_DECL nodes.  */
 344     tree usings;
 345
 346     /* A list of used namespaces. PURPOSE is the namespace,
 347        VALUE the common ancestor with this binding_level's namespace.  */
 348     tree using_directives;
 349
 350     /* If this binding level is the binding level for a class, then
 351        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 352        is the name of an entity bound in the class.  The TREE_TYPE is
 353        the DECL bound by this name in the class.  */
 354     tree class_shadowed;
 355
 356     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 357        is used for all binding levels. In addition the TREE_VALUE is the
 358        IDENTIFIER_TYPE_VALUE before we entered the class.  */
 359     tree type_shadowed;
 360
 361     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 362        label in this scope.  The TREE_PURPOSE is the previous value of
 363        the IDENTIFIER_LABEL VALUE.  */
 364     tree shadowed_labels;
 365
 366     /* For each level (except not the global one),
 367        a chain of BLOCK nodes for all the levels
 368        that were entered and exited one level down.  */
 369     tree blocks;
 370
 371     /* The _TYPE node for this level, if parm_flag == 2.  */
 372     tree this_class;
 373
 374     /* The binding level which this one is contained in (inherits from).  */
 375     struct cp_binding_level *level_chain;
 376
 377     /* List of VAR_DECLS saved from a previous for statement.
 378        These would be dead in ISO-conforming code, but might
 379        be referenced in ARM-era code.  These are stored in a
 380        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 381     tree dead_vars_from_for;
 382
 383     /* 1 for the level that holds the parameters of a function.
 384        2 for the level that holds a class declaration.  */
 385     unsigned parm_flag : 2;
 386
 387     /* 1 means make a BLOCK for this level regardless of all else.
 388        2 for temporary binding contours created by the compiler.  */
 389     unsigned keep : 2;
 390
 391     /* Nonzero if this level "doesn't exist" for tags.  */
 392     unsigned tag_transparent : 1;
 393
 394     /* Nonzero if this level can safely have additional
 395        cleanup-needing variables added to it.  */
 396     unsigned more_cleanups_ok : 1;
 397     unsigned have_cleanups : 1;
 398
 399     /* Nonzero if this scope is for storing the decls for template
 400        parameters and generic decls; these decls will be discarded and
 401        replaced with a TEMPLATE_DECL.  */
 402     unsigned template_parms_p : 1;
 403
 404     /* Nonzero if this scope corresponds to the `<>' in a
 405        `template <>' clause.  Whenever this flag is set,
 406        TEMPLATE_PARMS_P will be set as well.  */
 407     unsigned template_spec_p : 1;
 408
 409     /* This is set for a namespace binding level.  */
 410     unsigned namespace_p : 1;
 411
 412     /* True if this level is that of a for-statement where we need to
 413        worry about ambiguous (ARM or ISO) scope rules.  */
 414     unsigned is_for_scope : 1;
 415
 416     /* True if this level corresponds to a TRY block.  Currently this
 417        information is only available while building the tree structure.  */
 418     unsigned is_try_scope : 1;
 419
 420     /* True if this level corresponds to a CATCH block.  Currently this
 421        information is only available while building the tree structure.  */
 422     unsigned is_catch_scope : 1;
 423
 424     /* Three bits left for this word.  */
 425
 426     /* Binding depth at which this level began.  */
 427     unsigned binding_depth;
 428   };
 429
 430 #define NULL_BINDING_LEVEL ((struct cp_binding_level *) NULL)
 431
 432 /* The binding level currently in effect.  */
 433
 434 #define current_binding_level                   \
 435   (cfun && cp_function_chain->bindings          \
 436    ? cp_function_chain->bindings                \
 437    : scope_chain->bindings)
 438
 439 /* The binding level of the current class, if any.  */
 440
 441 #define class_binding_level scope_chain->class_bindings
 442
 443 /* A chain of binding_level structures awaiting reuse.  */
 444
 445 static GTY((deletable (""))) struct cp_binding_level *free_binding_level;
 446
 447 /* The outermost binding level, for names of file scope.
 448    This is created when the compiler is started and exists
 449    through the entire run.  */
 450
 451 static GTY(()) struct cp_binding_level *global_binding_level;
 452
 453 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 454
 455 static int keep_next_level_flag;
 456
 457 /* A TREE_LIST of VAR_DECLs.  The TREE_PURPOSE is a RECORD_TYPE or
 458    UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type.  At the
 459    time the VAR_DECL was declared, the type was incomplete.  */
 460
 461 static GTY(()) tree incomplete_vars;
 462
 463 #if defined(DEBUG_BINDING_LEVELS)
 464 static int binding_depth = 0;
 465 static int is_class_level = 0;
 466
 467 static void
 468 indent (void)
 469 {
 470   register unsigned i;
 471
 472   for (i = 0; i < binding_depth*2; i++)
 473     putc (' ', stderr);
 474 }
 475 #endif /* defined(DEBUG_BINDING_LEVELS) */
 476
 477 static tree pushdecl_with_scope (tree, struct cp_binding_level *);
 478
 479 static void
 480 push_binding_level (struct cp_binding_level *newlevel,
 481                     int tag_transparent,
 482                     int keep)
 483 {
 484   /* Add this level to the front of the chain (stack) of levels that
 485      are active.  */
 486   memset ((char*) newlevel, 0, sizeof (struct cp_binding_level));
 487   newlevel->level_chain = current_binding_level;
 488   current_binding_level = newlevel;
 489   newlevel->tag_transparent = tag_transparent;
 490   newlevel->more_cleanups_ok = 1;
 491
 492   newlevel->keep = keep;
 493 #if defined(DEBUG_BINDING_LEVELS)
 494   newlevel->binding_depth = binding_depth;
 495   indent ();
 496   fprintf (stderr, "push %s level 0x%08x line %d\n",
 497            (is_class_level) ? "class" : "block", newlevel, lineno);
 498   is_class_level = 0;
 499   binding_depth++;
 500 #endif /* defined(DEBUG_BINDING_LEVELS) */
 501 }
 502
 503 /* Find the innermost enclosing class scope, and reset
 504    CLASS_BINDING_LEVEL appropriately.  */
 505
 506 static void
 507 find_class_binding_level (void)
 508 {
 509   struct cp_binding_level *level = current_binding_level;
 510
 511   while (level && level->parm_flag != 2)
 512     level = level->level_chain;
 513   if (level && level->parm_flag == 2)
 514     class_binding_level = level;
 515   else
 516     class_binding_level = 0;
 517 }
 518
 519 static void
 520 pop_binding_level (void)
 521 {
 522   if (global_binding_level)
 523     {
 524       /* Cannot pop a level, if there are none left to pop.  */
 525       if (current_binding_level == global_binding_level)
 526         abort ();
 527     }
 528   /* Pop the current level, and free the structure for reuse.  */
 529 #if defined(DEBUG_BINDING_LEVELS)
 530   binding_depth--;
 531   indent ();
 532   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 533           (is_class_level) ? "class" : "block",
 534           current_binding_level, lineno);
 535   if (is_class_level != (current_binding_level == class_binding_level))
 536     {
 537       indent ();
 538       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 539     }
 540   is_class_level = 0;
 541 #endif /* defined(DEBUG_BINDING_LEVELS) */
 542   {
 543     register struct cp_binding_level *level = current_binding_level;
 544     current_binding_level = current_binding_level->level_chain;
 545     level->level_chain = free_binding_level;
 546 #if 0 /* defined(DEBUG_BINDING_LEVELS) */
 547     if (level->binding_depth != binding_depth)
 548       abort ();
 549 #endif /* defined(DEBUG_BINDING_LEVELS) */
 550     free_binding_level = level;
 551     find_class_binding_level ();
 552   }
 553 }
 554
 555 static void
 556 suspend_binding_level (void)
 557 {
 558   if (class_binding_level)
 559     current_binding_level = class_binding_level;
 560
 561   if (global_binding_level)
 562     {
 563       /* Cannot suspend a level, if there are none left to suspend.  */
 564       if (current_binding_level == global_binding_level)
 565         abort ();
 566     }
 567   /* Suspend the current level.  */
 568 #if defined(DEBUG_BINDING_LEVELS)
 569   binding_depth--;
 570   indent ();
 571   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 572           (is_class_level) ? "class" : "block",
 573           current_binding_level, lineno);
 574   if (is_class_level != (current_binding_level == class_binding_level))
 575     {
 576       indent ();
 577       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 578     }
 579   is_class_level = 0;
 580 #endif /* defined(DEBUG_BINDING_LEVELS) */
 581   current_binding_level = current_binding_level->level_chain;
 582   find_class_binding_level ();
 583 }
 584
 585 static void
 586 resume_binding_level (struct cp_binding_level* b)
 587 {
 588   /* Resuming binding levels is meant only for namespaces,
 589      and those cannot nest into classes.  */
 590   my_friendly_assert(!class_binding_level, 386);
 591   /* Also, resuming a non-directly nested namespace is a no-no.  */
 592   my_friendly_assert(b->level_chain == current_binding_level, 386);
 593   current_binding_level = b;
 594 #if defined(DEBUG_BINDING_LEVELS)
 595   b->binding_depth = binding_depth;
 596   indent ();
 597   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 598            (is_class_level) ? "class" : "block", b, lineno);
 599   is_class_level = 0;
 600   binding_depth++;
 601 #endif /* defined(DEBUG_BINDING_LEVELS) */
 602 }
 603 \f
 604 /* Create a new `struct cp_binding_level'.  */
 605
 606 static
 607 struct cp_binding_level *
 608 make_binding_level (void)
 609 {
 610   /* NOSTRICT */
 611   return (struct cp_binding_level *) ggc_alloc (sizeof (struct cp_binding_level));
 612 }
 613
 614 /* Nonzero if we are currently in the global binding level.  */
 615
 616 int
 617 global_bindings_p (void)
 618 {
 619   return current_binding_level == global_binding_level;
 620 }
 621
 622 /* Return the innermost binding level that is not for a class scope.  */
 623
 624 static struct cp_binding_level *
 625 innermost_nonclass_level (void)
 626 {
 627   struct cp_binding_level *b;
 628
 629   b = current_binding_level;
 630   while (b->parm_flag == 2)
 631     b = b->level_chain;
 632
 633   return b;
 634 }
 635
 636 /* Nonzero if we are currently in a toplevel binding level.  This
 637    means either the global binding level or a namespace in a toplevel
 638    binding level.  Since there are no non-toplevel namespace levels,
 639    this really means any namespace or template parameter level.  We
 640    also include a class whose context is toplevel.  */
 641
 642 int
 643 toplevel_bindings_p (void)
 644 {
 645   struct cp_binding_level *b = innermost_nonclass_level ();
 646
 647   return b->namespace_p || b->template_parms_p;
 648 }
 649
 650 /* Nonzero if this is a namespace scope, or if we are defining a class
 651    which is itself at namespace scope, or whose enclosing class is
 652    such a class, etc.  */
 653
 654 int
 655 namespace_bindings_p (void)
 656 {
 657   struct cp_binding_level *b = innermost_nonclass_level ();
 658
 659   return b->namespace_p;
 660 }
 661
 662 /* If KEEP is nonzero, make a BLOCK node for the next binding level,
 663    unconditionally.  Otherwise, use the normal logic to decide whether
 664    or not to create a BLOCK.  */
 665
 666 void
 667 keep_next_level (int keep)
 668 {
 669   keep_next_level_flag = keep;
 670 }
 671
 672 /* Nonzero if the current level needs to have a BLOCK made.  */
 673
 674 int
 675 kept_level_p (void)
 676 {
 677   return (current_binding_level->blocks != NULL_TREE
 678           || current_binding_level->keep
 679           || current_binding_level->names != NULL_TREE
 680           || (current_binding_level->tags != NULL_TREE
 681               && !current_binding_level->tag_transparent));
 682 }
 683
 684 static void
 685 declare_namespace_level (void)
 686 {
 687   current_binding_level->namespace_p = 1;
 688 }
 689
 690 /* Returns nonzero if this scope was created to store template
 691    parameters.  */
 692
 693 int
 694 template_parm_scope_p (void)
 695 {
 696   return current_binding_level->template_parms_p;
 697 }
 698
 699 /* Returns the kind of template specialization we are currently
 700    processing, given that it's declaration contained N_CLASS_SCOPES
 701    explicit scope qualifications.  */
 702
 703 tmpl_spec_kind
 704 current_tmpl_spec_kind (int n_class_scopes)
 705 {
 706   int n_template_parm_scopes = 0;
 707   int seen_specialization_p = 0;
 708   int innermost_specialization_p = 0;
 709   struct cp_binding_level *b;
 710
 711   /* Scan through the template parameter scopes.  */
 712   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 713     {
 714       /* If we see a specialization scope inside a parameter scope,
 715          then something is wrong.  That corresponds to a declaration
 716          like:
 717
 718             template <class T> template <> ...
 719
 720          which is always invalid since [temp.expl.spec] forbids the
 721          specialization of a class member template if the enclosing
 722          class templates are not explicitly specialized as well.  */
 723       if (b->template_spec_p)
 724         {
 725           if (n_template_parm_scopes == 0)
 726             innermost_specialization_p = 1;
 727           else
 728             seen_specialization_p = 1;
 729         }
 730       else if (seen_specialization_p == 1)
 731         return tsk_invalid_member_spec;
 732
 733       ++n_template_parm_scopes;
 734     }
 735
 736   /* Handle explicit instantiations.  */
 737   if (processing_explicit_instantiation)
 738     {
 739       if (n_template_parm_scopes != 0)
 740         /* We've seen a template parameter list during an explicit
 741            instantiation.  For example:
 742
 743              template <class T> template void f(int);
 744
 745            This is erroneous.  */
 746         return tsk_invalid_expl_inst;
 747       else
 748         return tsk_expl_inst;
 749     }
 750
 751   if (n_template_parm_scopes < n_class_scopes)
 752     /* We've not seen enough template headers to match all the
 753        specialized classes present.  For example:
 754
 755          template <class T> void R<T>::S<T>::f(int);
 756
 757        This is invalid; there needs to be one set of template
 758        parameters for each class.  */
 759     return tsk_insufficient_parms;
 760   else if (n_template_parm_scopes == n_class_scopes)
 761     /* We're processing a non-template declaration (even though it may
 762        be a member of a template class.)  For example:
 763
 764          template <class T> void S<T>::f(int);
 765
 766        The `class T' maches the `S<T>', leaving no template headers
 767        corresponding to the `f'.  */
 768     return tsk_none;
 769   else if (n_template_parm_scopes > n_class_scopes + 1)
 770     /* We've got too many template headers.  For example:
 771
 772          template <> template <class T> void f (T);
 773
 774        There need to be more enclosing classes.  */
 775     return tsk_excessive_parms;
 776   else
 777     /* This must be a template.  It's of the form:
 778
 779          template <class T> template <class U> void S<T>::f(U);
 780
 781        This is a specialization if the innermost level was a
 782        specialization; otherwise it's just a definition of the
 783        template.  */
 784     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 785 }
 786
 787 void
 788 set_class_shadows (tree shadows)
 789 {
 790   class_binding_level->class_shadowed = shadows;
 791 }
 792
 793 /* Enter a new binding level.
 794    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 795    not for that of tags.  */
 796
 797 void
 798 pushlevel (int tag_transparent)
 799 {
 800   struct cp_binding_level *newlevel;
 801
 802   if (cfun && !doing_semantic_analysis_p ())
 803     return;
 804
 805   /* Reuse or create a struct for this binding level.  */
 806 #if defined(DEBUG_BINDING_LEVELS)
 807   if (0)
 808 #else /* !defined(DEBUG_BINDING_LEVELS) */
 809   if (free_binding_level)
 810 #endif /* !defined(DEBUG_BINDING_LEVELS) */
 811     {
 812       newlevel = free_binding_level;
 813       free_binding_level = free_binding_level->level_chain;
 814     }
 815   else
 816     newlevel = make_binding_level ();
 817
 818   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 819   keep_next_level_flag = 0;
 820 }
 821
 822 /* We're defining an object of type TYPE.  If it needs a cleanup, but
 823    we're not allowed to add any more objects with cleanups to the current
 824    scope, create a new binding level.  */
 825
 826 void
 827 maybe_push_cleanup_level (tree type)
 828 {
 829   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
 830       && current_binding_level->more_cleanups_ok == 0)
 831     {
 832       keep_next_level (2);
 833       pushlevel (1);
 834       clear_last_expr ();
 835       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
 836     }
 837 }
 838
 839 /* Enter a new scope.  The KIND indicates what kind of scope is being
 840    created.  */
 841
 842 void
 843 begin_scope (scope_kind sk)
 844 {
 845   pushlevel (0);
 846
 847   switch (sk)
 848     {
 849     case sk_block:
 850       break;
 851
 852     case sk_try:
 853       current_binding_level->is_try_scope = 1;
 854       break;
 855
 856     case sk_catch:
 857       current_binding_level->is_catch_scope = 1;
 858       break;
 859
 860     case sk_for:
 861       current_binding_level->is_for_scope = 1;
 862       break;
 863
 864     case sk_template_spec:
 865       current_binding_level->template_spec_p = 1;
 866       /* Fall through.  */
 867
 868     case sk_template_parms:
 869       current_binding_level->template_parms_p = 1;
 870       break;
 871
 872     default:
 873       abort ();
 874     }
 875 }
 876
 877 /* Exit the current scope.  */
 878
 879 void
 880 finish_scope (void)
 881 {
 882   poplevel (0, 0, 0);
 883 }
 884
 885 /* For a binding between a name and an entity at a block scope,
 886    this is the `struct cp_binding_level' for the block.  */
 887 #define BINDING_LEVEL(NODE) \
 888   (((struct tree_binding*)(NODE))->scope.level)
 889
 890 /* A free list of CPLUS_BINDING nodes, connected by their
 891    TREE_CHAINs.  */
 892
 893 static GTY((deletable (""))) tree free_bindings;
 894
 895 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 896    level at which this declaration is being bound.  */
 897
 898 static void
 899 push_binding (tree id,
 900               tree decl,
 901               struct cp_binding_level* level)
 902 {
 903   tree binding;
 904
 905   if (free_bindings)
 906     {
 907       binding = free_bindings;
 908       free_bindings = TREE_CHAIN (binding);
 909     }
 910   else
 911     binding = make_node (CPLUS_BINDING);
 912
 913   /* Now, fill in the binding information.  */
 914   BINDING_VALUE (binding) = decl;
 915   BINDING_TYPE (binding) = NULL_TREE;
 916   BINDING_LEVEL (binding) = level;
 917   INHERITED_VALUE_BINDING_P (binding) = 0;
 918   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 919   BINDING_HAS_LEVEL_P (binding) = 1;
 920
 921   /* And put it on the front of the list of bindings for ID.  */
 922   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 923   IDENTIFIER_BINDING (id) = binding;
 924 }
 925
 926 /* ID is already bound in the current scope.  But, DECL is an
 927    additional binding for ID in the same scope.  This is the `struct
 928    stat' hack whereby a non-typedef class-name or enum-name can be
 929    bound at the same level as some other kind of entity.  It's the
 930    responsibility of the caller to check that inserting this name is
 931    valid here.  Returns nonzero if the new binding was successful.  */
 932 static int
 933 add_binding (tree id, tree decl)
 934 {
 935   tree binding = IDENTIFIER_BINDING (id);
 936   int ok = 1;
 937
 938   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 939     /* The new name is the type name.  */
 940     BINDING_TYPE (binding) = decl;
 941   else if (!BINDING_VALUE (binding))
 942     /* This situation arises when push_class_level_binding moves an
 943        inherited type-binding out of the way to make room for a new
 944        value binding.  */
 945     BINDING_VALUE (binding) = decl;
 946   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 947            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 948     {
 949       /* The old binding was a type name.  It was placed in
 950          BINDING_VALUE because it was thought, at the point it was
 951          declared, to be the only entity with such a name.  Move the
 952          type name into the type slot; it is now hidden by the new
 953          binding.  */
 954       BINDING_TYPE (binding) = BINDING_VALUE (binding);
 955       BINDING_VALUE (binding) = decl;
 956       INHERITED_VALUE_BINDING_P (binding) = 0;
 957     }
 958   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 959            && TREE_CODE (decl) == TYPE_DECL
 960            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
 961            && (same_type_p (TREE_TYPE (decl),
 962                             TREE_TYPE (BINDING_VALUE (binding)))
 963                /* If either type involves template parameters, we must
 964                   wait until instantiation.  */
 965                || uses_template_parms (TREE_TYPE (decl))
 966                || uses_template_parms (TREE_TYPE (BINDING_VALUE (binding)))))
 967     /* We have two typedef-names, both naming the same type to have
 968        the same name.  This is OK because of:
 969
 970          [dcl.typedef]
 971
 972          In a given scope, a typedef specifier can be used to redefine
 973          the name of any type declared in that scope to refer to the
 974          type to which it already refers.  */
 975     ok = 0;
 976   /* There can be two block-scope declarations of the same variable,
 977      so long as they are `extern' declarations.  */
 978   else if (TREE_CODE (decl) == VAR_DECL
 979            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
 980            && DECL_EXTERNAL (decl)
 981            && DECL_EXTERNAL (BINDING_VALUE (binding)))
 982     {
 983       duplicate_decls (decl, BINDING_VALUE (binding));
 984       ok = 0;
 985     }
 986   else
 987     {
 988       error ("declaration of `%#D'", decl);
 989       cp_error_at ("conflicts with previous declaration `%#D'",
 990                    BINDING_VALUE (binding));
 991       ok = 0;
 992     }
 993
 994   return ok;
 995 }
 996
 997 /* Add DECL to the list of things declared in B.  */
 998
 999 static void
1000 add_decl_to_level (tree decl,
1001                    struct cp_binding_level* b)
1002 {
1003   if (TREE_CODE (decl) == NAMESPACE_DECL
1004       && !DECL_NAMESPACE_ALIAS (decl))
1005     {
1006       TREE_CHAIN (decl) = b->namespaces;
1007       b->namespaces = decl;
1008     }
1009   else if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
1010     {
1011       TREE_CHAIN (decl) = b->vtables;
1012       b->vtables = decl;
1013     }
1014   else
1015     {
1016       /* We build up the list in reverse order, and reverse it later if
1017          necessary.  */
1018       TREE_CHAIN (decl) = b->names;
1019       b->names = decl;
1020       b->names_size++;
1021     }
1022 }
1023
1024 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1025    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1026    doesn't really belong to this binding level, that it got here
1027    through a using-declaration.  */
1028
1029 void
1030 push_local_binding (tree id, tree decl, int flags)
1031 {
1032   struct cp_binding_level *b;
1033
1034   /* Skip over any local classes.  This makes sense if we call
1035      push_local_binding with a friend decl of a local class.  */
1036   b = current_binding_level;
1037   while (b->parm_flag == 2)
1038     b = b->level_chain;
1039
1040   if (lookup_name_current_level (id))
1041     {
1042       /* Supplement the existing binding.  */
1043       if (!add_binding (id, decl))
1044         /* It didn't work.  Something else must be bound at this
1045            level.  Do not add DECL to the list of things to pop
1046            later.  */
1047         return;
1048     }
1049   else
1050     /* Create a new binding.  */
1051     push_binding (id, decl, b);
1052
1053   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1054     /* We must put the OVERLOAD into a TREE_LIST since the
1055        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1056        decls that got here through a using-declaration.  */
1057     decl = build_tree_list (NULL_TREE, decl);
1058
1059   /* And put DECL on the list of things declared by the current
1060      binding level.  */
1061   add_decl_to_level (decl, b);
1062 }
1063
1064 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1065    binding was successful.  */
1066
1067 int
1068 push_class_binding (tree id, tree decl)
1069 {
1070   int result = 1;
1071   tree binding = IDENTIFIER_BINDING (id);
1072   tree context;
1073
1074   /* Note that we declared this value so that we can issue an error if
1075      this is an invalid redeclaration of a name already used for some
1076      other purpose.  */
1077   note_name_declared_in_class (id, decl);
1078
1079   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1080     /* Supplement the existing binding.  */
1081     result = add_binding (id, decl);
1082   else
1083     /* Create a new binding.  */
1084     push_binding (id, decl, class_binding_level);
1085
1086   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1087      class-level declaration.  Note that we do not use DECL here
1088      because of the possibility of the `struct stat' hack; if DECL is
1089      a class-name or enum-name we might prefer a field-name, or some
1090      such.  */
1091   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1092
1093   /* If this is a binding from a base class, mark it as such.  */
1094   binding = IDENTIFIER_BINDING (id);
1095   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1096     {
1097       if (TREE_CODE (decl) == OVERLOAD)
1098         context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1099       else
1100         {
1101           my_friendly_assert (DECL_P (decl), 0);
1102           context = context_for_name_lookup (decl);
1103         }
1104
1105       if (is_properly_derived_from (current_class_type, context))
1106         INHERITED_VALUE_BINDING_P (binding) = 1;
1107       else
1108         INHERITED_VALUE_BINDING_P (binding) = 0;
1109     }
1110   else if (BINDING_VALUE (binding) == decl)
1111     /* We only encounter a TREE_LIST when push_class_decls detects an
1112        ambiguity.  Such an ambiguity can be overridden by a definition
1113        in this class.  */
1114     INHERITED_VALUE_BINDING_P (binding) = 1;
1115
1116   return result;
1117 }
1118
1119 /* Remove the binding for DECL which should be the innermost binding
1120    for ID.  */
1121
1122 static void
1123 pop_binding (tree id, tree decl)
1124 {
1125   tree binding;
1126
1127   if (id == NULL_TREE)
1128     /* It's easiest to write the loops that call this function without
1129        checking whether or not the entities involved have names.  We
1130        get here for such an entity.  */
1131     return;
1132
1133   /* Get the innermost binding for ID.  */
1134   binding = IDENTIFIER_BINDING (id);
1135
1136   /* The name should be bound.  */
1137   my_friendly_assert (binding != NULL_TREE, 0);
1138
1139   /* The DECL will be either the ordinary binding or the type
1140      binding for this identifier.  Remove that binding.  */
1141   if (BINDING_VALUE (binding) == decl)
1142     BINDING_VALUE (binding) = NULL_TREE;
1143   else if (BINDING_TYPE (binding) == decl)
1144     BINDING_TYPE (binding) = NULL_TREE;
1145   else
1146     abort ();
1147
1148   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1149     {
1150       /* We're completely done with the innermost binding for this
1151          identifier.  Unhook it from the list of bindings.  */
1152       IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1153
1154       /* Add it to the free list.  */
1155       TREE_CHAIN (binding) = free_bindings;
1156       free_bindings = binding;
1157
1158       /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
1159          it.  */
1160       BINDING_LEVEL (binding) = NULL;
1161     }
1162 }
1163
1164 /* When a label goes out of scope, check to see if that label was used
1165    in a valid manner, and issue any appropriate warnings or errors.  */
1166
1167 static void
1168 pop_label (tree label, tree old_value)
1169 {
1170   if (!processing_template_decl && doing_semantic_analysis_p ())
1171     {
1172       if (DECL_INITIAL (label) == NULL_TREE)
1173         {
1174           cp_error_at ("label `%D' used but not defined", label);
1175           /* Avoid crashing later.  */
1176           define_label (input_filename, 1, DECL_NAME (label));
1177         }
1178       else if (warn_unused_label && !TREE_USED (label))
1179         cp_warning_at ("label `%D' defined but not used", label);
1180     }
1181
1182   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1183 }
1184
1185 /* At the end of a function, all labels declared within the function
1186    go out of scope.  BLOCK is the top-level block for the
1187    function.  */
1188
1189 static void
1190 pop_labels (tree block)
1191 {
1192   struct named_label_list *link;
1193
1194   /* Clear out the definitions of all label names, since their scopes
1195      end here.  */
1196   for (link = named_labels; link; link = link->next)
1197     {
1198       pop_label (link->label_decl, link->old_value);
1199       /* Put the labels into the "variables" of the top-level block,
1200          so debugger can see them.  */
1201       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1202       BLOCK_VARS (block) = link->label_decl;
1203     }
1204
1205   named_labels = NULL;
1206 }
1207
1208 /* Exit a binding level.
1209    Pop the level off, and restore the state of the identifier-decl mappings
1210    that were in effect when this level was entered.
1211
1212    If KEEP == 1, this level had explicit declarations, so
1213    and create a "block" (a BLOCK node) for the level
1214    to record its declarations and subblocks for symbol table output.
1215
1216    If FUNCTIONBODY is nonzero, this level is the body of a function,
1217    so create a block as if KEEP were set and also clear out all
1218    label names.
1219
1220    If REVERSE is nonzero, reverse the order of decls before putting
1221    them into the BLOCK.  */
1222
1223 tree
1224 poplevel (int keep, int reverse, int functionbody)
1225 {
1226   register tree link;
1227   /* The chain of decls was accumulated in reverse order.
1228      Put it into forward order, just for cleanliness.  */
1229   tree decls;
1230   int tmp = functionbody;
1231   int real_functionbody;
1232   tree tags;
1233   tree subblocks;
1234   tree block = NULL_TREE;
1235   tree decl;
1236   int leaving_for_scope;
1237
1238   timevar_push (TV_NAME_LOOKUP);
1239   if (cfun && !doing_semantic_analysis_p ())
1240     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1241
1242   my_friendly_assert (current_binding_level->parm_flag != 2,
1243                       19990916);
1244
1245   real_functionbody = (current_binding_level->keep == 2
1246                        ? ((functionbody = 0), tmp) : functionbody);
1247   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1248   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1249
1250   my_friendly_assert (!current_binding_level->class_shadowed,
1251                       19990414);
1252
1253   /* We used to use KEEP == 2 to indicate that the new block should go
1254      at the beginning of the list of blocks at this binding level,
1255      rather than the end.  This hack is no longer used.  */
1256   my_friendly_assert (keep == 0 || keep == 1, 0);
1257
1258   if (current_binding_level->keep == 1)
1259     keep = 1;
1260
1261   /* Any uses of undefined labels, and any defined labels, now operate
1262      under constraints of next binding contour.  */
1263   if (cfun && !functionbody)
1264     {
1265       struct cp_binding_level *level_chain;
1266       level_chain = current_binding_level->level_chain;
1267       if (level_chain)
1268         {
1269           struct named_label_use_list *uses;
1270           struct named_label_list *labels;
1271           for (labels = named_labels; labels; labels = labels->next)
1272             if (labels->binding_level == current_binding_level)
1273               {
1274                 tree decl;
1275                 if (current_binding_level->is_try_scope)
1276                   labels->in_try_scope = 1;
1277                 if (current_binding_level->is_catch_scope)
1278                   labels->in_catch_scope = 1;
1279                 for (decl = labels->names_in_scope; decl;
1280                      decl = TREE_CHAIN (decl))
1281                   if (decl_jump_unsafe (decl))
1282                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1283                                                    labels->bad_decls);
1284                 labels->binding_level = level_chain;
1285                 labels->names_in_scope = level_chain->names;
1286               }
1287
1288           for (uses = named_label_uses; uses; uses = uses->next)
1289             if (uses->binding_level == current_binding_level)
1290               {
1291                 uses->binding_level = level_chain;
1292                 uses->names_in_scope = level_chain->names;
1293               }
1294         }
1295     }
1296
1297   /* Get the decls in the order they were written.
1298      Usually current_binding_level->names is in reverse order.
1299      But parameter decls were previously put in forward order.  */
1300
1301   if (reverse)
1302     current_binding_level->names
1303       = decls = nreverse (current_binding_level->names);
1304   else
1305     decls = current_binding_level->names;
1306
1307   /* Output any nested inline functions within this block
1308      if they weren't already output.  */
1309   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1310     if (TREE_CODE (decl) == FUNCTION_DECL
1311         && ! TREE_ASM_WRITTEN (decl)
1312         && DECL_INITIAL (decl) != NULL_TREE
1313         && TREE_ADDRESSABLE (decl)
1314         && decl_function_context (decl) == current_function_decl)
1315       {
1316         /* If this decl was copied from a file-scope decl
1317            on account of a block-scope extern decl,
1318            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1319         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1320           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1321         else
1322           {
1323             push_function_context ();
1324             output_inline_function (decl);
1325             pop_function_context ();
1326           }
1327       }
1328
1329   /* When not in function-at-a-time mode, expand_end_bindings will
1330      warn about unused variables.  But, in function-at-a-time mode
1331      expand_end_bindings is not passed the list of variables in the
1332      current scope, and therefore no warning is emitted.  So, we
1333      explicitly warn here.  */
1334   if (!processing_template_decl)
1335     warn_about_unused_variables (getdecls ());
1336
1337   /* If there were any declarations or structure tags in that level,
1338      or if this level is a function body,
1339      create a BLOCK to record them for the life of this function.  */
1340   block = NULL_TREE;
1341   if (keep == 1 || functionbody)
1342     block = make_node (BLOCK);
1343   if (block != NULL_TREE)
1344     {
1345       BLOCK_VARS (block) = decls;
1346       BLOCK_SUBBLOCKS (block) = subblocks;
1347     }
1348
1349   /* In each subblock, record that this is its superior.  */
1350   if (keep >= 0)
1351     for (link = subblocks; link; link = TREE_CHAIN (link))
1352       BLOCK_SUPERCONTEXT (link) = block;
1353
1354   /* We still support the old for-scope rules, whereby the variables
1355      in a for-init statement were in scope after the for-statement
1356      ended.  We only use the new rules if flag_new_for_scope is
1357      nonzero.  */
1358   leaving_for_scope
1359     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1360
1361   /* Remove declarations for all the DECLs in this level.  */
1362   for (link = decls; link; link = TREE_CHAIN (link))
1363     {
1364       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1365           && DECL_NAME (link))
1366         {
1367           tree outer_binding
1368             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1369           tree ns_binding;
1370
1371           if (!outer_binding)
1372             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1373           else
1374             ns_binding = NULL_TREE;
1375
1376           if (outer_binding
1377               && (BINDING_LEVEL (outer_binding)
1378                   == current_binding_level->level_chain))
1379             /* We have something like:
1380
1381                  int i;
1382                  for (int i; ;);
1383
1384                and we are leaving the `for' scope.  There's no reason to
1385                keep the binding of the inner `i' in this case.  */
1386             pop_binding (DECL_NAME (link), link);
1387           else if ((outer_binding
1388                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1389                         == TYPE_DECL))
1390                    || (ns_binding
1391                        && TREE_CODE (ns_binding) == TYPE_DECL))
1392             /* Here, we have something like:
1393
1394                  typedef int I;
1395
1396                  void f () {
1397                    for (int I; ;);
1398                  }
1399
1400                We must pop the for-scope binding so we know what's a
1401                type and what isn't.  */
1402             pop_binding (DECL_NAME (link), link);
1403           else
1404             {
1405               /* Mark this VAR_DECL as dead so that we can tell we left it
1406                  there only for backward compatibility.  */
1407               DECL_DEAD_FOR_LOCAL (link) = 1;
1408
1409               /* Keep track of what should of have happenned when we
1410                  popped the binding.  */
1411               if (outer_binding && BINDING_VALUE (outer_binding))
1412                 DECL_SHADOWED_FOR_VAR (link)
1413                   = BINDING_VALUE (outer_binding);
1414
1415               /* Add it to the list of dead variables in the next
1416                  outermost binding to that we can remove these when we
1417                  leave that binding.  */
1418               current_binding_level->level_chain->dead_vars_from_for
1419                 = tree_cons (NULL_TREE, link,
1420                              current_binding_level->level_chain->
1421                              dead_vars_from_for);
1422
1423               /* Although we don't pop the CPLUS_BINDING, we do clear
1424                  its BINDING_LEVEL since the level is going away now.  */
1425               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1426                 = 0;
1427             }
1428         }
1429       else
1430         {
1431           /* Remove the binding.  */
1432           decl = link;
1433           if (TREE_CODE (decl) == TREE_LIST)
1434             decl = TREE_VALUE (decl);
1435           if (DECL_P (decl))
1436             pop_binding (DECL_NAME (decl), decl);
1437           else if (TREE_CODE (decl) == OVERLOAD)
1438             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1439           else
1440             abort ();
1441         }
1442     }
1443
1444   /* Remove declarations for any `for' variables from inner scopes
1445      that we kept around.  */
1446   for (link = current_binding_level->dead_vars_from_for;
1447        link; link = TREE_CHAIN (link))
1448     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1449
1450   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1451   for (link = current_binding_level->type_shadowed;
1452        link; link = TREE_CHAIN (link))
1453     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1454
1455   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1456   for (link = current_binding_level->shadowed_labels;
1457        link;
1458        link = TREE_CHAIN (link))
1459     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1460
1461   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1462      list if a `using' declaration put them there.  The debugging
1463      back-ends won't understand OVERLOAD, so we remove them here.
1464      Because the BLOCK_VARS are (temporarily) shared with
1465      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1466      popped all the bindings.  */
1467   if (block)
1468     {
1469       tree* d;
1470
1471       for (d = &BLOCK_VARS (block); *d; )
1472         {
1473           if (TREE_CODE (*d) == TREE_LIST)
1474             *d = TREE_CHAIN (*d);
1475           else
1476             d = &TREE_CHAIN (*d);
1477         }
1478     }
1479
1480   /* If the level being exited is the top level of a function,
1481      check over all the labels.  */
1482   if (functionbody)
1483     {
1484       /* Since this is the top level block of a function, the vars are
1485          the function's parameters.  Don't leave them in the BLOCK
1486          because they are found in the FUNCTION_DECL instead.  */
1487       BLOCK_VARS (block) = 0;
1488       pop_labels (block);
1489     }
1490
1491   tmp = current_binding_level->keep;
1492
1493   pop_binding_level ();
1494   if (functionbody)
1495     DECL_INITIAL (current_function_decl) = block;
1496   else if (block)
1497     current_binding_level->blocks
1498       = chainon (current_binding_level->blocks, block);
1499
1500   /* If we did not make a block for the level just exited,
1501      any blocks made for inner levels
1502      (since they cannot be recorded as subblocks in that level)
1503      must be carried forward so they will later become subblocks
1504      of something else.  */
1505   else if (subblocks)
1506     current_binding_level->blocks
1507       = chainon (current_binding_level->blocks, subblocks);
1508
1509   /* Each and every BLOCK node created here in `poplevel' is important
1510      (e.g. for proper debugging information) so if we created one
1511      earlier, mark it as "used".  */
1512   if (block)
1513     TREE_USED (block) = 1;
1514
1515   /* Take care of compiler's internal binding structures.  */
1516   if (tmp == 2)
1517     {
1518       tree scope_stmts;
1519
1520       scope_stmts
1521         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1522       if (block)
1523         {
1524           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1525           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1526         }
1527
1528       block = poplevel (keep, reverse, functionbody);
1529     }
1530
1531   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
1532 }
1533
1534 /* Delete the node BLOCK from the current binding level.
1535    This is used for the block inside a stmt expr ({...})
1536    so that the block can be reinserted where appropriate.  */
1537
1538 void
1539 delete_block (tree block)
1540 {
1541   tree t;
1542   if (current_binding_level->blocks == block)
1543     current_binding_level->blocks = TREE_CHAIN (block);
1544   for (t = current_binding_level->blocks; t;)
1545     {
1546       if (TREE_CHAIN (t) == block)
1547         TREE_CHAIN (t) = TREE_CHAIN (block);
1548       else
1549         t = TREE_CHAIN (t);
1550     }
1551   TREE_CHAIN (block) = NULL_TREE;
1552   /* Clear TREE_USED which is always set by poplevel.
1553      The flag is set again if insert_block is called.  */
1554   TREE_USED (block) = 0;
1555 }
1556
1557 /* Insert BLOCK at the end of the list of subblocks of the
1558    current binding level.  This is used when a BIND_EXPR is expanded,
1559    to handle the BLOCK node inside the BIND_EXPR.  */
1560
1561 void
1562 insert_block (tree block)
1563 {
1564   TREE_USED (block) = 1;
1565   current_binding_level->blocks
1566     = chainon (current_binding_level->blocks, block);
1567 }
1568
1569 /* Set the BLOCK node for the innermost scope
1570    (the one we are currently in).  */
1571
1572 void
1573 set_block (tree block ATTRIBUTE_UNUSED )
1574 {
1575   /* The RTL expansion machinery requires us to provide this callback,
1576      but it is not applicable in function-at-a-time mode.  */
1577   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1578 }
1579
1580 /* Do a pushlevel for class declarations.  */
1581
1582 void
1583 pushlevel_class (void)
1584 {
1585   register struct cp_binding_level *newlevel;
1586
1587   /* Reuse or create a struct for this binding level.  */
1588 #if defined(DEBUG_BINDING_LEVELS)
1589   if (0)
1590 #else /* !defined(DEBUG_BINDING_LEVELS) */
1591   if (free_binding_level)
1592 #endif /* !defined(DEBUG_BINDING_LEVELS) */
1593     {
1594       newlevel = free_binding_level;
1595       free_binding_level = free_binding_level->level_chain;
1596     }
1597   else
1598     newlevel = make_binding_level ();
1599
1600 #if defined(DEBUG_BINDING_LEVELS)
1601   is_class_level = 1;
1602 #endif /* defined(DEBUG_BINDING_LEVELS) */
1603
1604   push_binding_level (newlevel, 0, 0);
1605
1606   class_binding_level = current_binding_level;
1607   class_binding_level->parm_flag = 2;
1608   class_binding_level->this_class = current_class_type;
1609 }
1610
1611 /* ...and a poplevel for class declarations.  */
1612
1613 void
1614 poplevel_class (void)
1615 {
1616   register struct cp_binding_level *level = class_binding_level;
1617   tree shadowed;
1618
1619   timevar_push (TV_NAME_LOOKUP);
1620   my_friendly_assert (level != 0, 354);
1621
1622   /* If we're leaving a toplevel class, don't bother to do the setting
1623      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1624      shouldn't even be used when current_class_type isn't set, and second,
1625      if we don't touch it here, we're able to use the cache effect if the
1626      next time we're entering a class scope, it is the same class.  */
1627   if (current_class_depth != 1)
1628     {
1629       struct cp_binding_level* b;
1630
1631       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1632       for (shadowed = level->class_shadowed;
1633            shadowed;
1634            shadowed = TREE_CHAIN (shadowed))
1635         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1636
1637       /* Find the next enclosing class, and recreate
1638          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1639       b = level->level_chain;
1640       while (b && b->parm_flag != 2)
1641         b = b->level_chain;
1642
1643       if (b)
1644         for (shadowed = b->class_shadowed;
1645              shadowed;
1646              shadowed = TREE_CHAIN (shadowed))
1647           {
1648             tree t;
1649
1650             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1651             while (t && BINDING_LEVEL (t) != b)
1652               t = TREE_CHAIN (t);
1653
1654             if (t)
1655               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1656                 = BINDING_VALUE (t);
1657           }
1658     }
1659   else
1660     /* Remember to save what IDENTIFIER's were bound in this scope so we
1661        can recover from cache misses.  */
1662     {
1663       previous_class_type = current_class_type;
1664       previous_class_values = class_binding_level->class_shadowed;
1665     }
1666   for (shadowed = level->type_shadowed;
1667        shadowed;
1668        shadowed = TREE_CHAIN (shadowed))
1669     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1670
1671   /* Remove the bindings for all of the class-level declarations.  */
1672   for (shadowed = level->class_shadowed;
1673        shadowed;
1674        shadowed = TREE_CHAIN (shadowed))
1675     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1676
1677   /* Now, pop out of the binding level which we created up in the
1678      `pushlevel_class' routine.  */
1679 #if defined(DEBUG_BINDING_LEVELS)
1680   is_class_level = 1;
1681 #endif /* defined(DEBUG_BINDING_LEVELS) */
1682
1683   pop_binding_level ();
1684   timevar_pop (TV_NAME_LOOKUP);
1685 }
1686
1687 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1688    for any names in enclosing classes.  */
1689
1690 void
1691 clear_identifier_class_values (void)
1692 {
1693   tree t;
1694
1695   if (!class_binding_level)
1696     return;
1697
1698   for (t = class_binding_level->class_shadowed;
1699        t;
1700        t = TREE_CHAIN (t))
1701     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1702 }
1703
1704 /* Returns nonzero if T is a virtual function table.  */
1705
1706 int
1707 vtable_decl_p (tree t, void* data ATTRIBUTE_UNUSED )
1708 {
1709   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1710 }
1711
1712 /* Returns nonzero if T is a TYPE_DECL for a type with virtual
1713    functions.  */
1714
1715 int
1716 vtype_decl_p (tree t, void *data ATTRIBUTE_UNUSED )
1717 {
1718   return (TREE_CODE (t) == TYPE_DECL
1719           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1720           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1721 }
1722
1723 /* Return the declarations that are members of the namespace NS.  */
1724
1725 tree
1726 cp_namespace_decls (tree ns)
1727 {
1728   return NAMESPACE_LEVEL (ns)->names;
1729 }
1730
1731 struct walk_globals_data {
1732   walk_globals_pred p;
1733   walk_globals_fn f;
1734   void *data;
1735 };
1736
1737 /* Walk the vtable declarations in NAMESPACE.  Whenever one is found
1738    for which P returns nonzero, call F with its address.  If any call
1739    to F returns a nonzero value, return a nonzero value.  */
1740
1741 static int
1742 walk_vtables_r (tree namespace, void* data)
1743 {
1744   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1745   walk_globals_fn f = wgd->f;
1746   void *d = wgd->data;
1747   tree decl = NAMESPACE_LEVEL (namespace)->vtables;
1748   int result = 0;
1749
1750   for (; decl ; decl = TREE_CHAIN (decl))
1751     result |= (*f) (&decl, d);
1752
1753   return result;
1754 }
1755
1756 /* Walk the vtable declarations.  Whenever one is found for which P
1757    returns nonzero, call F with its address.  If any call to F
1758    returns a nonzero value, return a nonzero value.  */
1759 bool
1760 walk_vtables (walk_globals_pred p, walk_globals_fn f, void *data)
1761 {
1762   struct walk_globals_data wgd;
1763   wgd.p = p;
1764   wgd.f = f;
1765   wgd.data = data;
1766
1767   return walk_namespaces (walk_vtables_r, &wgd);
1768 }
1769
1770 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1771    itself, calling F for each.  The DATA is passed to F as well.  */
1772
1773 static int
1774 walk_namespaces_r (tree namespace, walk_namespaces_fn f, void* data)
1775 {
1776   int result = 0;
1777   tree current = NAMESPACE_LEVEL (namespace)->namespaces;
1778
1779   result |= (*f) (namespace, data);
1780
1781   for (; current; current = TREE_CHAIN (current))
1782     result |= walk_namespaces_r (current, f, data);
1783
1784   return result;
1785 }
1786
1787 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1788    F as well.  */
1789
1790 int
1791 walk_namespaces (walk_namespaces_fn f, void* data)
1792 {
1793   return walk_namespaces_r (global_namespace, f, data);
1794 }
1795
1796 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1797    for which P returns nonzero, call F with its address.  If any call
1798    to F returns a nonzero value, return a nonzero value.  */
1799
1800 static int
1801 walk_globals_r (tree namespace, void* data)
1802 {
1803   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1804   walk_globals_pred p = wgd->p;
1805   walk_globals_fn f = wgd->f;
1806   void *d = wgd->data;
1807   tree *t;
1808   int result = 0;
1809
1810   t = &NAMESPACE_LEVEL (namespace)->names;
1811
1812   while (*t)
1813     {
1814       tree glbl = *t;
1815
1816       if ((*p) (glbl, d))
1817         result |= (*f) (t, d);
1818
1819       /* If F changed *T, then *T still points at the next item to
1820          examine.  */
1821       if (*t == glbl)
1822         t = &TREE_CHAIN (*t);
1823     }
1824
1825   return result;
1826 }
1827
1828 /* Walk the global declarations.  Whenever one is found for which P
1829    returns true, call F with its address.  If any call to F
1830    returns true, return true.  */
1831
1832 bool
1833 walk_globals (walk_globals_pred p, walk_globals_fn f, void *data)
1834 {
1835   struct walk_globals_data wgd;
1836   wgd.p = p;
1837   wgd.f = f;
1838   wgd.data = data;
1839
1840   return walk_namespaces (walk_globals_r, &wgd);
1841 }
1842
1843 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1844    DATA is non-NULL, this is the last time we will call
1845    wrapup_global_declarations for this NAMESPACE.  */
1846
1847 int
1848 wrapup_globals_for_namespace (tree namespace, void* data)
1849 {
1850   tree globals = cp_namespace_decls (namespace);
1851   int len = NAMESPACE_LEVEL (namespace)->names_size;
1852   tree *vec = (tree *) alloca (sizeof (tree) * len);
1853   int i;
1854   int result;
1855   tree decl;
1856   int last_time = (data != 0);
1857
1858   if (last_time && namespace == global_namespace)
1859     /* Let compile_file handle the global namespace.  */
1860     return 0;
1861
1862   /* Process the decls in reverse order--earliest first.
1863      Put them into VEC from back to front, then take out from front.  */
1864   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1865     vec[len - i - 1] = decl;
1866
1867   if (last_time)
1868     {
1869       check_global_declarations (vec, len);
1870       return 0;
1871     }
1872
1873   /* Write out any globals that need to be output.  */
1874   result = wrapup_global_declarations (vec, len);
1875
1876   return result;
1877 }
1878
1879 \f
1880 /* For debugging.  */
1881 static int no_print_functions = 0;
1882 static int no_print_builtins = 0;
1883
1884 void
1885 print_binding_level (struct cp_binding_level* lvl)
1886 {
1887   tree t;
1888   int i = 0, len;
1889   fprintf (stderr, " blocks=");
1890   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1891   if (lvl->tag_transparent)
1892     fprintf (stderr, " tag-transparent");
1893   if (lvl->more_cleanups_ok)
1894     fprintf (stderr, " more-cleanups-ok");
1895   if (lvl->have_cleanups)
1896     fprintf (stderr, " have-cleanups");
1897   fprintf (stderr, "\n");
1898   if (lvl->names)
1899     {
1900       fprintf (stderr, " names:\t");
1901       /* We can probably fit 3 names to a line?  */
1902       for (t = lvl->names; t; t = TREE_CHAIN (t))
1903         {
1904           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1905             continue;
1906           if (no_print_builtins
1907               && (TREE_CODE (t) == TYPE_DECL)
1908               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
1909             continue;
1910
1911           /* Function decls tend to have longer names.  */
1912           if (TREE_CODE (t) == FUNCTION_DECL)
1913             len = 3;
1914           else
1915             len = 2;
1916           i += len;
1917           if (i > 6)
1918             {
1919               fprintf (stderr, "\n\t");
1920               i = len;
1921             }
1922           print_node_brief (stderr, "", t, 0);
1923           if (t == error_mark_node)
1924             break;
1925         }
1926       if (i)
1927         fprintf (stderr, "\n");
1928     }
1929   if (lvl->tags)
1930     {
1931       fprintf (stderr, " tags:\t");
1932       i = 0;
1933       for (t = lvl->tags; t; t = TREE_CHAIN (t))
1934         {
1935           if (TREE_PURPOSE (t) == NULL_TREE)
1936             len = 3;
1937           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1938             len = 2;
1939           else
1940             len = 4;
1941           i += len;
1942           if (i > 5)
1943             {
1944               fprintf (stderr, "\n\t");
1945               i = len;
1946             }
1947           if (TREE_PURPOSE (t) == NULL_TREE)
1948             {
1949               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
1950               fprintf (stderr, ">");
1951             }
1952           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1953             print_node_brief (stderr, "", TREE_VALUE (t), 0);
1954           else
1955             {
1956               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
1957               print_node_brief (stderr, "", TREE_VALUE (t), 0);
1958               fprintf (stderr, ">");
1959             }
1960         }
1961       if (i)
1962         fprintf (stderr, "\n");
1963     }
1964   if (lvl->class_shadowed)
1965     {
1966       fprintf (stderr, " class-shadowed:");
1967       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
1968         {
1969           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1970         }
1971       fprintf (stderr, "\n");
1972     }
1973   if (lvl->type_shadowed)
1974     {
1975       fprintf (stderr, " type-shadowed:");
1976       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1977         {
1978           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1979         }
1980       fprintf (stderr, "\n");
1981     }
1982 }
1983
1984 void
1985 print_other_binding_stack (struct cp_binding_level *stack)
1986 {
1987   struct cp_binding_level *level;
1988   for (level = stack; level != global_binding_level; level = level->level_chain)
1989     {
1990       fprintf (stderr, "binding level ");
1991       fprintf (stderr, HOST_PTR_PRINTF, level);
1992       fprintf (stderr, "\n");
1993       print_binding_level (level);
1994     }
1995 }
1996
1997 void
1998 print_binding_stack (void)
1999 {
2000   struct cp_binding_level *b;
2001   fprintf (stderr, "current_binding_level=");
2002   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2003   fprintf (stderr, "\nclass_binding_level=");
2004   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2005   fprintf (stderr, "\nglobal_binding_level=");
2006   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2007   fprintf (stderr, "\n");
2008   if (class_binding_level)
2009     {
2010       for (b = class_binding_level; b; b = b->level_chain)
2011         if (b == current_binding_level)
2012           break;
2013       if (b)
2014         b = class_binding_level;
2015       else
2016         b = current_binding_level;
2017     }
2018   else
2019     b = current_binding_level;
2020   print_other_binding_stack (b);
2021   fprintf (stderr, "global:\n");
2022   print_binding_level (global_binding_level);
2023 }
2024
2025 /* Namespace binding access routines: The namespace_bindings field of
2026    the identifier is polymorphic, with three possible values:
2027    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2028    indicating the BINDING_VALUE of global_namespace.  */
2029
2030 /* Check whether the a binding for the name to scope is known.
2031    Assumes that the bindings of the name are already a list
2032    of bindings. Returns the binding found, or NULL_TREE.  */
2033
2034 static tree
2035 find_binding (tree name, tree scope)
2036 {
2037   tree iter, prev = NULL_TREE;
2038
2039   timevar_push (TV_NAME_LOOKUP);
2040   scope = ORIGINAL_NAMESPACE (scope);
2041
2042   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2043        iter = TREE_CHAIN (iter))
2044     {
2045       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2046       if (BINDING_SCOPE (iter) == scope)
2047         {
2048           /* Move binding found to the front of the list, so
2049              subsequent lookups will find it faster.  */
2050           if (prev)
2051             {
2052               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2053               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2054               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2055             }
2056           POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, iter);
2057         }
2058       prev = iter;
2059     }
2060   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2061 }
2062
2063 /* Always returns a binding for name in scope. If the
2064    namespace_bindings is not a list, convert it to one first.
2065    If no binding is found, make a new one.  */
2066
2067 tree
2068 binding_for_name (tree name, tree scope)
2069 {
2070   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2071   tree result;
2072
2073   scope = ORIGINAL_NAMESPACE (scope);
2074
2075   if (b && TREE_CODE (b) != CPLUS_BINDING)
2076     {
2077       /* Get rid of optimization for global scope.  */
2078       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2079       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2080       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2081     }
2082   if (b && (result = find_binding (name, scope)))
2083     return result;
2084   /* Not found, make a new one.  */
2085   result = make_node (CPLUS_BINDING);
2086   TREE_CHAIN (result) = b;
2087   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2088   BINDING_SCOPE (result) = scope;
2089   BINDING_TYPE (result) = NULL_TREE;
2090   BINDING_VALUE (result) = NULL_TREE;
2091   return result;
2092 }
2093
2094 /* Return the binding value for name in scope, considering that
2095    namespace_binding may or may not be a list of CPLUS_BINDINGS.  */
2096
2097 tree
2098 namespace_binding (tree name, tree scope)
2099 {
2100   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2101   if (b == NULL_TREE)
2102     return NULL_TREE;
2103   if (scope == NULL_TREE)
2104     scope = global_namespace;
2105   if (TREE_CODE (b) != CPLUS_BINDING)
2106     return (scope == global_namespace) ? b : NULL_TREE;
2107   name = find_binding (name,scope);
2108   if (name == NULL_TREE)
2109     return name;
2110   return BINDING_VALUE (name);
2111 }
2112
2113 /* Set the binding value for name in scope. If modifying the binding
2114    of global_namespace is attempted, try to optimize it.  */
2115
2116 void
2117 set_namespace_binding (tree name, tree scope, tree val)
2118 {
2119   tree b;
2120
2121   if (scope == NULL_TREE)
2122     scope = global_namespace;
2123
2124   if (scope == global_namespace)
2125     {
2126       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2127       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2128         {
2129           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2130           return;
2131         }
2132     }
2133   b = binding_for_name (name, scope);
2134   BINDING_VALUE (b) = val;
2135 }
2136
2137 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2138    select a name that is unique to this compilation unit.  */
2139
2140 void
2141 push_namespace (tree name)
2142 {
2143   tree d = NULL_TREE;
2144   int need_new = 1;
2145   int implicit_use = 0;
2146   int global = 0;
2147
2148   timevar_push (TV_NAME_LOOKUP);
2149
2150   if (!global_namespace)
2151     {
2152       /* This must be ::.  */
2153       my_friendly_assert (name == get_identifier ("::"), 377);
2154       global = 1;
2155     }
2156   else if (!name)
2157     {
2158       /* The name of anonymous namespace is unique for the translation
2159          unit.  */
2160       if (!anonymous_namespace_name)
2161         anonymous_namespace_name = get_file_function_name ('N');
2162       name = anonymous_namespace_name;
2163       d = IDENTIFIER_NAMESPACE_VALUE (name);
2164       if (d)
2165         /* Reopening anonymous namespace.  */
2166         need_new = 0;
2167       implicit_use = 1;
2168     }
2169   else
2170     {
2171       /* Check whether this is an extended namespace definition.  */
2172       d = IDENTIFIER_NAMESPACE_VALUE (name);
2173       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2174         {
2175           need_new = 0;
2176           if (DECL_NAMESPACE_ALIAS (d))
2177             {
2178               error ("namespace alias `%D' not allowed here, assuming `%D'",
2179                         d, DECL_NAMESPACE_ALIAS (d));
2180               d = DECL_NAMESPACE_ALIAS (d);
2181             }
2182         }
2183     }
2184
2185   if (need_new)
2186     {
2187       /* Make a new namespace, binding the name to it.  */
2188       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2189       /* The global namespace is not pushed, and the global binding
2190          level is set elsewhere.  */
2191       if (!global)
2192         {
2193           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2194           d = pushdecl (d);
2195           pushlevel (0);
2196           declare_namespace_level ();
2197           NAMESPACE_LEVEL (d) = current_binding_level;
2198         }
2199     }
2200   else
2201     resume_binding_level (NAMESPACE_LEVEL (d));
2202
2203   if (implicit_use)
2204     do_using_directive (d);
2205   /* Enter the name space.  */
2206   current_namespace = d;
2207
2208   timevar_pop (TV_NAME_LOOKUP);
2209 }
2210
2211 /* Pop from the scope of the current namespace.  */
2212
2213 void
2214 pop_namespace (void)
2215 {
2216   my_friendly_assert (current_namespace != global_namespace, 20010801);
2217   current_namespace = CP_DECL_CONTEXT (current_namespace);
2218   /* The binding level is not popped, as it might be re-opened later.  */
2219   suspend_binding_level ();
2220 }
2221
2222 /* Push into the scope of the namespace NS, even if it is deeply
2223    nested within another namespace.  */
2224
2225 void
2226 push_nested_namespace (tree ns)
2227 {
2228   if (ns == global_namespace)
2229     push_to_top_level ();
2230   else
2231     {
2232       push_nested_namespace (CP_DECL_CONTEXT (ns));
2233       push_namespace (DECL_NAME (ns));
2234     }
2235 }
2236
2237 /* Pop back from the scope of the namespace NS, which was previously
2238    entered with push_nested_namespace.  */
2239
2240 void
2241 pop_nested_namespace (tree ns)
2242 {
2243   timevar_push (TV_NAME_LOOKUP);
2244   while (ns != global_namespace)
2245     {
2246       pop_namespace ();
2247       ns = CP_DECL_CONTEXT (ns);
2248     }
2249
2250   pop_from_top_level ();
2251   timevar_pop (TV_NAME_LOOKUP);
2252 }
2253
2254 \f
2255 /* Subroutines for reverting temporarily to top-level for instantiation
2256    of templates and such.  We actually need to clear out the class- and
2257    local-value slots of all identifiers, so that only the global values
2258    are at all visible.  Simply setting current_binding_level to the global
2259    scope isn't enough, because more binding levels may be pushed.  */
2260 struct saved_scope *scope_chain;
2261
2262 static tree
2263 store_bindings (tree names, tree old_bindings)
2264 {
2265   tree t;
2266   tree search_bindings = old_bindings;
2267
2268   timevar_push (TV_NAME_LOOKUP);
2269   for (t = names; t; t = TREE_CHAIN (t))
2270     {
2271       tree binding, t1, id;
2272
2273       if (TREE_CODE (t) == TREE_LIST)
2274         id = TREE_PURPOSE (t);
2275       else
2276         id = DECL_NAME (t);
2277
2278       if (!id
2279           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2280              we have no IDENTIFIER_BINDING if we have left the class
2281              scope, but cached the class-level declarations.  */
2282           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2283         continue;
2284
2285       for (t1 = search_bindings; t1; t1 = TREE_CHAIN (t1))
2286         if (TREE_VEC_ELT (t1, 0) == id)
2287           goto skip_it;
2288
2289       my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2290       binding = make_tree_vec (4);
2291       TREE_VEC_ELT (binding, 0) = id;
2292       TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2293       TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2294       TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2295       IDENTIFIER_BINDING (id) = NULL_TREE;
2296       IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2297       TREE_CHAIN (binding) = old_bindings;
2298       old_bindings = binding;
2299     skip_it:
2300       ;
2301     }
2302   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, old_bindings);
2303 }
2304
2305 void
2306 maybe_push_to_top_level (int pseudo)
2307 {
2308   struct saved_scope *s;
2309   struct cp_binding_level *b;
2310   tree old_bindings;
2311   int need_pop;
2312
2313   timevar_push (TV_NAME_LOOKUP);
2314   s = (struct saved_scope *) ggc_alloc_cleared (sizeof (struct saved_scope));
2315
2316   b = scope_chain ? current_binding_level : 0;
2317
2318   /* If we're in the middle of some function, save our state.  */
2319   if (cfun)
2320     {
2321       need_pop = 1;
2322       push_function_context_to (NULL_TREE);
2323     }
2324   else
2325     need_pop = 0;
2326
2327   old_bindings = NULL_TREE;
2328   if (scope_chain && previous_class_type)
2329     old_bindings = store_bindings (previous_class_values, old_bindings);
2330
2331   /* Have to include global_binding_level, because class-level decls
2332      aren't listed anywhere useful.  */
2333   for (; b; b = b->level_chain)
2334     {
2335       tree t;
2336
2337       /* Template IDs are inserted into the global level. If they were
2338          inserted into namespace level, finish_file wouldn't find them
2339          when doing pending instantiations. Therefore, don't stop at
2340          namespace level, but continue until :: .  */
2341       if (b == global_binding_level || (pseudo && b->template_parms_p))
2342         break;
2343
2344       old_bindings = store_bindings (b->names, old_bindings);
2345       /* We also need to check class_shadowed to save class-level type
2346          bindings, since pushclass doesn't fill in b->names.  */
2347       if (b->parm_flag == 2)
2348         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2349
2350       /* Unwind type-value slots back to top level.  */
2351       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2352         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2353     }
2354   s->prev = scope_chain;
2355   s->old_bindings = old_bindings;
2356   s->bindings = b;
2357   s->need_pop_function_context = need_pop;
2358   s->function_decl = current_function_decl;
2359   s->last_parms = last_function_parms;
2360   s->check_access = flag_access_control;
2361
2362   scope_chain = s;
2363   current_function_decl = NULL_TREE;
2364   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2365   current_lang_name = lang_name_cplusplus;
2366   current_namespace = global_namespace;
2367   timevar_pop (TV_NAME_LOOKUP);
2368 }
2369
2370 void
2371 push_to_top_level (void)
2372 {
2373   maybe_push_to_top_level (0);
2374 }
2375
2376 void
2377 pop_from_top_level (void)
2378 {
2379   struct saved_scope *s = scope_chain;
2380   tree t;
2381
2382   timevar_push (TV_NAME_LOOKUP);
2383   /* Clear out class-level bindings cache.  */
2384   if (previous_class_type)
2385     invalidate_class_lookup_cache ();
2386
2387   current_lang_base = 0;
2388
2389   scope_chain = s->prev;
2390   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2391     {
2392       tree id = TREE_VEC_ELT (t, 0);
2393
2394       SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2395       IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2396       IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2397     }
2398
2399   /* If we were in the middle of compiling a function, restore our
2400      state.  */
2401   if (s->need_pop_function_context)
2402     pop_function_context_from (NULL_TREE);
2403   current_function_decl = s->function_decl;
2404   last_function_parms = s->last_parms;
2405   timevar_pop (TV_NAME_LOOKUP);
2406 }
2407 \f
2408 /* Push a definition of struct, union or enum tag "name".
2409    into binding_level "b".   "type" should be the type node,
2410    We assume that the tag "name" is not already defined.
2411
2412    Note that the definition may really be just a forward reference.
2413    In that case, the TYPE_SIZE will be a NULL_TREE.
2414
2415    C++ gratuitously puts all these tags in the name space.  */
2416
2417 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2418    record the shadowed value for this binding contour.  TYPE is
2419    the type that ID maps to.  */
2420
2421 static void
2422 set_identifier_type_value_with_scope (tree id,
2423                                       tree type,
2424                                       struct cp_binding_level* b)
2425 {
2426   if (!b->namespace_p)
2427     {
2428       /* Shadow the marker, not the real thing, so that the marker
2429          gets restored later.  */
2430       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2431       b->type_shadowed
2432         = tree_cons (id, old_type_value, b->type_shadowed);
2433     }
2434   else
2435     {
2436       tree binding = binding_for_name (id, current_namespace);
2437       BINDING_TYPE (binding) = type;
2438       /* Store marker instead of real type.  */
2439       type = global_type_node;
2440     }
2441   SET_IDENTIFIER_TYPE_VALUE (id, type);
2442 }
2443
2444 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2445
2446 void
2447 set_identifier_type_value (tree id, tree type)
2448 {
2449   set_identifier_type_value_with_scope (id, type, current_binding_level);
2450 }
2451
2452 /* Return the type associated with id.  */
2453
2454 tree
2455 identifier_type_value (tree id)
2456 {
2457   timevar_push (TV_NAME_LOOKUP);
2458   /* There is no type with that name, anywhere.  */
2459   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2460     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2461   /* This is not the type marker, but the real thing.  */
2462   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2463     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
2464   /* Have to search for it. It must be on the global level, now.
2465      Ask lookup_name not to return non-types. */
2466   id = lookup_name_real (id, 2, 1, 0, LOOKUP_COMPLAIN);
2467   if (id)
2468     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
2469   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2470 }
2471
2472 /* Pop off extraneous binding levels left over due to syntax errors.
2473
2474    We don't pop past namespaces, as they might be valid.  */
2475
2476 void
2477 pop_everything (void)
2478 {
2479 #ifdef DEBUG_BINDING_LEVELS
2480   fprintf (stderr, "XXX entering pop_everything ()\n");
2481 #endif
2482   while (!toplevel_bindings_p ())
2483     {
2484       if (current_binding_level->parm_flag == 2)
2485         pop_nested_class ();
2486       else
2487         poplevel (0, 0, 0);
2488     }
2489 #ifdef DEBUG_BINDING_LEVELS
2490   fprintf (stderr, "XXX leaving pop_everything ()\n");
2491 #endif
2492 }
2493
2494 /* The type TYPE is being declared.  If it is a class template, or a
2495    specialization of a class template, do any processing required and
2496    perform error-checking.  If IS_FRIEND is nonzero, this TYPE is
2497    being declared a friend.  B is the binding level at which this TYPE
2498    should be bound.
2499
2500    Returns the TYPE_DECL for TYPE, which may have been altered by this
2501    processing.  */
2502
2503 static tree
2504 maybe_process_template_type_declaration (tree type,
2505                                          int globalize,
2506                                          struct cp_binding_level* b)
2507 {
2508   tree decl = TYPE_NAME (type);
2509
2510   if (processing_template_parmlist)
2511     /* You can't declare a new template type in a template parameter
2512        list.  But, you can declare a non-template type:
2513
2514          template <class A*> struct S;
2515
2516        is a forward-declaration of `A'.  */
2517     ;
2518   else
2519     {
2520       maybe_check_template_type (type);
2521
2522       my_friendly_assert (IS_AGGR_TYPE (type)
2523                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2524
2525
2526       if (processing_template_decl)
2527         {
2528           /* This may change after the call to
2529              push_template_decl_real, but we want the original value.  */
2530           tree name = DECL_NAME (decl);
2531
2532           decl = push_template_decl_real (decl, globalize);
2533           /* If the current binding level is the binding level for the
2534              template parameters (see the comment in
2535              begin_template_parm_list) and the enclosing level is a class
2536              scope, and we're not looking at a friend, push the
2537              declaration of the member class into the class scope.  In the
2538              friend case, push_template_decl will already have put the
2539              friend into global scope, if appropriate.  */
2540           if (TREE_CODE (type) != ENUMERAL_TYPE
2541               && !globalize && b->template_parms_p
2542               && b->level_chain->parm_flag == 2)
2543             {
2544               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2545               /* Put this tag on the list of tags for the class, since
2546                  that won't happen below because B is not the class
2547                  binding level, but is instead the pseudo-global level.  */
2548               b->level_chain->tags =
2549                 tree_cons (name, type, b->level_chain->tags);
2550               if (!COMPLETE_TYPE_P (current_class_type))
2551                 {
2552                   maybe_add_class_template_decl_list (current_class_type,
2553                                                       type, /*friend_p=*/0);
2554                   CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2555                 }
2556             }
2557         }
2558     }
2559
2560   return decl;
2561 }
2562
2563 /* In C++, you don't have to write `struct S' to refer to `S'; you
2564    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2565    if the user had written `typedef struct S S'.  Create and return
2566    the TYPE_DECL for TYPE.  */
2567
2568 tree
2569 create_implicit_typedef (tree name, tree type)
2570 {
2571   tree decl;
2572
2573   decl = build_decl (TYPE_DECL, name, type);
2574   DECL_ARTIFICIAL (decl) = 1;
2575   /* There are other implicit type declarations, like the one *within*
2576      a class that allows you to write `S::S'.  We must distinguish
2577      amongst these.  */
2578   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2579   TYPE_NAME (type) = decl;
2580
2581   return decl;
2582 }
2583
2584 /* Remember a local name for name-mangling purposes.  */
2585
2586 static void
2587 push_local_name (tree decl)
2588 {
2589   size_t i, nelts;
2590   tree t, name;
2591
2592   timevar_push (TV_NAME_LOOKUP);
2593   if (!local_names)
2594     VARRAY_TREE_INIT (local_names, 8, "local_names");
2595
2596   name = DECL_NAME (decl);
2597
2598   nelts = VARRAY_ACTIVE_SIZE (local_names);
2599   for (i = 0; i < nelts; i++)
2600     {
2601       t = VARRAY_TREE (local_names, i);
2602       if (DECL_NAME (t) == name)
2603         {
2604           if (!DECL_LANG_SPECIFIC (decl))
2605             retrofit_lang_decl (decl);
2606           DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
2607           if (DECL_LANG_SPECIFIC (t))
2608             DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
2609           else
2610             DECL_DISCRIMINATOR (decl) = 1;
2611
2612           VARRAY_TREE (local_names, i) = decl;
2613           POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (void)0);
2614         }
2615     }
2616
2617   VARRAY_PUSH_TREE (local_names, decl);
2618   timevar_pop (TV_NAME_LOOKUP);
2619 }
2620
2621 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2622    Normally put it into the inner-most non-tag-transparent scope,
2623    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2624    The latter is needed for implicit declarations.  */
2625
2626 void
2627 pushtag (tree name, tree type, int globalize)
2628 {
2629   register struct cp_binding_level *b;
2630
2631   timevar_push (TV_NAME_LOOKUP);
2632   b = current_binding_level;
2633   while (b->tag_transparent
2634          || (b->parm_flag == 2
2635              && (globalize
2636                  /* We may be defining a new type in the initializer
2637                     of a static member variable. We allow this when
2638                     not pedantic, and it is particularly useful for
2639                     type punning via an anonymous union.  */
2640                  || COMPLETE_TYPE_P (b->this_class))))
2641     b = b->level_chain;
2642
2643   b->tags = tree_cons (name, type, b->tags);
2644
2645   if (name)
2646     {
2647       /* Do C++ gratuitous typedefing.  */
2648       if (IDENTIFIER_TYPE_VALUE (name) != type)
2649         {
2650           register tree d = NULL_TREE;
2651           int in_class = 0;
2652           tree context = TYPE_CONTEXT (type);
2653
2654           if (! context)
2655             {
2656               tree cs = current_scope ();
2657
2658               if (! globalize)
2659                 context = cs;
2660               else if (cs != NULL_TREE && TYPE_P (cs))
2661                 /* When declaring a friend class of a local class, we want
2662                    to inject the newly named class into the scope
2663                    containing the local class, not the namespace scope.  */
2664                 context = decl_function_context (get_type_decl (cs));
2665             }
2666           if (!context)
2667             context = current_namespace;
2668
2669           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2670               || b->parm_flag == 2)
2671             in_class = 1;
2672
2673           if (current_lang_name == lang_name_java)
2674             TYPE_FOR_JAVA (type) = 1;
2675
2676           d = create_implicit_typedef (name, type);
2677           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2678           if (! in_class)
2679             set_identifier_type_value_with_scope (name, type, b);
2680
2681           d = maybe_process_template_type_declaration (type,
2682                                                        globalize, b);
2683
2684           if (b->parm_flag == 2)
2685             {
2686               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2687                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2688                    class.  But if it's a member template class, we
2689                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2690                    is done later.  */
2691                 finish_member_declaration (d);
2692               else
2693                 pushdecl_class_level (d);
2694             }
2695           else
2696             d = pushdecl_with_scope (d, b);
2697
2698           /* FIXME what if it gets a name from typedef?  */
2699           if (ANON_AGGRNAME_P (name))
2700             DECL_IGNORED_P (d) = 1;
2701
2702           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2703
2704           /* If this is a local class, keep track of it.  We need this
2705              information for name-mangling, and so that it is possible to find
2706              all function definitions in a translation unit in a convenient
2707              way.  (It's otherwise tricky to find a member function definition
2708              it's only pointed to from within a local class.)  */
2709           if (TYPE_CONTEXT (type)
2710               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2711               && !processing_template_decl)
2712             VARRAY_PUSH_TREE (local_classes, type);
2713         }
2714       if (b->parm_flag == 2)
2715         {
2716           if (!COMPLETE_TYPE_P (current_class_type))
2717             {
2718               maybe_add_class_template_decl_list (current_class_type,
2719                                                   type, /*friend_p=*/0);
2720               CLASSTYPE_TAGS (current_class_type) = b->tags;
2721             }
2722         }
2723     }
2724
2725   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2726     /* Use the canonical TYPE_DECL for this node.  */
2727     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2728   else
2729     {
2730       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2731          will be the tagged type we just added to the current
2732          binding level.  This fake NULL-named TYPE_DECL node helps
2733          dwarfout.c to know when it needs to output a
2734          representation of a tagged type, and it also gives us a
2735          convenient place to record the "scope start" address for
2736          the tagged type.  */
2737
2738       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2739       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2740     }
2741   timevar_pop (TV_NAME_LOOKUP);
2742 }
2743
2744 /* Counter used to create anonymous type names.  */
2745
2746 static GTY(()) int anon_cnt;
2747
2748 /* Return an IDENTIFIER which can be used as a name for
2749    anonymous structs and unions.  */
2750
2751 tree
2752 make_anon_name (void)
2753 {
2754   char buf[32];
2755
2756   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2757   return get_identifier (buf);
2758 }
2759
2760 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2761    This keeps dbxout from getting confused.  */
2762
2763 void
2764 clear_anon_tags (void)
2765 {
2766   register struct cp_binding_level *b;
2767   register tree tags;
2768   static int last_cnt = 0;
2769
2770   /* Fast out if no new anon names were declared.  */
2771   if (last_cnt == anon_cnt)
2772     return;
2773
2774   b = current_binding_level;
2775   while (b->tag_transparent)
2776     b = b->level_chain;
2777   tags = b->tags;
2778   while (tags)
2779     {
2780       /* A NULL purpose means we have already processed all tags
2781          from here to the end of the list.  */
2782       if (TREE_PURPOSE (tags) == NULL_TREE)
2783         break;
2784       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2785         TREE_PURPOSE (tags) = NULL_TREE;
2786       tags = TREE_CHAIN (tags);
2787     }
2788   last_cnt = anon_cnt;
2789 }
2790 \f
2791 /* Subroutine of duplicate_decls: return truthvalue of whether
2792    or not types of these decls match.
2793
2794    For C++, we must compare the parameter list so that `int' can match
2795    `int&' in a parameter position, but `int&' is not confused with
2796    `const int&'.  */
2797
2798 int
2799 decls_match (tree newdecl, tree olddecl)
2800 {
2801   int types_match;
2802
2803   if (newdecl == olddecl)
2804     return 1;
2805
2806   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2807     /* If the two DECLs are not even the same kind of thing, we're not
2808        interested in their types.  */
2809     return 0;
2810
2811   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2812     {
2813       tree f1 = TREE_TYPE (newdecl);
2814       tree f2 = TREE_TYPE (olddecl);
2815       tree p1 = TYPE_ARG_TYPES (f1);
2816       tree p2 = TYPE_ARG_TYPES (f2);
2817
2818       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2819           && ! (DECL_EXTERN_C_P (newdecl)
2820                 && DECL_EXTERN_C_P (olddecl)))
2821         return 0;
2822
2823       if (TREE_CODE (f1) != TREE_CODE (f2))
2824         return 0;
2825
2826       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2827         {
2828           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
2829               && (DECL_BUILT_IN (olddecl)
2830 #ifndef NO_IMPLICIT_EXTERN_C
2831                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
2832                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
2833 #endif
2834               ))
2835             {
2836               types_match = self_promoting_args_p (p1);
2837               if (p1 == void_list_node)
2838                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2839             }
2840 #ifndef NO_IMPLICIT_EXTERN_C
2841           else if (p1 == NULL_TREE
2842                    && (DECL_EXTERN_C_P (olddecl)
2843                        && DECL_IN_SYSTEM_HEADER (olddecl)
2844                        && !DECL_CLASS_SCOPE_P (olddecl))
2845                    && (DECL_EXTERN_C_P (newdecl)
2846                        && DECL_IN_SYSTEM_HEADER (newdecl)
2847                        && !DECL_CLASS_SCOPE_P (newdecl)))
2848             {
2849               types_match = self_promoting_args_p (p2);
2850               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2851             }
2852 #endif
2853           else
2854             types_match = compparms (p1, p2);
2855         }
2856       else
2857         types_match = 0;
2858     }
2859   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2860     {
2861       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2862                                 DECL_TEMPLATE_PARMS (olddecl)))
2863         return 0;
2864
2865       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
2866           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
2867         return 0;
2868
2869       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2870         types_match = 1;
2871       else
2872         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2873                                    DECL_TEMPLATE_RESULT (newdecl));
2874     }
2875   else
2876     {
2877       if (TREE_TYPE (newdecl) == error_mark_node)
2878         types_match = TREE_TYPE (olddecl) == error_mark_node;
2879       else if (TREE_TYPE (olddecl) == NULL_TREE)
2880         types_match = TREE_TYPE (newdecl) == NULL_TREE;
2881       else if (TREE_TYPE (newdecl) == NULL_TREE)
2882         types_match = 0;
2883       else
2884         types_match = comptypes (TREE_TYPE (newdecl),
2885                                  TREE_TYPE (olddecl),
2886                                  COMPARE_REDECLARATION);
2887     }
2888
2889   return types_match;
2890 }
2891
2892 /* If NEWDECL is `static' and an `extern' was seen previously,
2893    warn about it.  OLDDECL is the previous declaration.
2894
2895    Note that this does not apply to the C++ case of declaring
2896    a variable `extern const' and then later `const'.
2897
2898    Don't complain about built-in functions, since they are beyond
2899    the user's control.  */
2900
2901 static void
2902 warn_extern_redeclared_static (tree newdecl, tree olddecl)
2903 {
2904   static const char *const explicit_extern_static_warning
2905     = "`%D' was declared `extern' and later `static'";
2906   static const char *const implicit_extern_static_warning
2907     = "`%D' was declared implicitly `extern' and later `static'";
2908
2909   tree name;
2910
2911   if (TREE_CODE (newdecl) == TYPE_DECL
2912       || TREE_CODE (newdecl) == TEMPLATE_DECL
2913       || TREE_CODE (newdecl) == CONST_DECL)
2914     return;
2915
2916   /* Don't get confused by static member functions; that's a different
2917      use of `static'.  */
2918   if (TREE_CODE (newdecl) == FUNCTION_DECL
2919       && DECL_STATIC_FUNCTION_P (newdecl))
2920     return;
2921
2922   /* If the old declaration was `static', or the new one isn't, then
2923      then everything is OK.  */
2924   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
2925     return;
2926
2927   /* It's OK to declare a builtin function as `static'.  */
2928   if (TREE_CODE (olddecl) == FUNCTION_DECL
2929       && DECL_ARTIFICIAL (olddecl))
2930     return;
2931
2932   name = DECL_ASSEMBLER_NAME (newdecl);
2933   pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
2934               ? implicit_extern_static_warning
2935               : explicit_extern_static_warning, newdecl);
2936   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
2937 }
2938
2939 /* Handle when a new declaration NEWDECL has the same name as an old
2940    one OLDDECL in the same binding contour.  Prints an error message
2941    if appropriate.
2942
2943    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2944    Otherwise, return 0.  */
2945
2946 int
2947 duplicate_decls (tree newdecl, tree olddecl)
2948 {
2949   unsigned olddecl_uid = DECL_UID (olddecl);
2950   int olddecl_friend = 0, types_match = 0;
2951   int new_defines_function = 0;
2952
2953   if (newdecl == olddecl)
2954     return 1;
2955
2956   types_match = decls_match (newdecl, olddecl);
2957
2958   /* If either the type of the new decl or the type of the old decl is an
2959      error_mark_node, then that implies that we have already issued an
2960      error (earlier) for some bogus type specification, and in that case,
2961      it is rather pointless to harass the user with yet more error message
2962      about the same declaration, so just pretend the types match here.  */
2963   if (TREE_TYPE (newdecl) == error_mark_node
2964       || TREE_TYPE (olddecl) == error_mark_node)
2965     types_match = 1;
2966
2967   if (DECL_P (olddecl)
2968       && TREE_CODE (newdecl) == FUNCTION_DECL
2969       && TREE_CODE (olddecl) == FUNCTION_DECL
2970       && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
2971     {
2972       if (DECL_DECLARED_INLINE_P (newdecl)
2973           && DECL_UNINLINABLE (newdecl)
2974           && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
2975         /* Already warned elsewhere.  */;
2976       else if (DECL_DECLARED_INLINE_P (olddecl)
2977                && DECL_UNINLINABLE (olddecl)
2978                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
2979         /* Already warned.  */;
2980       else if (DECL_DECLARED_INLINE_P (newdecl)
2981                && DECL_UNINLINABLE (olddecl)
2982                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
2983         {
2984           warning_with_decl (newdecl,
2985                              "function `%s' redeclared as inline");
2986           warning_with_decl (olddecl,
2987                              "previous declaration of function `%s' with attribute noinline");
2988         }
2989       else if (DECL_DECLARED_INLINE_P (olddecl)
2990                && DECL_UNINLINABLE (newdecl)
2991                && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
2992         {
2993           warning_with_decl (newdecl,
2994                              "function `%s' redeclared with attribute noinline");
2995           warning_with_decl (olddecl,
2996                              "previous declaration of function `%s' was inline");
2997         }
2998     }
2999
3000   /* Check for redeclaration and other discrepancies.  */
3001   if (TREE_CODE (olddecl) == FUNCTION_DECL
3002       && DECL_ARTIFICIAL (olddecl))
3003     {
3004       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3005         {
3006           /* Avoid warnings redeclaring anticipated built-ins.  */
3007           if (DECL_ANTICIPATED (olddecl))
3008             return 0;
3009
3010           /* If you declare a built-in or predefined function name as static,
3011              the old definition is overridden, but optionally warn this was a
3012              bad choice of name.  */
3013           if (! TREE_PUBLIC (newdecl))
3014             {
3015               if (warn_shadow)
3016                 warning ("shadowing %s function `%#D'",
3017                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3018                             olddecl);
3019               /* Discard the old built-in function.  */
3020               return 0;
3021             }
3022           /* If the built-in is not ansi, then programs can override
3023              it even globally without an error.  */
3024           else if (! DECL_BUILT_IN (olddecl))
3025             warning ("library function `%#D' redeclared as non-function `%#D'",
3026                         olddecl, newdecl);
3027           else
3028             {
3029               error ("declaration of `%#D'", newdecl);
3030               error ("conflicts with built-in declaration `%#D'",
3031                         olddecl);
3032             }
3033           return 0;
3034         }
3035       else if (!types_match)
3036         {
3037           /* Avoid warnings redeclaring anticipated built-ins.  */
3038           if (DECL_ANTICIPATED (olddecl))
3039             ;  /* Do nothing yet.  */
3040           else if ((DECL_EXTERN_C_P (newdecl)
3041                && DECL_EXTERN_C_P (olddecl))
3042               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3043                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3044             {
3045               /* A near match; override the builtin.  */
3046
3047               if (TREE_PUBLIC (newdecl))
3048                 {
3049                   warning ("new declaration `%#D'", newdecl);
3050                   warning ("ambiguates built-in declaration `%#D'",
3051                               olddecl);
3052                 }
3053               else if (warn_shadow)
3054                 warning ("shadowing %s function `%#D'",
3055                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3056                             olddecl);
3057             }
3058           else
3059             /* Discard the old built-in function.  */
3060             return 0;
3061
3062           /* Replace the old RTL to avoid problems with inlining.  */
3063           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3064         }
3065
3066       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3067         {
3068           /* If a builtin function is redeclared as `static', merge
3069              the declarations, but make the original one static.  */
3070           DECL_THIS_STATIC (olddecl) = 1;
3071           TREE_PUBLIC (olddecl) = 0;
3072
3073           /* Make the old declaration consistent with the new one so
3074              that all remnants of the builtin-ness of this function
3075              will be banished.  */
3076           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3077           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3078         }
3079     }
3080   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3081     {
3082       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3083            && TREE_CODE (newdecl) != TYPE_DECL
3084            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3085                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3086           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3087               && TREE_CODE (olddecl) != TYPE_DECL
3088               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3089                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3090                         == TYPE_DECL))))
3091         {
3092           /* We do nothing special here, because C++ does such nasty
3093              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3094              get shadowed, and know that if we need to find a TYPE_DECL
3095              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3096              slot of the identifier.  */
3097           return 0;
3098         }
3099
3100       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3101            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3102           || (TREE_CODE (olddecl) == FUNCTION_DECL
3103               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3104         return 0;
3105
3106       error ("`%#D' redeclared as different kind of symbol", newdecl);
3107       if (TREE_CODE (olddecl) == TREE_LIST)
3108         olddecl = TREE_VALUE (olddecl);
3109       cp_error_at ("previous declaration of `%#D'", olddecl);
3110
3111       /* New decl is completely inconsistent with the old one =>
3112          tell caller to replace the old one.  */
3113
3114       return 0;
3115     }
3116   else if (!types_match)
3117     {
3118       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3119         /* These are certainly not duplicate declarations; they're
3120            from different scopes.  */
3121         return 0;
3122
3123       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3124         {
3125           /* The name of a class template may not be declared to refer to
3126              any other template, class, function, object, namespace, value,
3127              or type in the same scope.  */
3128           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3129               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3130             {
3131               error ("declaration of template `%#D'", newdecl);
3132               cp_error_at ("conflicts with previous declaration `%#D'",
3133                            olddecl);
3134             }
3135           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3136                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3137                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3138                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3139                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3140                                            DECL_TEMPLATE_PARMS (olddecl))
3141                    /* Template functions can be disambiguated by
3142                       return type.  */
3143                    && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
3144                                    TREE_TYPE (TREE_TYPE (olddecl))))
3145             {
3146               error ("new declaration `%#D'", newdecl);
3147               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3148             }
3149           return 0;
3150         }
3151       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3152         {
3153           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3154             {
3155               error ("declaration of C function `%#D' conflicts with",
3156                         newdecl);
3157               cp_error_at ("previous declaration `%#D' here", olddecl);
3158             }
3159           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3160                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3161             {
3162               error ("new declaration `%#D'", newdecl);
3163               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3164             }
3165           else
3166             return 0;
3167         }
3168
3169       /* Already complained about this, so don't do so again.  */
3170       else if (current_class_type == NULL_TREE
3171           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3172         {
3173           error ("conflicting types for `%#D'", newdecl);
3174           cp_error_at ("previous declaration as `%#D'", olddecl);
3175         }
3176     }
3177   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3178             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3179                  && (!DECL_TEMPLATE_INFO (newdecl)
3180                      || (DECL_TI_TEMPLATE (newdecl)
3181                          != DECL_TI_TEMPLATE (olddecl))))
3182                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3183                     && (!DECL_TEMPLATE_INFO (olddecl)
3184                         || (DECL_TI_TEMPLATE (olddecl)
3185                             != DECL_TI_TEMPLATE (newdecl))))))
3186     /* It's OK to have a template specialization and a non-template
3187        with the same type, or to have specializations of two
3188        different templates with the same type.  Note that if one is a
3189        specialization, and the other is an instantiation of the same
3190        template, that we do not exit at this point.  That situation
3191        can occur if we instantiate a template class, and then
3192        specialize one of its methods.  This situation is valid, but
3193        the declarations must be merged in the usual way.  */
3194     return 0;
3195   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3196            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3197                 && !DECL_USE_TEMPLATE (newdecl))
3198                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3199                    && !DECL_USE_TEMPLATE (olddecl))))
3200     /* One of the declarations is a template instantiation, and the
3201        other is not a template at all.  That's OK.  */
3202     return 0;
3203   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3204            && DECL_NAMESPACE_ALIAS (newdecl)
3205            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3206     /* Redeclaration of namespace alias, ignore it.  */
3207     return 1;
3208   else
3209     {
3210       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3211       if (errmsg)
3212         {
3213           error (errmsg, newdecl);
3214           if (DECL_NAME (olddecl) != NULL_TREE)
3215             cp_error_at ((DECL_INITIAL (olddecl)
3216                           && namespace_bindings_p ())
3217                          ? "`%#D' previously defined here"
3218                          : "`%#D' previously declared here", olddecl);
3219           return 0;
3220         }
3221       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3222                && DECL_INITIAL (olddecl) != NULL_TREE
3223                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3224                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3225         {
3226           /* Prototype decl follows defn w/o prototype.  */
3227           cp_warning_at ("prototype for `%#D'", newdecl);
3228           cp_warning_at ("follows non-prototype definition here", olddecl);
3229         }
3230       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3231                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3232         {
3233           /* extern "C" int foo ();
3234              int foo () { bar (); }
3235              is OK.  */
3236           if (current_lang_depth () == 0)
3237             SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3238           else
3239             {
3240               cp_error_at ("previous declaration of `%#D' with %L linkage",
3241                            olddecl, DECL_LANGUAGE (olddecl));
3242               error ("conflicts with new declaration with %L linkage",
3243                         DECL_LANGUAGE (newdecl));
3244             }
3245         }
3246
3247       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3248         ;
3249       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3250         {
3251           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3252           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3253           int i = 1;
3254
3255           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3256             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3257
3258           for (; t1 && t1 != void_list_node;
3259                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3260             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3261               {
3262                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3263                                            TREE_PURPOSE (t2)))
3264                   {
3265                     pedwarn ("default argument given for parameter %d of `%#D'",
3266                              i, newdecl);
3267                     cp_pedwarn_at ("after previous specification in `%#D'",
3268                                    olddecl);
3269                   }
3270                 else
3271                   {
3272                     error ("default argument given for parameter %d of `%#D'",
3273                               i, newdecl);
3274                     cp_error_at ("after previous specification in `%#D'",
3275                                  olddecl);
3276                   }
3277               }
3278
3279           if (DECL_DECLARED_INLINE_P (newdecl)
3280               && ! DECL_DECLARED_INLINE_P (olddecl)
3281               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3282             {
3283               warning ("`%#D' was used before it was declared inline",
3284                           newdecl);
3285               cp_warning_at ("previous non-inline declaration here",
3286                              olddecl);
3287             }
3288         }
3289     }
3290
3291   /* Do not merge an implicit typedef with an explicit one.  In:
3292
3293        class A;
3294        ...
3295        typedef class A A __attribute__ ((foo));
3296
3297      the attribute should apply only to the typedef.  */
3298   if (TREE_CODE (olddecl) == TYPE_DECL
3299       && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
3300           || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
3301     return 0;
3302
3303   /* If new decl is `static' and an `extern' was seen previously,
3304      warn about it.  */
3305   warn_extern_redeclared_static (newdecl, olddecl);
3306
3307   /* We have committed to returning 1 at this point.  */
3308   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3309     {
3310       /* Now that functions must hold information normally held
3311          by field decls, there is extra work to do so that
3312          declaration information does not get destroyed during
3313          definition.  */
3314       if (DECL_VINDEX (olddecl))
3315         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3316       if (DECL_CONTEXT (olddecl))
3317         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3318       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3319       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3320       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3321       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3322       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3323       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3324       if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
3325         SET_OVERLOADED_OPERATOR_CODE
3326           (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
3327       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3328
3329       /* Optionally warn about more than one declaration for the same
3330          name, but don't warn about a function declaration followed by a
3331          definition.  */
3332       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3333           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3334           /* Don't warn about extern decl followed by definition.  */
3335           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3336           /* Don't warn about friends, let add_friend take care of it.  */
3337           && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
3338         {
3339           warning ("redundant redeclaration of `%D' in same scope", newdecl);
3340           cp_warning_at ("previous declaration of `%D'", olddecl);
3341         }
3342     }
3343
3344   /* Deal with C++: must preserve virtual function table size.  */
3345   if (TREE_CODE (olddecl) == TYPE_DECL)
3346     {
3347       register tree newtype = TREE_TYPE (newdecl);
3348       register tree oldtype = TREE_TYPE (olddecl);
3349
3350       if (newtype != error_mark_node && oldtype != error_mark_node
3351           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3352         CLASSTYPE_FRIEND_CLASSES (newtype)
3353           = CLASSTYPE_FRIEND_CLASSES (oldtype);
3354 \
3355       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3356     }
3357
3358   /* Copy all the DECL_... slots specified in the new decl
3359      except for any that we copy here from the old type.  */
3360   DECL_ATTRIBUTES (newdecl)
3361     = (*targetm.merge_decl_attributes) (olddecl, newdecl);
3362
3363   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3364     {
3365       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3366       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3367         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3368                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3369
3370       /* If the new declaration is a definition, update the file and
3371          line information on the declaration.  */
3372       if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
3373           && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
3374         {
3375           DECL_SOURCE_LOCATION (olddecl)
3376             = DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (olddecl))
3377             = DECL_SOURCE_LOCATION (newdecl);
3378         }
3379
3380       return 1;
3381     }
3382
3383   if (types_match)
3384     {
3385       /* Automatically handles default parameters.  */
3386       tree oldtype = TREE_TYPE (olddecl);
3387       tree newtype;
3388
3389       /* Merge the data types specified in the two decls.  */
3390       newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3391
3392       /* If merge_types produces a non-typedef type, just use the old type.  */
3393       if (TREE_CODE (newdecl) == TYPE_DECL
3394           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3395         newtype = oldtype;
3396
3397       if (TREE_CODE (newdecl) == VAR_DECL)
3398         {
3399           DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3400           DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
3401         }
3402
3403       /* Do this after calling `merge_types' so that default
3404          parameters don't confuse us.  */
3405       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3406           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3407               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3408         {
3409           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3410                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3411           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3412                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3413
3414           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3415               && DECL_SOURCE_LINE (olddecl) != 0
3416               && flag_exceptions
3417               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3418                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3419             {
3420               error ("declaration of `%F' throws different exceptions",
3421                         newdecl);
3422               cp_error_at ("than previous declaration `%F'", olddecl);
3423             }
3424         }
3425       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3426
3427       /* Lay the type out, unless already done.  */
3428       if (! same_type_p (newtype, oldtype)
3429           && TREE_TYPE (newdecl) != error_mark_node
3430           && !(processing_template_decl && uses_template_parms (newdecl)))
3431         layout_type (TREE_TYPE (newdecl));
3432
3433       if ((TREE_CODE (newdecl) == VAR_DECL
3434            || TREE_CODE (newdecl) == PARM_DECL
3435            || TREE_CODE (newdecl) == RESULT_DECL
3436            || TREE_CODE (newdecl) == FIELD_DECL
3437            || TREE_CODE (newdecl) == TYPE_DECL)
3438           && !(processing_template_decl && uses_template_parms (newdecl)))
3439         layout_decl (newdecl, 0);
3440
3441       /* Merge the type qualifiers.  */
3442       if (TREE_READONLY (newdecl))
3443         TREE_READONLY (olddecl) = 1;
3444       if (TREE_THIS_VOLATILE (newdecl))
3445         TREE_THIS_VOLATILE (olddecl) = 1;
3446
3447       /* Merge the initialization information.  */
3448       if (DECL_INITIAL (newdecl) == NULL_TREE
3449           && DECL_INITIAL (olddecl) != NULL_TREE)
3450         {
3451           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3452           DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
3453           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3454               && DECL_LANG_SPECIFIC (newdecl)
3455               && DECL_LANG_SPECIFIC (olddecl))
3456             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3457         }
3458
3459       /* Merge the section attribute.
3460          We want to issue an error if the sections conflict but that must be
3461          done later in decl_attributes since we are called before attributes
3462          are assigned.  */
3463       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3464         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3465
3466       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3467         {
3468           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3469             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3470           DECL_NO_LIMIT_STACK (newdecl)
3471             |= DECL_NO_LIMIT_STACK (olddecl);
3472           /* Keep the old RTL.  */
3473           COPY_DECL_RTL (olddecl, newdecl);
3474         }
3475       else if (TREE_CODE (newdecl) == VAR_DECL
3476                && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
3477         {
3478           /* Keep the old RTL.  We cannot keep the old RTL if the old
3479              declaration was for an incomplete object and the new
3480              declaration is not since many attributes of the RTL will
3481              change.  */
3482           COPY_DECL_RTL (olddecl, newdecl);
3483         }
3484     }
3485   /* If cannot merge, then use the new type and qualifiers,
3486      and don't preserve the old rtl.  */
3487   else
3488     {
3489       /* Clean out any memory we had of the old declaration.  */
3490       tree oldstatic = value_member (olddecl, static_aggregates);
3491       if (oldstatic)
3492         TREE_VALUE (oldstatic) = error_mark_node;
3493
3494       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3495       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3496       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3497       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3498     }
3499
3500   /* Merge the storage class information.  */
3501   merge_weak (newdecl, olddecl);
3502
3503   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3504   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3505   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3506   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3507   if (! DECL_EXTERNAL (olddecl))
3508     DECL_EXTERNAL (newdecl) = 0;
3509
3510   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3511     {
3512       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3513       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3514       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3515       DECL_TEMPLATE_INSTANTIATED (newdecl)
3516         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3517       /* Don't really know how much of the language-specific
3518          values we should copy from old to new.  */
3519       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3520       DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
3521         DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
3522       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3523       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3524       DECL_INITIALIZED_IN_CLASS_P (newdecl)
3525         |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
3526       olddecl_friend = DECL_FRIEND_P (olddecl);
3527
3528       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3529       if (TREE_CODE (newdecl) == FUNCTION_DECL
3530           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3531         {
3532           DECL_BEFRIENDING_CLASSES (newdecl)
3533             = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3534                        DECL_BEFRIENDING_CLASSES (olddecl));
3535           DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
3536         }
3537     }
3538
3539   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3540     {
3541       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3542           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3543         {
3544           /* If newdecl is not a specialization, then it is not a
3545              template-related function at all.  And that means that we
3546              shoud have exited above, returning 0.  */
3547           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3548                               0);
3549
3550           if (TREE_USED (olddecl))
3551             /* From [temp.expl.spec]:
3552
3553                If a template, a member template or the member of a class
3554                template is explicitly specialized then that
3555                specialization shall be declared before the first use of
3556                that specialization that would cause an implicit
3557                instantiation to take place, in every translation unit in
3558                which such a use occurs.  */
3559             error ("explicit specialization of %D after first use",
3560                       olddecl);
3561
3562           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3563
3564           /* [temp.expl.spec/14] We don't inline explicit specialization
3565              just because the primary template says so.  */
3566         }
3567       else
3568         {
3569           if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3570             DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3571
3572           DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
3573
3574           /* If either decl says `inline', this fn is inline, unless
3575              its definition was passed already.  */
3576           if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3577             DECL_INLINE (olddecl) = 1;
3578           DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3579
3580           DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
3581             = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
3582         }
3583
3584       /* Preserve abstractness on cloned [cd]tors.  */
3585       DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
3586
3587       if (! types_match)
3588         {
3589           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3590           COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
3591           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3592         }
3593       if (! types_match || new_defines_function)
3594         {
3595           /* These need to be copied so that the names are available.
3596              Note that if the types do match, we'll preserve inline
3597              info and other bits, but if not, we won't.  */
3598           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3599           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3600         }
3601       if (new_defines_function)
3602         /* If defining a function declared with other language
3603            linkage, use the previously declared language linkage.  */
3604         SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3605       else if (types_match)
3606         {
3607           /* If redeclaring a builtin function, and not a definition,
3608              it stays built in.  */
3609           if (DECL_BUILT_IN (olddecl))
3610             {
3611               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3612               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3613               /* If we're keeping the built-in definition, keep the rtl,
3614                  regardless of declaration matches.  */
3615               SET_DECL_RTL (newdecl, DECL_RTL (olddecl));
3616             }
3617           else
3618             DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
3619
3620           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3621           /* Don't clear out the arguments if we're redefining a function.  */
3622           if (DECL_ARGUMENTS (olddecl))
3623             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3624         }
3625     }
3626   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3627     NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3628
3629   /* Now preserve various other info from the definition.  */
3630   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3631   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3632   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3633   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3634
3635   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3636     {
3637       int function_size;
3638
3639       function_size = sizeof (struct tree_decl);
3640
3641       memcpy ((char *) olddecl + sizeof (struct tree_common),
3642               (char *) newdecl + sizeof (struct tree_common),
3643               function_size - sizeof (struct tree_common));
3644
3645       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3646         {
3647           /* If newdecl is a template instantiation, it is possible that
3648              the following sequence of events has occurred:
3649
3650              o A friend function was declared in a class template.  The
3651              class template was instantiated.
3652
3653              o The instantiation of the friend declaration was
3654              recorded on the instantiation list, and is newdecl.
3655
3656              o Later, however, instantiate_class_template called pushdecl
3657              on the newdecl to perform name injection.  But, pushdecl in
3658              turn called duplicate_decls when it discovered that another
3659              declaration of a global function with the same name already
3660              existed.
3661
3662              o Here, in duplicate_decls, we decided to clobber newdecl.
3663
3664              If we're going to do that, we'd better make sure that
3665              olddecl, and not newdecl, is on the list of
3666              instantiations so that if we try to do the instantiation
3667              again we won't get the clobbered declaration.  */
3668
3669           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3670           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3671
3672           for (; decls; decls = TREE_CHAIN (decls))
3673             if (TREE_VALUE (decls) == newdecl)
3674               TREE_VALUE (decls) = olddecl;
3675         }
3676     }
3677   else
3678     {
3679       memcpy ((char *) olddecl + sizeof (struct tree_common),
3680               (char *) newdecl + sizeof (struct tree_common),
3681               sizeof (struct tree_decl) - sizeof (struct tree_common)
3682               + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
3683     }
3684
3685   DECL_UID (olddecl) = olddecl_uid;
3686   if (olddecl_friend)
3687     DECL_FRIEND_P (olddecl) = 1;
3688
3689   /* NEWDECL contains the merged attribute lists.
3690      Update OLDDECL to be the same.  */
3691   DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
3692
3693   return 1;
3694 }
3695
3696 /* Record a decl-node X as belonging to the current lexical scope.
3697    Check for errors (such as an incompatible declaration for the same
3698    name already seen in the same scope).
3699
3700    Returns either X or an old decl for the same name.
3701    If an old decl is returned, it may have been smashed
3702    to agree with what X says.  */
3703
3704 tree
3705 pushdecl (tree x)
3706 {
3707   register tree t;
3708   register tree name;
3709   int need_new_binding;
3710
3711   timevar_push (TV_NAME_LOOKUP);
3712   /* We shouldn't be calling pushdecl when we're generating RTL for a
3713      function that we already did semantic analysis on previously.  */
3714   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3715                       19990913);
3716
3717   need_new_binding = 1;
3718
3719   if (DECL_TEMPLATE_PARM_P (x))
3720     /* Template parameters have no context; they are not X::T even
3721        when declared within a class or namespace.  */
3722     ;
3723   else
3724     {
3725       if (current_function_decl && x != current_function_decl
3726           /* A local declaration for a function doesn't constitute
3727              nesting.  */
3728           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3729           /* A local declaration for an `extern' variable is in the
3730              scope of the current namespace, not the current
3731              function.  */
3732           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3733           && !DECL_CONTEXT (x))
3734         DECL_CONTEXT (x) = current_function_decl;
3735
3736       /* If this is the declaration for a namespace-scope function,
3737          but the declaration itself is in a local scope, mark the
3738          declaration.  */
3739       if (TREE_CODE (x) == FUNCTION_DECL
3740           && DECL_NAMESPACE_SCOPE_P (x)
3741           && current_function_decl
3742           && x != current_function_decl)
3743         DECL_LOCAL_FUNCTION_P (x) = 1;
3744     }
3745
3746   name = DECL_NAME (x);
3747   if (name)
3748     {
3749       int different_binding_level = 0;
3750
3751       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3752         name = TREE_OPERAND (name, 0);
3753
3754       /* In case this decl was explicitly namespace-qualified, look it
3755          up in its namespace context.  */
3756       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3757           && namespace_bindings_p ())
3758         t = namespace_binding (name, DECL_CONTEXT (x));
3759       else
3760         t = lookup_name_current_level (name);
3761
3762       /* [basic.link] If there is a visible declaration of an entity
3763          with linkage having the same name and type, ignoring entities
3764          declared outside the innermost enclosing namespace scope, the
3765          block scope declaration declares that same entity and
3766          receives the linkage of the previous declaration.  */
3767       if (! t && current_function_decl && x != current_function_decl
3768           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3769           && DECL_EXTERNAL (x))
3770         {
3771           /* Look in block scope.  */
3772           t = IDENTIFIER_VALUE (name);
3773           /* Or in the innermost namespace.  */
3774           if (! t)
3775             t = namespace_binding (name, DECL_CONTEXT (x));
3776           /* Does it have linkage?  Note that if this isn't a DECL, it's an
3777              OVERLOAD, which is OK.  */
3778           if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3779             t = NULL_TREE;
3780           if (t)
3781             different_binding_level = 1;
3782         }
3783
3784       /* If we are declaring a function, and the result of name-lookup
3785          was an OVERLOAD, look for an overloaded instance that is
3786          actually the same as the function we are declaring.  (If
3787          there is one, we have to merge our declaration with the
3788          previous declaration.)  */
3789       if (t && TREE_CODE (t) == OVERLOAD)
3790         {
3791           tree match;
3792
3793           if (TREE_CODE (x) == FUNCTION_DECL)
3794             for (match = t; match; match = OVL_NEXT (match))
3795               {
3796                 if (decls_match (OVL_CURRENT (match), x))
3797                   break;
3798               }
3799           else
3800             /* Just choose one.  */
3801             match = t;
3802
3803           if (match)
3804             t = OVL_CURRENT (match);
3805           else
3806             t = NULL_TREE;
3807         }
3808
3809       if (t == error_mark_node)
3810         {
3811           /* error_mark_node is 0 for a while during initialization!  */
3812           t = NULL_TREE;
3813           cp_error_at ("`%#D' used prior to declaration", x);
3814         }
3815       else if (t != NULL_TREE)
3816         {
3817           if (different_binding_level)
3818             {
3819               if (decls_match (x, t))
3820                 /* The standard only says that the local extern
3821                    inherits linkage from the previous decl; in
3822                    particular, default args are not shared.  It would
3823                    be nice to propagate inlining info, though.  FIXME.  */
3824                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3825             }
3826           else if (TREE_CODE (t) == PARM_DECL)
3827             {
3828               if (DECL_CONTEXT (t) == NULL_TREE)
3829                 /* This is probaby caused by too many errors, but calling
3830                    abort will say that if errors have occurred.  */
3831                 abort ();
3832
3833               /* Check for duplicate params.  */
3834               if (duplicate_decls (x, t))
3835                 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3836             }
3837           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3838                     || DECL_FUNCTION_TEMPLATE_P (x))
3839                    && is_overloaded_fn (t))
3840             /* Don't do anything just yet.  */;
3841           else if (t == wchar_decl_node)
3842             {
3843               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3844                 pedwarn ("redeclaration of `wchar_t' as `%T'",
3845                             TREE_TYPE (x));
3846
3847               /* Throw away the redeclaration.  */
3848               POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3849             }
3850           else if (TREE_CODE (t) != TREE_CODE (x))
3851             {
3852               if (duplicate_decls (x, t))
3853                 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3854             }
3855           else if (duplicate_decls (x, t))
3856             {
3857               if (TREE_CODE (t) == TYPE_DECL)
3858                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3859               else if (TREE_CODE (t) == FUNCTION_DECL)
3860                 check_default_args (t);
3861
3862               POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3863             }
3864           else if (DECL_MAIN_P (x))
3865             {
3866               /* A redeclaration of main, but not a duplicate of the
3867                  previous one.
3868
3869                  [basic.start.main]
3870
3871                  This function shall not be overloaded.  */
3872               cp_error_at ("invalid redeclaration of `%D'", t);
3873               error ("as `%D'", x);
3874               /* We don't try to push this declaration since that
3875                  causes a crash.  */
3876               POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3877             }
3878         }
3879
3880       check_template_shadow (x);
3881
3882       /* If this is a function conjured up by the backend, massage it
3883          so it looks friendly.  */
3884       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3885         {
3886           retrofit_lang_decl (x);
3887           SET_DECL_LANGUAGE (x, lang_c);
3888         }
3889
3890       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3891         {
3892           t = push_overloaded_decl (x, PUSH_LOCAL);
3893           if (t != x)
3894             POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3895           if (!namespace_bindings_p ())
3896             /* We do not need to create a binding for this name;
3897                push_overloaded_decl will have already done so if
3898                necessary.  */
3899             need_new_binding = 0;
3900         }
3901       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3902         {
3903           t = push_overloaded_decl (x, PUSH_GLOBAL);
3904           if (t == x)
3905             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3906           POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3907         }
3908
3909       /* If declaring a type as a typedef, copy the type (unless we're
3910          at line 0), and install this TYPE_DECL as the new type's typedef
3911          name.  See the extensive comment in ../c-decl.c (pushdecl).  */
3912       if (TREE_CODE (x) == TYPE_DECL)
3913         {
3914           tree type = TREE_TYPE (x);
3915           if (DECL_SOURCE_LINE (x) == 0)
3916             {
3917               if (TYPE_NAME (type) == 0)
3918                 TYPE_NAME (type) = x;
3919             }
3920           else if (type != error_mark_node && TYPE_NAME (type) != x
3921                    /* We don't want to copy the type when all we're
3922                       doing is making a TYPE_DECL for the purposes of
3923                       inlining.  */
3924                    && (!TYPE_NAME (type)
3925                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3926             {
3927               DECL_ORIGINAL_TYPE (x) = type;
3928               type = build_type_copy (type);
3929               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3930               TYPE_NAME (type) = x;
3931               TREE_TYPE (x) = type;
3932             }
3933
3934           if (type != error_mark_node
3935               && TYPE_NAME (type)
3936               && TYPE_IDENTIFIER (type))
3937             set_identifier_type_value_with_scope (DECL_NAME (x), type,
3938                                                   current_binding_level);
3939
3940         }
3941
3942       /* Multiple external decls of the same identifier ought to match.
3943
3944          We get warnings about inline functions where they are defined.
3945          We get warnings about other functions from push_overloaded_decl.
3946
3947          Avoid duplicate warnings where they are used.  */
3948       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
3949         {
3950           tree decl;
3951
3952           decl = IDENTIFIER_NAMESPACE_VALUE (name);
3953           if (decl && TREE_CODE (decl) == OVERLOAD)
3954             decl = OVL_FUNCTION (decl);
3955
3956           if (decl && decl != error_mark_node
3957               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
3958               /* If different sort of thing, we already gave an error.  */
3959               && TREE_CODE (decl) == TREE_CODE (x)
3960               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
3961             {
3962               pedwarn ("type mismatch with previous external decl", x);
3963               cp_pedwarn_at ("previous external decl of `%#D'", decl);
3964             }
3965         }
3966
3967       /* This name is new in its binding level.
3968          Install the new declaration and return it.  */
3969       if (namespace_bindings_p ())
3970         {
3971           /* Install a global value.  */
3972
3973           /* If the first global decl has external linkage,
3974              warn if we later see static one.  */
3975           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
3976             TREE_PUBLIC (name) = 1;
3977
3978           /* Bind the name for the entity.  */
3979           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
3980                 && t != NULL_TREE)
3981               && (TREE_CODE (x) == TYPE_DECL
3982                   || TREE_CODE (x) == VAR_DECL
3983                   || TREE_CODE (x) == ALIAS_DECL
3984                   || TREE_CODE (x) == NAMESPACE_DECL
3985                   || TREE_CODE (x) == CONST_DECL
3986                   || TREE_CODE (x) == TEMPLATE_DECL))
3987             SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
3988
3989           /* Don't forget if the function was used via an implicit decl.  */
3990           if (IDENTIFIER_IMPLICIT_DECL (name)
3991               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
3992             TREE_USED (x) = 1;
3993
3994           /* Don't forget if its address was taken in that way.  */
3995           if (IDENTIFIER_IMPLICIT_DECL (name)
3996               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
3997             TREE_ADDRESSABLE (x) = 1;
3998
3999           /* Warn about mismatches against previous implicit decl.  */
4000           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4001               /* If this real decl matches the implicit, don't complain.  */
4002               && ! (TREE_CODE (x) == FUNCTION_DECL
4003                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4004             warning
4005               ("`%D' was previously implicitly declared to return `int'", x);
4006
4007           /* If new decl is `static' and an `extern' was seen previously,
4008              warn about it.  */
4009           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4010             warn_extern_redeclared_static (x, t);
4011         }
4012       else
4013         {
4014           /* Here to install a non-global value.  */
4015           tree oldlocal = IDENTIFIER_VALUE (name);
4016           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4017
4018           if (need_new_binding)
4019             {
4020               push_local_binding (name, x, 0);
4021               /* Because push_local_binding will hook X on to the
4022                  current_binding_level's name list, we don't want to
4023                  do that again below.  */
4024               need_new_binding = 0;
4025             }
4026
4027           /* If this is a TYPE_DECL, push it into the type value slot.  */
4028           if (TREE_CODE (x) == TYPE_DECL)
4029             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4030                                                   current_binding_level);
4031
4032           /* Clear out any TYPE_DECL shadowed by a namespace so that
4033              we won't think this is a type.  The C struct hack doesn't
4034              go through namespaces.  */
4035           if (TREE_CODE (x) == NAMESPACE_DECL)
4036             set_identifier_type_value_with_scope (name, NULL_TREE,
4037                                                   current_binding_level);
4038
4039           if (oldlocal)
4040             {
4041               tree d = oldlocal;
4042
4043               while (oldlocal
4044                      && TREE_CODE (oldlocal) == VAR_DECL
4045                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4046                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4047
4048               if (oldlocal == NULL_TREE)
4049                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4050             }
4051
4052           /* If this is an extern function declaration, see if we
4053              have a global definition or declaration for the function.  */
4054           if (oldlocal == NULL_TREE
4055               && DECL_EXTERNAL (x)
4056               && oldglobal != NULL_TREE
4057               && TREE_CODE (x) == FUNCTION_DECL
4058               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4059             {
4060               /* We have one.  Their types must agree.  */
4061               if (decls_match (x, oldglobal))
4062                 /* OK */;
4063               else
4064                 {
4065                   warning ("extern declaration of `%#D' doesn't match", x);
4066                   cp_warning_at ("global declaration `%#D'", oldglobal);
4067                 }
4068             }
4069           /* If we have a local external declaration,
4070              and no file-scope declaration has yet been seen,
4071              then if we later have a file-scope decl it must not be static.  */
4072           if (oldlocal == NULL_TREE
4073               && oldglobal == NULL_TREE
4074               && DECL_EXTERNAL (x)
4075               && TREE_PUBLIC (x))
4076             TREE_PUBLIC (name) = 1;
4077
4078           /* Warn if shadowing an argument at the top level of the body.  */
4079           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4080               /* Inline decls shadow nothing.  */
4081               && !DECL_FROM_INLINE (x)
4082               && TREE_CODE (oldlocal) == PARM_DECL)
4083             {
4084               bool err = false;
4085
4086               /* Don't complain if it's from an enclosing function.  */
4087               if (DECL_CONTEXT (oldlocal) == current_function_decl
4088                   && TREE_CODE (x) != PARM_DECL)
4089                 {
4090                   /* Go to where the parms should be and see if we find
4091                      them there.  */
4092                   struct cp_binding_level *b = current_binding_level->level_chain;
4093
4094                   /* Skip the ctor/dtor cleanup level.  */
4095                   b = b->level_chain;
4096
4097                   /* ARM $8.3 */
4098                   if (b->parm_flag == 1)
4099                     {
4100                       error ("declaration of `%#D' shadows a parameter",
4101                                 name);
4102                       err = true;
4103                     }
4104                 }
4105
4106               if (warn_shadow && !err)
4107                 shadow_warning ("a parameter", name, oldlocal);
4108             }
4109
4110           /* Maybe warn if shadowing something else.  */
4111           else if (warn_shadow && !DECL_EXTERNAL (x)
4112               /* No shadow warnings for internally generated vars.  */
4113               && ! DECL_ARTIFICIAL (x)
4114               /* No shadow warnings for vars made for inlining.  */
4115               && ! DECL_FROM_INLINE (x))
4116             {
4117               if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4118                        && current_class_ptr
4119                        && !TREE_STATIC (name))
4120                 warning ("declaration of `%s' shadows a member of `this'",
4121                             IDENTIFIER_POINTER (name));
4122               else if (oldlocal != NULL_TREE
4123                        && TREE_CODE (oldlocal) == VAR_DECL)
4124                 shadow_warning ("a previous local", name, oldlocal);
4125               else if (oldglobal != NULL_TREE
4126                        && TREE_CODE (oldglobal) == VAR_DECL)
4127                 /* XXX shadow warnings in outer-more namespaces */
4128                 shadow_warning ("a global declaration", name, oldglobal);
4129             }
4130         }
4131
4132       if (TREE_CODE (x) == FUNCTION_DECL)
4133         check_default_args (x);
4134
4135       if (TREE_CODE (x) == VAR_DECL)
4136         maybe_register_incomplete_var (x);
4137     }
4138
4139   if (need_new_binding)
4140     add_decl_to_level (x,
4141                        DECL_NAMESPACE_SCOPE_P (x)
4142                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4143                        : current_binding_level);
4144
4145   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
4146 }
4147
4148 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4149    caller to set DECL_CONTEXT properly.  */
4150
4151 static tree
4152 pushdecl_with_scope (tree x, struct cp_binding_level* level)
4153 {
4154   register struct cp_binding_level *b;
4155   tree function_decl = current_function_decl;
4156
4157   timevar_push (TV_NAME_LOOKUP);
4158   current_function_decl = NULL_TREE;
4159   if (level->parm_flag == 2)
4160     {
4161       b = class_binding_level;
4162       class_binding_level = level;
4163       pushdecl_class_level (x);
4164       class_binding_level = b;
4165     }
4166   else
4167     {
4168       b = current_binding_level;
4169       current_binding_level = level;
4170       x = pushdecl (x);
4171       current_binding_level = b;
4172     }
4173   current_function_decl = function_decl;
4174   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
4175 }
4176
4177 /* Like pushdecl, only it places X in the current namespace,
4178    if appropriate.  */
4179
4180 tree
4181 pushdecl_namespace_level (tree x)
4182 {
4183   register struct cp_binding_level *b = current_binding_level;
4184   register tree t;
4185
4186   timevar_push (TV_NAME_LOOKUP);
4187   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4188
4189   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4190      what we want.  */
4191   if (TREE_CODE (x) == TYPE_DECL)
4192     {
4193       tree name = DECL_NAME (x);
4194       tree newval;
4195       tree *ptr = (tree *)0;
4196       for (; b != global_binding_level; b = b->level_chain)
4197         {
4198           tree shadowed = b->type_shadowed;
4199           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4200             if (TREE_PURPOSE (shadowed) == name)
4201               {
4202                 ptr = &TREE_VALUE (shadowed);
4203                 /* Can't break out of the loop here because sometimes
4204                    a binding level will have duplicate bindings for
4205                    PT names.  It's gross, but I haven't time to fix it.  */
4206               }
4207         }
4208       newval = TREE_TYPE (x);
4209       if (ptr == (tree *)0)
4210         {
4211           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4212              up here if this is changed to an assertion.  --KR  */
4213           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4214         }
4215       else
4216         {
4217           *ptr = newval;
4218         }
4219     }
4220   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4221 }
4222
4223 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4224    if appropriate.  */
4225
4226 tree
4227 pushdecl_top_level (tree x)
4228 {
4229   timevar_push (TV_NAME_LOOKUP);
4230   push_to_top_level ();
4231   x = pushdecl_namespace_level (x);
4232   pop_from_top_level ();
4233   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
4234 }
4235
4236 /* Make the declaration of X appear in CLASS scope.  */
4237
4238 void
4239 pushdecl_class_level (tree x)
4240 {
4241   tree name;
4242
4243   timevar_push (TV_NAME_LOOKUP);
4244   /* Get the name of X.  */
4245   if (TREE_CODE (x) == OVERLOAD)
4246     name = DECL_NAME (get_first_fn (x));
4247   else
4248     name = DECL_NAME (x);
4249
4250   if (name)
4251     {
4252       push_class_level_binding (name, x);
4253       if (TREE_CODE (x) == TYPE_DECL)
4254         set_identifier_type_value (name, TREE_TYPE (x));
4255     }
4256   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4257     {
4258       /* If X is an anonymous aggregate, all of its members are
4259          treated as if they were members of the class containing the
4260          aggregate, for naming purposes.  */
4261       tree f;
4262
4263       for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
4264         pushdecl_class_level (f);
4265     }
4266   timevar_pop (TV_NAME_LOOKUP);
4267 }
4268
4269 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4270    DECL, or a modified version thereof.  */
4271
4272 tree
4273 maybe_push_decl (tree decl)
4274 {
4275   tree type = TREE_TYPE (decl);
4276
4277   /* Add this decl to the current binding level, but not if it comes
4278      from another scope, e.g. a static member variable.  TEM may equal
4279      DECL or it may be a previous decl of the same name.  */
4280   if (decl == error_mark_node
4281       || (TREE_CODE (decl) != PARM_DECL
4282           && DECL_CONTEXT (decl) != NULL_TREE
4283           /* Definitions of namespace members outside their namespace are
4284              possible.  */
4285           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4286       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4287       || TREE_CODE (type) == UNKNOWN_TYPE
4288       /* The declaration of a template specialization does not affect
4289          the functions available for overload resolution, so we do not
4290          call pushdecl.  */
4291       || (TREE_CODE (decl) == FUNCTION_DECL
4292           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4293     return decl;
4294   else
4295     return pushdecl (decl);
4296 }
4297
4298 /* Make the declaration(s) of X appear in CLASS scope
4299    under the name NAME.  */
4300
4301 void
4302 push_class_level_binding (tree name, tree x)
4303 {
4304   tree binding;
4305   timevar_push (TV_NAME_LOOKUP);
4306   /* The class_binding_level will be NULL if x is a template
4307      parameter name in a member template.  */
4308   if (!class_binding_level)
4309     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (void)0);
4310
4311   /* Make sure that this new member does not have the same name
4312      as a template parameter.  */
4313   if (TYPE_BEING_DEFINED (current_class_type))
4314     check_template_shadow (x);
4315
4316   /* If this declaration shadows a declaration from an enclosing
4317      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4318      we leave this class.  Record the shadowed declaration here.  */
4319   binding = IDENTIFIER_BINDING (name);
4320   if (binding
4321       && ((TREE_CODE (x) == OVERLOAD
4322            && BINDING_VALUE (binding)
4323            && is_overloaded_fn (BINDING_VALUE (binding)))
4324           || INHERITED_VALUE_BINDING_P (binding)))
4325     {
4326       tree shadow;
4327       tree old_decl;
4328
4329       /* If the old binding was from a base class, and was for a tag
4330          name, slide it over to make room for the new binding.  The
4331          old binding is still visible if explicitly qualified with a
4332          class-key.  */
4333       if (INHERITED_VALUE_BINDING_P (binding)
4334           && BINDING_VALUE (binding)
4335           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4336           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4337           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4338         {
4339           old_decl = BINDING_TYPE (binding);
4340           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4341           BINDING_VALUE (binding) = NULL_TREE;
4342           INHERITED_VALUE_BINDING_P (binding) = 0;
4343         }
4344       else
4345         old_decl = BINDING_VALUE (binding);
4346
4347       /* Find the previous binding of name on the class-shadowed
4348          list, and update it.  */
4349       for (shadow = class_binding_level->class_shadowed;
4350            shadow;
4351            shadow = TREE_CHAIN (shadow))
4352         if (TREE_PURPOSE (shadow) == name
4353             && TREE_TYPE (shadow) == old_decl)
4354           {
4355             BINDING_VALUE (binding) = x;
4356             INHERITED_VALUE_BINDING_P (binding) = 0;
4357             TREE_TYPE (shadow) = x;
4358             IDENTIFIER_CLASS_VALUE (name) = x;
4359             POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (void)0);
4360           }
4361     }
4362
4363   /* If we didn't replace an existing binding, put the binding on the
4364      stack of bindings for the identifier, and update the shadowed list.  */
4365   if (push_class_binding (name, x))
4366     {
4367       class_binding_level->class_shadowed
4368         = tree_cons (name, NULL,
4369                      class_binding_level->class_shadowed);
4370       /* Record the value we are binding NAME to so that we can know
4371          what to pop later.  */
4372       TREE_TYPE (class_binding_level->class_shadowed) = x;
4373     }
4374   timevar_pop (TV_NAME_LOOKUP);
4375 }
4376
4377 /* Insert another USING_DECL into the current binding level, returning
4378    this declaration. If this is a redeclaration, do nothing, and
4379    return NULL_TREE if this not in namespace scope (in namespace
4380    scope, a using decl might extend any previous bindings).  */
4381
4382 tree
4383 push_using_decl (tree scope, tree name)
4384 {
4385   tree decl;
4386
4387   timevar_push (TV_NAME_LOOKUP);
4388   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4389   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4390   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4391     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4392       break;
4393   if (decl)
4394     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4395                             namespace_bindings_p () ? decl : NULL_TREE);
4396   decl = build_lang_decl (USING_DECL, name, void_type_node);
4397   DECL_INITIAL (decl) = scope;
4398   TREE_CHAIN (decl) = current_binding_level->usings;
4399   current_binding_level->usings = decl;
4400   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4401 }
4402
4403 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4404    changed (i.e. there was already a directive), or the fresh
4405    TREE_LIST otherwise.  */
4406
4407 tree
4408 push_using_directive (tree used)
4409 {
4410   tree ud = current_binding_level->using_directives;
4411   tree iter, ancestor;
4412
4413   timevar_push (TV_NAME_LOOKUP);
4414   /* Check if we already have this.  */
4415   if (purpose_member (used, ud) != NULL_TREE)
4416     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4417
4418   /* Recursively add all namespaces used.  */
4419   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4420     push_using_directive (TREE_PURPOSE (iter));
4421
4422   ancestor = namespace_ancestor (current_decl_namespace (), used);
4423   ud = current_binding_level->using_directives;
4424   ud = tree_cons (used, ancestor, ud);
4425   current_binding_level->using_directives = ud;
4426   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4427 }
4428
4429 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4430    other definitions already in place.  We get around this by making
4431    the value of the identifier point to a list of all the things that
4432    want to be referenced by that name.  It is then up to the users of
4433    that name to decide what to do with that list.
4434
4435    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4436    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4437
4438    FLAGS is a bitwise-or of the following values:
4439      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4440                  namespace scope.
4441      PUSH_USING: DECL is being pushed as the result of a using
4442                  declaration.
4443
4444    The value returned may be a previous declaration if we guessed wrong
4445    about what language DECL should belong to (C or C++).  Otherwise,
4446    it's always DECL (and never something that's not a _DECL).  */
4447
4448 tree
4449 push_overloaded_decl (tree decl, int flags)
4450 {
4451   tree name = DECL_NAME (decl);
4452   tree old;
4453   tree new_binding;
4454   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4455
4456   timevar_push (TV_NAME_LOOKUP);
4457   if (doing_global)
4458     old = namespace_binding (name, DECL_CONTEXT (decl));
4459   else
4460     old = lookup_name_current_level (name);
4461
4462   if (old)
4463     {
4464       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4465         {
4466           tree t = TREE_TYPE (old);
4467           if (IS_AGGR_TYPE (t) && warn_shadow
4468               && (! DECL_IN_SYSTEM_HEADER (decl)
4469                   || ! DECL_IN_SYSTEM_HEADER (old)))
4470             warning ("`%#D' hides constructor for `%#T'", decl, t);
4471           old = NULL_TREE;
4472         }
4473       else if (is_overloaded_fn (old))
4474         {
4475           tree tmp;
4476
4477           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4478             {
4479               tree fn = OVL_CURRENT (tmp);
4480
4481               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4482                   && !(flags & PUSH_USING)
4483                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4484                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4485                 error ("`%#D' conflicts with previous using declaration `%#D'",
4486                           decl, fn);
4487
4488               if (duplicate_decls (decl, fn))
4489                 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fn);
4490             }
4491         }
4492       else if (old == error_mark_node)
4493         /* Ignore the undefined symbol marker.  */
4494         old = NULL_TREE;
4495       else
4496         {
4497           cp_error_at ("previous non-function declaration `%#D'", old);
4498           error ("conflicts with function declaration `%#D'", decl);
4499           POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4500         }
4501     }
4502
4503   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4504     {
4505       if (old && TREE_CODE (old) != OVERLOAD)
4506         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4507       else
4508         new_binding = ovl_cons (decl, old);
4509       if (flags & PUSH_USING)
4510         OVL_USED (new_binding) = 1;
4511     }
4512   else
4513     /* NAME is not ambiguous.  */
4514     new_binding = decl;
4515
4516   if (doing_global)
4517     set_namespace_binding (name, current_namespace, new_binding);
4518   else
4519     {
4520       /* We only create an OVERLOAD if there was a previous binding at
4521          this level, or if decl is a template. In the former case, we
4522          need to remove the old binding and replace it with the new
4523          binding.  We must also run through the NAMES on the binding
4524          level where the name was bound to update the chain.  */
4525
4526       if (TREE_CODE (new_binding) == OVERLOAD && old)
4527         {
4528           tree *d;
4529
4530           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4531                *d;
4532                d = &TREE_CHAIN (*d))
4533             if (*d == old
4534                 || (TREE_CODE (*d) == TREE_LIST
4535                     && TREE_VALUE (*d) == old))
4536               {
4537                 if (TREE_CODE (*d) == TREE_LIST)
4538                   /* Just replace the old binding with the new.  */
4539                   TREE_VALUE (*d) = new_binding;
4540                 else
4541                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4542                   *d = tree_cons (NULL_TREE, new_binding,
4543                                   TREE_CHAIN (*d));
4544
4545                 /* And update the CPLUS_BINDING node.  */
4546                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4547                   = new_binding;
4548                 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4549               }
4550
4551           /* We should always find a previous binding in this case.  */
4552           abort ();
4553         }
4554
4555       /* Install the new binding.  */
4556       push_local_binding (name, new_binding, flags);
4557     }
4558
4559   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4560 }
4561 \f
4562 /* Generate an implicit declaration for identifier FUNCTIONID
4563    as a function of type int ().  Print a warning if appropriate.  */
4564
4565 tree
4566 implicitly_declare (tree functionid)
4567 {
4568   register tree decl;
4569
4570   /* We used to reuse an old implicit decl here,
4571      but this loses with inline functions because it can clobber
4572      the saved decl chains.  */
4573   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4574
4575   DECL_EXTERNAL (decl) = 1;
4576   TREE_PUBLIC (decl) = 1;
4577
4578   /* ISO standard says implicit declarations are in the innermost block.
4579      So we record the decl in the standard fashion.  */
4580   pushdecl (decl);
4581   rest_of_decl_compilation (decl, NULL, 0, 0);
4582
4583   if (warn_implicit
4584       /* Only one warning per identifier.  */
4585       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4586     {
4587       pedwarn ("implicit declaration of function `%#D'", decl);
4588     }
4589
4590   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4591
4592   return decl;
4593 }
4594
4595 /* Return zero if the declaration NEWDECL is valid
4596    when the declaration OLDDECL (assumed to be for the same name)
4597    has already been seen.
4598    Otherwise return an error message format string with a %s
4599    where the identifier should go.  */
4600
4601 static const char *
4602 redeclaration_error_message (tree newdecl, tree olddecl)
4603 {
4604   if (TREE_CODE (newdecl) == TYPE_DECL)
4605     {
4606       /* Because C++ can put things into name space for free,
4607          constructs like "typedef struct foo { ... } foo"
4608          would look like an erroneous redeclaration.  */
4609       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4610         return 0;
4611       else
4612         return "redefinition of `%#D'";
4613     }
4614   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4615     {
4616       /* If this is a pure function, its olddecl will actually be
4617          the original initialization to `0' (which we force to call
4618          abort()).  Don't complain about redefinition in this case.  */
4619       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4620         return 0;
4621
4622       /* If both functions come from different namespaces, this is not
4623          a redeclaration - this is a conflict with a used function.  */
4624       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4625           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4626         return "`%D' conflicts with used function";
4627
4628       /* We'll complain about linkage mismatches in
4629          warn_extern_redeclared_static.  */
4630
4631       /* Defining the same name twice is no good.  */
4632       if (DECL_INITIAL (olddecl) != NULL_TREE
4633           && DECL_INITIAL (newdecl) != NULL_TREE)
4634         {
4635           if (DECL_NAME (olddecl) == NULL_TREE)
4636             return "`%#D' not declared in class";
4637           else
4638             return "redefinition of `%#D'";
4639         }
4640       return 0;
4641     }
4642   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4643     {
4644       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4645            && (DECL_TEMPLATE_RESULT (newdecl)
4646                != DECL_TEMPLATE_RESULT (olddecl))
4647            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4648            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4649           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4650               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4651               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4652         return "redefinition of `%#D'";
4653       return 0;
4654     }
4655   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4656     {
4657       /* Objects declared at top level:  */
4658       /* If at least one is a reference, it's ok.  */
4659       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4660         return 0;
4661       /* Reject two definitions.  */
4662       return "redefinition of `%#D'";
4663     }
4664   else
4665     {
4666       /* Objects declared with block scope:  */
4667       /* Reject two definitions, and reject a definition
4668          together with an external reference.  */
4669       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4670         return "redeclaration of `%#D'";
4671       return 0;
4672     }
4673 }
4674 \f
4675 /* Create a new label, named ID.  */
4676
4677 static tree
4678 make_label_decl (tree id, int local_p)
4679 {
4680   tree decl;
4681
4682   decl = build_decl (LABEL_DECL, id, void_type_node);
4683   if (expanding_p)
4684     /* Make sure every label has an rtx.  */
4685     label_rtx (decl);
4686
4687   DECL_CONTEXT (decl) = current_function_decl;
4688   DECL_MODE (decl) = VOIDmode;
4689   C_DECLARED_LABEL_FLAG (decl) = local_p;
4690
4691   /* Say where one reference is to the label, for the sake of the
4692      error if it is not defined.  */
4693   DECL_SOURCE_LINE (decl) = lineno;
4694   DECL_SOURCE_FILE (decl) = input_filename;
4695
4696   /* Record the fact that this identifier is bound to this label.  */
4697   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4698
4699   return decl;
4700 }
4701
4702 /* Record this label on the list of used labels so that we can check
4703    at the end of the function to see whether or not the label was
4704    actually defined, and so we can check when the label is defined whether
4705    this use is valid.  */
4706
4707 static void
4708 use_label (tree decl)
4709 {
4710   if (named_label_uses == NULL
4711       || named_label_uses->names_in_scope != current_binding_level->names
4712       || named_label_uses->label_decl != decl)
4713     {
4714       struct named_label_use_list *new_ent;
4715       new_ent = ((struct named_label_use_list *)
4716                  ggc_alloc (sizeof (struct named_label_use_list)));
4717       new_ent->label_decl = decl;
4718       new_ent->names_in_scope = current_binding_level->names;
4719       new_ent->binding_level = current_binding_level;
4720       new_ent->lineno_o_goto = lineno;
4721       new_ent->filename_o_goto = input_filename;
4722       new_ent->next = named_label_uses;
4723       named_label_uses = new_ent;
4724     }
4725 }
4726
4727 /* Look for a label named ID in the current function.  If one cannot
4728    be found, create one.  (We keep track of used, but undefined,
4729    labels, and complain about them at the end of a function.)  */
4730
4731 tree
4732 lookup_label (tree id)
4733 {
4734   tree decl;
4735   struct named_label_list *ent;
4736
4737   timevar_push (TV_NAME_LOOKUP);
4738   /* You can't use labels at global scope.  */
4739   if (current_function_decl == NULL_TREE)
4740     {
4741       error ("label `%s' referenced outside of any function",
4742              IDENTIFIER_POINTER (id));
4743       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4744     }
4745
4746   /* See if we've already got this label.  */
4747   decl = IDENTIFIER_LABEL_VALUE (id);
4748   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4749     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4750
4751   /* Record this label on the list of labels used in this function.
4752      We do this before calling make_label_decl so that we get the
4753      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4754   ent = ((struct named_label_list *)
4755          ggc_alloc_cleared (sizeof (struct named_label_list)));
4756   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4757   ent->next = named_labels;
4758   named_labels = ent;
4759
4760   /* We need a new label.  */
4761   decl = make_label_decl (id, /*local_p=*/0);
4762
4763   /* Now fill in the information we didn't have before.  */
4764   ent->label_decl = decl;
4765
4766   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4767 }
4768
4769 /* Declare a local label named ID.  */
4770
4771 tree
4772 declare_local_label (tree id)
4773 {
4774   tree decl;
4775
4776   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4777      this scope we can restore the old value of
4778      IDENTIFIER_TYPE_VALUE.  */
4779   current_binding_level->shadowed_labels
4780     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4781                  current_binding_level->shadowed_labels);
4782   /* Look for the label.  */
4783   decl = make_label_decl (id, /*local_p=*/1);
4784   /* Now fill in the information we didn't have before.  */
4785   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4786
4787   return decl;
4788 }
4789
4790 /* Returns nonzero if it is ill-formed to jump past the declaration of
4791    DECL.  Returns 2 if it's also a real problem.  */
4792
4793 static int
4794 decl_jump_unsafe (tree decl)
4795 {
4796   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4797     return 0;
4798
4799   if (DECL_INITIAL (decl) == NULL_TREE
4800       && pod_type_p (TREE_TYPE (decl)))
4801     return 0;
4802
4803   /* This is really only important if we're crossing an initialization.
4804      The POD stuff is just pedantry; why should it matter if the class
4805      contains a field of pointer to member type?  */
4806   if (DECL_INITIAL (decl)
4807       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4808     return 2;
4809   return 1;
4810 }
4811
4812 /* Check that a single previously seen jump to a newly defined label
4813    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4814    the jump context; NAMES are the names in scope in LEVEL at the jump
4815    context; FILE and LINE are the source position of the jump or 0.  */
4816
4817 static void
4818 check_previous_goto_1 (tree decl,
4819                        struct cp_binding_level* level,
4820                        tree names,
4821                        const char* file,
4822                        int line)
4823 {
4824   int identified = 0;
4825   int saw_eh = 0;
4826   struct cp_binding_level *b = current_binding_level;
4827   for (; b; b = b->level_chain)
4828     {
4829       tree new_decls = b->names;
4830       tree old_decls = (b == level ? names : NULL_TREE);
4831       for (; new_decls != old_decls;
4832            new_decls = TREE_CHAIN (new_decls))
4833         {
4834           int problem = decl_jump_unsafe (new_decls);
4835           if (! problem)
4836             continue;
4837
4838           if (! identified)
4839             {
4840               if (decl)
4841                 pedwarn ("jump to label `%D'", decl);
4842               else
4843                 pedwarn ("jump to case label");
4844
4845               if (file)
4846                 pedwarn_with_file_and_line (file, line, "  from here");
4847               identified = 1;
4848             }
4849
4850           if (problem > 1)
4851             cp_error_at ("  crosses initialization of `%#D'",
4852                          new_decls);
4853           else
4854             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4855                            new_decls);
4856         }
4857
4858       if (b == level)
4859         break;
4860       if ((b->is_try_scope || b->is_catch_scope) && ! saw_eh)
4861         {
4862           if (! identified)
4863             {
4864               if (decl)
4865                 pedwarn ("jump to label `%D'", decl);
4866               else
4867                 pedwarn ("jump to case label");
4868
4869               if (file)
4870                 pedwarn_with_file_and_line (file, line, "  from here");
4871               identified = 1;
4872             }
4873           if (b->is_try_scope)
4874             error ("  enters try block");
4875           else
4876             error ("  enters catch block");
4877           saw_eh = 1;
4878         }
4879     }
4880 }
4881
4882 static void
4883 check_previous_goto (struct named_label_use_list* use)
4884 {
4885   check_previous_goto_1 (use->label_decl, use->binding_level,
4886                          use->names_in_scope, use->filename_o_goto,
4887                          use->lineno_o_goto);
4888 }
4889
4890 static void
4891 check_switch_goto (struct cp_binding_level* level)
4892 {
4893   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
4894 }
4895
4896 /* Check that any previously seen jumps to a newly defined label DECL
4897    are OK.  Called by define_label.  */
4898
4899 static void
4900 check_previous_gotos (tree decl)
4901 {
4902   struct named_label_use_list **usep;
4903
4904   if (! TREE_USED (decl))
4905     return;
4906
4907   for (usep = &named_label_uses; *usep; )
4908     {
4909       struct named_label_use_list *use = *usep;
4910       if (use->label_decl == decl)
4911         {
4912           check_previous_goto (use);
4913           *usep = use->next;
4914         }
4915       else
4916         usep = &(use->next);
4917     }
4918 }
4919
4920 /* Check that a new jump to a label DECL is OK.  Called by
4921    finish_goto_stmt.  */
4922
4923 void
4924 check_goto (tree decl)
4925 {
4926   int identified = 0;
4927   tree bad;
4928   struct named_label_list *lab;
4929
4930   /* We can't know where a computed goto is jumping.  So we assume
4931      that it's OK.  */
4932   if (! DECL_P (decl))
4933     return;
4934
4935   /* If the label hasn't been defined yet, defer checking.  */
4936   if (! DECL_INITIAL (decl))
4937     {
4938       use_label (decl);
4939       return;
4940     }
4941
4942   for (lab = named_labels; lab; lab = lab->next)
4943     if (decl == lab->label_decl)
4944       break;
4945
4946   /* If the label is not on named_labels it's a gcc local label, so
4947      it must be in an outer scope, so jumping to it is always OK.  */
4948   if (lab == 0)
4949     return;
4950
4951   if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
4952       && !identified)
4953     {
4954       cp_pedwarn_at ("jump to label `%D'", decl);
4955       pedwarn ("  from here");
4956       identified = 1;
4957     }
4958
4959   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
4960     {
4961       tree b = TREE_VALUE (bad);
4962       int u = decl_jump_unsafe (b);
4963
4964       if (u > 1 && DECL_ARTIFICIAL (b))
4965         /* Can't skip init of __exception_info.  */
4966         cp_error_at ("  enters catch block", b);
4967       else if (u > 1)
4968         cp_error_at ("  skips initialization of `%#D'", b);
4969       else
4970         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
4971     }
4972
4973   if (lab->in_try_scope)
4974     error ("  enters try block");
4975   else if (lab->in_catch_scope)
4976     error ("  enters catch block");
4977 }
4978
4979 /* Define a label, specifying the location in the source file.
4980    Return the LABEL_DECL node for the label, if the definition is valid.
4981    Otherwise return 0.  */
4982
4983 tree
4984 define_label (const char* filename, int line, tree name)
4985 {
4986   tree decl = lookup_label (name);
4987   struct named_label_list *ent;
4988   register struct cp_binding_level *p;
4989
4990   timevar_push (TV_NAME_LOOKUP);
4991   for (ent = named_labels; ent; ent = ent->next)
4992     if (ent->label_decl == decl)
4993       break;
4994
4995   /* After labels, make any new cleanups in the function go into their
4996      own new (temporary) binding contour.  */
4997   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
4998     p->more_cleanups_ok = 0;
4999
5000   if (name == get_identifier ("wchar_t"))
5001     pedwarn ("label named wchar_t");
5002
5003   if (DECL_INITIAL (decl) != NULL_TREE)
5004     {
5005       error ("duplicate label `%D'", decl);
5006       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL);
5007     }
5008   else
5009     {
5010       /* Mark label as having been defined.  */
5011       DECL_INITIAL (decl) = error_mark_node;
5012       /* Say where in the source.  */
5013       DECL_SOURCE_FILE (decl) = filename;
5014       DECL_SOURCE_LINE (decl) = line;
5015       if (ent)
5016         {
5017           ent->names_in_scope = current_binding_level->names;
5018           ent->binding_level = current_binding_level;
5019         }
5020       check_previous_gotos (decl);
5021       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5022     }
5023   timevar_pop (TV_NAME_LOOKUP);
5024 }
5025
5026 struct cp_switch
5027 {
5028   struct cp_binding_level *level;
5029   struct cp_switch *next;
5030   /* The SWITCH_STMT being built.  */
5031   tree switch_stmt;
5032   /* A splay-tree mapping the low element of a case range to the high
5033      element, or NULL_TREE if there is no high element.  Used to
5034      determine whether or not a new case label duplicates an old case
5035      label.  We need a tree, rather than simply a hash table, because
5036      of the GNU case range extension.  */
5037   splay_tree cases;
5038 };
5039
5040 /* A stack of the currently active switch statements.  The innermost
5041    switch statement is on the top of the stack.  There is no need to
5042    mark the stack for garbage collection because it is only active
5043    during the processing of the body of a function, and we never
5044    collect at that point.  */
5045
5046 static struct cp_switch *switch_stack;
5047
5048 /* Called right after a switch-statement condition is parsed.
5049    SWITCH_STMT is the switch statement being parsed.  */
5050
5051 void
5052 push_switch (tree switch_stmt)
5053 {
5054   struct cp_switch *p
5055     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5056   p->level = current_binding_level;
5057   p->next = switch_stack;
5058   p->switch_stmt = switch_stmt;
5059   p->cases = splay_tree_new (case_compare, NULL, NULL);
5060   switch_stack = p;
5061 }
5062
5063 void
5064 pop_switch (void)
5065 {
5066   struct cp_switch *cs;
5067
5068   cs = switch_stack;
5069   splay_tree_delete (cs->cases);
5070   switch_stack = switch_stack->next;
5071   free (cs);
5072 }
5073
5074 /* Note that we've seen a definition of a case label, and complain if this
5075    is a bad place for one.  */
5076
5077 tree
5078 finish_case_label (tree low_value, tree high_value)
5079 {
5080   tree cond, r;
5081   register struct cp_binding_level *p;
5082
5083   if (! switch_stack)
5084     {
5085       if (high_value)
5086         error ("case label not within a switch statement");
5087       else if (low_value)
5088         error ("case label `%E' not within a switch statement",
5089                   low_value);
5090       else
5091         error ("`default' label not within a switch statement");
5092       return NULL_TREE;
5093     }
5094
5095   if (processing_template_decl)
5096     {
5097       tree label;
5098
5099       /* For templates, just add the case label; we'll do semantic
5100          analysis at instantiation-time.  */
5101       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5102       return add_stmt (build_case_label (low_value, high_value, label));
5103     }
5104
5105   /* Find the condition on which this switch statement depends.  */
5106   cond = SWITCH_COND (switch_stack->switch_stmt);
5107   if (cond && TREE_CODE (cond) == TREE_LIST)
5108     cond = TREE_VALUE (cond);
5109
5110   r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5111
5112   check_switch_goto (switch_stack->level);
5113
5114   /* After labels, make any new cleanups in the function go into their
5115      own new (temporary) binding contour.  */
5116   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5117     p->more_cleanups_ok = 0;
5118
5119   return r;
5120 }
5121 \f
5122 /* Return the list of declarations of the current level.
5123    Note that this list is in reverse order unless/until
5124    you nreverse it; and when you do nreverse it, you must
5125    store the result back using `storedecls' or you will lose.  */
5126
5127 tree
5128 getdecls (void)
5129 {
5130   return current_binding_level->names;
5131 }
5132
5133 /* Return the list of type-tags (for structs, etc) of the current level.  */
5134
5135 tree
5136 gettags (void)
5137 {
5138   return current_binding_level->tags;
5139 }
5140
5141 /* Store the list of declarations of the current level.
5142    This is done for the parameter declarations of a function being defined,
5143    after they are modified in the light of any missing parameters.  */
5144
5145 static void
5146 storedecls (tree decls)
5147 {
5148   current_binding_level->names = decls;
5149 }
5150
5151 /* Similarly, store the list of tags of the current level.  */
5152
5153 void
5154 storetags (tree tags)
5155 {
5156   current_binding_level->tags = tags;
5157 }
5158 \f
5159 /* Return the type that should be used when TYPE's name is preceded
5160    by a tag such as 'struct' or 'union', or null if the name cannot
5161    be used in this way.
5162
5163    For example, when processing the third line of:
5164
5165         struct A;
5166         typedef struct A A;
5167         struct A;
5168
5169    lookup of A will find the typedef.  Given A's typedef, this function
5170    will return the type associated with "struct A".  For the tag to be
5171    anything other than TYPE, TYPE must be a typedef whose original type
5172    has the same name and context as TYPE itself.
5173
5174    It is not valid for a typedef of an anonymous type to be used with
5175    an explicit tag:
5176
5177        typedef struct { ... } B;
5178        struct B;
5179
5180    Return null for this case.  */
5181
5182 static tree
5183 follow_tag_typedef (tree type)
5184 {
5185   tree original;
5186
5187   original = original_type (type);
5188   if (! TYPE_NAME (original))
5189     return NULL_TREE;
5190   if (TYPE_IDENTIFIER (original) == TYPE_IDENTIFIER (type)
5191       && (CP_DECL_CONTEXT (TYPE_NAME (original))
5192           == CP_DECL_CONTEXT (TYPE_NAME (type)))
5193       && !(CLASS_TYPE_P (original) && TYPE_WAS_ANONYMOUS (original)))
5194     return original;
5195   else
5196     return NULL_TREE;
5197 }
5198
5199 /* Given NAME, an IDENTIFIER_NODE,
5200    return the structure (or union or enum) definition for that name.
5201    Searches binding levels from BINDING_LEVEL up to the global level.
5202    If THISLEVEL_ONLY is nonzero, searches only the specified context
5203    (but skips any tag-transparent contexts to find one that is
5204    meaningful for tags).
5205    FORM says which kind of type the caller wants;
5206    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5207    If the wrong kind of type is found, and it's not a template, an error is
5208    reported.  */
5209
5210 static tree
5211 lookup_tag (enum tree_code form,
5212             tree name,
5213             struct cp_binding_level* binding_level,
5214             int thislevel_only)
5215 {
5216   register struct cp_binding_level *level;
5217   /* Nonzero if, we should look past a template parameter level, even
5218      if THISLEVEL_ONLY.  */
5219   int allow_template_parms_p = 1;
5220
5221   timevar_push (TV_NAME_LOOKUP);
5222   for (level = binding_level; level; level = level->level_chain)
5223     {
5224       register tree tail;
5225       if (ANON_AGGRNAME_P (name))
5226         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5227           {
5228             /* There's no need for error checking here, because
5229                anon names are unique throughout the compilation.  */
5230             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5231               POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_VALUE (tail));
5232           }
5233       else if (level->namespace_p)
5234         /* Do namespace lookup.  */
5235         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5236           {
5237             tree old = binding_for_name (name, tail);
5238
5239             /* If we just skipped past a template parameter level,
5240                even though THISLEVEL_ONLY, and we find a template
5241                class declaration, then we use the _TYPE node for the
5242                template.  See the example below.  */
5243             if (thislevel_only && !allow_template_parms_p
5244                 && old && BINDING_VALUE (old)
5245                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5246               old = TREE_TYPE (BINDING_VALUE (old));
5247             else
5248               old = BINDING_TYPE (old);
5249
5250             if (old)
5251               {
5252                 /* We've found something at this binding level.  If it is
5253                    a typedef, extract the tag it refers to.  Lookup fails
5254                    if the typedef doesn't refer to a taggable type.  */
5255                 old = follow_tag_typedef (old);
5256                 if (!old)
5257                   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5258                 if (TREE_CODE (old) != form
5259                     && (form == ENUMERAL_TYPE
5260                         || TREE_CODE (old) == ENUMERAL_TYPE))
5261                   {
5262                     error ("`%#D' redeclared as %C", old, form);
5263                     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5264                   }
5265                 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, old);
5266               }
5267             if (thislevel_only || tail == global_namespace)
5268               POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5269           }
5270       else
5271         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5272           {
5273             if (TREE_PURPOSE (tail) == name)
5274               {
5275                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5276
5277                 if (code != form
5278                     && (form == ENUMERAL_TYPE || code == ENUMERAL_TYPE))
5279                   {
5280                     /* Definition isn't the kind we were looking for.  */
5281                     error ("`%#D' redeclared as %C", TREE_VALUE (tail), form);
5282                     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5283                   }
5284                 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_VALUE (tail));
5285               }
5286           }
5287       if (thislevel_only && ! level->tag_transparent)
5288         {
5289           if (level->template_parms_p && allow_template_parms_p)
5290             {
5291               /* We must deal with cases like this:
5292
5293                    template <class T> struct S;
5294                    template <class T> struct S {};
5295
5296                  When looking up `S', for the second declaration, we
5297                  would like to find the first declaration.  But, we
5298                  are in the pseudo-global level created for the
5299                  template parameters, rather than the (surrounding)
5300                  namespace level.  Thus, we keep going one more level,
5301                  even though THISLEVEL_ONLY is nonzero.  */
5302               allow_template_parms_p = 0;
5303               continue;
5304             }
5305           else
5306             POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5307         }
5308     }
5309   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5310 }
5311
5312 /* Given a type, find the tag that was defined for it and return the tag name.
5313    Otherwise return 0.  However, the value can never be 0
5314    in the cases in which this is used.
5315
5316    C++: If NAME is nonzero, this is the new name to install.  This is
5317    done when replacing anonymous tags with real tag names.  */
5318
5319 static tree
5320 lookup_tag_reverse (tree type, tree name)
5321 {
5322   register struct cp_binding_level *level;
5323
5324   timevar_push (TV_NAME_LOOKUP);
5325   for (level = current_binding_level; level; level = level->level_chain)
5326     {
5327       register tree tail;
5328       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5329         {
5330           if (TREE_VALUE (tail) == type)
5331             {
5332               if (name)
5333                 TREE_PURPOSE (tail) = name;
5334               POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_PURPOSE (tail));
5335             }
5336         }
5337     }
5338   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5339 }
5340 \f
5341 /* Look up NAME in the NAMESPACE.  */
5342
5343 tree
5344 lookup_namespace_name (tree namespace, tree name)
5345 {
5346   tree val;
5347   tree template_id = NULL_TREE;
5348
5349   timevar_push (TV_NAME_LOOKUP);
5350   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5351
5352   if (TREE_CODE (name) == NAMESPACE_DECL)
5353     /* This happens for A::B<int> when B is a namespace.  */
5354     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, name);
5355   else if (TREE_CODE (name) == TEMPLATE_DECL)
5356     {
5357       /* This happens for A::B where B is a template, and there are no
5358          template arguments.  */
5359       error ("invalid use of `%D'", name);
5360       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5361     }
5362
5363   namespace = ORIGINAL_NAMESPACE (namespace);
5364
5365   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5366     {
5367       template_id = name;
5368       name = TREE_OPERAND (name, 0);
5369       if (TREE_CODE (name) == OVERLOAD)
5370         name = DECL_NAME (OVL_CURRENT (name));
5371       else if (DECL_P (name))
5372         name = DECL_NAME (name);
5373     }
5374
5375   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5376
5377   val = make_node (CPLUS_BINDING);
5378   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5379     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5380
5381   if (BINDING_VALUE (val))
5382     {
5383       val = BINDING_VALUE (val);
5384
5385       if (template_id)
5386         {
5387           if (DECL_CLASS_TEMPLATE_P (val))
5388             val = lookup_template_class (val,
5389                                          TREE_OPERAND (template_id, 1),
5390                                          /*in_decl=*/NULL_TREE,
5391                                          /*context=*/NULL_TREE,
5392                                          /*entering_scope=*/0,
5393                                          tf_error | tf_warning);
5394           else if (DECL_FUNCTION_TEMPLATE_P (val)
5395                    || TREE_CODE (val) == OVERLOAD)
5396             val = lookup_template_function (val,
5397                                             TREE_OPERAND (template_id, 1));
5398           else
5399             {
5400               error ("`%D::%D' is not a template",
5401                         namespace, name);
5402               POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5403             }
5404         }
5405
5406       /* If we have a single function from a using decl, pull it out.  */
5407       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5408         val = OVL_FUNCTION (val);
5409
5410       /* Ignore built-in functions that haven't been prototyped yet.  */
5411       if (!val || !DECL_P(val)
5412           || !DECL_LANG_SPECIFIC(val)
5413           || !DECL_ANTICIPATED (val))
5414         POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
5415     }
5416
5417   error ("`%D' undeclared in namespace `%D'", name, namespace);
5418   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5419 }
5420
5421 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5422
5423 static hashval_t
5424 typename_hash (const void* k)
5425 {
5426   hashval_t hash;
5427   tree t = (tree) k;
5428
5429   hash = (htab_hash_pointer (TYPE_CONTEXT (t))
5430           ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
5431
5432   return hash;
5433 }
5434
5435 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5436
5437 static int
5438 typename_compare (const void * k1, const void * k2)
5439 {
5440   tree t1;
5441   tree t2;
5442   tree d1;
5443   tree d2;
5444
5445   t1 = (tree) k1;
5446   t2 = (tree) k2;
5447   d1 = TYPE_NAME (t1);
5448   d2 = TYPE_NAME (t2);
5449
5450   return (DECL_NAME (d1) == DECL_NAME (d2)
5451           && TYPE_CONTEXT (t1) == TYPE_CONTEXT (t2)
5452           && ((TREE_TYPE (t1) != NULL_TREE)
5453               == (TREE_TYPE (t2) != NULL_TREE))
5454           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5455           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5456 }
5457
5458 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5459    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5460    is non-NULL, this type is being created by the implicit typename
5461    extension, and BASE_TYPE is a type named `t' in some base class of
5462    `T' which depends on template parameters.
5463
5464    Returns the new TYPENAME_TYPE.  */
5465
5466 static GTY ((param_is (union tree_node))) htab_t typename_htab;
5467
5468 tree
5469 build_typename_type (tree context, tree name, tree fullname)
5470 {
5471   tree t;
5472   tree d;
5473   PTR *e;
5474
5475   if (typename_htab == NULL)
5476     {
5477       typename_htab = htab_create_ggc (61, &typename_hash,
5478                                        &typename_compare, NULL);
5479     }
5480
5481   /* Build the TYPENAME_TYPE.  */
5482   t = make_aggr_type (TYPENAME_TYPE);
5483   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5484   TYPENAME_TYPE_FULLNAME (t) = fullname;
5485
5486   /* Build the corresponding TYPE_DECL.  */
5487   d = build_decl (TYPE_DECL, name, t);
5488   TYPE_NAME (TREE_TYPE (d)) = d;
5489   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5490   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5491   DECL_ARTIFICIAL (d) = 1;
5492
5493   /* See if we already have this type.  */
5494   e = htab_find_slot (typename_htab, t, INSERT);
5495   if (*e)
5496     t = (tree) *e;
5497   else
5498     *e = t;
5499
5500   return t;
5501 }
5502
5503 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5504    unless an error occurs, in which case error_mark_node is returned.
5505    If we locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is
5506    set, we return that, rather than the _TYPE it corresponds to, in
5507    other cases we look through the type decl.  If TF_ERROR is set,
5508    complain about errors, otherwise be quiet.  */
5509
5510 tree
5511 make_typename_type (tree context, tree name, tsubst_flags_t complain)
5512 {
5513   tree fullname;
5514
5515   if (TYPE_P (name))
5516     {
5517       if (!(TYPE_LANG_SPECIFIC (name)
5518             && (CLASSTYPE_IS_TEMPLATE (name)
5519                 || CLASSTYPE_USE_TEMPLATE (name))))
5520         name = TYPE_IDENTIFIER (name);
5521       else
5522         /* Create a TEMPLATE_ID_EXPR for the type.  */
5523         name = build_nt (TEMPLATE_ID_EXPR,
5524                          CLASSTYPE_TI_TEMPLATE (name),
5525                          CLASSTYPE_TI_ARGS (name));
5526     }
5527   else if (TREE_CODE (name) == TYPE_DECL)
5528     name = DECL_NAME (name);
5529
5530   fullname = name;
5531
5532   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5533     {
5534       name = TREE_OPERAND (name, 0);
5535       if (TREE_CODE (name) == TEMPLATE_DECL)
5536         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5537     }
5538   if (TREE_CODE (name) == TEMPLATE_DECL)
5539     {
5540       error ("`%D' used without template parameters", name);
5541       return error_mark_node;
5542     }
5543   if (TREE_CODE (name) != IDENTIFIER_NODE)
5544     abort ();
5545
5546   if (TREE_CODE (context) == NAMESPACE_DECL)
5547     {
5548       /* We can get here from typename_sub0 in the explicit_template_type
5549          expansion.  Just fail.  */
5550       if (complain & tf_error)
5551         error ("no class template named `%#T' in `%#T'",
5552                   name, context);
5553       return error_mark_node;
5554     }
5555
5556   if (! uses_template_parms (context)
5557       || currently_open_class (context))
5558     {
5559       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5560         {
5561           tree tmpl = NULL_TREE;
5562           if (IS_AGGR_TYPE (context))
5563             tmpl = lookup_field (context, name, 0, 0);
5564           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5565             {
5566               if (complain & tf_error)
5567                 error ("no class template named `%#T' in `%#T'",
5568                           name, context);
5569               return error_mark_node;
5570             }
5571
5572           if (complain & tf_error)
5573             {
5574               if (complain & tf_parsing)
5575                 perform_or_defer_access_check (context, tmpl);
5576               else
5577                 enforce_access (context, tmpl);
5578             }
5579
5580           return lookup_template_class (tmpl,
5581                                         TREE_OPERAND (fullname, 1),
5582                                         NULL_TREE, context,
5583                                         /*entering_scope=*/0,
5584                                         tf_error | tf_warning);
5585         }
5586       else
5587         {
5588           tree t;
5589
5590           if (!IS_AGGR_TYPE (context))
5591             {
5592               if (complain & tf_error)
5593                 error ("no type named `%#T' in `%#T'", name, context);
5594               return error_mark_node;
5595             }
5596
5597           t = lookup_field (context, name, 0, 1);
5598           if (t)
5599             {
5600               if (TREE_CODE (t) != TYPE_DECL)
5601                 {
5602                   if (complain & tf_error)
5603                     error ("no type named `%#T' in `%#T'", name, context);
5604                   return error_mark_node;
5605                 }
5606
5607               if (complain & tf_error)
5608                 {
5609                   if (complain & tf_parsing)
5610                     perform_or_defer_access_check (context, t);
5611                   else
5612                     enforce_access (context, t);
5613                 }
5614
5615               if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
5616                 t = TREE_TYPE (t);
5617
5618               return t;
5619             }
5620         }
5621     }
5622
5623   /* If the CONTEXT is not a template type, then either the field is
5624      there now or its never going to be.  */
5625   if (!uses_template_parms (context))
5626     {
5627       if (complain & tf_error)
5628         error ("no type named `%#T' in `%#T'", name, context);
5629       return error_mark_node;
5630     }
5631
5632   return build_typename_type (context, name, fullname);
5633 }
5634
5635 /* Resolve `CONTEXT::template NAME'.  Returns an appropriate type,
5636    unless an error occurs, in which case error_mark_node is returned.
5637    If we locate a TYPE_DECL, we return that, rather than the _TYPE it
5638    corresponds to.  If COMPLAIN zero, don't complain about any errors
5639    that occur.  */
5640
5641 tree
5642 make_unbound_class_template (tree context, tree name, tsubst_flags_t complain)
5643 {
5644   tree t;
5645   tree d;
5646
5647   if (TYPE_P (name))
5648     name = TYPE_IDENTIFIER (name);
5649   else if (DECL_P (name))
5650     name = DECL_NAME (name);
5651   if (TREE_CODE (name) != IDENTIFIER_NODE)
5652     abort ();
5653
5654   if (!uses_template_parms (context)
5655       || currently_open_class (context))
5656     {
5657       tree tmpl = NULL_TREE;
5658
5659       if (IS_AGGR_TYPE (context))
5660         tmpl = lookup_field (context, name, 0, 0);
5661
5662       if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5663         {
5664           if (complain & tf_error)
5665             error ("no class template named `%#T' in `%#T'", name, context);
5666           return error_mark_node;
5667         }
5668
5669       if (complain & tf_error)
5670         {
5671           if (complain & tf_parsing)
5672             perform_or_defer_access_check (context, tmpl);
5673           else
5674             enforce_access (context, tmpl);
5675         }
5676
5677       return tmpl;
5678     }
5679
5680   /* Build the UNBOUND_CLASS_TEMPLATE.  */
5681   t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
5682   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5683   TREE_TYPE (t) = NULL_TREE;
5684
5685   /* Build the corresponding TEMPLATE_DECL.  */
5686   d = build_decl (TEMPLATE_DECL, name, t);
5687   TYPE_NAME (TREE_TYPE (d)) = d;
5688   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5689   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5690   DECL_ARTIFICIAL (d) = 1;
5691
5692   return t;
5693 }
5694
5695 /* Select the right _DECL from multiple choices.  */
5696
5697 static tree
5698 select_decl (tree binding, int flags)
5699 {
5700   tree val;
5701   val = BINDING_VALUE (binding);
5702
5703   timevar_push (TV_NAME_LOOKUP);
5704   if (LOOKUP_NAMESPACES_ONLY (flags))
5705     {
5706       /* We are not interested in types.  */
5707       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5708         POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
5709       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5710     }
5711
5712   /* If we could have a type and
5713      we have nothing or we need a type and have none.  */
5714   if (BINDING_TYPE (binding)
5715       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5716                    && TREE_CODE (val) != TYPE_DECL)))
5717     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5718   /* Don't return non-types if we really prefer types.  */
5719   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5720            && (TREE_CODE (val) != TEMPLATE_DECL
5721                || !DECL_CLASS_TEMPLATE_P (val)))
5722     val = NULL_TREE;
5723
5724   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
5725 }
5726
5727 /* Unscoped lookup of a global: iterate over current namespaces,
5728    considering using-directives.  If SPACESP is non-NULL, store a list
5729    of the namespaces we've considered in it.  */
5730
5731 tree
5732 unqualified_namespace_lookup (tree name, int flags, tree* spacesp)
5733 {
5734   tree b = make_node (CPLUS_BINDING);
5735   tree initial = current_decl_namespace ();
5736   tree scope = initial;
5737   tree siter;
5738   struct cp_binding_level *level;
5739   tree val = NULL_TREE;
5740
5741   timevar_push (TV_NAME_LOOKUP);
5742   if (spacesp)
5743     *spacesp = NULL_TREE;
5744
5745   for (; !val; scope = CP_DECL_CONTEXT (scope))
5746     {
5747       if (spacesp)
5748         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5749       val = binding_for_name (name, scope);
5750
5751       /* Ignore anticipated built-in functions.  */
5752       if (val && BINDING_VALUE (val)
5753           && DECL_P (BINDING_VALUE (val))
5754           && DECL_LANG_SPECIFIC (BINDING_VALUE (val))
5755           && DECL_ANTICIPATED (BINDING_VALUE (val)))
5756         {
5757           BINDING_VALUE (b) = NULL_TREE;
5758           BINDING_TYPE (b) = NULL_TREE;
5759         }
5760       else
5761         {
5762           /* Initialize binding for this context.  */
5763           BINDING_VALUE (b) = BINDING_VALUE (val);
5764           BINDING_TYPE (b) = BINDING_TYPE (val);
5765         }
5766
5767       /* Add all _DECLs seen through local using-directives.  */
5768       for (level = current_binding_level;
5769            !level->namespace_p;
5770            level = level->level_chain)
5771         if (!lookup_using_namespace (name, b, level->using_directives,
5772                                      scope, flags, spacesp))
5773           /* Give up because of error.  */
5774           POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5775
5776       /* Add all _DECLs seen through global using-directives.  */
5777       /* XXX local and global using lists should work equally.  */
5778       siter = initial;
5779       while (1)
5780         {
5781           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5782                                        scope, flags, spacesp))
5783             /* Give up because of error.  */
5784             POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5785           if (siter == scope) break;
5786           siter = CP_DECL_CONTEXT (siter);
5787         }
5788
5789       val = select_decl (b, flags);
5790       if (scope == global_namespace)
5791         break;
5792     }
5793   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
5794 }
5795
5796 /* Combine prefer_type and namespaces_only into flags.  */
5797
5798 static int
5799 lookup_flags (int prefer_type, int namespaces_only)
5800 {
5801   if (namespaces_only)
5802     return LOOKUP_PREFER_NAMESPACES;
5803   if (prefer_type > 1)
5804     return LOOKUP_PREFER_TYPES;
5805   if (prefer_type > 0)
5806     return LOOKUP_PREFER_BOTH;
5807   return 0;
5808 }
5809
5810 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5811    ignore it or not.  Subroutine of lookup_name_real.  */
5812
5813 static tree
5814 qualify_lookup (tree val, int flags)
5815 {
5816   if (val == NULL_TREE)
5817     return val;
5818   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5819     return val;
5820   if ((flags & LOOKUP_PREFER_TYPES) && TREE_CODE (val) == TYPE_DECL)
5821     return val;
5822   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5823     return NULL_TREE;
5824   return val;
5825 }
5826
5827 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
5828    or a class TYPE).  If IS_TYPE_P is TRUE, then ignore non-type
5829    bindings.
5830
5831    Returns a DECL (or OVERLOAD, or BASELINK) representing the
5832    declaration found.  */
5833
5834 tree
5835 lookup_qualified_name (tree scope, tree name, bool is_type_p, int flags)
5836 {
5837   if (TREE_CODE (scope) == NAMESPACE_DECL)
5838     {
5839       tree val;
5840
5841       val = make_node (CPLUS_BINDING);
5842       flags |= LOOKUP_COMPLAIN;
5843       if (is_type_p)
5844         flags |= LOOKUP_PREFER_TYPES;
5845       if (!qualified_lookup_using_namespace (name, scope, val, flags))
5846         return NULL_TREE;
5847       return select_decl (val, flags);
5848     }
5849   else
5850     return lookup_member (scope, name, 0, is_type_p);
5851 }
5852
5853 /* Check to see whether or not DECL is a variable that would have been
5854    in scope under the ARM, but is not in scope under the ANSI/ISO
5855    standard.  If so, issue an error message.  If name lookup would
5856    work in both cases, but return a different result, this function
5857    returns the result of ANSI/ISO lookup.  Otherwise, it returns
5858    DECL.  */
5859
5860 tree
5861 check_for_out_of_scope_variable (tree decl)
5862 {
5863   tree shadowed;
5864
5865   /* We only care about out of scope variables.  */
5866   if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
5867     return decl;
5868
5869   shadowed = DECL_SHADOWED_FOR_VAR (decl);
5870   while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
5871          && DECL_DEAD_FOR_LOCAL (shadowed))
5872     shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
5873   if (!shadowed)
5874     shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
5875   if (shadowed)
5876     {
5877       if (!DECL_ERROR_REPORTED (decl))
5878         {
5879           warning ("name lookup of `%D' changed",
5880                       DECL_NAME (decl));
5881           cp_warning_at ("  matches this `%D' under ISO standard rules",
5882                          shadowed);
5883           cp_warning_at ("  matches this `%D' under old rules", decl);
5884           DECL_ERROR_REPORTED (decl) = 1;
5885         }
5886       return shadowed;
5887     }
5888
5889   /* If we have already complained about this declaration, there's no
5890      need to do it again.  */
5891   if (DECL_ERROR_REPORTED (decl))
5892     return decl;
5893
5894   DECL_ERROR_REPORTED (decl) = 1;
5895   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5896     {
5897       error ("name lookup of `%D' changed for new ISO `for' scoping",
5898              DECL_NAME (decl));
5899       cp_error_at ("  cannot use obsolete binding at `%D' because it has a destructor", decl);
5900       return error_mark_node;
5901     }
5902   else
5903     {
5904       pedwarn ("name lookup of `%D' changed for new ISO `for' scoping",
5905                DECL_NAME (decl));
5906       cp_pedwarn_at ("  using obsolete binding at `%D'", decl);
5907     }
5908
5909   return decl;
5910 }
5911
5912 /* Look up NAME in the current binding level and its superiors in the
5913    namespace of variables, functions and typedefs.  Return a ..._DECL
5914    node of some kind representing its definition if there is only one
5915    such declaration, or return a TREE_LIST with all the overloaded
5916    definitions if there are many, or return 0 if it is undefined.
5917
5918    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5919    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5920    Otherwise we prefer non-TYPE_DECLs.
5921
5922    If NONCLASS is nonzero, we don't look for the NAME in class scope,
5923    using IDENTIFIER_CLASS_VALUE.  */
5924
5925 tree
5926 lookup_name_real (tree name,
5927                   int prefer_type,
5928                   int nonclass,
5929                   int namespaces_only,
5930                   int flags)
5931 {
5932   tree t;
5933   tree val = NULL_TREE;
5934
5935   timevar_push (TV_NAME_LOOKUP);
5936   /* Conversion operators are handled specially because ordinary
5937      unqualified name lookup will not find template conversion
5938      operators.  */
5939   if (IDENTIFIER_TYPENAME_P (name))
5940     {
5941       struct cp_binding_level *level;
5942
5943       for (level = current_binding_level;
5944            level && !level->namespace_p;
5945            level = level->level_chain)
5946         {
5947           tree class_type;
5948           tree operators;
5949
5950           /* A conversion operator can only be declared in a class
5951              scope.  */
5952           if (level->parm_flag != 2)
5953             continue;
5954
5955           /* Lookup the conversion operator in the class.  */
5956           class_type = level->this_class;
5957           operators = lookup_fnfields (class_type, name, /*protect=*/0);
5958           if (operators)
5959             POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
5960         }
5961
5962       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5963     }
5964
5965   flags |= lookup_flags (prefer_type, namespaces_only);
5966
5967   /* First, look in non-namespace scopes.  */
5968
5969   if (current_class_type == NULL_TREE)
5970     nonclass = 1;
5971
5972   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5973     {
5974       tree binding;
5975
5976       if (!LOCAL_BINDING_P (t) && nonclass)
5977         /* We're not looking for class-scoped bindings, so keep going.  */
5978         continue;
5979
5980       /* If this is the kind of thing we're looking for, we're done.  */
5981       if (qualify_lookup (BINDING_VALUE (t), flags))
5982         binding = BINDING_VALUE (t);
5983       else if ((flags & LOOKUP_PREFER_TYPES)
5984                && qualify_lookup (BINDING_TYPE (t), flags))
5985         binding = BINDING_TYPE (t);
5986       else
5987         binding = NULL_TREE;
5988
5989       if (binding)
5990         {
5991           val = binding;
5992           break;
5993         }
5994     }
5995
5996   /* Now lookup in namespace scopes.  */
5997   if (!val)
5998     {
5999       t = unqualified_namespace_lookup (name, flags, 0);
6000       if (t)
6001         val = t;
6002     }
6003
6004   if (val)
6005     {
6006       /* If we have a single function from a using decl, pull it out.  */
6007       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6008         val = OVL_FUNCTION (val);
6009     }
6010
6011   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
6012 }
6013
6014 tree
6015 lookup_name_nonclass (tree name)
6016 {
6017   return lookup_name_real (name, 0, 1, 0, LOOKUP_COMPLAIN);
6018 }
6019
6020 tree
6021 lookup_function_nonclass (tree name, tree args)
6022 {
6023   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6024 }
6025
6026 tree
6027 lookup_name (tree name, int prefer_type)
6028 {
6029   return lookup_name_real (name, prefer_type, 0, 0, LOOKUP_COMPLAIN);
6030 }
6031
6032 /* Similar to `lookup_name' but look only in the innermost non-class
6033    binding level.  */
6034
6035 tree
6036 lookup_name_current_level (tree name)
6037 {
6038   struct cp_binding_level *b;
6039   tree t = NULL_TREE;
6040
6041   timevar_push (TV_NAME_LOOKUP);
6042   b = current_binding_level;
6043   while (b->parm_flag == 2)
6044     b = b->level_chain;
6045
6046   if (b->namespace_p)
6047     {
6048       t = IDENTIFIER_NAMESPACE_VALUE (name);
6049
6050       /* extern "C" function() */
6051       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6052         t = TREE_VALUE (t);
6053     }
6054   else if (IDENTIFIER_BINDING (name)
6055            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6056     {
6057       while (1)
6058         {
6059           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6060             POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, IDENTIFIER_VALUE (name));
6061
6062           if (b->keep == 2)
6063             b = b->level_chain;
6064           else
6065             break;
6066         }
6067     }
6068
6069   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
6070 }
6071
6072 /* Like lookup_name_current_level, but for types.  */
6073
6074 tree
6075 lookup_type_current_level (tree name)
6076 {
6077   register tree t = NULL_TREE;
6078
6079   timevar_push (TV_NAME_LOOKUP);
6080   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6081
6082   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6083       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6084     {
6085       struct cp_binding_level *b = current_binding_level;
6086       while (1)
6087         {
6088           if (purpose_member (name, b->type_shadowed))
6089             POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
6090                                     REAL_IDENTIFIER_TYPE_VALUE (name));
6091           if (b->keep == 2)
6092             b = b->level_chain;
6093           else
6094             break;
6095         }
6096     }
6097
6098   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
6099 }
6100
6101 \f
6102 /* Push the declarations of builtin types into the namespace.
6103    RID_INDEX is the index of the builtin type
6104    in the array RID_POINTERS.  NAME is the name used when looking
6105    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6106
6107 void
6108 record_builtin_type (enum rid rid_index,
6109                      const char* name,
6110                      tree type)
6111 {
6112   tree rname = NULL_TREE, tname = NULL_TREE;
6113   tree tdecl = NULL_TREE;
6114
6115   if ((int) rid_index < (int) RID_MAX)
6116     rname = ridpointers[(int) rid_index];
6117   if (name)
6118     tname = get_identifier (name);
6119
6120   if (tname)
6121     {
6122       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6123       set_identifier_type_value (tname, NULL_TREE);
6124       if ((int) rid_index < (int) RID_MAX)
6125         /* Built-in types live in the global namespace.  */
6126         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6127     }
6128   if (rname != NULL_TREE)
6129     {
6130       if (tname != NULL_TREE)
6131         {
6132           set_identifier_type_value (rname, NULL_TREE);
6133           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6134         }
6135       else
6136         {
6137           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6138           set_identifier_type_value (rname, NULL_TREE);
6139         }
6140     }
6141 }
6142
6143 /* Record one of the standard Java types.
6144  * Declare it as having the given NAME.
6145  * If SIZE > 0, it is the size of one of the integral types;
6146  * otherwise it is the negative of the size of one of the other types.  */
6147
6148 static tree
6149 record_builtin_java_type (const char* name, int size)
6150 {
6151   tree type, decl;
6152   if (size > 0)
6153     type = make_signed_type (size);
6154   else if (size > -32)
6155     { /* "__java_char" or ""__java_boolean".  */
6156       type = make_unsigned_type (-size);
6157       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6158     }
6159   else
6160     { /* "__java_float" or ""__java_double".  */
6161       type = make_node (REAL_TYPE);
6162       TYPE_PRECISION (type) = - size;
6163       layout_type (type);
6164     }
6165   record_builtin_type (RID_MAX, name, type);
6166   decl = TYPE_NAME (type);
6167
6168   /* Suppress generate debug symbol entries for these types,
6169      since for normal C++ they are just clutter.
6170      However, push_lang_context undoes this if extern "Java" is seen.  */
6171   DECL_IGNORED_P (decl) = 1;
6172
6173   TYPE_FOR_JAVA (type) = 1;
6174   return type;
6175 }
6176
6177 /* Push a type into the namespace so that the back-ends ignore it.  */
6178
6179 static void
6180 record_unknown_type (tree type, const char* name)
6181 {
6182   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6183   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6184   DECL_IGNORED_P (decl) = 1;
6185   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6186   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6187   TYPE_ALIGN (type) = 1;
6188   TYPE_USER_ALIGN (type) = 0;
6189   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6190 }
6191
6192 /* An string for which we should create an IDENTIFIER_NODE at
6193    startup.  */
6194
6195 typedef struct predefined_identifier
6196 {
6197   /* The name of the identifier.  */
6198   const char *const name;
6199   /* The place where the IDENTIFIER_NODE should be stored.  */
6200   tree *const node;
6201   /* Nonzero if this is the name of a constructor or destructor.  */
6202   const int ctor_or_dtor_p;
6203 } predefined_identifier;
6204
6205 /* Create all the predefined identifiers.  */
6206
6207 static void
6208 initialize_predefined_identifiers (void)
6209 {
6210   const predefined_identifier *pid;
6211
6212   /* A table of identifiers to create at startup.  */
6213   static const predefined_identifier predefined_identifiers[] = {
6214     { "C++", &lang_name_cplusplus, 0 },
6215     { "C", &lang_name_c, 0 },
6216     { "Java", &lang_name_java, 0 },
6217     { CTOR_NAME, &ctor_identifier, 1 },
6218     { "__base_ctor", &base_ctor_identifier, 1 },
6219     { "__comp_ctor", &complete_ctor_identifier, 1 },
6220     { DTOR_NAME, &dtor_identifier, 1 },
6221     { "__comp_dtor", &complete_dtor_identifier, 1 },
6222     { "__base_dtor", &base_dtor_identifier, 1 },
6223     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6224     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6225     { "nelts", &nelts_identifier, 0 },
6226     { THIS_NAME, &this_identifier, 0 },
6227     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6228     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6229     { "_vptr", &vptr_identifier, 0 },
6230     { "__vtt_parm", &vtt_parm_identifier, 0 },
6231     { "std", &std_identifier, 0 },
6232     { NULL, NULL, 0 }
6233   };
6234
6235   for (pid = predefined_identifiers; pid->name; ++pid)
6236     {
6237       *pid->node = get_identifier (pid->name);
6238       if (pid->ctor_or_dtor_p)
6239         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6240     }
6241 }
6242
6243 /* Create the predefined scalar types of C,
6244    and some nodes representing standard constants (0, 1, (void *)0).
6245    Initialize the global binding level.
6246    Make definitions for built-in primitive functions.  */
6247
6248 void
6249 cxx_init_decl_processing (void)
6250 {
6251   tree void_ftype;
6252   tree void_ftype_ptr;
6253
6254   /* Create all the identifiers we need.  */
6255   initialize_predefined_identifiers ();
6256
6257   /* Fill in back-end hooks.  */
6258   lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
6259
6260   /* Create the global variables.  */
6261   push_to_top_level ();
6262
6263   /* Enter the global namespace.  */
6264   my_friendly_assert (global_namespace == NULL_TREE, 375);
6265   push_namespace (get_identifier ("::"));
6266   global_namespace = current_namespace;
6267   current_lang_name = NULL_TREE;
6268
6269   /* Adjust various flags based on command-line settings.  */
6270   if (! flag_permissive && ! pedantic)
6271     flag_pedantic_errors = 1;
6272   if (!flag_no_inline)
6273     {
6274       flag_inline_trees = 1;
6275       flag_no_inline = 1;
6276     }
6277   if (flag_inline_functions)
6278     {
6279       flag_inline_trees = 2;
6280       flag_inline_functions = 0;
6281     }
6282
6283   /* Force minimum function alignment if using the least significant
6284      bit of function pointers to store the virtual bit.  */
6285   if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
6286       && force_align_functions_log < 1)
6287     force_align_functions_log = 1;
6288
6289   /* Initially, C.  */
6290   current_lang_name = lang_name_c;
6291
6292   current_function_decl = NULL_TREE;
6293   current_binding_level = NULL_BINDING_LEVEL;
6294   free_binding_level = NULL_BINDING_LEVEL;
6295
6296   build_common_tree_nodes (flag_signed_char);
6297
6298   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6299   TREE_TYPE (error_mark_list) = error_mark_node;
6300
6301   /* Make the binding_level structure for global names.  */
6302   pushlevel (0);
6303   global_binding_level = current_binding_level;
6304   /* The global level is the namespace level of ::.  */
6305   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6306   declare_namespace_level ();
6307
6308   /* Create the `std' namespace.  */
6309   push_namespace (std_identifier);
6310   std_node = current_namespace;
6311   pop_namespace ();
6312
6313   c_common_nodes_and_builtins ();
6314
6315   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6316   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6317   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6318   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6319   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6320   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6321   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6322   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6323
6324   integer_two_node = build_int_2 (2, 0);
6325   TREE_TYPE (integer_two_node) = integer_type_node;
6326   integer_three_node = build_int_2 (3, 0);
6327   TREE_TYPE (integer_three_node) = integer_type_node;
6328
6329   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6330   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6331   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6332   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6333   TYPE_PRECISION (boolean_type_node) = 1;
6334   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6335   boolean_false_node = build_int_2 (0, 0);
6336   TREE_TYPE (boolean_false_node) = boolean_type_node;
6337   boolean_true_node = build_int_2 (1, 0);
6338   TREE_TYPE (boolean_true_node) = boolean_type_node;
6339
6340   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6341
6342 #if 0
6343   record_builtin_type (RID_MAX, NULL, string_type_node);
6344 #endif
6345
6346   delta_type_node = ptrdiff_type_node;
6347   vtable_index_type = ptrdiff_type_node;
6348
6349   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6350   void_ftype = build_function_type (void_type_node, void_list_node);
6351   void_ftype_ptr = build_function_type (void_type_node,
6352                                         tree_cons (NULL_TREE,
6353                                                    ptr_type_node,
6354                                                    void_list_node));
6355   void_ftype_ptr
6356     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6357
6358   /* C++ extensions */
6359
6360   unknown_type_node = make_node (UNKNOWN_TYPE);
6361   record_unknown_type (unknown_type_node, "unknown type");
6362
6363   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6364   TREE_TYPE (unknown_type_node) = unknown_type_node;
6365
6366   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6367      result.  */
6368   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6369   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6370
6371   {
6372     /* Make sure we get a unique function type, so we can give
6373        its pointer type a name.  (This wins for gdb.) */
6374     tree vfunc_type = make_node (FUNCTION_TYPE);
6375     TREE_TYPE (vfunc_type) = integer_type_node;
6376     TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6377     layout_type (vfunc_type);
6378
6379     vtable_entry_type = build_pointer_type (vfunc_type);
6380   }
6381   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6382
6383   vtbl_type_node
6384     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6385   layout_type (vtbl_type_node);
6386   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6387   record_builtin_type (RID_MAX, NULL, vtbl_type_node);
6388   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6389   layout_type (vtbl_ptr_type_node);
6390   record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
6391
6392   push_namespace (get_identifier ("__cxxabiv1"));
6393   abi_node = current_namespace;
6394   pop_namespace ();
6395
6396   global_type_node = make_node (LANG_TYPE);
6397   record_unknown_type (global_type_node, "global type");
6398
6399   /* Now, C++.  */
6400   current_lang_name = lang_name_cplusplus;
6401
6402   {
6403     tree bad_alloc_type_node, newtype, deltype;
6404     tree ptr_ftype_sizetype;
6405
6406     push_namespace (std_identifier);
6407     bad_alloc_type_node
6408       = xref_tag (class_type, get_identifier ("bad_alloc"),
6409                   /*attributes=*/NULL_TREE, 1);
6410     pop_namespace ();
6411     ptr_ftype_sizetype
6412       = build_function_type (ptr_type_node,
6413                              tree_cons (NULL_TREE,
6414                                         size_type_node,
6415                                         void_list_node));
6416     newtype = build_exception_variant
6417       (ptr_ftype_sizetype, add_exception_specifier
6418        (NULL_TREE, bad_alloc_type_node, -1));
6419     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6420     push_cp_library_fn (NEW_EXPR, newtype);
6421     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6422     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6423     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6424   }
6425
6426   abort_fndecl
6427     = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
6428
6429   /* Perform other language dependent initializations.  */
6430   init_class_processing ();
6431   init_search_processing ();
6432   init_rtti_processing ();
6433
6434   if (flag_exceptions)
6435     init_exception_processing ();
6436
6437   if (! supports_one_only ())
6438     flag_weak = 0;
6439
6440   make_fname_decl = cp_make_fname_decl;
6441   start_fname_decls ();
6442
6443   /* Show we use EH for cleanups.  */
6444   using_eh_for_cleanups ();
6445
6446   /* Maintain consistency.  Perhaps we should just complain if they
6447      say -fwritable-strings?  */
6448   if (flag_writable_strings)
6449     flag_const_strings = 0;
6450 }
6451
6452 /* Generate an initializer for a function naming variable from
6453    NAME. NAME may be NULL, in which case we generate a special
6454    ERROR_MARK node which should be replaced later.  */
6455
6456 tree
6457 cp_fname_init (const char* name)
6458 {
6459   tree domain = NULL_TREE;
6460   tree type;
6461   tree init = NULL_TREE;
6462   size_t length = 0;
6463
6464   if (name)
6465     {
6466       length = strlen (name);
6467       domain = build_index_type (size_int (length));
6468       init = build_string (length + 1, name);
6469     }
6470
6471   type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
6472   type = build_cplus_array_type (type, domain);
6473
6474   if (init)
6475     TREE_TYPE (init) = type;
6476   else
6477     /* We don't know the value until instantiation time. Make
6478        something which will be digested now, but replaced later.  */
6479     init = build (ERROR_MARK, type);
6480
6481   return init;
6482 }
6483
6484 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6485    decl, NAME is the initialization string and TYPE_DEP indicates whether
6486    NAME depended on the type of the function. We make use of that to detect
6487    __PRETTY_FUNCTION__ inside a template fn. This is being done
6488    lazily at the point of first use, so we musn't push the decl now.  */
6489
6490 static tree
6491 cp_make_fname_decl (tree id, int type_dep)
6492 {
6493   const char *const name = (type_dep && processing_template_decl
6494                       ? NULL : fname_as_string (type_dep));
6495   tree init = cp_fname_init (name);
6496   tree decl = build_decl (VAR_DECL, id, TREE_TYPE (init));
6497
6498   /* As we're using pushdecl_with_scope, we must set the context.  */
6499   DECL_CONTEXT (decl) = current_function_decl;
6500   DECL_PRETTY_FUNCTION_P (decl) = type_dep;
6501
6502   TREE_STATIC (decl) = 1;
6503   TREE_READONLY (decl) = 1;
6504   DECL_ARTIFICIAL (decl) = 1;
6505   DECL_INITIAL (decl) = init;
6506
6507   TREE_USED (decl) = 1;
6508
6509   if (current_function_decl)
6510     {
6511       struct cp_binding_level *b = current_binding_level;
6512       while (b->level_chain->parm_flag == 0)
6513         b = b->level_chain;
6514       pushdecl_with_scope (decl, b);
6515     }
6516
6517   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6518
6519   return decl;
6520 }
6521
6522 /* Make a definition for a builtin function named NAME in the current
6523    namespace, whose data type is TYPE and whose context is CONTEXT.
6524    TYPE should be a function type with argument types.
6525
6526    CLASS and CODE tell later passes how to compile calls to this function.
6527    See tree.h for possible values.
6528
6529    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6530    the name to be called if we can't opencode the function.
6531    If ATTRS is nonzero, use that for the function's attribute
6532    list.  */
6533
6534 static tree
6535 builtin_function_1 (const char* name,
6536                     tree type,
6537                     tree context,
6538                     int code,
6539                     enum built_in_class class,
6540                     const char* libname,
6541                     tree attrs)
6542 {
6543   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6544   DECL_BUILT_IN_CLASS (decl) = class;
6545   DECL_FUNCTION_CODE (decl) = code;
6546   DECL_CONTEXT (decl) = context;
6547
6548   pushdecl (decl);
6549
6550   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6551      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6552      function in the namespace.  */
6553   if (libname)
6554     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
6555   make_decl_rtl (decl, NULL);
6556
6557   /* Warn if a function in the namespace for users
6558      is used without an occasion to consider it declared.  */
6559   if (name[0] != '_' || name[1] != '_')
6560     DECL_ANTICIPATED (decl) = 1;
6561
6562   /* Possibly apply some default attributes to this built-in function.  */
6563   if (attrs)
6564     decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
6565   else
6566     decl_attributes (&decl, NULL_TREE, 0);
6567
6568   return decl;
6569 }
6570
6571 /* Entry point for the benefit of c_common_nodes_and_builtins.
6572
6573    Make a defintion for a builtin function named NAME and whose data type
6574    is TYPE.  TYPE should be a function type with argument types.  This
6575    function places the anticipated declaration in the global namespace
6576    and additionally in the std namespace if appropriate.
6577
6578    CLASS and CODE tell later passes how to compile calls to this function.
6579    See tree.h for possible values.
6580
6581    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6582    the name to be called if we can't opencode the function.
6583
6584    If ATTRS is nonzero, use that for the function's attribute
6585    list.  */
6586
6587 tree
6588 builtin_function (const char* name,
6589                   tree type,
6590                   int code,
6591                   enum built_in_class class,
6592                   const char* libname,
6593                   tree attrs)
6594 {
6595   /* All builtins that don't begin with an '_' should additionally
6596      go in the 'std' namespace.  */
6597   if (name[0] != '_')
6598     {
6599       push_namespace (std_identifier);
6600       builtin_function_1 (name, type, std_node, code, class, libname, attrs);
6601       pop_namespace ();
6602     }
6603
6604   return builtin_function_1 (name, type, NULL_TREE, code,
6605                              class, libname, attrs);
6606 }
6607
6608 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6609    function.  Not called directly.  */
6610
6611 static tree
6612 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
6613 {
6614   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6615   DECL_EXTERNAL (fn) = 1;
6616   TREE_PUBLIC (fn) = 1;
6617   DECL_ARTIFICIAL (fn) = 1;
6618   TREE_NOTHROW (fn) = 1;
6619   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6620   SET_DECL_LANGUAGE (fn, lang_c);
6621   return fn;
6622 }
6623
6624 /* Returns the _DECL for a library function with C linkage.
6625    We assume that such functions never throw; if this is incorrect,
6626    callers should unset TREE_NOTHROW.  */
6627
6628 tree
6629 build_library_fn (tree name, tree type)
6630 {
6631   return build_library_fn_1 (name, ERROR_MARK, type);
6632 }
6633
6634 /* Returns the _DECL for a library function with C++ linkage.  */
6635
6636 static tree
6637 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
6638 {
6639   tree fn = build_library_fn_1 (name, operator_code, type);
6640   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6641   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6642   SET_DECL_LANGUAGE (fn, lang_cplusplus);
6643   set_mangled_name_for_decl (fn);
6644   return fn;
6645 }
6646
6647 /* Like build_library_fn, but takes a C string instead of an
6648    IDENTIFIER_NODE.  */
6649
6650 tree
6651 build_library_fn_ptr (const char* name, tree type)
6652 {
6653   return build_library_fn (get_identifier (name), type);
6654 }
6655
6656 /* Like build_cp_library_fn, but takes a C string instead of an
6657    IDENTIFIER_NODE.  */
6658
6659 tree
6660 build_cp_library_fn_ptr (const char* name, tree type)
6661 {
6662   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6663 }
6664
6665 /* Like build_library_fn, but also pushes the function so that we will
6666    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6667
6668 tree
6669 push_library_fn (tree name, tree type)
6670 {
6671   tree fn = build_library_fn (name, type);
6672   pushdecl_top_level (fn);
6673   return fn;
6674 }
6675
6676 /* Like build_cp_library_fn, but also pushes the function so that it
6677    will be found by normal lookup.  */
6678
6679 static tree
6680 push_cp_library_fn (enum tree_code operator_code, tree type)
6681 {
6682   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6683                                  operator_code,
6684                                  type);
6685   pushdecl (fn);
6686   return fn;
6687 }
6688
6689 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6690    a FUNCTION_TYPE.  */
6691
6692 tree
6693 push_void_library_fn (tree name, tree parmtypes)
6694 {
6695   tree type = build_function_type (void_type_node, parmtypes);
6696   return push_library_fn (name, type);
6697 }
6698
6699 /* Like push_library_fn, but also note that this function throws
6700    and does not return.  Used for __throw_foo and the like.  */
6701
6702 tree
6703 push_throw_library_fn (tree name, tree type)
6704 {
6705   tree fn = push_library_fn (name, type);
6706   TREE_THIS_VOLATILE (fn) = 1;
6707   TREE_NOTHROW (fn) = 0;
6708   return fn;
6709 }
6710
6711 /* Apply default attributes to a function, if a system function with default
6712    attributes.  */
6713
6714 void
6715 cxx_insert_default_attributes (tree decl)
6716 {
6717   if (!DECL_EXTERN_C_FUNCTION_P (decl))
6718     return;
6719   if (!TREE_PUBLIC (decl))
6720     return;
6721   c_common_insert_default_attributes (decl);
6722 }
6723 \f
6724 /* When we call finish_struct for an anonymous union, we create
6725    default copy constructors and such.  But, an anonymous union
6726    shouldn't have such things; this function undoes the damage to the
6727    anonymous union type T.
6728
6729    (The reason that we create the synthesized methods is that we don't
6730    distinguish `union { int i; }' from `typedef union { int i; } U'.
6731    The first is an anonymous union; the second is just an ordinary
6732    union type.)  */
6733
6734 void
6735 fixup_anonymous_aggr (tree t)
6736 {
6737   tree *q;
6738
6739   /* Wipe out memory of synthesized methods */
6740   TYPE_HAS_CONSTRUCTOR (t) = 0;
6741   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6742   TYPE_HAS_INIT_REF (t) = 0;
6743   TYPE_HAS_CONST_INIT_REF (t) = 0;
6744   TYPE_HAS_ASSIGN_REF (t) = 0;
6745   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6746
6747   /* Splice the implicitly generated functions out of the TYPE_METHODS
6748      list.  */
6749   q = &TYPE_METHODS (t);
6750   while (*q)
6751     {
6752       if (DECL_ARTIFICIAL (*q))
6753         *q = TREE_CHAIN (*q);
6754       else
6755         q = &TREE_CHAIN (*q);
6756     }
6757
6758   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6759   if (TYPE_METHODS (t))
6760     cp_error_at ("an anonymous union cannot have function members", t);
6761
6762   /* Anonymous aggregates cannot have fields with ctors, dtors or complex
6763      assignment operators (because they cannot have these methods themselves).
6764      For anonymous unions this is already checked because they are not allowed
6765      in any union, otherwise we have to check it.  */
6766   if (TREE_CODE (t) != UNION_TYPE)
6767     {
6768       tree field, type;
6769
6770       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
6771         if (TREE_CODE (field) == FIELD_DECL)
6772           {
6773             type = TREE_TYPE (field);
6774             if (CLASS_TYPE_P (type))
6775               {
6776                 if (TYPE_NEEDS_CONSTRUCTING (type))
6777                   cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
6778                                field);
6779                 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6780                   cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
6781                                field);
6782                 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
6783                   cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
6784                                field);
6785               }
6786           }
6787     }
6788 }
6789
6790 /* Make sure that a declaration with no declarator is well-formed, i.e.
6791    just declares a tagged type or anonymous union.
6792
6793    Returns the type declared; or NULL_TREE if none.  */
6794
6795 tree
6796 check_tag_decl (tree declspecs)
6797 {
6798   int found_type = 0;
6799   int saw_friend = 0;
6800   int saw_typedef = 0;
6801   tree ob_modifier = NULL_TREE;
6802   register tree link;
6803   /* If a class, struct, or enum type is declared by the DECLSPECS
6804      (i.e, if a class-specifier, enum-specifier, or non-typename
6805      elaborated-type-specifier appears in the DECLSPECS),
6806      DECLARED_TYPE is set to the corresponding type.  */
6807   tree declared_type = NULL_TREE;
6808   bool error_p = false;
6809
6810   for (link = declspecs; link; link = TREE_CHAIN (link))
6811     {
6812       tree value = TREE_VALUE (link);
6813
6814       if (TYPE_P (value)
6815           || TREE_CODE (value) == TYPE_DECL
6816           || (TREE_CODE (value) == IDENTIFIER_NODE
6817               && IDENTIFIER_GLOBAL_VALUE (value)
6818               && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value)) == TYPE_DECL))
6819         {
6820           ++found_type;
6821
6822           if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
6823             {
6824               if (! in_system_header)
6825                 pedwarn ("redeclaration of C++ built-in type `%T'", value);
6826               return NULL_TREE;
6827             }
6828
6829           if (TYPE_P (value)
6830               && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
6831                   || TREE_CODE (value) == ENUMERAL_TYPE))
6832             {
6833               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6834               declared_type = value;
6835             }
6836         }
6837       else if (value == ridpointers[(int) RID_TYPEDEF])
6838         saw_typedef = 1;
6839       else if (value == ridpointers[(int) RID_FRIEND])
6840         {
6841           if (current_class_type == NULL_TREE
6842               || current_scope () != current_class_type)
6843             ob_modifier = value;
6844           else
6845             saw_friend = 1;
6846         }
6847       else if (value == ridpointers[(int) RID_STATIC]
6848                || value == ridpointers[(int) RID_EXTERN]
6849                || value == ridpointers[(int) RID_AUTO]
6850                || value == ridpointers[(int) RID_REGISTER]
6851                || value == ridpointers[(int) RID_INLINE]
6852                || value == ridpointers[(int) RID_VIRTUAL]
6853                || value == ridpointers[(int) RID_CONST]
6854                || value == ridpointers[(int) RID_VOLATILE]
6855                || value == ridpointers[(int) RID_EXPLICIT]
6856                || value == ridpointers[(int) RID_THREAD])
6857         ob_modifier = value;
6858       else if (value == error_mark_node)
6859         error_p = true;
6860     }
6861
6862   if (found_type > 1)
6863     error ("multiple types in one declaration");
6864
6865   if (declared_type == NULL_TREE && ! saw_friend && !error_p)
6866     pedwarn ("declaration does not declare anything");
6867   /* Check for an anonymous union.  */
6868   else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type))
6869            && TYPE_ANONYMOUS_P (declared_type))
6870     {
6871       /* 7/3 In a simple-declaration, the optional init-declarator-list
6872          can be omitted only when declaring a class (clause 9) or
6873          enumeration (7.2), that is, when the decl-specifier-seq contains
6874          either a class-specifier, an elaborated-type-specifier with
6875          a class-key (9.1), or an enum-specifier.  In these cases and
6876          whenever a class-specifier or enum-specifier is present in the
6877          decl-specifier-seq, the identifiers in these specifiers are among
6878          the names being declared by the declaration (as class-name,
6879          enum-names, or enumerators, depending on the syntax).  In such
6880          cases, and except for the declaration of an unnamed bit-field (9.6),
6881          the decl-specifier-seq shall introduce one or more names into the
6882          program, or shall redeclare a name introduced by a previous
6883          declaration.  [Example:
6884              enum { };            // ill-formed
6885              typedef class { };   // ill-formed
6886          --end example]  */
6887       if (saw_typedef)
6888         {
6889           error ("missing type-name in typedef-declaration");
6890           return NULL_TREE;
6891         }
6892       /* Anonymous unions are objects, so they can have specifiers.  */;
6893       SET_ANON_AGGR_TYPE_P (declared_type);
6894
6895       if (TREE_CODE (declared_type) != UNION_TYPE && pedantic
6896           && !in_system_header)
6897         pedwarn ("ISO C++ prohibits anonymous structs");
6898     }
6899
6900   else if (ob_modifier)
6901     {
6902       if (ob_modifier == ridpointers[(int) RID_INLINE]
6903           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6904         error ("`%D' can only be specified for functions", ob_modifier);
6905       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
6906         error ("`%D' can only be specified inside a class", ob_modifier);
6907       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6908         error ("`%D' can only be specified for constructors",
6909                   ob_modifier);
6910       else
6911         error ("`%D' can only be specified for objects and functions",
6912                   ob_modifier);
6913     }
6914
6915   return declared_type;
6916 }
6917
6918 /* Called when a declaration is seen that contains no names to declare.
6919    If its type is a reference to a structure, union or enum inherited
6920    from a containing scope, shadow that tag name for the current scope
6921    with a forward reference.
6922    If its type defines a new named structure or union
6923    or defines an enum, it is valid but we need not do anything here.
6924    Otherwise, it is an error.
6925
6926    C++: may have to grok the declspecs to learn about static,
6927    complain for anonymous unions.
6928
6929    Returns the TYPE declared -- or NULL_TREE if none.  */
6930
6931 tree
6932 shadow_tag (tree declspecs)
6933 {
6934   tree t = check_tag_decl (declspecs);
6935
6936   if (!t)
6937     return NULL_TREE;
6938
6939   maybe_process_partial_specialization (t);
6940
6941   /* This is where the variables in an anonymous union are
6942      declared.  An anonymous union declaration looks like:
6943      union { ... } ;
6944      because there is no declarator after the union, the parser
6945      sends that declaration here.  */
6946   if (ANON_AGGR_TYPE_P (t))
6947     {
6948       fixup_anonymous_aggr (t);
6949
6950       if (TYPE_FIELDS (t))
6951         {
6952           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
6953                                       NULL);
6954           finish_anon_union (decl);
6955         }
6956     }
6957
6958   return t;
6959 }
6960 \f
6961 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
6962
6963 tree
6964 groktypename (tree typename)
6965 {
6966   tree specs, attrs;
6967   tree type;
6968   if (TREE_CODE (typename) != TREE_LIST)
6969     return typename;
6970   split_specs_attrs (TREE_PURPOSE (typename), &specs, &attrs);
6971   type = grokdeclarator (TREE_VALUE (typename), specs,
6972                          TYPENAME, 0, &attrs);
6973   if (attrs)
6974     cplus_decl_attributes (&type, attrs, 0);
6975   return type;
6976 }
6977
6978 /* Decode a declarator in an ordinary declaration or data definition.
6979    This is called as soon as the type information and variable name
6980    have been parsed, before parsing the initializer if any.
6981    Here we create the ..._DECL node, fill in its type,
6982    and put it on the list of decls for the current context.
6983    The ..._DECL node is returned as the value.
6984
6985    Exception: for arrays where the length is not specified,
6986    the type is left null, to be filled in by `cp_finish_decl'.
6987
6988    Function definitions do not come here; they go to start_function
6989    instead.  However, external and forward declarations of functions
6990    do go through here.  Structure field declarations are done by
6991    grokfield and not through here.  */
6992
6993 tree
6994 start_decl (tree declarator,
6995             tree declspecs,
6996             int initialized,
6997             tree attributes,
6998             tree prefix_attributes)
6999 {
7000   tree decl;
7001   register tree type, tem;
7002   tree context;
7003
7004   /* This should only be done once on the top most decl.  */
7005   if (have_extern_spec)
7006     {
7007       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7008                              declspecs);
7009       have_extern_spec = false;
7010     }
7011
7012   /* An object declared as __attribute__((deprecated)) suppresses
7013      warnings of uses of other deprecated items.  */
7014   if (lookup_attribute ("deprecated", attributes))
7015     deprecated_state = DEPRECATED_SUPPRESS;
7016
7017   attributes = chainon (attributes, prefix_attributes);
7018
7019   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7020                          &attributes);
7021
7022   deprecated_state = DEPRECATED_NORMAL;
7023
7024   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7025     return NULL_TREE;
7026
7027   type = TREE_TYPE (decl);
7028
7029   if (type == error_mark_node)
7030     return NULL_TREE;
7031
7032   context = DECL_CONTEXT (decl);
7033
7034   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7035       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7036     {
7037       /* When parsing the initializer, lookup should use the object's
7038          namespace.  */
7039       push_decl_namespace (context);
7040     }
7041
7042   /* We are only interested in class contexts, later.  */
7043   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7044     context = NULL_TREE;
7045
7046   if (initialized)
7047     /* Is it valid for this decl to have an initializer at all?
7048        If not, set INITIALIZED to zero, which will indirectly
7049        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7050     switch (TREE_CODE (decl))
7051       {
7052       case TYPE_DECL:
7053         error ("typedef `%D' is initialized (use __typeof__ instead)", decl);
7054         initialized = 0;
7055         break;
7056
7057       case FUNCTION_DECL:
7058         error ("function `%#D' is initialized like a variable", decl);
7059         initialized = 0;
7060         break;
7061
7062       default:
7063         break;
7064       }
7065
7066   if (initialized)
7067     {
7068       if (! toplevel_bindings_p ()
7069           && DECL_EXTERNAL (decl))
7070         warning ("declaration of `%#D' has `extern' and is initialized",
7071                     decl);
7072       DECL_EXTERNAL (decl) = 0;
7073       if (toplevel_bindings_p ())
7074         TREE_STATIC (decl) = 1;
7075
7076       /* Tell `pushdecl' this is an initialized decl
7077          even though we don't yet have the initializer expression.
7078          Also tell `cp_finish_decl' it may store the real initializer.  */
7079       DECL_INITIAL (decl) = error_mark_node;
7080     }
7081
7082   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7083   cplus_decl_attributes (&decl, attributes, 0);
7084
7085   /* If #pragma weak was used, mark the decl weak now.  */
7086   if (current_binding_level == global_binding_level)
7087     maybe_apply_pragma_weak (decl);
7088
7089   if (TREE_CODE (decl) == FUNCTION_DECL
7090       && DECL_DECLARED_INLINE_P (decl)
7091       && DECL_UNINLINABLE (decl)
7092       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
7093     warning_with_decl (decl,
7094                        "inline function `%s' given attribute noinline");
7095
7096   if (context && COMPLETE_TYPE_P (complete_type (context)))
7097     {
7098       push_nested_class (context);
7099
7100       if (TREE_CODE (decl) == VAR_DECL)
7101         {
7102           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7103           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7104             error ("`%#D' is not a static member of `%#T'", decl, context);
7105           else
7106             {
7107               if (DECL_CONTEXT (field) != context)
7108                 {
7109                   if (!same_type_p (DECL_CONTEXT (field), context))
7110                     pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7111                              DECL_CONTEXT (field), DECL_NAME (decl),
7112                              context, DECL_NAME (decl));
7113                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7114                 }
7115               /* Static data member are tricky; an in-class initialization
7116                  still doesn't provide a definition, so the in-class
7117                  declaration will have DECL_EXTERNAL set, but will have an
7118                  initialization.  Thus, duplicate_decls won't warn
7119                  about this situation, and so we check here.  */
7120               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7121                 error ("duplicate initialization of %D", decl);
7122               if (duplicate_decls (decl, field))
7123                 decl = field;
7124             }
7125         }
7126       else
7127         {
7128           tree field = check_classfn (context, decl);
7129           if (field && duplicate_decls (decl, field))
7130             decl = field;
7131         }
7132
7133       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7134       DECL_IN_AGGR_P (decl) = 0;
7135       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7136           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7137         {
7138           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7139           /* [temp.expl.spec] An explicit specialization of a static data
7140              member of a template is a definition if the declaration
7141              includes an initializer; otherwise, it is a declaration.
7142
7143              We check for processing_specialization so this only applies
7144              to the new specialization syntax.  */
7145           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7146             DECL_EXTERNAL (decl) = 1;
7147         }
7148
7149       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7150         pedwarn ("declaration of `%#D' outside of class is not definition",
7151                     decl);
7152     }
7153
7154   /* Enter this declaration into the symbol table.  */
7155   tem = maybe_push_decl (decl);
7156
7157   if (processing_template_decl)
7158     tem = push_template_decl (tem);
7159
7160 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7161   /* Tell the back-end to use or not use .common as appropriate.  If we say
7162      -fconserve-space, we want this to save .data space, at the expense of
7163      wrong semantics.  If we say -fno-conserve-space, we want this to
7164      produce errors about redefs; to do this we force variables into the
7165      data segment.  */
7166   DECL_COMMON (tem) = ((TREE_CODE (tem) != VAR_DECL
7167                         || !DECL_THREAD_LOCAL (tem))
7168                        && (flag_conserve_space || ! TREE_PUBLIC (tem)));
7169 #endif
7170
7171   if (! processing_template_decl)
7172     start_decl_1 (tem);
7173
7174   return tem;
7175 }
7176
7177 void
7178 start_decl_1 (tree decl)
7179 {
7180   tree type = TREE_TYPE (decl);
7181   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7182
7183   if (type == error_mark_node)
7184     return;
7185
7186   maybe_push_cleanup_level (type);
7187
7188   if (initialized)
7189     /* Is it valid for this decl to have an initializer at all?
7190        If not, set INITIALIZED to zero, which will indirectly
7191        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7192     {
7193       /* Don't allow initializations for incomplete types except for
7194          arrays which might be completed by the initialization.  */
7195       if (COMPLETE_TYPE_P (complete_type (type)))
7196         ;                       /* A complete type is ok.  */
7197       else if (TREE_CODE (type) != ARRAY_TYPE)
7198         {
7199           error ("variable `%#D' has initializer but incomplete type",
7200                     decl);
7201           initialized = 0;
7202           type = TREE_TYPE (decl) = error_mark_node;
7203         }
7204       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7205         {
7206           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7207             error ("elements of array `%#D' have incomplete type", decl);
7208           /* else we already gave an error in start_decl.  */
7209           initialized = 0;
7210         }
7211     }
7212
7213   if (!initialized
7214       && TREE_CODE (decl) != TYPE_DECL
7215       && TREE_CODE (decl) != TEMPLATE_DECL
7216       && type != error_mark_node
7217       && IS_AGGR_TYPE (type)
7218       && ! DECL_EXTERNAL (decl))
7219     {
7220       if ((! processing_template_decl || ! uses_template_parms (type))
7221           && !COMPLETE_TYPE_P (complete_type (type)))
7222         {
7223           error ("aggregate `%#D' has incomplete type and cannot be defined",
7224                  decl);
7225           /* Change the type so that assemble_variable will give
7226              DECL an rtl we can live with: (mem (const_int 0)).  */
7227           type = TREE_TYPE (decl) = error_mark_node;
7228         }
7229       else
7230         {
7231           /* If any base type in the hierarchy of TYPE needs a constructor,
7232              then we set initialized to 1.  This way any nodes which are
7233              created for the purposes of initializing this aggregate
7234              will live as long as it does.  This is necessary for global
7235              aggregates which do not have their initializers processed until
7236              the end of the file.  */
7237           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7238         }
7239     }
7240
7241   if (! initialized)
7242     DECL_INITIAL (decl) = NULL_TREE;
7243 }
7244
7245 /* Handle initialization of references.
7246    These three arguments are from `cp_finish_decl', and have the
7247    same meaning here that they do there.
7248
7249    Quotes on semantics can be found in ARM 8.4.3.  */
7250
7251 static tree
7252 grok_reference_init (tree decl, tree type, tree init)
7253 {
7254   tree tmp;
7255
7256   if (init == NULL_TREE)
7257     {
7258       if ((DECL_LANG_SPECIFIC (decl) == 0
7259            || DECL_IN_AGGR_P (decl) == 0)
7260           && ! DECL_THIS_EXTERN (decl))
7261         error ("`%D' declared as reference but not initialized", decl);
7262       return NULL_TREE;
7263     }
7264
7265   if (TREE_CODE (init) == CONSTRUCTOR)
7266     {
7267       error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7268       return NULL_TREE;
7269     }
7270
7271   if (TREE_CODE (init) == TREE_LIST)
7272     init = build_compound_expr (init);
7273
7274   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7275     init = convert_from_reference (init);
7276
7277   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7278       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7279     {
7280       /* Note: default conversion is only called in very special cases.  */
7281       init = default_conversion (init);
7282     }
7283
7284   /* Convert INIT to the reference type TYPE.  This may involve the
7285      creation of a temporary, whose lifetime must be the same as that
7286      of the reference.  If so, a DECL_STMT for the temporary will be
7287      added just after the DECL_STMT for DECL.  That's why we don't set
7288      DECL_INITIAL for local references (instead assigning to them
7289      explicitly); we need to allow the temporary to be initialized
7290      first.  */
7291   tmp = convert_to_reference
7292     (type, init, CONV_IMPLICIT,
7293      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7294      decl);
7295
7296   if (tmp == error_mark_node)
7297     return NULL_TREE;
7298   else if (tmp == NULL_TREE)
7299     {
7300       error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7301       return NULL_TREE;
7302     }
7303
7304   if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
7305     return tmp;
7306
7307   DECL_INITIAL (decl) = tmp;
7308
7309   return NULL_TREE;
7310 }
7311
7312 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7313    array until we finish parsing the initializer.  If that's the
7314    situation we're in, update DECL accordingly.  */
7315
7316 static void
7317 maybe_deduce_size_from_array_init (tree decl, tree init)
7318 {
7319   tree type = TREE_TYPE (decl);
7320
7321   if (TREE_CODE (type) == ARRAY_TYPE
7322       && TYPE_DOMAIN (type) == NULL_TREE
7323       && TREE_CODE (decl) != TYPE_DECL)
7324     {
7325       /* do_default is really a C-ism to deal with tentative definitions.
7326          But let's leave it here to ease the eventual merge.  */
7327       int do_default = !DECL_EXTERNAL (decl);
7328       tree initializer = init ? init : DECL_INITIAL (decl);
7329       int failure = complete_array_type (type, initializer, do_default);
7330
7331       if (failure == 1)
7332         error ("initializer fails to determine size of `%D'", decl);
7333
7334       if (failure == 2)
7335         {
7336           if (do_default)
7337             error ("array size missing in `%D'", decl);
7338           /* If a `static' var's size isn't known, make it extern as
7339              well as static, so it does not get allocated.  If it's not
7340              `static', then don't mark it extern; finish_incomplete_decl
7341              will give it a default size and it will get allocated.  */
7342           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7343             DECL_EXTERNAL (decl) = 1;
7344         }
7345
7346       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7347           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7348                               integer_zero_node))
7349         error ("zero-size array `%D'", decl);
7350
7351       layout_decl (decl, 0);
7352     }
7353 }
7354
7355 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7356    any appropriate error messages regarding the layout.  */
7357
7358 static void
7359 layout_var_decl (tree decl)
7360 {
7361   tree type = TREE_TYPE (decl);
7362 #if 0
7363   tree ttype = target_type (type);
7364 #endif
7365
7366   /* If we haven't already layed out this declaration, do so now.
7367      Note that we must not call complete type for an external object
7368      because it's type might involve templates that we are not
7369      supposed to isntantiate yet.  (And it's perfectly valid to say
7370      `extern X x' for some incomplete type `X'.)  */
7371   if (!DECL_EXTERNAL (decl))
7372     complete_type (type);
7373   if (!DECL_SIZE (decl)
7374       && TREE_TYPE (decl) != error_mark_node
7375       && (COMPLETE_TYPE_P (type)
7376           || (TREE_CODE (type) == ARRAY_TYPE
7377               && !TYPE_DOMAIN (type)
7378               && COMPLETE_TYPE_P (TREE_TYPE (type)))))
7379     layout_decl (decl, 0);
7380
7381   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7382     {
7383       /* An automatic variable with an incomplete type: that is an error.
7384          Don't talk about array types here, since we took care of that
7385          message in grokdeclarator.  */
7386       error ("storage size of `%D' isn't known", decl);
7387       TREE_TYPE (decl) = error_mark_node;
7388     }
7389 #if 0
7390   /* Keep this code around in case we later want to control debug info
7391      based on whether a type is "used".  (jason 1999-11-11) */
7392
7393   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7394     /* Let debugger know it should output info for this type.  */
7395     note_debug_info_needed (ttype);
7396
7397   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7398     note_debug_info_needed (DECL_CONTEXT (decl));
7399 #endif
7400
7401   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7402       && DECL_SIZE (decl) != NULL_TREE
7403       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7404     {
7405       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7406         constant_expression_warning (DECL_SIZE (decl));
7407       else
7408         error ("storage size of `%D' isn't constant", decl);
7409     }
7410
7411   if (TREE_STATIC (decl)
7412       && !DECL_ARTIFICIAL (decl)
7413       && current_function_decl
7414       && DECL_CONTEXT (decl) == current_function_decl)
7415     push_local_name (decl);
7416 }
7417
7418 /* If a local static variable is declared in an inline function, or if
7419    we have a weak definition, we must endeavor to create only one
7420    instance of the variable at link-time.  */
7421
7422 static void
7423 maybe_commonize_var (tree decl)
7424 {
7425   /* Static data in a function with comdat linkage also has comdat
7426      linkage.  */
7427   if (TREE_STATIC (decl)
7428       /* Don't mess with __FUNCTION__.  */
7429       && ! DECL_ARTIFICIAL (decl)
7430       && current_function_decl
7431       && DECL_CONTEXT (decl) == current_function_decl
7432       && (DECL_DECLARED_INLINE_P (current_function_decl)
7433           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7434       && TREE_PUBLIC (current_function_decl))
7435     {
7436       /* If flag_weak, we don't need to mess with this, as we can just
7437          make the function weak, and let it refer to its unique local
7438          copy.  This works because we don't allow the function to be
7439          inlined.  */
7440       if (! flag_weak)
7441         {
7442           if (DECL_INTERFACE_KNOWN (current_function_decl))
7443             {
7444               TREE_PUBLIC (decl) = 1;
7445               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7446             }
7447           else if (DECL_INITIAL (decl) == NULL_TREE
7448                    || DECL_INITIAL (decl) == error_mark_node)
7449             {
7450               TREE_PUBLIC (decl) = 1;
7451               DECL_COMMON (decl) = 1;
7452             }
7453           /* else we lose. We can only do this if we can use common,
7454              which we can't if it has been initialized.  */
7455
7456           if (!TREE_PUBLIC (decl))
7457             {
7458               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7459               cp_warning_at ("  you can work around this by removing the initializer", decl);
7460             }
7461         }
7462       else
7463         comdat_linkage (decl);
7464     }
7465   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7466     /* Set it up again; we might have set DECL_INITIAL since the last
7467        time.  */
7468     comdat_linkage (decl);
7469 }
7470
7471 /* Issue an error message if DECL is an uninitialized const variable.  */
7472
7473 static void
7474 check_for_uninitialized_const_var (tree decl)
7475 {
7476   tree type = TREE_TYPE (decl);
7477
7478   /* ``Unless explicitly declared extern, a const object does not have
7479      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7480      7.1.6 */
7481   if (TREE_CODE (decl) == VAR_DECL
7482       && TREE_CODE (type) != REFERENCE_TYPE
7483       && CP_TYPE_CONST_P (type)
7484       && !TYPE_NEEDS_CONSTRUCTING (type)
7485       && !DECL_INITIAL (decl))
7486     error ("uninitialized const `%D'", decl);
7487 }
7488
7489 /* FIELD is a FIELD_DECL or NULL.  In the former case, the value
7490    returned is the next FIELD_DECL (possibly FIELD itself) that can be
7491    initialized.  If there are no more such fields, the return value
7492    will be NULL.  */
7493
7494 static tree
7495 next_initializable_field (tree field)
7496 {
7497   while (field
7498          && (TREE_CODE (field) != FIELD_DECL
7499              || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
7500              || DECL_ARTIFICIAL (field)))
7501     field = TREE_CHAIN (field);
7502
7503   return field;
7504 }
7505
7506 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
7507    brace-enclosed aggregate initializer.
7508
7509    *INITP is one of a list of initializers describing a brace-enclosed
7510    initializer for an entity of the indicated aggregate TYPE.  It may
7511    not presently match the shape of the TYPE; for example:
7512
7513      struct S { int a; int b; };
7514      struct S a[] = { 1, 2, 3, 4 };
7515
7516    Here *INITP will point to TREE_LIST of four elements, rather than a
7517    list of two elements, each itself a list of two elements.  This
7518    routine transforms INIT from the former form into the latter.  The
7519    revised initializer is returned.  */
7520
7521 static tree
7522 reshape_init (tree type, tree *initp)
7523 {
7524   tree inits;
7525   tree old_init;
7526   tree old_init_value;
7527   tree new_init;
7528   bool brace_enclosed_p;
7529
7530   old_init = *initp;
7531   old_init_value = (TREE_CODE (*initp) == TREE_LIST
7532                     ? TREE_VALUE (*initp) : old_init);
7533
7534   /* For some parse errors, OLD_INIT_VALUE may be NULL.  */
7535   if (!old_init_value)
7536     {
7537       my_friendly_assert (TREE_CODE (old_init) == TREE_LIST, 20021202);
7538       TREE_VALUE (old_init) = error_mark_node;
7539       return old_init;
7540     }
7541
7542   /* If the initializer is brace-enclosed, pull initializers from the
7543      enclosed elements.  Advance past the brace-enclosed initializer
7544      now.  */
7545   if (TREE_CODE (old_init_value) == CONSTRUCTOR
7546       && TREE_HAS_CONSTRUCTOR (old_init_value))
7547     {
7548       *initp = TREE_CHAIN (old_init);
7549       TREE_CHAIN (old_init) = NULL_TREE;
7550       inits = CONSTRUCTOR_ELTS (old_init_value);
7551       initp = &inits;
7552       brace_enclosed_p = true;
7553     }
7554   else
7555     {
7556       inits = NULL_TREE;
7557       brace_enclosed_p = false;
7558     }
7559
7560   /* A non-aggregate type is always initialized with a single
7561      initializer.  */
7562   if (!CP_AGGREGATE_TYPE_P (type))
7563       {
7564         *initp = TREE_CHAIN (old_init);
7565         TREE_CHAIN (old_init) = NULL_TREE;
7566         /* It is invalid to initialize a non-aggregate type with a
7567            brace-enclosed initializer.  */
7568         if (brace_enclosed_p)
7569           {
7570             error ("brace-enclosed initializer used to initialize `%T'",
7571                    type);
7572             if (TREE_CODE (old_init) == TREE_LIST)
7573               TREE_VALUE (old_init) = error_mark_node;
7574             else
7575               old_init = error_mark_node;
7576           }
7577
7578         return old_init;
7579       }
7580
7581   /* [dcl.init.aggr]
7582
7583      All implicit type conversions (clause _conv_) are considered when
7584      initializing the aggregate member with an initializer from an
7585      initializer-list.  If the initializer can initialize a member,
7586      the member is initialized.  Otherwise, if the member is itself a
7587      non-empty subaggregate, brace elision is assumed and the
7588      initializer is considered for the initialization of the first
7589      member of the subaggregate.  */
7590   if (CLASS_TYPE_P (type)
7591       && !brace_enclosed_p
7592       && can_convert_arg (type, TREE_TYPE (old_init_value), old_init_value))
7593     {
7594       *initp = TREE_CHAIN (old_init);
7595       TREE_CHAIN (old_init) = NULL_TREE;
7596       return old_init;
7597     }
7598
7599   if (TREE_CODE (old_init_value) == STRING_CST
7600       && TREE_CODE (type) == ARRAY_TYPE
7601       && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
7602     {
7603       /* [dcl.init.string]
7604
7605          A char array (whether plain char, signed char, or unsigned char)
7606          can be initialized by a string-literal (optionally enclosed in
7607          braces); a wchar_t array can be initialized by a wide
7608          string-literal (optionally enclosed in braces).  */
7609       new_init = old_init;
7610       /* Move past the initializer.  */
7611       *initp = TREE_CHAIN (old_init);
7612       TREE_CHAIN (old_init) = NULL_TREE;
7613     }
7614   else
7615     {
7616       /* Build a CONSTRUCTOR to hold the contents of the aggregate.  */
7617       new_init = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
7618       TREE_HAS_CONSTRUCTOR (new_init) = 1;
7619
7620       if (CLASS_TYPE_P (type))
7621         {
7622           tree field;
7623
7624           field = next_initializable_field (TYPE_FIELDS (type));
7625
7626           if (!field)
7627             {
7628               /* [dcl.init.aggr]
7629
7630                  An initializer for an aggregate member that is an
7631                  empty class shall have the form of an empty
7632                  initializer-list {}.  */
7633               if (!brace_enclosed_p)
7634                 error ("initializer for `%T' must be brace-enclosed",
7635                        type);
7636             }
7637           else
7638             {
7639               /* Loop through the initializable fields, gathering
7640                  initializers.  */
7641               while (*initp && field)
7642                 {
7643                   tree field_init;
7644
7645                   field_init = reshape_init (TREE_TYPE (field), initp);
7646                   TREE_CHAIN (field_init) = CONSTRUCTOR_ELTS (new_init);
7647                   CONSTRUCTOR_ELTS (new_init) = field_init;
7648                   /* [dcl.init.aggr]
7649
7650                      When a union  is  initialized with a brace-enclosed
7651                      initializer, the braces shall only contain an
7652                      initializer for the first member of the union.  */
7653                   if (TREE_CODE (type) == UNION_TYPE)
7654                     break;
7655                   if (TREE_PURPOSE (field_init))
7656                     field = TREE_PURPOSE (field_init);
7657                   field = next_initializable_field (TREE_CHAIN (field));
7658                 }
7659             }
7660         }
7661       else if (TREE_CODE (type) == ARRAY_TYPE)
7662         {
7663           tree index;
7664           tree max_index;
7665
7666           /* If the bound of the array is known, take no more initializers
7667              than are allowed.  */
7668           max_index = (TYPE_DOMAIN (type)
7669                        ? array_type_nelts (type) : NULL_TREE);
7670           /* Loop through the array elements, gathering initializers.  */
7671           for (index = size_zero_node;
7672                *initp && (!max_index || !tree_int_cst_lt (max_index, index));
7673                index = size_binop (PLUS_EXPR, index, size_one_node))
7674             {
7675               tree element_init;
7676
7677               element_init = reshape_init (TREE_TYPE (type), initp);
7678               TREE_CHAIN (element_init) = CONSTRUCTOR_ELTS (new_init);
7679               CONSTRUCTOR_ELTS (new_init) = element_init;
7680               if (TREE_PURPOSE (element_init))
7681                 index = TREE_PURPOSE (element_init);
7682             }
7683         }
7684       else
7685         abort ();
7686
7687       /* The initializers were placed in reverse order in the
7688          CONSTRUCTOR.  */
7689       CONSTRUCTOR_ELTS (new_init) = nreverse (CONSTRUCTOR_ELTS (new_init));
7690
7691       if (TREE_CODE (old_init) == TREE_LIST)
7692         new_init = build_tree_list (TREE_PURPOSE (old_init), new_init);
7693     }
7694
7695   /* If this was a brace-enclosed initializer and all of the
7696      initializers were not used up, there is a problem.  */
7697   if (brace_enclosed_p && *initp)
7698     error ("too many initializers for `%T'", type);
7699
7700   return new_init;
7701 }
7702
7703 /* Verify INIT (the initializer for DECL), and record the
7704    initialization in DECL_INITIAL, if appropriate.
7705
7706    If the return value is non-NULL, it is an expression that must be
7707    evaluated dynamically to initialize DECL.  */
7708
7709 static tree
7710 check_initializer (tree decl, tree init, int flags)
7711 {
7712   tree type = TREE_TYPE (decl);
7713
7714   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7715   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7716     init = NULL_TREE;
7717
7718   /* If an initializer is present, DECL_INITIAL has been
7719      error_mark_node, to indicate that an as-of-yet unevaluated
7720      initialization will occur.  From now on, DECL_INITIAL reflects
7721      the static initialization -- if any -- of DECL.  */
7722   DECL_INITIAL (decl) = NULL_TREE;
7723
7724   /* Things that are going to be initialized need to have complete
7725      type.  */
7726   TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7727
7728   if (type == error_mark_node)
7729     /* We will have already complained.  */
7730     init = NULL_TREE;
7731   else if (init && COMPLETE_TYPE_P (type)
7732            && !TREE_CONSTANT (TYPE_SIZE (type)))
7733     {
7734       error ("variable-sized object `%D' may not be initialized", decl);
7735       init = NULL_TREE;
7736     }
7737   else if (TREE_CODE (type) == ARRAY_TYPE
7738            && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7739     {
7740       error ("elements of array `%#D' have incomplete type", decl);
7741       init = NULL_TREE;
7742     }
7743   else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
7744     {
7745       error ("`%D' has incomplete type", decl);
7746       TREE_TYPE (decl) = error_mark_node;
7747       init = NULL_TREE;
7748     }
7749
7750   if (TREE_CODE (decl) == CONST_DECL)
7751     {
7752       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7753
7754       DECL_INITIAL (decl) = init;
7755
7756       my_friendly_assert (init != NULL_TREE, 149);
7757       init = NULL_TREE;
7758     }
7759   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7760     init = grok_reference_init (decl, type, init);
7761   else if (init)
7762     {
7763       if (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))
7764         {
7765           /* [dcl.init] paragraph 13,
7766              If T is a scalar type, then a declaration of the form
7767              T x = { a };
7768              is equivalent to
7769              T x = a;
7770
7771              reshape_init will complain about the extra braces,
7772              and doesn't do anything useful in the case where TYPE is
7773              scalar, so just don't call it.  */
7774           if (CP_AGGREGATE_TYPE_P (type))
7775             init = reshape_init (type, &init);
7776         }
7777
7778       /* If DECL has an array type without a specific bound, deduce the
7779          array size from the initializer.  */
7780       maybe_deduce_size_from_array_init (decl, init);
7781       type = TREE_TYPE (decl);
7782       if (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))
7783         TREE_TYPE (init) = type;
7784
7785       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7786         {
7787           if (TREE_CODE (type) == ARRAY_TYPE)
7788             goto initialize_aggr;
7789           else if (TREE_CODE (init) == CONSTRUCTOR
7790                    && TREE_HAS_CONSTRUCTOR (init))
7791             {
7792               if (TYPE_NON_AGGREGATE_CLASS (type))
7793                 {
7794                   error ("`%D' must be initialized by constructor, not by `{...}'",
7795                          decl);
7796                   init = error_mark_node;
7797                 }
7798               else
7799                 goto dont_use_constructor;
7800             }
7801           else
7802             {
7803               int saved_stmts_are_full_exprs_p;
7804
7805             initialize_aggr:
7806               saved_stmts_are_full_exprs_p = 0;
7807               if (building_stmt_tree ())
7808                 {
7809                   saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7810                   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
7811                 }
7812               init = build_aggr_init (decl, init, flags);
7813               if (building_stmt_tree ())
7814                 current_stmt_tree ()->stmts_are_full_exprs_p =
7815                   saved_stmts_are_full_exprs_p;
7816               return init;
7817             }
7818         }
7819       else
7820         {
7821         dont_use_constructor:
7822           if (TREE_CODE (init) != TREE_VEC)
7823             init = store_init_value (decl, init);
7824         }
7825     }
7826   else if (DECL_EXTERNAL (decl))
7827     ;
7828   else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7829     goto initialize_aggr;
7830   else if (IS_AGGR_TYPE (type))
7831     {
7832       tree core_type = strip_array_types (type);
7833
7834       if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7835         error ("structure `%D' with uninitialized const members", decl);
7836       if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7837         error ("structure `%D' with uninitialized reference members",
7838                decl);
7839
7840       check_for_uninitialized_const_var (decl);
7841     }
7842   else
7843     check_for_uninitialized_const_var (decl);
7844
7845   if (init && init != error_mark_node)
7846     init = build (INIT_EXPR, type, decl, init);
7847
7848   return init;
7849 }
7850
7851 /* If DECL is not a local variable, give it RTL.  */
7852
7853 static void
7854 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
7855 {
7856   int toplev = toplevel_bindings_p ();
7857   int defer_p;
7858
7859   /* Handle non-variables up front.  */
7860   if (TREE_CODE (decl) != VAR_DECL)
7861     {
7862       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7863       return;
7864     }
7865
7866   /* If we see a class member here, it should be a static data
7867      member.  */
7868   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7869     {
7870       my_friendly_assert (TREE_STATIC (decl), 19990828);
7871       /* An in-class declaration of a static data member should be
7872          external; it is only a declaration, and not a definition.  */
7873       if (init == NULL_TREE)
7874         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7875     }
7876
7877   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7878   if (asmspec)
7879     {
7880       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
7881       /* The `register' keyword, when used together with an
7882          asm-specification, indicates that the variable should be
7883          placed in a particular register.  */
7884       if (DECL_REGISTER (decl))
7885         DECL_C_HARD_REGISTER (decl) = 1;
7886     }
7887
7888   /* We don't create any RTL for local variables.  */
7889   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7890     return;
7891
7892   /* We defer emission of local statics until the corresponding
7893      DECL_STMT is expanded.  */
7894   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7895
7896   /* We try to defer namespace-scope static constants so that they are
7897      not emitted into the object file unnecessarily.  */
7898   if (!DECL_VIRTUAL_P (decl)
7899       && TREE_READONLY (decl)
7900       && DECL_INITIAL (decl) != NULL_TREE
7901       && DECL_INITIAL (decl) != error_mark_node
7902       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7903       && toplev
7904       && !TREE_PUBLIC (decl))
7905     {
7906       /* Fool with the linkage of static consts according to #pragma
7907          interface.  */
7908       if (!interface_unknown && !TREE_PUBLIC (decl))
7909         {
7910           TREE_PUBLIC (decl) = 1;
7911           DECL_EXTERNAL (decl) = interface_only;
7912         }
7913
7914       defer_p = 1;
7915     }
7916   /* Likewise for template instantiations.  */
7917   else if (DECL_COMDAT (decl))
7918     defer_p = 1;
7919
7920   /* If we're deferring the variable, we only need to make RTL if
7921      there's an ASMSPEC.  Otherwise, we'll lazily create it later when
7922      we need it.  (There's no way to lazily create RTL for things that
7923      have assembly specs because the information about the specifier
7924      isn't stored in the tree, yet)  */
7925   if (defer_p && asmspec)
7926     make_decl_rtl (decl, asmspec);
7927   /* If we're not deferring, go ahead and assemble the variable.  */
7928   else if (!defer_p)
7929     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7930 }
7931
7932 /* The old ARM scoping rules injected variables declared in the
7933    initialization statement of a for-statement into the surrounding
7934    scope.  We support this usage, in order to be backward-compatible.
7935    DECL is a just-declared VAR_DECL; if necessary inject its
7936    declaration into the surrounding scope.  */
7937
7938 void
7939 maybe_inject_for_scope_var (tree decl)
7940 {
7941   timevar_push (TV_NAME_LOOKUP);
7942   if (!DECL_NAME (decl))
7943     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (void)0);
7944
7945   /* Declarations of __FUNCTION__ and its ilk appear magically when
7946      the variable is first used.  If that happens to be inside a
7947      for-loop, we don't want to do anything special.  */
7948   if (DECL_PRETTY_FUNCTION_P (decl))
7949     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (void)0);
7950
7951   if (current_binding_level->is_for_scope)
7952     {
7953       struct cp_binding_level *outer
7954         = current_binding_level->level_chain;
7955
7956       /* Check to see if the same name is already bound at the outer
7957          level, either because it was directly declared, or because a
7958          dead for-decl got preserved.  In either case, the code would
7959          not have been valid under the ARM scope rules, so clear
7960          is_for_scope for the current_binding_level.
7961
7962          Otherwise, we need to preserve the temp slot for decl to last
7963          into the outer binding level.  */
7964
7965       tree outer_binding
7966         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7967
7968       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7969           && (TREE_CODE (BINDING_VALUE (outer_binding))
7970               == VAR_DECL)
7971           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7972         {
7973           BINDING_VALUE (outer_binding)
7974             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7975           current_binding_level->is_for_scope = 0;
7976         }
7977     }
7978   timevar_pop (TV_NAME_LOOKUP);
7979 }
7980
7981 /* Generate code to initialize DECL (a local variable).  */
7982
7983 static void
7984 initialize_local_var (tree decl, tree init)
7985 {
7986   tree type = TREE_TYPE (decl);
7987
7988   my_friendly_assert (TREE_CODE (decl) == VAR_DECL
7989                       || TREE_CODE (decl) == RESULT_DECL,
7990                       20021010);
7991   my_friendly_assert (!TREE_STATIC (decl), 20021010);
7992
7993   if (DECL_SIZE (decl) == NULL_TREE)
7994     {
7995       /* If we used it already as memory, it must stay in memory.  */
7996       DECL_INITIAL (decl) = NULL_TREE;
7997       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7998     }
7999
8000   if (DECL_SIZE (decl) && type != error_mark_node)
8001     {
8002       int already_used;
8003
8004       /* Compute and store the initial value.  */
8005       already_used = TREE_USED (decl) || TREE_USED (type);
8006
8007       /* Perform the initialization.  */
8008       if (init)
8009         {
8010           int saved_stmts_are_full_exprs_p;
8011
8012           my_friendly_assert (building_stmt_tree (), 20000906);
8013           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
8014           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
8015           finish_expr_stmt (init);
8016           current_stmt_tree ()->stmts_are_full_exprs_p =
8017             saved_stmts_are_full_exprs_p;
8018         }
8019
8020       /* Set this to 0 so we can tell whether an aggregate which was
8021          initialized was ever used.  Don't do this if it has a
8022          destructor, so we don't complain about the 'resource
8023          allocation is initialization' idiom.  Now set
8024          attribute((unused)) on types so decls of that type will be
8025          marked used. (see TREE_USED, above.)  */
8026       if (TYPE_NEEDS_CONSTRUCTING (type)
8027           && ! already_used
8028           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
8029           && DECL_NAME (decl))
8030         TREE_USED (decl) = 0;
8031       else if (already_used)
8032         TREE_USED (decl) = 1;
8033     }
8034
8035   /* Generate a cleanup, if necessary.  */
8036   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8037     {
8038       tree cleanup;
8039
8040       /* Compute the cleanup.  */
8041       cleanup = cxx_maybe_build_cleanup (decl);
8042
8043       /* Record the cleanup required for this declaration.  */
8044       if (DECL_SIZE (decl) && cleanup)
8045         finish_decl_cleanup (decl, cleanup);
8046     }
8047 }
8048
8049 /* Finish processing of a declaration;
8050    install its line number and initial value.
8051    If the length of an array type is not known before,
8052    it must be determined now, from the initial value, or it is an error.
8053
8054    INIT holds the value of an initializer that should be allowed to escape
8055    the normal rules.
8056
8057    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8058    if the (init) syntax was used.  */
8059
8060 void
8061 cp_finish_decl (tree decl, tree init, tree asmspec_tree, int flags)
8062 {
8063   register tree type;
8064   tree ttype = NULL_TREE;
8065   const char *asmspec = NULL;
8066   int was_readonly = 0;
8067
8068   if (! decl)
8069     {
8070       if (init)
8071         error ("assignment (not initialization) in declaration");
8072       return;
8073     }
8074
8075   /* If a name was specified, get the string.  */
8076   if (current_binding_level == global_binding_level)
8077     asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
8078   if (asmspec_tree)
8079     asmspec = TREE_STRING_POINTER (asmspec_tree);
8080
8081   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8082     {
8083       error ("cannot initialize `%D' to namespace `%D'",
8084                 decl, init);
8085       init = NULL_TREE;
8086     }
8087
8088   if (current_class_type
8089       && CP_DECL_CONTEXT (decl) == current_class_type
8090       && TYPE_BEING_DEFINED (current_class_type)
8091       && (DECL_INITIAL (decl) || init))
8092     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
8093
8094   if (TREE_CODE (decl) == VAR_DECL
8095       && DECL_CONTEXT (decl)
8096       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8097       && DECL_CONTEXT (decl) != current_namespace
8098       && init)
8099     {
8100       /* Leave the namespace of the object.  */
8101       pop_decl_namespace ();
8102     }
8103
8104   type = TREE_TYPE (decl);
8105
8106   if (type == error_mark_node)
8107     return;
8108
8109   if (TYPE_HAS_MUTABLE_P (type))
8110     TREE_READONLY (decl) = 0;
8111
8112   if (processing_template_decl)
8113     {
8114       /* Add this declaration to the statement-tree.  */
8115       if (at_function_scope_p ()
8116           && TREE_CODE (decl) != RESULT_DECL)
8117         add_decl_stmt (decl);
8118
8119       if (init && DECL_INITIAL (decl))
8120         DECL_INITIAL (decl) = init;
8121       goto finish_end0;
8122     }
8123
8124   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8125   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8126
8127   /* Take care of TYPE_DECLs up front.  */
8128   if (TREE_CODE (decl) == TYPE_DECL)
8129     {
8130       if (type != error_mark_node
8131           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8132         {
8133           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8134             warning ("shadowing previous type declaration of `%#D'", decl);
8135           set_identifier_type_value (DECL_NAME (decl), type);
8136           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8137         }
8138
8139       /* If we have installed this as the canonical typedef for this
8140          type, and that type has not been defined yet, delay emitting
8141          the debug information for it, as we will emit it later.  */
8142       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8143           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8144         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8145
8146       rest_of_decl_compilation (decl, NULL,
8147                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8148       goto finish_end;
8149     }
8150
8151   if (TREE_CODE (decl) != FUNCTION_DECL)
8152     ttype = target_type (type);
8153
8154   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8155       && TYPE_NEEDS_CONSTRUCTING (type))
8156     {
8157       /* Currently, GNU C++ puts constants in text space, making them
8158          impossible to initialize.  In the future, one would hope for
8159          an operating system which understood the difference between
8160          initialization and the running of a program.  */
8161       was_readonly = 1;
8162       TREE_READONLY (decl) = 0;
8163     }
8164
8165   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8166     {
8167       /* This must override the asm specifier which was placed by
8168          grokclassfn.  Lay this out fresh.  */
8169       SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
8170       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8171       make_decl_rtl (decl, asmspec);
8172     }
8173   else if (TREE_CODE (decl) == RESULT_DECL)
8174     init = check_initializer (decl, init, flags);
8175   else if (TREE_CODE (decl) == VAR_DECL)
8176     {
8177       /* Only PODs can have thread-local storage.  Other types may require
8178          various kinds of non-trivial initialization.  */
8179       if (DECL_THREAD_LOCAL (decl) && !pod_type_p (TREE_TYPE (decl)))
8180         error ("`%D' cannot be thread-local because it has non-POD type `%T'",
8181                decl, TREE_TYPE (decl));
8182       /* Convert the initializer to the type of DECL, if we have not
8183          already initialized DECL.  */
8184       if (!DECL_INITIALIZED_P (decl)
8185           /* If !DECL_EXTERNAL then DECL is being defined.  In the
8186              case of a static data member initialized inside the
8187              class-specifier, there can be an initializer even if DECL
8188              is *not* defined.  */
8189           && (!DECL_EXTERNAL (decl) || init))
8190         {
8191           init = check_initializer (decl, init, flags);
8192           /* Thread-local storage cannot be dynamically initialized.  */
8193           if (DECL_THREAD_LOCAL (decl) && init)
8194             {
8195               error ("`%D' is thread-local and so cannot be dynamically "
8196                      "initialized", decl);
8197               init = NULL_TREE;
8198             }
8199           /* Handle:
8200
8201              [dcl.init]
8202
8203              The memory occupied by any object of static storage
8204              duration is zero-initialized at program startup before
8205              any other initialization takes place.
8206
8207              We cannot create an appropriate initializer until after
8208              the type of DECL is finalized.  If DECL_INITIAL is set,
8209              then the DECL is statically initialized, and any
8210              necessary zero-initialization has already been performed.  */
8211           if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
8212             DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
8213                                                    /*static_storage_p=*/true);
8214           /* Remember that the initialization for this variable has
8215              taken place.  */
8216           DECL_INITIALIZED_P (decl) = 1;
8217         }
8218       /* If the variable has an array type, lay out the type, even if
8219          there is no initializer.  It is valid to index through the
8220          array, and we must get TYPE_ALIGN set correctly on the array
8221          type.  */
8222       else if (TREE_CODE (type) == ARRAY_TYPE)
8223         layout_type (type);
8224     }
8225
8226   /* Add this declaration to the statement-tree.  This needs to happen
8227      after the call to check_initializer so that the DECL_STMT for a
8228      reference temp is added before the DECL_STMT for the reference itself.  */
8229   if (building_stmt_tree ()
8230       && at_function_scope_p ()
8231       && TREE_CODE (decl) != RESULT_DECL)
8232     add_decl_stmt (decl);
8233
8234   if (TREE_CODE (decl) == VAR_DECL)
8235     layout_var_decl (decl);
8236
8237   /* Output the assembler code and/or RTL code for variables and functions,
8238      unless the type is an undefined structure or union.
8239      If not, it will get done when the type is completed.  */
8240   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8241       || TREE_CODE (decl) == RESULT_DECL)
8242     {
8243       if (TREE_CODE (decl) == VAR_DECL)
8244         maybe_commonize_var (decl);
8245
8246       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8247
8248       if (TREE_CODE (type) == FUNCTION_TYPE
8249           || TREE_CODE (type) == METHOD_TYPE)
8250         abstract_virtuals_error (decl,
8251                                  strip_array_types (TREE_TYPE (type)));
8252       else
8253         abstract_virtuals_error (decl, strip_array_types (type));
8254
8255       if (TREE_CODE (decl) == FUNCTION_DECL
8256           || TREE_TYPE (decl) == error_mark_node)
8257         /* No initialization required.  */
8258         ;
8259       else if (DECL_EXTERNAL (decl)
8260                && ! (DECL_LANG_SPECIFIC (decl)
8261                      && DECL_NOT_REALLY_EXTERN (decl)))
8262         {
8263           if (init)
8264             DECL_INITIAL (decl) = init;
8265         }
8266       else
8267         {
8268           /* A variable definition.  */
8269           if (DECL_FUNCTION_SCOPE_P (decl))
8270             {
8271               /* This is a local declaration.  */
8272               if (doing_semantic_analysis_p ())
8273                 maybe_inject_for_scope_var (decl);
8274               /* Initialize the local variable.  */
8275               if (processing_template_decl)
8276                 {
8277                   if (init || DECL_INITIAL (decl) == error_mark_node)
8278                     DECL_INITIAL (decl) = init;
8279                 }
8280               else if (!TREE_STATIC (decl))
8281                 initialize_local_var (decl, init);
8282             }
8283
8284           if (TREE_STATIC (decl))
8285             expand_static_init (decl, init);
8286         }
8287     finish_end0:
8288
8289       /* Undo call to `pushclass' that was done in `start_decl'
8290          due to initialization of qualified member variable.
8291          I.e., Foo::x = 10;  */
8292       {
8293         tree context = CP_DECL_CONTEXT (decl);
8294         if (context
8295             && TYPE_P (context)
8296             && (TREE_CODE (decl) == VAR_DECL
8297                 /* We also have a pushclass done that we need to undo here
8298                    if we're at top level and declare a method.  */
8299                 || TREE_CODE (decl) == FUNCTION_DECL)
8300             /* If size hasn't been set, we're still defining it,
8301                and therefore inside the class body; don't pop
8302                the binding level..  */
8303             && COMPLETE_TYPE_P (context)
8304             && context == current_class_type)
8305           pop_nested_class ();
8306       }
8307     }
8308
8309  finish_end:
8310
8311   if (was_readonly)
8312     TREE_READONLY (decl) = 1;
8313 }
8314
8315 /* This is here for a midend callback from c-common.c */
8316
8317 void
8318 finish_decl (tree decl, tree init, tree asmspec_tree)
8319 {
8320   cp_finish_decl (decl, init, asmspec_tree, 0);
8321 }
8322
8323 /* Returns a declaration for a VAR_DECL as if:
8324
8325      extern "C" TYPE NAME;
8326
8327    had been seen.  Used to create compiler-generated global
8328    variables.  */
8329
8330 tree
8331 declare_global_var (tree name, tree type)
8332 {
8333   tree decl;
8334
8335   push_to_top_level ();
8336   decl = build_decl (VAR_DECL, name, type);
8337   TREE_PUBLIC (decl) = 1;
8338   DECL_EXTERNAL (decl) = 1;
8339   DECL_ARTIFICIAL (decl) = 1;
8340   pushdecl (decl);
8341   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8342   pop_from_top_level ();
8343
8344   return decl;
8345 }
8346
8347 /* Returns a pointer to the `atexit' function.  Note that if
8348    FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
8349    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8350
8351 static tree
8352 get_atexit_node (void)
8353 {
8354   tree atexit_fndecl;
8355   tree arg_types;
8356   tree fn_type;
8357   tree fn_ptr_type;
8358   const char *name;
8359
8360   if (atexit_node)
8361     return atexit_node;
8362
8363   if (flag_use_cxa_atexit)
8364     {
8365       /* The declaration for `__cxa_atexit' is:
8366
8367            int __cxa_atexit (void (*)(void *), void *, void *)
8368
8369          We build up the argument types and then then function type
8370          itself.  */
8371
8372       /* First, build the pointer-to-function type for the first
8373          argument.  */
8374       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8375       fn_type = build_function_type (void_type_node, arg_types);
8376       fn_ptr_type = build_pointer_type (fn_type);
8377       /* Then, build the rest of the argument types.  */
8378       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8379       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8380       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8381       /* And the final __cxa_atexit type.  */
8382       fn_type = build_function_type (integer_type_node, arg_types);
8383       fn_ptr_type = build_pointer_type (fn_type);
8384       name = "__cxa_atexit";
8385     }
8386   else
8387     {
8388       /* The declaration for `atexit' is:
8389
8390            int atexit (void (*)());
8391
8392          We build up the argument types and then then function type
8393          itself.  */
8394       fn_type = build_function_type (void_type_node, void_list_node);
8395       fn_ptr_type = build_pointer_type (fn_type);
8396       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8397       /* Build the final atexit type.  */
8398       fn_type = build_function_type (integer_type_node, arg_types);
8399       name = "atexit";
8400     }
8401
8402   /* Now, build the function declaration.  */
8403   push_lang_context (lang_name_c);
8404   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8405   mark_used (atexit_fndecl);
8406   pop_lang_context ();
8407   atexit_node = default_conversion (atexit_fndecl);
8408
8409   return atexit_node;
8410 }
8411
8412 /* Returns the __dso_handle VAR_DECL.  */
8413
8414 static tree
8415 get_dso_handle_node (void)
8416 {
8417   if (dso_handle_node)
8418     return dso_handle_node;
8419
8420   /* Declare the variable.  */
8421   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8422                                         ptr_type_node);
8423
8424   return dso_handle_node;
8425 }
8426
8427 /* Begin a new function with internal linkage whose job will be simply
8428    to destroy some particular variable.  */
8429
8430 static tree
8431 start_cleanup_fn (void)
8432 {
8433   static int counter = 0;
8434   int old_interface_only = interface_only;
8435   int old_interface_unknown = interface_unknown;
8436   char name[32];
8437   tree parmtypes;
8438   tree fntype;
8439   tree fndecl;
8440
8441   push_to_top_level ();
8442
8443   /* No need to mangle this.  */
8444   push_lang_context (lang_name_c);
8445
8446   interface_only = 0;
8447   interface_unknown = 1;
8448
8449   /* Build the parameter-types.  */
8450   parmtypes = void_list_node;
8451   /* Functions passed to __cxa_atexit take an additional parameter.
8452      We'll just ignore it.  After we implement the new calling
8453      convention for destructors, we can eliminate the use of
8454      additional cleanup functions entirely in the -fnew-abi case.  */
8455   if (flag_use_cxa_atexit)
8456     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8457   /* Build the function type itself.  */
8458   fntype = build_function_type (void_type_node, parmtypes);
8459   /* Build the name of the function.  */
8460   sprintf (name, "__tcf_%d", counter++);
8461   /* Build the function declaration.  */
8462   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8463   /* It's a function with internal linkage, generated by the
8464      compiler.  */
8465   TREE_PUBLIC (fndecl) = 0;
8466   DECL_ARTIFICIAL (fndecl) = 1;
8467   /* Make the function `inline' so that it is only emitted if it is
8468      actually needed.  It is unlikely that it will be inlined, since
8469      it is only called via a function pointer, but we avoid unnecessary
8470      emissions this way.  */
8471   DECL_INLINE (fndecl) = 1;
8472   /* Build the parameter.  */
8473   if (flag_use_cxa_atexit)
8474     {
8475       tree parmdecl;
8476
8477       parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
8478       DECL_CONTEXT (parmdecl) = fndecl;
8479       TREE_USED (parmdecl) = 1;
8480       DECL_ARGUMENTS (fndecl) = parmdecl;
8481     }
8482
8483   pushdecl (fndecl);
8484   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8485
8486   interface_unknown = old_interface_unknown;
8487   interface_only = old_interface_only;
8488
8489   pop_lang_context ();
8490
8491   return current_function_decl;
8492 }
8493
8494 /* Finish the cleanup function begun by start_cleanup_fn.  */
8495
8496 static void
8497 end_cleanup_fn (void)
8498 {
8499   expand_body (finish_function (0));
8500
8501   pop_from_top_level ();
8502 }
8503
8504 /* Generate code to handle the destruction of DECL, an object with
8505    static storage duration.  */
8506
8507 void
8508 register_dtor_fn (tree decl)
8509 {
8510   tree cleanup;
8511   tree compound_stmt;
8512   tree args;
8513   tree fcall;
8514   int saved_flag_access_control;
8515
8516   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8517     return;
8518
8519   /* Call build_cleanup before we enter the anonymous function so that
8520      any access checks will be done relative to the current scope,
8521      rather than the scope of the anonymous function.  */
8522   build_cleanup (decl);
8523
8524   /* Now start the function.  */
8525   cleanup = start_cleanup_fn ();
8526
8527   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8528      to the original function, rather than the anonymous one.  That
8529      will make the back-end think that nested functions are in use,
8530      which causes confusion.  */
8531   saved_flag_access_control = flag_access_control;
8532   scope_chain->check_access = flag_access_control = 0;
8533   fcall = build_cleanup (decl);
8534   scope_chain->check_access = flag_access_control = saved_flag_access_control;
8535
8536   /* Create the body of the anonymous function.  */
8537   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8538   finish_expr_stmt (fcall);
8539   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8540   end_cleanup_fn ();
8541
8542   /* Call atexit with the cleanup function.  */
8543   cxx_mark_addressable (cleanup);
8544   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8545   if (flag_use_cxa_atexit)
8546     {
8547       args = tree_cons (NULL_TREE,
8548                         build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
8549                         NULL_TREE);
8550       args = tree_cons (NULL_TREE, null_pointer_node, args);
8551       args = tree_cons (NULL_TREE, cleanup, args);
8552     }
8553   else
8554     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8555   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8556 }
8557
8558 /* DECL is a VAR_DECL with static storage duration.  INIT, if present,
8559    is its initializer.  Generate code to handle the construction
8560    and destruction of DECL.  */
8561
8562 static void
8563 expand_static_init (tree decl, tree init)
8564 {
8565   tree oldstatic;
8566
8567   my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 20021010);
8568   my_friendly_assert (TREE_STATIC (decl), 20021010);
8569
8570   /* Some variables require no initialization.  */
8571   if (!init
8572       && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8573       && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8574     return;
8575
8576   oldstatic = value_member (decl, static_aggregates);
8577
8578   if (oldstatic)
8579     {
8580       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8581         error ("multiple initializations given for `%D'", decl);
8582     }
8583   else if (! toplevel_bindings_p ())
8584     {
8585       /* Emit code to perform this initialization but once.  */
8586       tree if_stmt;
8587       tree then_clause;
8588       tree assignment;
8589       tree guard;
8590       tree guard_init;
8591
8592       /* Emit code to perform this initialization but once.  This code
8593          looks like:
8594
8595            static int guard = 0;
8596            if (!guard) {
8597              // Do initialization.
8598              guard = 1;
8599              // Register variable for destruction at end of program.
8600            }
8601
8602          Note that the `temp' variable is only set to 1 *after* the
8603          initialization is complete.  This ensures that an exception,
8604          thrown during the construction, will cause the variable to
8605          reinitialized when we pass through this code again, as per:
8606
8607            [stmt.dcl]
8608
8609            If the initialization exits by throwing an exception, the
8610            initialization is not complete, so it will be tried again
8611            the next time control enters the declaration.
8612
8613          In theory, this process should be thread-safe, too; multiple
8614          threads should not be able to initialize the variable more
8615          than once.  We don't yet attempt to ensure thread-safety.  */
8616
8617       /* Create the guard variable.  */
8618       guard = get_guard (decl);
8619
8620       /* Begin the conditional initialization.  */
8621       if_stmt = begin_if_stmt ();
8622       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8623       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8624
8625       /* Do the initialization itself.  */
8626       assignment = init ? init : NULL_TREE;
8627
8628       /* Once the assignment is complete, set TEMP to 1.  Since the
8629          construction of the static object is complete at this point,
8630          we want to make sure TEMP is set to 1 even if a temporary
8631          constructed during the initialization throws an exception
8632          when it is destroyed.  So, we combine the initialization and
8633          the assignment to TEMP into a single expression, ensuring
8634          that when we call finish_expr_stmt the cleanups will not be
8635          run until after TEMP is set to 1.  */
8636       guard_init = set_guard (guard);
8637       if (assignment)
8638         {
8639           assignment = tree_cons (NULL_TREE, assignment,
8640                                   build_tree_list (NULL_TREE,
8641                                                    guard_init));
8642           assignment = build_compound_expr (assignment);
8643         }
8644       else
8645         assignment = guard_init;
8646       finish_expr_stmt (assignment);
8647
8648       /* Use atexit to register a function for destroying this static
8649          variable.  */
8650       register_dtor_fn (decl);
8651
8652       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8653       finish_then_clause (if_stmt);
8654       finish_if_stmt ();
8655     }
8656   else
8657     static_aggregates = tree_cons (init, decl, static_aggregates);
8658 }
8659
8660 /* Finish the declaration of a catch-parameter.  */
8661
8662 tree
8663 start_handler_parms (tree declspecs, tree declarator)
8664 {
8665   tree decl;
8666   if (declspecs)
8667     {
8668       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8669                              1, NULL);
8670       if (decl == NULL_TREE)
8671         error ("invalid catch parameter");
8672     }
8673   else
8674     decl = NULL_TREE;
8675
8676   return decl;
8677 }
8678
8679 \f
8680 /* Make TYPE a complete type based on INITIAL_VALUE.
8681    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8682    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8683
8684 int
8685 complete_array_type (tree type, tree initial_value, int do_default)
8686 {
8687   register tree maxindex = NULL_TREE;
8688   int value = 0;
8689
8690   if (initial_value)
8691     {
8692       /* An array of character type can be initialized from a
8693          brace-enclosed string constant.  */
8694       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8695           && TREE_CODE (initial_value) == CONSTRUCTOR
8696           && CONSTRUCTOR_ELTS (initial_value)
8697           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8698               == STRING_CST)
8699           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8700         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8701
8702       /* Note MAXINDEX is really the maximum index, one less than the
8703          size.  */
8704       if (TREE_CODE (initial_value) == STRING_CST)
8705         {
8706           int eltsize
8707             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8708           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8709                                    / eltsize) - 1, 0);
8710         }
8711       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8712         {
8713           tree elts = CONSTRUCTOR_ELTS (initial_value);
8714
8715           maxindex = ssize_int (-1);
8716           for (; elts; elts = TREE_CHAIN (elts))
8717             {
8718               if (TREE_PURPOSE (elts))
8719                 maxindex = TREE_PURPOSE (elts);
8720               else
8721                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8722             }
8723           maxindex = copy_node (maxindex);
8724         }
8725       else
8726         {
8727           /* Make an error message unless that happened already.  */
8728           if (initial_value != error_mark_node)
8729             value = 1;
8730           else
8731             initial_value = NULL_TREE;
8732
8733           /* Prevent further error messages.  */
8734           maxindex = build_int_2 (0, 0);
8735         }
8736     }
8737
8738   if (!maxindex)
8739     {
8740       if (do_default)
8741         maxindex = build_int_2 (0, 0);
8742       value = 2;
8743     }
8744
8745   if (maxindex)
8746     {
8747       tree itype;
8748       tree domain;
8749
8750       domain = build_index_type (maxindex);
8751       TYPE_DOMAIN (type) = domain;
8752
8753       if (! TREE_TYPE (maxindex))
8754         TREE_TYPE (maxindex) = domain;
8755       if (initial_value)
8756         itype = TREE_TYPE (initial_value);
8757       else
8758         itype = NULL;
8759       if (itype && !TYPE_DOMAIN (itype))
8760         TYPE_DOMAIN (itype) = domain;
8761       /* The type of the main variant should never be used for arrays
8762          of different sizes.  It should only ever be completed with the
8763          size of the array.  */
8764       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8765         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8766     }
8767
8768   /* Lay out the type now that we can get the real answer.  */
8769
8770   layout_type (type);
8771
8772   return value;
8773 }
8774 \f
8775 /* Return zero if something is declared to be a member of type
8776    CTYPE when in the context of CUR_TYPE.  STRING is the error
8777    message to print in that case.  Otherwise, quietly return 1.  */
8778
8779 static int
8780 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
8781 {
8782   if (ctype && ctype != cur_type)
8783     {
8784       if (flags == DTOR_FLAG)
8785         error ("destructor for alien class `%T' cannot be a member",
8786                   ctype);
8787       else
8788         error ("constructor for alien class `%T' cannot be a member",
8789                   ctype);
8790       return 0;
8791     }
8792   return 1;
8793 }
8794 \f
8795 /* Subroutine of `grokdeclarator'.  */
8796
8797 /* Generate errors possibly applicable for a given set of specifiers.
8798    This is for ARM $7.1.2.  */
8799
8800 static void
8801 bad_specifiers (tree object,
8802                 const char* type,
8803                 int virtualp,
8804                 int quals,
8805                 int inlinep,
8806                 int friendp,
8807                 int raises)
8808 {
8809   if (virtualp)
8810     error ("`%D' declared as a `virtual' %s", object, type);
8811   if (inlinep)
8812     error ("`%D' declared as an `inline' %s", object, type);
8813   if (quals)
8814     error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8815               object, type);
8816   if (friendp)
8817     cp_error_at ("`%D' declared as a friend", object);
8818   if (raises
8819       && (TREE_CODE (object) == TYPE_DECL
8820           || (!TYPE_PTRFN_P (TREE_TYPE (object))
8821               && !TYPE_REFFN_P (TREE_TYPE (object))
8822               && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
8823     cp_error_at ("`%D' declared with an exception specification", object);
8824 }
8825
8826 /* CTYPE is class type, or null if non-class.
8827    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8828    or METHOD_TYPE.
8829    DECLARATOR is the function's name.
8830    VIRTUALP is truthvalue of whether the function is virtual or not.
8831    FLAGS are to be passed through to `grokclassfn'.
8832    QUALS are qualifiers indicating whether the function is `const'
8833    or `volatile'.
8834    RAISES is a list of exceptions that this function can raise.
8835    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8836    not look, and -1 if we should not call `grokclassfn' at all.
8837
8838    Returns `NULL_TREE' if something goes wrong, after issuing
8839    applicable error messages.  */
8840
8841 static tree
8842 grokfndecl (tree ctype,
8843             tree type,
8844             tree declarator,
8845             tree orig_declarator,
8846             int virtualp,
8847             enum overload_flags flags,
8848             tree quals,
8849             tree raises,
8850             int check,
8851             int friendp,
8852             int publicp,
8853             int inlinep,
8854             int funcdef_flag,
8855             int template_count,
8856             tree in_namespace)
8857 {
8858   tree decl;
8859   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8860   int has_default_arg = 0;
8861   tree t;
8862
8863   if (raises)
8864     type = build_exception_variant (type, raises);
8865
8866   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8867   /* Propagate volatile out from type to decl.  */
8868   if (TYPE_VOLATILE (type))
8869     TREE_THIS_VOLATILE (decl) = 1;
8870
8871   /* If this decl has namespace scope, set that up.  */
8872   if (in_namespace)
8873     set_decl_namespace (decl, in_namespace, friendp);
8874   else if (!ctype)
8875     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8876
8877   /* `main' and builtins have implicit 'C' linkage.  */
8878   if ((MAIN_NAME_P (declarator)
8879        || (IDENTIFIER_LENGTH (declarator) > 10
8880            && IDENTIFIER_POINTER (declarator)[0] == '_'
8881            && IDENTIFIER_POINTER (declarator)[1] == '_'
8882            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8883       && current_lang_name == lang_name_cplusplus
8884       && ctype == NULL_TREE
8885       /* NULL_TREE means global namespace.  */
8886       && DECL_CONTEXT (decl) == NULL_TREE)
8887     SET_DECL_LANGUAGE (decl, lang_c);
8888
8889   /* Should probably propagate const out from type to decl I bet (mrs).  */
8890   if (staticp)
8891     {
8892       DECL_STATIC_FUNCTION_P (decl) = 1;
8893       DECL_CONTEXT (decl) = ctype;
8894     }
8895
8896   if (ctype)
8897     DECL_CONTEXT (decl) = ctype;
8898
8899   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8900     {
8901       if (processing_template_decl)
8902         error ("cannot declare `::main' to be a template");
8903       if (inlinep)
8904         error ("cannot declare `::main' to be inline");
8905       if (!publicp)
8906         error ("cannot declare `::main' to be static");
8907       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8908                         integer_type_node))
8909         error ("`main' must return `int'");
8910       inlinep = 0;
8911       publicp = 1;
8912     }
8913
8914   /* Members of anonymous types and local classes have no linkage; make
8915      them internal.  */
8916   /* FIXME what if it gets a name from typedef?  */
8917   if (ctype && (TYPE_ANONYMOUS_P (ctype)
8918                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8919     publicp = 0;
8920
8921   if (publicp)
8922     {
8923       /* [basic.link]: A name with no linkage (notably, the name of a class
8924          or enumeration declared in a local scope) shall not be used to
8925          declare an entity with linkage.
8926
8927          Only check this for public decls for now.  */
8928       t = no_linkage_check (TREE_TYPE (decl));
8929       if (t)
8930         {
8931           if (TYPE_ANONYMOUS_P (t))
8932             {
8933               if (DECL_EXTERN_C_P (decl))
8934                 /* Allow this; it's pretty common in C.  */;
8935               else
8936                 {
8937                   pedwarn ("non-local function `%#D' uses anonymous type",
8938                               decl);
8939                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
8940                     cp_pedwarn_at ("\
8941 `%#D' does not refer to the unqualified type, so it is not used for linkage",
8942                                 TYPE_NAME (t));
8943                 }
8944             }
8945           else
8946             pedwarn ("non-local function `%#D' uses local type `%T'",
8947                         decl, t);
8948         }
8949     }
8950
8951   TREE_PUBLIC (decl) = publicp;
8952   if (! publicp)
8953     {
8954       DECL_INTERFACE_KNOWN (decl) = 1;
8955       DECL_NOT_REALLY_EXTERN (decl) = 1;
8956     }
8957
8958   /* If the declaration was declared inline, mark it as such.  */
8959   if (inlinep)
8960     DECL_DECLARED_INLINE_P (decl) = 1;
8961   /* We inline functions that are explicitly declared inline, or, when
8962      the user explicitly asks us to, all functions.  */
8963   if (DECL_DECLARED_INLINE_P (decl) || flag_inline_trees == 2)
8964     DECL_INLINE (decl) = 1;
8965
8966   DECL_EXTERNAL (decl) = 1;
8967   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8968     {
8969       error ("%smember function `%D' cannot have `%T' method qualifier",
8970                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8971       quals = NULL_TREE;
8972     }
8973
8974   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8975     grok_op_properties (decl, friendp);
8976
8977   if (ctype && decl_function_context (decl))
8978     DECL_NO_STATIC_CHAIN (decl) = 1;
8979
8980   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8981     if (TREE_PURPOSE (t)
8982         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8983       {
8984         has_default_arg = 1;
8985         break;
8986       }
8987
8988   if (friendp
8989       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8990     {
8991       if (funcdef_flag)
8992         error
8993           ("defining explicit specialization `%D' in friend declaration",
8994            orig_declarator);
8995       else
8996         {
8997           tree fns = TREE_OPERAND (orig_declarator, 0);
8998           tree args = TREE_OPERAND (orig_declarator, 1);
8999
9000           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
9001             {
9002               /* Something like `template <class T> friend void f<T>()'.  */
9003               error ("invalid use of template-id `%D' in declaration of primary template",
9004                         orig_declarator);
9005               return NULL_TREE;
9006             }
9007
9008
9009           /* A friend declaration of the form friend void f<>().  Record
9010              the information in the TEMPLATE_ID_EXPR.  */
9011           SET_DECL_IMPLICIT_INSTANTIATION (decl);
9012
9013           if (TREE_CODE (fns) == COMPONENT_REF)
9014             {
9015               /* Due to bison parser ickiness, we will have already looked
9016                  up an operator_name or PFUNCNAME within the current class
9017                  (see template_id in parse.y). If the current class contains
9018                  such a name, we'll get a COMPONENT_REF here. Undo that.  */
9019
9020               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
9021                                   == current_class_type, 20001120);
9022               fns = TREE_OPERAND (fns, 1);
9023             }
9024           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
9025                               || TREE_CODE (fns) == LOOKUP_EXPR
9026                               || TREE_CODE (fns) == OVERLOAD, 20001120);
9027           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
9028
9029           if (has_default_arg)
9030             {
9031               error ("default arguments are not allowed in declaration of friend template specialization `%D'",
9032                         decl);
9033               return NULL_TREE;
9034             }
9035
9036           if (inlinep)
9037             {
9038               error ("`inline' is not allowed in declaration of friend template specialization `%D'",
9039                         decl);
9040               return NULL_TREE;
9041             }
9042         }
9043     }
9044
9045   if (funcdef_flag)
9046     /* Make the init_value nonzero so pushdecl knows this is not
9047        tentative.  error_mark_node is replaced later with the BLOCK.  */
9048     DECL_INITIAL (decl) = error_mark_node;
9049
9050   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
9051     TREE_NOTHROW (decl) = 1;
9052
9053   /* Caller will do the rest of this.  */
9054   if (check < 0)
9055     return decl;
9056
9057   if (flags == NO_SPECIAL && ctype && constructor_name_p (declarator, ctype))
9058     DECL_CONSTRUCTOR_P (decl) = 1;
9059
9060   /* Function gets the ugly name, field gets the nice one.  This call
9061      may change the type of the function (because of default
9062      parameters)!  */
9063   if (ctype != NULL_TREE)
9064     grokclassfn (ctype, decl, flags, quals);
9065
9066   decl = check_explicit_specialization (orig_declarator, decl,
9067                                         template_count,
9068                                         2 * (funcdef_flag != 0) +
9069                                         4 * (friendp != 0));
9070   if (decl == error_mark_node)
9071     return NULL_TREE;
9072
9073   if (ctype != NULL_TREE
9074       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9075       && check)
9076     {
9077       tree old_decl;
9078
9079       old_decl = check_classfn (ctype, decl);
9080
9081       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9082         /* Because grokfndecl is always supposed to return a
9083            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9084            here.  We depend on our callers to figure out that its
9085            really a template that's being returned.  */
9086         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9087
9088       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9089           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9090         {
9091           /* Remove the `this' parm added by grokclassfn.
9092              XXX Isn't this done in start_function, too?  */
9093           revert_static_member_fn (decl);
9094           last_function_parms = TREE_CHAIN (last_function_parms);
9095         }
9096       if (old_decl && DECL_ARTIFICIAL (old_decl))
9097         error ("definition of implicitly-declared `%D'", old_decl);
9098
9099       if (old_decl)
9100         {
9101           /* Since we've smashed OLD_DECL to its
9102              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9103           if (TREE_CODE (decl) == TEMPLATE_DECL)
9104             decl = DECL_TEMPLATE_RESULT (decl);
9105
9106           /* Attempt to merge the declarations.  This can fail, in
9107              the case of some invalid specialization declarations.  */
9108           push_scope (ctype);
9109           if (!duplicate_decls (decl, old_decl))
9110             error ("no `%#D' member function declared in class `%T'",
9111                       decl, ctype);
9112           pop_scope (ctype);
9113           return old_decl;
9114         }
9115     }
9116
9117   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9118     return NULL_TREE;
9119
9120   if (ctype == NULL_TREE || check)
9121     return decl;
9122
9123   if (virtualp)
9124     DECL_VIRTUAL_P (decl) = 1;
9125
9126   return decl;
9127 }
9128
9129 /* Create a VAR_DECL named NAME with the indicated TYPE.
9130
9131    If SCOPE is non-NULL, it is the class type or namespace containing
9132    the variable.  If SCOPE is NULL, the variable should is created in
9133    the innermost enclosings scope.  */
9134
9135 static tree
9136 grokvardecl (tree type,
9137              tree name,
9138              RID_BIT_TYPE * specbits_in,
9139              int initialized,
9140              int constp,
9141              tree scope)
9142 {
9143   tree decl;
9144   RID_BIT_TYPE specbits;
9145
9146   my_friendly_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE,
9147                       20020808);
9148
9149   specbits = *specbits_in;
9150
9151   /* Compute the scope in which to place the variable.  */
9152   if (!scope)
9153     {
9154       /* An explicit "extern" specifier indicates a namespace-scope
9155          variable.  */
9156       if (RIDBIT_SETP (RID_EXTERN, specbits))
9157         scope = current_namespace;
9158       else if (!at_function_scope_p ())
9159         {
9160           scope = current_scope ();
9161           if (!scope)
9162             scope = current_namespace;
9163         }
9164     }
9165
9166   if (scope
9167       && (/* If the variable is a namespace-scope variable declared in a
9168              template, we need DECL_LANG_SPECIFIC.  */
9169           (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
9170           /* Similarly for namespace-scope variables with language linkage
9171              other than C++.  */
9172           || (TREE_CODE (scope) == NAMESPACE_DECL
9173               && current_lang_name != lang_name_cplusplus)
9174           /* Similarly for static data members.  */
9175           || TYPE_P (scope)))
9176     decl = build_lang_decl (VAR_DECL, name, type);
9177   else
9178     decl = build_decl (VAR_DECL, name, type);
9179
9180   if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
9181     set_decl_namespace (decl, scope, 0);
9182   else
9183     DECL_CONTEXT (decl) = scope;
9184
9185   if (name && scope && current_lang_name != lang_name_c)
9186     /* We can't mangle lazily here because we don't have any
9187        way to recover whether or not a variable was `extern
9188        "C"' later.  */
9189     mangle_decl (decl);
9190
9191   if (RIDBIT_SETP (RID_EXTERN, specbits))
9192     {
9193       DECL_THIS_EXTERN (decl) = 1;
9194       DECL_EXTERNAL (decl) = !initialized;
9195     }
9196
9197   /* In class context, static means one per class,
9198      public access, and static storage.  */
9199   if (DECL_CLASS_SCOPE_P (decl))
9200     {
9201       TREE_PUBLIC (decl) = 1;
9202       TREE_STATIC (decl) = 1;
9203       DECL_EXTERNAL (decl) = 0;
9204     }
9205   /* At top level, either `static' or no s.c. makes a definition
9206      (perhaps tentative), and absence of `static' makes it public.  */
9207   else if (toplevel_bindings_p ())
9208     {
9209       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9210                             && (DECL_THIS_EXTERN (decl) || ! constp));
9211       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9212     }
9213   /* Not at top level, only `static' makes a static definition.  */
9214   else
9215     {
9216       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9217       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9218     }
9219
9220   if (RIDBIT_SETP (RID_THREAD, specbits))
9221     {
9222       if (targetm.have_tls)
9223         DECL_THREAD_LOCAL (decl) = 1;
9224       else
9225         /* A mere warning is sure to result in improper semantics
9226            at runtime.  Don't bother to allow this to compile.  */
9227         error ("thread-local storage not supported for this target");
9228     }
9229
9230   if (TREE_PUBLIC (decl))
9231     {
9232       /* [basic.link]: A name with no linkage (notably, the name of a class
9233          or enumeration declared in a local scope) shall not be used to
9234          declare an entity with linkage.
9235
9236          Only check this for public decls for now.  */
9237       tree t = no_linkage_check (TREE_TYPE (decl));
9238       if (t)
9239         {
9240           if (TYPE_ANONYMOUS_P (t))
9241             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9242           else
9243             pedwarn ("non-local variable `%#D' uses local type `%T'",
9244                         decl, t);
9245         }
9246     }
9247
9248   return decl;
9249 }
9250
9251 /* Create and return a canonical pointer to member function type, for
9252    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9253
9254 tree
9255 build_ptrmemfunc_type (tree type)
9256 {
9257   tree field, fields;
9258   tree t;
9259   tree unqualified_variant = NULL_TREE;
9260
9261   if (type == error_mark_node)
9262     return type;
9263
9264   /* If a canonical type already exists for this type, use it.  We use
9265      this method instead of type_hash_canon, because it only does a
9266      simple equality check on the list of field members.  */
9267
9268   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9269     return t;
9270
9271   /* Make sure that we always have the unqualified pointer-to-member
9272      type first.  */
9273   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9274     unqualified_variant
9275       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9276
9277   t = make_aggr_type (RECORD_TYPE);
9278   /* Let the front-end know this is a pointer to member function...  */
9279   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9280   /* ... and not really an aggregate.  */
9281   SET_IS_AGGR_TYPE (t, 0);
9282
9283   field = build_decl (FIELD_DECL, pfn_identifier, type);
9284   fields = field;
9285
9286   field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
9287   TREE_CHAIN (field) = fields;
9288   fields = field;
9289
9290   finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
9291
9292   /* Zap out the name so that the back-end will give us the debugging
9293      information for this anonymous RECORD_TYPE.  */
9294   TYPE_NAME (t) = NULL_TREE;
9295
9296   /* If this is not the unqualified form of this pointer-to-member
9297      type, set the TYPE_MAIN_VARIANT for this type to be the
9298      unqualified type.  Since they are actually RECORD_TYPEs that are
9299      not variants of each other, we must do this manually.  */
9300   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9301     {
9302       t = build_qualified_type (t, cp_type_quals (type));
9303       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9304       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9305       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9306     }
9307
9308   /* Cache this pointer-to-member type so that we can find it again
9309      later.  */
9310   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9311
9312   /* Seems to be wanted.  */
9313   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9314
9315   return t;
9316 }
9317
9318 /* Create and return a pointer to data member type.  */
9319
9320 tree
9321 build_ptrmem_type (tree class_type, tree member_type)
9322 {
9323   return build_pointer_type (build_offset_type (class_type, member_type));
9324 }
9325
9326 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9327    Check to see that the definition is valid.  Issue appropriate error
9328    messages.  Return 1 if the definition is particularly bad, or 0
9329    otherwise.  */
9330
9331 int
9332 check_static_variable_definition (tree decl, tree type)
9333 {
9334   /* Motion 10 at San Diego: If a static const integral data member is
9335      initialized with an integral constant expression, the initializer
9336      may appear either in the declaration (within the class), or in
9337      the definition, but not both.  If it appears in the class, the
9338      member is a member constant.  The file-scope definition is always
9339      required.  */
9340   if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
9341     {
9342       error ("invalid in-class initialization of static data member of non-integral type `%T'",
9343              type);
9344       /* If we just return the declaration, crashes will sometimes
9345          occur.  We therefore return void_type_node, as if this was a
9346          friend declaration, to cause callers to completely ignore
9347          this declaration.  */
9348       return 1;
9349     }
9350   else if (!CP_TYPE_CONST_P (type))
9351     error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9352               decl);
9353   else if (pedantic && !INTEGRAL_TYPE_P (type))
9354     pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9355
9356   return 0;
9357 }
9358
9359 /* Given the SIZE (i.e., number of elements) in an array, compute an
9360    appropriate index type for the array.  If non-NULL, NAME is the
9361    name of the thing being declared.  */
9362
9363 tree
9364 compute_array_index_type (tree name, tree size)
9365 {
9366   tree itype;
9367
9368   /* If this involves a template parameter, it will be a constant at
9369      instantiation time, but we don't know what the value is yet.
9370      Even if no template parameters are involved, we may an expression
9371      that is not a constant; we don't even simplify `1 + 2' when
9372      processing a template.  */
9373   if (processing_template_decl)
9374     {
9375       /* Resolve a qualified reference to an enumerator or static
9376          const data member of ours.  */
9377       if (TREE_CODE (size) == SCOPE_REF
9378           && TREE_OPERAND (size, 0) == current_class_type)
9379         {
9380           tree t = lookup_field (current_class_type,
9381                                  TREE_OPERAND (size, 1), 0, 0);
9382           if (t)
9383             size = t;
9384         }
9385
9386       return build_index_type (build_min (MINUS_EXPR, sizetype,
9387                                           size, integer_one_node));
9388     }
9389
9390   /* The size might be the result of a cast.  */
9391   STRIP_TYPE_NOPS (size);
9392
9393   /* It might be a const variable or enumeration constant.  */
9394   size = decl_constant_value (size);
9395
9396   /* The array bound must be an integer type.  */
9397   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9398       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9399       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9400     {
9401       if (name)
9402         error ("size of array `%D' has non-integer type", name);
9403       else
9404         error ("size of array has non-integer type");
9405       size = integer_one_node;
9406     }
9407
9408   /* Normally, the array-bound will be a constant.  */
9409   if (TREE_CODE (size) == INTEGER_CST)
9410     {
9411       /* Check to see if the array bound overflowed.  Make that an
9412          error, no matter how generous we're being.  */
9413       int old_flag_pedantic_errors = flag_pedantic_errors;
9414       int old_pedantic = pedantic;
9415       pedantic = flag_pedantic_errors = 1;
9416       constant_expression_warning (size);
9417       pedantic = old_pedantic;
9418       flag_pedantic_errors = old_flag_pedantic_errors;
9419
9420       /* An array must have a positive number of elements.  */
9421       if (INT_CST_LT (size, integer_zero_node))
9422         {
9423           if (name)
9424             error ("size of array `%D' is negative", name);
9425           else
9426             error ("size of array is negative");
9427           size = integer_one_node;
9428         }
9429       /* Except that an extension we allow zero-sized arrays.  We
9430          always allow them in system headers because glibc uses
9431          them.  */
9432       else if (integer_zerop (size) && pedantic && !in_system_header)
9433         {
9434           if (name)
9435             pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9436           else
9437             pedwarn ("ISO C++ forbids zero-size array");
9438         }
9439     }
9440   else if (TREE_CONSTANT (size))
9441     {
9442       /* `(int) &fn' is not a valid array bound.  */
9443       if (name)
9444         error ("size of array `%D' is not an integral constant-expression",
9445                   name);
9446       else
9447         error ("size of array is not an integral constant-expression");
9448     }
9449
9450   /* Compute the index of the largest element in the array.  It is
9451      one less than the number of elements in the array.  */
9452   itype
9453     = fold (cp_build_binary_op (MINUS_EXPR,
9454                                 cp_convert (ssizetype, size),
9455                                 cp_convert (ssizetype,
9456                                             integer_one_node)));
9457
9458   /* Check for variable-sized arrays.  We allow such things as an
9459      extension, even though they are not allowed in ANSI/ISO C++.  */
9460   if (!TREE_CONSTANT (itype))
9461     {
9462       if (pedantic)
9463         {
9464           if (name)
9465             pedwarn ("ISO C++ forbids variable-size array `%D'",
9466                         name);
9467           else
9468             pedwarn ("ISO C++ forbids variable-size array");
9469         }
9470
9471       /* Create a variable-sized array index type.  */
9472       itype = variable_size (itype);
9473     }
9474   /* Make sure that there was no overflow when creating to a signed
9475      index type.  (For example, on a 32-bit machine, an array with
9476      size 2^32 - 1 is too big.)  */
9477   else if (TREE_OVERFLOW (itype))
9478     {
9479       error ("overflow in array dimension");
9480       TREE_OVERFLOW (itype) = 0;
9481     }
9482
9483   /* Create and return the appropriate index type.  */
9484   return build_index_type (itype);
9485 }
9486
9487 /* Returns the scope (if any) in which the entity declared by
9488    DECLARATOR will be located.  If the entity was declared with an
9489    unqualified name, NULL_TREE is returned.  */
9490
9491 tree
9492 get_scope_of_declarator (tree declarator)
9493 {
9494   if (!declarator)
9495     return NULL_TREE;
9496
9497   switch (TREE_CODE (declarator))
9498     {
9499     case CALL_EXPR:
9500     case ARRAY_REF:
9501     case INDIRECT_REF:
9502     case ADDR_EXPR:
9503       /* For any of these, the main declarator is the first operand.  */
9504       return get_scope_of_declarator (TREE_OPERAND
9505                                       (declarator, 0));
9506
9507     case SCOPE_REF:
9508       /* For a pointer-to-member, continue descending.  */
9509       if (TREE_CODE (TREE_OPERAND (declarator, 1))
9510           == INDIRECT_REF)
9511         return get_scope_of_declarator (TREE_OPERAND
9512                                         (declarator, 1));
9513       /* Otherwise, if the declarator-id is a SCOPE_REF, the scope in
9514          which the declaration occurs is the first operand.  */
9515       return TREE_OPERAND (declarator, 0);
9516
9517     case TREE_LIST:
9518       /* Attributes to be applied. The declarator is TREE_VALUE.  */
9519       return get_scope_of_declarator (TREE_VALUE (declarator));
9520
9521     default:
9522       /* Otherwise, we have a declarator-id which is not a qualified
9523          name; the entity will be declared in the current scope.  */
9524       return NULL_TREE;
9525     }
9526 }
9527
9528 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9529    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9530    with this type.  */
9531
9532 static tree
9533 create_array_type_for_decl (tree name, tree type, tree size)
9534 {
9535   tree itype = NULL_TREE;
9536   const char* error_msg;
9537
9538   /* If things have already gone awry, bail now.  */
9539   if (type == error_mark_node || size == error_mark_node)
9540     return error_mark_node;
9541
9542   /* Assume that everything will go OK.  */
9543   error_msg = NULL;
9544
9545   /* There are some types which cannot be array elements.  */
9546   switch (TREE_CODE (type))
9547     {
9548     case VOID_TYPE:
9549       error_msg = "array of void";
9550       break;
9551
9552     case FUNCTION_TYPE:
9553       error_msg = "array of functions";
9554       break;
9555
9556     case REFERENCE_TYPE:
9557       error_msg = "array of references";
9558       break;
9559
9560     case OFFSET_TYPE:
9561       error_msg = "array of data members";
9562       break;
9563
9564     case METHOD_TYPE:
9565       error_msg = "array of function members";
9566       break;
9567
9568     default:
9569       break;
9570     }
9571
9572   /* If something went wrong, issue an error-message and return.  */
9573   if (error_msg)
9574     {
9575       if (name)
9576         error ("declaration of `%D' as %s", name, error_msg);
9577       else
9578         error ("creating %s", error_msg);
9579
9580       return error_mark_node;
9581     }
9582
9583   /* [dcl.array]
9584
9585      The constant expressions that specify the bounds of the arrays
9586      can be omitted only for the first member of the sequence.  */
9587   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9588     {
9589       if (name)
9590         error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9591                   name);
9592       else
9593         error ("multidimensional array must have bounds for all dimensions except the first");
9594
9595       return error_mark_node;
9596     }
9597
9598   /* Figure out the index type for the array.  */
9599   if (size)
9600     itype = compute_array_index_type (name, size);
9601
9602   return build_cplus_array_type (type, itype);
9603 }
9604
9605 /* Check that it's OK to declare a function with the indicated TYPE.
9606    SFK indicates the kind of special function (if any) that this
9607    function is.  OPTYPE is the type given in a conversion operator
9608    declaration.  Returns the actual return type of the function; that
9609    may be different than TYPE if an error occurs, or for certain
9610    special functions.  */
9611
9612 static tree
9613 check_special_function_return_type (special_function_kind sfk,
9614                                     tree type,
9615                                     tree optype)
9616 {
9617   switch (sfk)
9618     {
9619     case sfk_constructor:
9620       if (type)
9621         error ("return type specification for constructor invalid");
9622
9623       type = void_type_node;
9624       break;
9625
9626     case sfk_destructor:
9627       if (type)
9628         error ("return type specification for destructor invalid");
9629       type = void_type_node;
9630       break;
9631
9632     case sfk_conversion:
9633       if (type && !same_type_p (type, optype))
9634         error ("operator `%T' declared to return `%T'", optype, type);
9635       else if (type)
9636         pedwarn ("return type specified for `operator %T'",  optype);
9637       type = optype;
9638       break;
9639
9640     default:
9641       abort ();
9642       break;
9643     }
9644
9645   return type;
9646 }
9647
9648 /* Given declspecs and a declarator (abstract or otherwise), determine
9649    the name and type of the object declared and construct a DECL node
9650    for it.
9651
9652    DECLSPECS is a chain of tree_list nodes whose value fields
9653     are the storage classes and type specifiers.
9654
9655    DECL_CONTEXT says which syntactic context this declaration is in:
9656      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9657      FUNCDEF for a function definition.  Like NORMAL but a few different
9658       error messages in each case.  Return value may be zero meaning
9659       this definition is too screwy to try to parse.
9660      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9661       handle member functions (which have FIELD context).
9662       Return value may be zero meaning this definition is too screwy to
9663       try to parse.
9664      PARM for a parameter declaration (either within a function prototype
9665       or before a function body).  Make a PARM_DECL, or return void_type_node.
9666      CATCHPARM for a parameter declaration before a catch clause.
9667      TYPENAME if for a typename (in a cast or sizeof).
9668       Don't make a DECL node; just return the ..._TYPE node.
9669      FIELD for a struct or union field; make a FIELD_DECL.
9670      BITFIELD for a field with specified width.
9671    INITIALIZED is 1 if the decl has an initializer.
9672
9673    ATTRLIST is a pointer to the list of attributes, which may be NULL
9674    if there are none; *ATTRLIST may be modified if attributes from inside
9675    the declarator should be applied to the declaration.
9676
9677    When this function is called, scoping variables (such as
9678    CURRENT_CLASS_TYPE) should reflect the scope in which the
9679    declaration occurs, not the scope in which the new declaration will
9680    be placed.  For example, on:
9681
9682      void S::f() { ... }
9683
9684    when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
9685    should not be `S'.  */
9686
9687 tree
9688 grokdeclarator (tree declarator,
9689                 tree declspecs,
9690                 enum decl_context decl_context,
9691                 int initialized,
9692                 tree* attrlist)
9693 {
9694   RID_BIT_TYPE specbits;
9695   int nclasses = 0;
9696   tree spec;
9697   tree type = NULL_TREE;
9698   int longlong = 0;
9699   int type_quals;
9700   int virtualp, explicitp, friendp, inlinep, staticp;
9701   int explicit_int = 0;
9702   int explicit_char = 0;
9703   int defaulted_int = 0;
9704   int extern_langp = 0;
9705   tree dependant_name = NULL_TREE;
9706
9707   tree typedef_decl = NULL_TREE;
9708   const char *name;
9709   tree typedef_type = NULL_TREE;
9710   int funcdef_flag = 0;
9711   enum tree_code innermost_code = ERROR_MARK;
9712   int bitfield = 0;
9713 #if 0
9714   /* See the code below that used this.  */
9715   tree decl_attr = NULL_TREE;
9716 #endif
9717
9718   /* Keep track of what sort of function is being processed
9719      so that we can warn about default return values, or explicit
9720      return values which do not match prescribed defaults.  */
9721   special_function_kind sfk = sfk_none;
9722
9723   tree dname = NULL_TREE;
9724   tree ctype = current_class_type;
9725   tree ctor_return_type = NULL_TREE;
9726   enum overload_flags flags = NO_SPECIAL;
9727   tree quals = NULL_TREE;
9728   tree raises = NULL_TREE;
9729   int template_count = 0;
9730   tree in_namespace = NULL_TREE;
9731   tree returned_attrs = NULL_TREE;
9732   tree scope = NULL_TREE;
9733
9734   RIDBIT_RESET_ALL (specbits);
9735   if (decl_context == FUNCDEF)
9736     funcdef_flag = 1, decl_context = NORMAL;
9737   else if (decl_context == MEMFUNCDEF)
9738     funcdef_flag = -1, decl_context = FIELD;
9739   else if (decl_context == BITFIELD)
9740     bitfield = 1, decl_context = FIELD;
9741
9742   /* Look inside a declarator for the name being declared
9743      and get it as a string, for an error message.  */
9744   {
9745     tree *next = &declarator;
9746     register tree decl;
9747     name = NULL;
9748
9749     while (next && *next)
9750       {
9751         decl = *next;
9752         switch (TREE_CODE (decl))
9753           {
9754           case TREE_LIST:
9755             /* For attributes.  */
9756             next = &TREE_VALUE (decl);
9757             break;
9758
9759           case COND_EXPR:
9760             ctype = NULL_TREE;
9761             next = &TREE_OPERAND (decl, 0);
9762             break;
9763
9764           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9765             {
9766               tree name = TREE_OPERAND (decl, 0);
9767               tree rename = NULL_TREE;
9768
9769               my_friendly_assert (flags == NO_SPECIAL, 152);
9770               flags = DTOR_FLAG;
9771               sfk = sfk_destructor;
9772               if (TYPE_P (name))
9773                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9774               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9775               if (ctype == NULL_TREE)
9776                 {
9777                   if (current_class_type == NULL_TREE)
9778                     {
9779                       error ("destructors must be member functions");
9780                       flags = NO_SPECIAL;
9781                     }
9782                   else
9783                     {
9784                       tree t = constructor_name (current_class_type);
9785                       if (t != name)
9786                         rename = t;
9787                     }
9788                 }
9789               else
9790                 {
9791                   tree t = constructor_name (ctype);
9792                   if (t != name)
9793                     rename = t;
9794                 }
9795
9796               if (rename)
9797                 {
9798                   error ("destructor `%T' must match class name `%T'",
9799                             name, rename);
9800                   TREE_OPERAND (decl, 0) = rename;
9801                 }
9802               next = &name;
9803             }
9804             break;
9805
9806           case ADDR_EXPR:       /* C++ reference declaration */
9807             /* Fall through.  */
9808           case ARRAY_REF:
9809           case INDIRECT_REF:
9810             ctype = NULL_TREE;
9811             innermost_code = TREE_CODE (decl);
9812             next = &TREE_OPERAND (decl, 0);
9813             break;
9814
9815           case CALL_EXPR:
9816             innermost_code = TREE_CODE (decl);
9817             if (decl_context == FIELD && ctype == NULL_TREE)
9818               ctype = current_class_type;
9819             if (ctype
9820                 && TREE_OPERAND (decl, 0)
9821                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9822                     && constructor_name_p (DECL_NAME (TREE_OPERAND (decl, 0)),
9823                                            ctype)))
9824               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9825             next = &TREE_OPERAND (decl, 0);
9826             decl = *next;
9827             if (ctype != NULL_TREE
9828                 && decl != NULL_TREE && flags != DTOR_FLAG
9829                 && constructor_name_p (decl, ctype))
9830               {
9831                 sfk = sfk_constructor;
9832                 ctor_return_type = ctype;
9833               }
9834             ctype = NULL_TREE;
9835             break;
9836
9837           case TEMPLATE_ID_EXPR:
9838               {
9839                 tree fns = TREE_OPERAND (decl, 0);
9840
9841                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9842                   fns = TREE_OPERAND (fns, 0);
9843
9844                 dname = fns;
9845                 if (TREE_CODE (dname) == COMPONENT_REF)
9846                   dname = TREE_OPERAND (dname, 1);
9847                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9848                   {
9849                     my_friendly_assert (is_overloaded_fn (dname),
9850                                         19990331);
9851                     dname = DECL_NAME (get_first_fn (dname));
9852                   }
9853               }
9854           /* Fall through.  */
9855
9856           case IDENTIFIER_NODE:
9857             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9858               dname = decl;
9859
9860             next = 0;
9861
9862             if (C_IS_RESERVED_WORD (dname))
9863               {
9864                 error ("declarator-id missing; using reserved word `%D'",
9865                           dname);
9866                 name = IDENTIFIER_POINTER (dname);
9867               }
9868             else if (!IDENTIFIER_TYPENAME_P (dname))
9869               name = IDENTIFIER_POINTER (dname);
9870             else
9871               {
9872                 my_friendly_assert (flags == NO_SPECIAL, 154);
9873                 flags = TYPENAME_FLAG;
9874                 ctor_return_type = TREE_TYPE (dname);
9875                 sfk = sfk_conversion;
9876                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9877                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9878                         == TYPE_DECL))
9879                   name = IDENTIFIER_POINTER (dname);
9880                 else
9881                   name = "<invalid operator>";
9882               }
9883             break;
9884
9885             /* C++ extension */
9886           case SCOPE_REF:
9887             {
9888               /* Perform error checking, and decide on a ctype.  */
9889               tree cname = TREE_OPERAND (decl, 0);
9890               if (cname == NULL_TREE)
9891                 ctype = NULL_TREE;
9892               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9893                 {
9894                   ctype = NULL_TREE;
9895                   in_namespace = TREE_OPERAND (decl, 0);
9896                 }
9897               else if (! is_aggr_type (cname, 1))
9898                 ctype = NULL_TREE;
9899               /* Must test TREE_OPERAND (decl, 1), in case user gives
9900                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9901               else if (TREE_OPERAND (decl, 1)
9902                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9903                 ctype = cname;
9904               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9905                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9906                 {
9907                   /* This might be declaring a member of a template
9908                      parm to be a friend.  */
9909                   ctype = cname;
9910                   dependant_name = TREE_OPERAND (decl, 1);
9911                 }
9912               else if (ctype == NULL_TREE)
9913                 ctype = cname;
9914               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9915                 ;
9916               else
9917                 {
9918                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9919                     {
9920                       error ("type `%T' is not derived from type `%T'",
9921                                 cname, ctype);
9922                       ctype = NULL_TREE;
9923                     }
9924                   else
9925                     ctype = cname;
9926                 }
9927
9928               /* It is valid to write:
9929
9930                    class C { void f(); };
9931                    typedef C D;
9932                    void D::f();
9933
9934                  The standard is not clear about whether `typedef const C D' is
9935                  legal; as of 2002-09-15 the committee is considering
9936                  that question.  EDG 3.0 allows that syntax.
9937                  Therefore, we do as well.  */
9938               if (ctype)
9939                 ctype = TYPE_MAIN_VARIANT (ctype);
9940               /* Update the declarator so that when we process it
9941                  again the correct type is present.  */
9942               TREE_OPERAND (decl, 0) = ctype;
9943
9944               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9945                   && constructor_name_p (DECL_NAME (TREE_OPERAND (decl, 1)),
9946                                          ctype))
9947                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9948               next = &TREE_OPERAND (decl, 1);
9949               decl = *next;
9950               if (ctype)
9951                 {
9952                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9953                       && constructor_name_p (decl, ctype))
9954                     {
9955                       sfk = sfk_constructor;
9956                       ctor_return_type = ctype;
9957                     }
9958                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9959                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9960                            && constructor_name_p (TREE_OPERAND (decl, 0),
9961                                                   ctype))
9962                     {
9963                       sfk = sfk_destructor;
9964                       ctor_return_type = ctype;
9965                       flags = DTOR_FLAG;
9966                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9967                       next = &TREE_OPERAND (decl, 0);
9968                     }
9969                 }
9970             }
9971             break;
9972
9973           case ERROR_MARK:
9974             next = 0;
9975             break;
9976
9977           case TYPE_DECL:
9978             /* Parse error puts this typespec where
9979                a declarator should go.  */
9980             error ("`%T' specified as declarator-id", DECL_NAME (decl));
9981             if (TREE_TYPE (decl) == current_class_type)
9982               error ("  perhaps you want `%T' for a constructor",
9983                         current_class_name);
9984             dname = DECL_NAME (decl);
9985             name = IDENTIFIER_POINTER (dname);
9986
9987             /* Avoid giving two errors for this.  */
9988             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9989
9990             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9991             *next = dname;
9992             next = 0;
9993             break;
9994
9995           case BASELINK:
9996             next = &BASELINK_FUNCTIONS (decl);
9997             break;
9998
9999           case TEMPLATE_DECL:
10000             /* Sometimes, we see a template-name used as part of a
10001                decl-specifier like in
10002                   std::allocator alloc;
10003                Handle that gracefully.  */
10004             error ("invalid use of template-name '%E' in a declarator", decl);
10005             return error_mark_node;
10006             break;
10007
10008           default:
10009             my_friendly_assert (0, 20020917);
10010           }
10011       }
10012   }
10013
10014   /* A function definition's declarator must have the form of
10015      a function declarator.  */
10016
10017   if (funcdef_flag && innermost_code != CALL_EXPR)
10018     return 0;
10019
10020   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
10021       && innermost_code != CALL_EXPR
10022       && ! (ctype && declspecs == NULL_TREE))
10023     {
10024       error ("declaration of `%D' as non-function", dname);
10025       return void_type_node;
10026     }
10027
10028   /* Anything declared one level down from the top level
10029      must be one of the parameters of a function
10030      (because the body is at least two levels down).  */
10031
10032   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10033      by not allowing C++ class definitions to specify their parameters
10034      with xdecls (must be spec.d in the parmlist).
10035
10036      Since we now wait to push a class scope until we are sure that
10037      we are in a legitimate method context, we must set oldcname
10038      explicitly (since current_class_name is not yet alive).
10039
10040      We also want to avoid calling this a PARM if it is in a namespace.  */
10041
10042   if (decl_context == NORMAL && !toplevel_bindings_p ())
10043     {
10044       struct cp_binding_level *b = current_binding_level;
10045       current_binding_level = b->level_chain;
10046       if (current_binding_level != 0 && toplevel_bindings_p ())
10047         decl_context = PARM;
10048       current_binding_level = b;
10049     }
10050
10051   if (name == NULL)
10052     name = decl_context == PARM ? "parameter" : "type name";
10053
10054   /* Look through the decl specs and record which ones appear.
10055      Some typespecs are defined as built-in typenames.
10056      Others, the ones that are modifiers of other types,
10057      are represented by bits in SPECBITS: set the bits for
10058      the modifiers that appear.  Storage class keywords are also in SPECBITS.
10059
10060      If there is a typedef name or a type, store the type in TYPE.
10061      This includes builtin typedefs such as `int'.
10062
10063      Set EXPLICIT_INT if the type is `int' or `char' and did not
10064      come from a user typedef.
10065
10066      Set LONGLONG if `long' is mentioned twice.
10067
10068      For C++, constructors and destructors have their own fast treatment.  */
10069
10070   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10071     {
10072       register int i;
10073       register tree id;
10074
10075       /* Certain parse errors slip through.  For example,
10076          `int class;' is not caught by the parser. Try
10077          weakly to recover here.  */
10078       if (TREE_CODE (spec) != TREE_LIST)
10079         return 0;
10080
10081       id = TREE_VALUE (spec);
10082
10083       /* If the entire declaration is itself tagged as deprecated then
10084          suppress reports of deprecated items.  */
10085       if (!adding_implicit_members && id && TREE_DEPRECATED (id))
10086         {
10087           if (deprecated_state != DEPRECATED_SUPPRESS)
10088             warn_deprecated_use (id);
10089         }
10090
10091       if (TREE_CODE (id) == IDENTIFIER_NODE)
10092         {
10093           if (id == ridpointers[(int) RID_INT]
10094               || id == ridpointers[(int) RID_CHAR]
10095               || id == ridpointers[(int) RID_BOOL]
10096               || id == ridpointers[(int) RID_WCHAR])
10097             {
10098               if (type)
10099                 {
10100                   if (id == ridpointers[(int) RID_BOOL])
10101                     error ("`bool' is now a keyword");
10102                   else
10103                     error ("extraneous `%T' ignored", id);
10104                 }
10105               else
10106                 {
10107                   if (id == ridpointers[(int) RID_INT])
10108                     explicit_int = 1;
10109                   else if (id == ridpointers[(int) RID_CHAR])
10110                     explicit_char = 1;
10111                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10112                 }
10113               goto found;
10114             }
10115           /* C++ aggregate types.  */
10116           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10117             {
10118               if (type)
10119                 error ("multiple declarations `%T' and `%T'", type, id);
10120               else
10121                 type = IDENTIFIER_TYPE_VALUE (id);
10122               goto found;
10123             }
10124
10125           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10126             {
10127               if (ridpointers[i] == id)
10128                 {
10129                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10130                     {
10131                       if (pedantic && ! in_system_header && warn_long_long)
10132                         pedwarn ("ISO C++ does not support `long long'");
10133                       if (longlong)
10134                         error ("`long long long' is too long for GCC");
10135                       else
10136                         longlong = 1;
10137                     }
10138                   else if (RIDBIT_SETP (i, specbits))
10139                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10140
10141                   /* Diagnose "__thread extern" or "__thread static".  */
10142                   if (RIDBIT_SETP (RID_THREAD, specbits))
10143                     {
10144                       if (i == (int)RID_EXTERN)
10145                         error ("`__thread' before `extern'");
10146                       else if (i == (int)RID_STATIC)
10147                         error ("`__thread' before `static'");
10148                     }
10149
10150                   if (i == (int)RID_EXTERN
10151                       && TREE_PURPOSE (spec) == error_mark_node)
10152                     /* This extern was part of a language linkage.  */
10153                     extern_langp = 1;
10154
10155                   RIDBIT_SET (i, specbits);
10156                   goto found;
10157                 }
10158             }
10159         }
10160       else if (TREE_CODE (id) == TYPE_DECL)
10161         {
10162           if (type)
10163             error ("multiple declarations `%T' and `%T'", type,
10164                       TREE_TYPE (id));
10165           else
10166             {
10167               type = TREE_TYPE (id);
10168               TREE_VALUE (spec) = type;
10169               typedef_decl = id;
10170             }
10171           goto found;
10172         }
10173       if (type)
10174         error ("two or more data types in declaration of `%s'", name);
10175       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10176         {
10177           register tree t = lookup_name (id, 1);
10178           if (!t || TREE_CODE (t) != TYPE_DECL)
10179             error ("`%s' fails to be a typedef or built in type",
10180                    IDENTIFIER_POINTER (id));
10181           else
10182             {
10183               type = TREE_TYPE (t);
10184               typedef_decl = t;
10185             }
10186         }
10187       else if (id != error_mark_node)
10188         /* Can't change CLASS nodes into RECORD nodes here!  */
10189         type = id;
10190
10191     found: ;
10192     }
10193
10194 #if 0
10195   /* See the code below that used this.  */
10196   if (typedef_decl)
10197     decl_attr = DECL_ATTRIBUTES (typedef_decl);
10198 #endif
10199   typedef_type = type;
10200
10201   /* No type at all: default to `int', and set DEFAULTED_INT
10202      because it was not a user-defined typedef.  */
10203
10204   if (type == NULL_TREE
10205       && (RIDBIT_SETP (RID_SIGNED, specbits)
10206           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10207           || RIDBIT_SETP (RID_LONG, specbits)
10208           || RIDBIT_SETP (RID_SHORT, specbits)))
10209     {
10210       /* These imply 'int'.  */
10211       type = integer_type_node;
10212       defaulted_int = 1;
10213     }
10214
10215   if (sfk != sfk_none)
10216     type = check_special_function_return_type (sfk, type,
10217                                                ctor_return_type);
10218   else if (type == NULL_TREE)
10219     {
10220       int is_main;
10221
10222       explicit_int = -1;
10223
10224       /* We handle `main' specially here, because 'main () { }' is so
10225          common.  With no options, it is allowed.  With -Wreturn-type,
10226          it is a warning.  It is only an error with -pedantic-errors.  */
10227       is_main = (funcdef_flag
10228                  && dname && MAIN_NAME_P (dname)
10229                  && ctype == NULL_TREE
10230                  && in_namespace == NULL_TREE
10231                  && current_namespace == global_namespace);
10232
10233       if (in_system_header || flag_ms_extensions)
10234         /* Allow it, sigh.  */;
10235       else if (pedantic || ! is_main)
10236         pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10237                     name);
10238       else if (warn_return_type)
10239         warning ("ISO C++ forbids declaration of `%s' with no type",
10240                     name);
10241
10242       type = integer_type_node;
10243     }
10244
10245   ctype = NULL_TREE;
10246
10247   /* Now process the modifiers that were specified
10248      and check for invalid combinations.  */
10249
10250   /* Long double is a special combination.  */
10251
10252   if (RIDBIT_SETP (RID_LONG, specbits)
10253       && TYPE_MAIN_VARIANT (type) == double_type_node)
10254     {
10255       RIDBIT_RESET (RID_LONG, specbits);
10256       type = build_qualified_type (long_double_type_node,
10257                                    cp_type_quals (type));
10258     }
10259
10260   /* Check all other uses of type modifiers.  */
10261
10262   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10263       || RIDBIT_SETP (RID_SIGNED, specbits)
10264       || RIDBIT_SETP (RID_LONG, specbits)
10265       || RIDBIT_SETP (RID_SHORT, specbits))
10266     {
10267       int ok = 0;
10268
10269       if (TREE_CODE (type) == REAL_TYPE)
10270         error ("short, signed or unsigned invalid for `%s'", name);
10271       else if (TREE_CODE (type) != INTEGER_TYPE)
10272         error ("long, short, signed or unsigned invalid for `%s'", name);
10273       else if (RIDBIT_SETP (RID_LONG, specbits)
10274                && RIDBIT_SETP (RID_SHORT, specbits))
10275         error ("long and short specified together for `%s'", name);
10276       else if ((RIDBIT_SETP (RID_LONG, specbits)
10277                 || RIDBIT_SETP (RID_SHORT, specbits))
10278                && explicit_char)
10279         error ("long or short specified with char for `%s'", name);
10280       else if ((RIDBIT_SETP (RID_LONG, specbits)
10281                 || RIDBIT_SETP (RID_SHORT, specbits))
10282                && TREE_CODE (type) == REAL_TYPE)
10283         error ("long or short specified with floating type for `%s'", name);
10284       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10285                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10286         error ("signed and unsigned given together for `%s'", name);
10287       else
10288         {
10289           ok = 1;
10290           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10291             {
10292               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10293                        name);
10294               if (flag_pedantic_errors)
10295                 ok = 0;
10296             }
10297         }
10298
10299       /* Discard the type modifiers if they are invalid.  */
10300       if (! ok)
10301         {
10302           RIDBIT_RESET (RID_UNSIGNED, specbits);
10303           RIDBIT_RESET (RID_SIGNED, specbits);
10304           RIDBIT_RESET (RID_LONG, specbits);
10305           RIDBIT_RESET (RID_SHORT, specbits);
10306           longlong = 0;
10307         }
10308     }
10309
10310   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10311       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10312     {
10313       error ("complex invalid for `%s'", name);
10314       RIDBIT_RESET (RID_COMPLEX, specbits);
10315     }
10316
10317   /* Decide whether an integer type is signed or not.
10318      Optionally treat bitfields as signed by default.  */
10319   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10320       /* [class.bit]
10321
10322          It is implementation-defined whether a plain (neither
10323          explicitly signed or unsigned) char, short, int, or long
10324          bit-field is signed or unsigned.
10325
10326          Naturally, we extend this to long long as well.  Note that
10327          this does not include wchar_t.  */
10328       || (bitfield && !flag_signed_bitfields
10329           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10330           /* A typedef for plain `int' without `signed' can be
10331              controlled just like plain `int', but a typedef for
10332              `signed int' cannot be so controlled.  */
10333           && !(typedef_decl
10334                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10335           && (TREE_CODE (type) == INTEGER_TYPE
10336               || TREE_CODE (type) == CHAR_TYPE)
10337           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10338     {
10339       if (longlong)
10340         type = long_long_unsigned_type_node;
10341       else if (RIDBIT_SETP (RID_LONG, specbits))
10342         type = long_unsigned_type_node;
10343       else if (RIDBIT_SETP (RID_SHORT, specbits))
10344         type = short_unsigned_type_node;
10345       else if (type == char_type_node)
10346         type = unsigned_char_type_node;
10347       else if (typedef_decl)
10348         type = c_common_unsigned_type (type);
10349       else
10350         type = unsigned_type_node;
10351     }
10352   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10353            && type == char_type_node)
10354     type = signed_char_type_node;
10355   else if (longlong)
10356     type = long_long_integer_type_node;
10357   else if (RIDBIT_SETP (RID_LONG, specbits))
10358     type = long_integer_type_node;
10359   else if (RIDBIT_SETP (RID_SHORT, specbits))
10360     type = short_integer_type_node;
10361
10362   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10363     {
10364       /* If we just have "complex", it is equivalent to
10365          "complex double", but if any modifiers at all are specified it is
10366          the complex form of TYPE.  E.g, "complex short" is
10367          "complex short int".  */
10368
10369       if (defaulted_int && ! longlong
10370           && ! (RIDBIT_SETP (RID_LONG, specbits)
10371                 || RIDBIT_SETP (RID_SHORT, specbits)
10372                 || RIDBIT_SETP (RID_SIGNED, specbits)
10373                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10374         type = complex_double_type_node;
10375       else if (type == integer_type_node)
10376         type = complex_integer_type_node;
10377       else if (type == float_type_node)
10378         type = complex_float_type_node;
10379       else if (type == double_type_node)
10380         type = complex_double_type_node;
10381       else if (type == long_double_type_node)
10382         type = complex_long_double_type_node;
10383       else
10384         type = build_complex_type (type);
10385     }
10386
10387   type_quals = TYPE_UNQUALIFIED;
10388   if (RIDBIT_SETP (RID_CONST, specbits))
10389     type_quals |= TYPE_QUAL_CONST;
10390   if (RIDBIT_SETP (RID_VOLATILE, specbits))
10391     type_quals |= TYPE_QUAL_VOLATILE;
10392   if (RIDBIT_SETP (RID_RESTRICT, specbits))
10393     type_quals |= TYPE_QUAL_RESTRICT;
10394   if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
10395     error ("qualifiers are not allowed on declaration of `operator %T'",
10396               ctor_return_type);
10397
10398   type_quals |= cp_type_quals (type);
10399   type = cp_build_qualified_type_real
10400     (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
10401                          ? tf_ignore_bad_quals : 0) | tf_error | tf_warning));
10402   /* We might have ignored or rejected some of the qualifiers.  */
10403   type_quals = cp_type_quals (type);
10404
10405   staticp = 0;
10406   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10407   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10408   RIDBIT_RESET (RID_VIRTUAL, specbits);
10409   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10410   RIDBIT_RESET (RID_EXPLICIT, specbits);
10411
10412   if (RIDBIT_SETP (RID_STATIC, specbits))
10413     staticp = 1 + (decl_context == FIELD);
10414
10415   if (virtualp && staticp == 2)
10416     {
10417       error ("member `%D' cannot be declared both virtual and static",
10418                 dname);
10419       staticp = 0;
10420     }
10421   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10422   RIDBIT_RESET (RID_FRIEND, specbits);
10423
10424   if (dependant_name && !friendp)
10425     {
10426       error ("`%T::%D' is not a valid declarator", ctype, dependant_name);
10427       return void_type_node;
10428     }
10429
10430   /* Warn if two storage classes are given. Default to `auto'.  */
10431
10432   if (RIDBIT_ANY_SET (specbits))
10433     {
10434       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10435       if (RIDBIT_SETP (RID_EXTERN, specbits) && !extern_langp) nclasses++;
10436       if (RIDBIT_SETP (RID_THREAD, specbits)) nclasses++;
10437       if (decl_context == PARM && nclasses > 0)
10438         error ("storage class specifiers invalid in parameter declarations");
10439       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10440         {
10441           if (decl_context == PARM)
10442             error ("typedef declaration invalid in parameter declaration");
10443           nclasses++;
10444         }
10445       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10446       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10447       if (!nclasses && !friendp && extern_langp)
10448         nclasses++;
10449     }
10450
10451   /* Give error if `virtual' is used outside of class declaration.  */
10452   if (virtualp
10453       && (current_class_name == NULL_TREE || decl_context != FIELD))
10454     {
10455       error ("virtual outside class declaration");
10456       virtualp = 0;
10457     }
10458
10459   /* Static anonymous unions are dealt with here.  */
10460   if (staticp && decl_context == TYPENAME
10461       && TREE_CODE (declspecs) == TREE_LIST
10462       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10463     decl_context = FIELD;
10464
10465   /* Warn about storage classes that are invalid for certain
10466      kinds of declarations (parameters, typenames, etc.).  */
10467
10468   /* "static __thread" and "extern __thread" are allowed.  */
10469   if (nclasses == 2
10470       && RIDBIT_SETP (RID_THREAD, specbits)
10471       && (RIDBIT_SETP (RID_EXTERN, specbits)
10472           || RIDBIT_SETP (RID_STATIC, specbits)))
10473     nclasses = 1;
10474
10475   if (nclasses > 1)
10476     error ("multiple storage classes in declaration of `%s'", name);
10477   else if (decl_context != NORMAL && nclasses > 0)
10478     {
10479       if ((decl_context == PARM || decl_context == CATCHPARM)
10480           && (RIDBIT_SETP (RID_REGISTER, specbits)
10481               || RIDBIT_SETP (RID_AUTO, specbits)))
10482         ;
10483       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10484         ;
10485       else if (decl_context == FIELD
10486                /* C++ allows static class elements  */
10487                && RIDBIT_SETP (RID_STATIC, specbits))
10488         /* C++ also allows inlines and signed and unsigned elements,
10489            but in those cases we don't come in here.  */
10490         ;
10491       else
10492         {
10493           if (decl_context == FIELD)
10494             {
10495               tree tmp = NULL_TREE;
10496               register int op = 0;
10497
10498               if (declarator)
10499                 {
10500                   /* Avoid trying to get an operand off an identifier node.  */
10501                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10502                     tmp = declarator;
10503                   else
10504                     tmp = TREE_OPERAND (declarator, 0);
10505                   op = IDENTIFIER_OPNAME_P (tmp);
10506                   if (IDENTIFIER_TYPENAME_P (tmp))
10507                     {
10508                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10509                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10510                               == TYPE_DECL))
10511                         name = IDENTIFIER_POINTER (tmp);
10512                       else
10513                         name = "<invalid operator>";
10514                     }
10515                 }
10516               error ("storage class specified for %s `%s'",
10517                      op ? "member operator" : "field",
10518                      name);
10519             }
10520           else
10521             {
10522               if (decl_context == PARM || decl_context == CATCHPARM)
10523                 error ("storage class specified for parameter `%s'", name);
10524               else
10525                 error ("storage class specified for typename");
10526             }
10527           RIDBIT_RESET (RID_REGISTER, specbits);
10528           RIDBIT_RESET (RID_AUTO, specbits);
10529           RIDBIT_RESET (RID_EXTERN, specbits);
10530           RIDBIT_RESET (RID_THREAD, specbits);
10531         }
10532     }
10533   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10534     {
10535       if (toplevel_bindings_p ())
10536         {
10537           /* It's common practice (and completely valid) to have a const
10538              be initialized and declared extern.  */
10539           if (!(type_quals & TYPE_QUAL_CONST))
10540             warning ("`%s' initialized and declared `extern'", name);
10541         }
10542       else
10543         error ("`%s' has both `extern' and initializer", name);
10544     }
10545   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10546            && ! toplevel_bindings_p ())
10547     error ("nested function `%s' declared `extern'", name);
10548   else if (toplevel_bindings_p ())
10549     {
10550       if (RIDBIT_SETP (RID_AUTO, specbits))
10551         error ("top-level declaration of `%s' specifies `auto'", name);
10552     }
10553   else if (RIDBIT_SETP (RID_THREAD, specbits)
10554            && !RIDBIT_SETP (RID_EXTERN, specbits)
10555            && !RIDBIT_SETP (RID_STATIC, specbits))
10556     {
10557       error ("function-scope `%s' implicitly auto and declared `__thread'",
10558              name);
10559       RIDBIT_RESET (RID_THREAD, specbits);
10560     }
10561
10562   if (nclasses > 0 && friendp)
10563     error ("storage class specifiers invalid in friend function declarations");
10564
10565   scope = get_scope_of_declarator (declarator);
10566
10567   /* Now figure out the structure of the declarator proper.
10568      Descend through it, creating more complex types, until we reach
10569      the declared identifier (or NULL_TREE, in an abstract declarator).  */
10570
10571   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10572          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10573     {
10574       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10575          an INDIRECT_REF (for *...),
10576          a CALL_EXPR (for ...(...)),
10577          an identifier (for the name being declared)
10578          or a null pointer (for the place in an absolute declarator
10579          where the name was omitted).
10580          For the last two cases, we have just exited the loop.
10581
10582          For C++ it could also be
10583          a SCOPE_REF (for class :: ...).  In this case, we have converted
10584          sensible names to types, and those are the values we use to
10585          qualify the member name.
10586          an ADDR_EXPR (for &...),
10587          a BIT_NOT_EXPR (for destructors)
10588
10589          At this point, TYPE is the type of elements of an array,
10590          or for a function to return, or for a pointer to point to.
10591          After this sequence of ifs, TYPE is the type of the
10592          array or function or pointer, and DECLARATOR has had its
10593          outermost layer removed.  */
10594
10595       if (type == error_mark_node)
10596         {
10597           if (TREE_CODE (declarator) == SCOPE_REF)
10598             declarator = TREE_OPERAND (declarator, 1);
10599           else
10600             declarator = TREE_OPERAND (declarator, 0);
10601           continue;
10602         }
10603       if (quals != NULL_TREE
10604           && (declarator == NULL_TREE
10605               || TREE_CODE (declarator) != SCOPE_REF))
10606         {
10607           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10608             ctype = TYPE_METHOD_BASETYPE (type);
10609           if (ctype != NULL_TREE)
10610             {
10611               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10612               grok_method_quals (ctype, dummy, quals);
10613               type = TREE_TYPE (dummy);
10614               quals = NULL_TREE;
10615             }
10616         }
10617
10618       switch (TREE_CODE (declarator))
10619         {
10620         case TREE_LIST:
10621           {
10622             /* We encode a declarator with embedded attributes using
10623                a TREE_LIST.  */
10624             tree attrs = TREE_PURPOSE (declarator);
10625             tree inner_decl;
10626             int attr_flags;
10627
10628             declarator = TREE_VALUE (declarator);
10629             inner_decl = declarator;
10630             while (inner_decl != NULL_TREE
10631                    && TREE_CODE (inner_decl) == TREE_LIST)
10632               inner_decl = TREE_VALUE (inner_decl);
10633             attr_flags = 0;
10634             if (inner_decl == NULL_TREE
10635                 || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
10636               attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
10637             if (TREE_CODE (inner_decl) == CALL_EXPR)
10638               attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
10639             if (TREE_CODE (inner_decl) == ARRAY_REF)
10640               attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
10641             returned_attrs = decl_attributes (&type,
10642                                               chainon (returned_attrs, attrs),
10643                                               attr_flags);
10644           }
10645           break;
10646
10647         case ARRAY_REF:
10648           {
10649             register tree size;
10650
10651             size = TREE_OPERAND (declarator, 1);
10652
10653             /* VC++ spells a zero-sized array with [].  */
10654             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10655                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10656               size = integer_zero_node;
10657
10658             declarator = TREE_OPERAND (declarator, 0);
10659
10660             type = create_array_type_for_decl (dname, type, size);
10661
10662             ctype = NULL_TREE;
10663           }
10664           break;
10665
10666         case CALL_EXPR:
10667           {
10668             tree arg_types;
10669             int funcdecl_p;
10670             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10671             tree inner_decl = TREE_OPERAND (declarator, 0);
10672
10673             /* Declaring a function type.
10674                Make sure we have a valid type for the function to return.  */
10675
10676             /* We now know that the TYPE_QUALS don't apply to the
10677                decl, but to its return type.  */
10678             type_quals = TYPE_UNQUALIFIED;
10679
10680             /* Warn about some types functions can't return.  */
10681
10682             if (TREE_CODE (type) == FUNCTION_TYPE)
10683               {
10684                 error ("`%s' declared as function returning a function", name);
10685                 type = integer_type_node;
10686               }
10687             if (TREE_CODE (type) == ARRAY_TYPE)
10688               {
10689                 error ("`%s' declared as function returning an array", name);
10690                 type = integer_type_node;
10691               }
10692
10693             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10694               inner_decl = TREE_OPERAND (inner_decl, 1);
10695
10696             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10697               inner_decl = dname;
10698
10699             /* Pick up type qualifiers which should be applied to `this'.  */
10700             quals = CALL_DECLARATOR_QUALS (declarator);
10701
10702             /* Pick up the exception specifications.  */
10703             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10704
10705             /* Say it's a definition only for the CALL_EXPR
10706                closest to the identifier.  */
10707             funcdecl_p
10708               = inner_decl
10709               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10710                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10711                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10712
10713             if (ctype == NULL_TREE
10714                 && decl_context == FIELD
10715                 && funcdecl_p
10716                 && (friendp == 0 || dname == current_class_name))
10717               ctype = current_class_type;
10718
10719             if (ctype && sfk == sfk_conversion)
10720               TYPE_HAS_CONVERSION (ctype) = 1;
10721             if (ctype && constructor_name_p (dname, ctype))
10722               {
10723                 /* We are within a class's scope. If our declarator name
10724                    is the same as the class name, and we are defining
10725                    a function, then it is a constructor/destructor, and
10726                    therefore returns a void type.  */
10727
10728                 if (flags == DTOR_FLAG)
10729                   {
10730                     /* ISO C++ 12.4/2.  A destructor may not be
10731                        declared const or volatile.  A destructor may
10732                        not be static.  */
10733                     if (staticp == 2)
10734                       error ("destructor cannot be static member function");
10735                     if (quals)
10736                       {
10737                         error ("destructors may not be `%s'",
10738                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10739                         quals = NULL_TREE;
10740                       }
10741                     if (decl_context == FIELD)
10742                       {
10743                         if (! member_function_or_else (ctype,
10744                                                        current_class_type,
10745                                                        flags))
10746                           return void_type_node;
10747                       }
10748                   }
10749                 else            /* It's a constructor.  */
10750                   {
10751                     if (explicitp == 1)
10752                       explicitp = 2;
10753                     /* ISO C++ 12.1.  A constructor may not be
10754                        declared const or volatile.  A constructor may
10755                        not be virtual.  A constructor may not be
10756                        static.  */
10757                     if (staticp == 2)
10758                       error ("constructor cannot be static member function");
10759                     if (virtualp)
10760                       {
10761                         pedwarn ("constructors cannot be declared virtual");
10762                         virtualp = 0;
10763                       }
10764                     if (quals)
10765                       {
10766                         error ("constructors may not be `%s'",
10767                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10768                         quals = NULL_TREE;
10769                       }
10770                     {
10771                       RID_BIT_TYPE tmp_bits;
10772                       memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
10773                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10774                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10775                       if (RIDBIT_ANY_SET (tmp_bits))
10776                         error ("return value type specifier for constructor ignored");
10777                     }
10778                     if (decl_context == FIELD)
10779                       {
10780                         if (! member_function_or_else (ctype,
10781                                                        current_class_type,
10782                                                        flags))
10783                           return void_type_node;
10784                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10785                         if (sfk != sfk_constructor)
10786                           return NULL_TREE;
10787                       }
10788                   }
10789                 if (decl_context == FIELD)
10790                   staticp = 0;
10791               }
10792             else if (friendp)
10793               {
10794                 if (initialized)
10795                   error ("can't initialize friend function `%s'", name);
10796                 if (virtualp)
10797                   {
10798                     /* Cannot be both friend and virtual.  */
10799                     error ("virtual functions cannot be friends");
10800                     RIDBIT_RESET (RID_FRIEND, specbits);
10801                     friendp = 0;
10802                   }
10803                 if (decl_context == NORMAL)
10804                   error ("friend declaration not in class definition");
10805                 if (current_function_decl && funcdef_flag)
10806                   error ("can't define friend function `%s' in a local class definition",
10807                             name);
10808               }
10809
10810             /* Construct the function type and go to the next
10811                inner layer of declarator.  */
10812
10813             declarator = TREE_OPERAND (declarator, 0);
10814
10815             /* FIXME: This is where default args should be fully
10816                processed.  */
10817
10818             arg_types = grokparms (inner_parms);
10819
10820             if (declarator && flags == DTOR_FLAG)
10821               {
10822                 /* A destructor declared in the body of a class will
10823                    be represented as a BIT_NOT_EXPR.  But, we just
10824                    want the underlying IDENTIFIER.  */
10825                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10826                   declarator = TREE_OPERAND (declarator, 0);
10827
10828                 if (arg_types != void_list_node)
10829                   {
10830                     error ("destructors may not have parameters");
10831                     arg_types = void_list_node;
10832                     last_function_parms = NULL_TREE;
10833                   }
10834               }
10835
10836             /* ANSI says that `const int foo ();'
10837                does not make the function foo const.  */
10838             type = build_function_type (type, arg_types);
10839           }
10840           break;
10841
10842         case ADDR_EXPR:
10843         case INDIRECT_REF:
10844           /* Filter out pointers-to-references and references-to-references.
10845              We can get these if a TYPE_DECL is used.  */
10846
10847           if (TREE_CODE (type) == REFERENCE_TYPE)
10848             {
10849               error (TREE_CODE (declarator) == ADDR_EXPR
10850                      ? "cannot declare reference to `%#T'"
10851                      : "cannot declare pointer to `%#T'", type);
10852               type = TREE_TYPE (type);
10853             }
10854           else if (VOID_TYPE_P (type)
10855                    && (ctype || TREE_CODE (declarator) == ADDR_EXPR))
10856             error (ctype ? "cannot declare pointer to `%#T' member"
10857                      : "cannot declare reference to `%#T'", type);
10858
10859           /* Merge any constancy or volatility into the target type
10860              for the pointer.  */
10861
10862           /* We now know that the TYPE_QUALS don't apply to the decl,
10863              but to the target of the pointer.  */
10864           type_quals = TYPE_UNQUALIFIED;
10865
10866           if (TREE_CODE (declarator) == ADDR_EXPR)
10867             {
10868               if (!VOID_TYPE_P (type))
10869                 type = build_reference_type (type);
10870             }
10871           else if (TREE_CODE (type) == METHOD_TYPE)
10872             type = build_ptrmemfunc_type (build_pointer_type (type));
10873           else if (ctype)
10874             type = build_ptrmem_type (ctype, type);
10875           else
10876             type = build_pointer_type (type);
10877
10878           /* Process a list of type modifier keywords (such as
10879              const or volatile) that were given inside the `*' or `&'.  */
10880
10881           if (TREE_TYPE (declarator))
10882             {
10883               register tree typemodlist;
10884               int erred = 0;
10885               int constp = 0;
10886               int volatilep = 0;
10887               int restrictp = 0;
10888
10889               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10890                    typemodlist = TREE_CHAIN (typemodlist))
10891                 {
10892                   tree qualifier = TREE_VALUE (typemodlist);
10893
10894                   if (qualifier == ridpointers[(int) RID_CONST])
10895                     {
10896                       constp++;
10897                       type_quals |= TYPE_QUAL_CONST;
10898                     }
10899                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10900                     {
10901                       volatilep++;
10902                       type_quals |= TYPE_QUAL_VOLATILE;
10903                     }
10904                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10905                     {
10906                       restrictp++;
10907                       type_quals |= TYPE_QUAL_RESTRICT;
10908                     }
10909                   else if (!erred)
10910                     {
10911                       erred = 1;
10912                       error ("invalid type modifier within pointer declarator");
10913                     }
10914                 }
10915               if (constp > 1)
10916                 pedwarn ("duplicate `const'");
10917               if (volatilep > 1)
10918                 pedwarn ("duplicate `volatile'");
10919               if (restrictp > 1)
10920                 pedwarn ("duplicate `restrict'");
10921               type = cp_build_qualified_type (type, type_quals);
10922               type_quals = cp_type_quals (type);
10923             }
10924           declarator = TREE_OPERAND (declarator, 0);
10925           ctype = NULL_TREE;
10926           break;
10927
10928         case SCOPE_REF:
10929           {
10930             /* We have converted type names to NULL_TREE if the
10931                name was bogus, or to a _TYPE node, if not.
10932
10933                The variable CTYPE holds the type we will ultimately
10934                resolve to.  The code here just needs to build
10935                up appropriate member types.  */
10936             tree sname = TREE_OPERAND (declarator, 1);
10937             tree t;
10938
10939             /* Destructors can have their visibilities changed as well.  */
10940             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10941               sname = TREE_OPERAND (sname, 0);
10942
10943             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10944               {
10945                 /* We had a reference to a global decl, or
10946                    perhaps we were given a non-aggregate typedef,
10947                    in which case we cleared this out, and should just
10948                    keep going as though it wasn't there.  */
10949                 declarator = sname;
10950                 continue;
10951               }
10952             ctype = TREE_OPERAND (declarator, 0);
10953
10954             t = ctype;
10955             while (t != NULL_TREE && CLASS_TYPE_P (t))
10956               {
10957                 /* You're supposed to have one `template <...>'
10958                    for every template class, but you don't need one
10959                    for a full specialization.  For example:
10960
10961                      template <class T> struct S{};
10962                      template <> struct S<int> { void f(); };
10963                      void S<int>::f () {}
10964
10965                    is correct; there shouldn't be a `template <>' for
10966                    the definition of `S<int>::f'.  */
10967                 if (CLASSTYPE_TEMPLATE_INFO (t)
10968                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10969                         || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
10970                     && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
10971                   template_count += 1;
10972
10973                 t = TYPE_MAIN_DECL (t);
10974                 t = DECL_CONTEXT (t);
10975               }
10976
10977             if (sname == NULL_TREE)
10978               goto done_scoping;
10979
10980             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10981               {
10982                 /* This is the `standard' use of the scoping operator:
10983                    basetype :: member .  */
10984
10985                 if (ctype == current_class_type)
10986                   {
10987                     /* class A {
10988                          void A::f ();
10989                        };
10990
10991                        Is this ill-formed?  */
10992
10993                     if (pedantic)
10994                       pedwarn ("extra qualification `%T::' on member `%s' ignored",
10995                                   ctype, name);
10996                   }
10997                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10998                   {
10999                     if (current_class_type == NULL_TREE || friendp)
11000                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11001                                                       TYPE_ARG_TYPES (type));
11002                     else
11003                       {
11004                         error ("cannot declare member function `%T::%s' within `%T'",
11005                                   ctype, name, current_class_type);
11006                         return error_mark_node;
11007                       }
11008                   }
11009                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
11010                          || COMPLETE_TYPE_P (complete_type (ctype)))
11011                   {
11012                     /* Have to move this code elsewhere in this function.
11013                        this code is used for i.e., typedef int A::M; M *pm;
11014
11015                        It is?  How? jason 10/2/94 */
11016
11017                     if (current_class_type)
11018                       {
11019                         error ("cannot declare member `%T::%s' within `%T'",
11020                                   ctype, name, current_class_type);
11021                         return void_type_node;
11022                       }
11023                   }
11024                 else
11025                   {
11026                     cxx_incomplete_type_error (NULL_TREE, ctype);
11027                     return error_mark_node;
11028                   }
11029
11030                 declarator = sname;
11031               }
11032             else if (TREE_CODE (sname) == SCOPE_REF)
11033               abort ();
11034             else
11035               {
11036               done_scoping:
11037                 declarator = TREE_OPERAND (declarator, 1);
11038                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
11039                   /* In this case, we will deal with it later.  */
11040                   ;
11041                 else if (TREE_CODE (type) == FUNCTION_TYPE)
11042                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11043                                                   TYPE_ARG_TYPES (type));
11044               }
11045           }
11046           break;
11047
11048         case BIT_NOT_EXPR:
11049           declarator = TREE_OPERAND (declarator, 0);
11050           break;
11051
11052         case BASELINK:
11053           declarator = BASELINK_FUNCTIONS (declarator);
11054           break;
11055
11056         case RECORD_TYPE:
11057         case UNION_TYPE:
11058         case ENUMERAL_TYPE:
11059           declarator = NULL_TREE;
11060           break;
11061
11062         case ERROR_MARK:
11063           declarator = NULL_TREE;
11064           break;
11065
11066         default:
11067           abort ();
11068         }
11069     }
11070
11071   if (returned_attrs)
11072     {
11073       if (attrlist)
11074         *attrlist = chainon (returned_attrs, *attrlist);
11075       else
11076         attrlist = &returned_attrs;
11077     }
11078
11079   /* Now TYPE has the actual type.  */
11080
11081   /* Did array size calculations overflow?  */
11082
11083   if (TREE_CODE (type) == ARRAY_TYPE
11084       && COMPLETE_TYPE_P (type)
11085       && TREE_OVERFLOW (TYPE_SIZE (type)))
11086     {
11087       error ("size of array `%s' is too large", name);
11088       /* If we proceed with the array type as it is, we'll eventually
11089          crash in tree_low_cst().  */
11090       type = error_mark_node;
11091     }
11092
11093   if (decl_context == FIELD
11094       && !processing_template_decl
11095       && variably_modified_type_p (type))
11096     {
11097       error ("data member may not have variably modified type `%T'", type);
11098       type = error_mark_node;
11099     }
11100
11101   if (explicitp == 1 || (explicitp && friendp))
11102     {
11103       /* [dcl.fct.spec] The explicit specifier shall only be used in
11104          declarations of constructors within a class definition.  */
11105       error ("only declarations of constructors can be `explicit'");
11106       explicitp = 0;
11107     }
11108
11109   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11110     {
11111       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11112         {
11113           error ("non-member `%s' cannot be declared `mutable'", name);
11114           RIDBIT_RESET (RID_MUTABLE, specbits);
11115         }
11116       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11117         {
11118           error ("non-object member `%s' cannot be declared `mutable'", name);
11119           RIDBIT_RESET (RID_MUTABLE, specbits);
11120         }
11121       else if (TREE_CODE (type) == FUNCTION_TYPE
11122                || TREE_CODE (type) == METHOD_TYPE)
11123         {
11124           error ("function `%s' cannot be declared `mutable'", name);
11125           RIDBIT_RESET (RID_MUTABLE, specbits);
11126         }
11127       else if (staticp)
11128         {
11129           error ("static `%s' cannot be declared `mutable'", name);
11130           RIDBIT_RESET (RID_MUTABLE, specbits);
11131         }
11132       else if (type_quals & TYPE_QUAL_CONST)
11133         {
11134           error ("const `%s' cannot be declared `mutable'", name);
11135           RIDBIT_RESET (RID_MUTABLE, specbits);
11136         }
11137     }
11138
11139   if (declarator == NULL_TREE
11140       || TREE_CODE (declarator) == IDENTIFIER_NODE
11141       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11142           && (TREE_CODE (type) == FUNCTION_TYPE
11143               || TREE_CODE (type) == METHOD_TYPE)))
11144     /* OK */;
11145   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11146     {
11147       error ("template-id `%D' used as a declarator", declarator);
11148       declarator = dname;
11149     }
11150   else
11151     /* Unexpected declarator format.  */
11152     abort ();
11153
11154   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11155
11156   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11157     {
11158       tree decl;
11159
11160       /* Note that the grammar rejects storage classes
11161          in typenames, fields or parameters.  */
11162       if (current_lang_name == lang_name_java)
11163         TYPE_FOR_JAVA (type) = 1;
11164
11165       if (decl_context == FIELD)
11166         {
11167           if (constructor_name_p (declarator, current_class_type))
11168             pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11169                         declarator);
11170           decl = build_lang_decl (TYPE_DECL, declarator, type);
11171         }
11172       else
11173         {
11174           decl = build_decl (TYPE_DECL, declarator, type);
11175           if (in_namespace || ctype)
11176             cp_error_at ("typedef name may not be a nested-name-specifier",
11177                          decl);
11178           if (!current_function_decl)
11179             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11180         }
11181
11182       /* If the user declares "typedef struct {...} foo" then the
11183          struct will have an anonymous name.  Fill that name in now.
11184          Nothing can refer to it, so nothing needs know about the name
11185          change.  */
11186       if (type != error_mark_node
11187           && declarator
11188           && TYPE_NAME (type)
11189           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11190           && TYPE_ANONYMOUS_P (type)
11191           /* Don't do this if there are attributes.  */
11192           && (!attrlist || !*attrlist)
11193           && cp_type_quals (type) == TYPE_UNQUALIFIED)
11194         {
11195           tree oldname = TYPE_NAME (type);
11196           tree t;
11197
11198           /* Replace the anonymous name with the real name everywhere.  */
11199           lookup_tag_reverse (type, declarator);
11200           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11201             if (TYPE_NAME (t) == oldname)
11202               TYPE_NAME (t) = decl;
11203
11204           if (TYPE_LANG_SPECIFIC (type))
11205             TYPE_WAS_ANONYMOUS (type) = 1;
11206
11207           /* If this is a typedef within a template class, the nested
11208              type is a (non-primary) template.  The name for the
11209              template needs updating as well.  */
11210           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11211             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11212               = TYPE_IDENTIFIER (type);
11213
11214           /* FIXME remangle member functions; member functions of a
11215              type with external linkage have external linkage.  */
11216         }
11217
11218       if (quals)
11219         {
11220           if (ctype == NULL_TREE)
11221             {
11222               if (TREE_CODE (type) != METHOD_TYPE)
11223                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11224               else
11225                 ctype = TYPE_METHOD_BASETYPE (type);
11226             }
11227           if (ctype != NULL_TREE)
11228             grok_method_quals (ctype, decl, quals);
11229         }
11230
11231       if (RIDBIT_SETP (RID_SIGNED, specbits)
11232           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11233         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11234
11235       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11236                       inlinep, friendp, raises != NULL_TREE);
11237
11238       return decl;
11239     }
11240
11241   /* Detect the case of an array type of unspecified size
11242      which came, as such, direct from a typedef name.
11243      We must copy the type, so that the array's domain can be
11244      individually set by the object's initializer.  */
11245
11246   if (type && typedef_type
11247       && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
11248       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
11249     type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
11250
11251   /* Detect where we're using a typedef of function type to declare a
11252      function. last_function_parms will not be set, so we must create
11253      it now.  */
11254
11255   if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
11256     {
11257       tree decls = NULL_TREE;
11258       tree args;
11259
11260       for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
11261         {
11262           tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
11263
11264           TREE_CHAIN (decl) = decls;
11265           decls = decl;
11266         }
11267
11268       last_function_parms = nreverse (decls);
11269     }
11270
11271   /* If this is a type name (such as, in a cast or sizeof),
11272      compute the type and return it now.  */
11273
11274   if (decl_context == TYPENAME)
11275     {
11276       /* Note that the grammar rejects storage classes
11277          in typenames, fields or parameters.  */
11278       if (type_quals != TYPE_UNQUALIFIED)
11279         type_quals = TYPE_UNQUALIFIED;
11280
11281       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11282       if (friendp)
11283         {
11284           if (type_quals != TYPE_UNQUALIFIED)
11285             {
11286               error ("type qualifiers specified for friend class declaration");
11287               type_quals = TYPE_UNQUALIFIED;
11288             }
11289           if (inlinep)
11290             {
11291               error ("`inline' specified for friend class declaration");
11292               inlinep = 0;
11293             }
11294
11295           if (!current_aggr)
11296             {
11297               /* Don't allow friend declaration without a class-key.  */
11298               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11299                 pedwarn ("template parameters cannot be friends");
11300               else if (TREE_CODE (type) == TYPENAME_TYPE)
11301                 pedwarn ("friend declaration requires class-key, "
11302                          "i.e. `friend class %T::%D'",
11303                          TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
11304               else
11305                 pedwarn ("friend declaration requires class-key, "
11306                          "i.e. `friend %#T'",
11307                          type);
11308             }
11309
11310           /* Only try to do this stuff if we didn't already give up.  */
11311           if (type != integer_type_node)
11312             {
11313               /* A friendly class?  */
11314               if (current_class_type)
11315                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11316               else
11317                 error ("trying to make class `%T' a friend of global scope",
11318                           type);
11319
11320               type = void_type_node;
11321             }
11322         }
11323       else if (quals)
11324         {
11325           if (ctype == NULL_TREE)
11326             {
11327               if (TREE_CODE (type) != METHOD_TYPE)
11328                 error ("invalid qualifiers on non-member function type");
11329               else
11330                 ctype = TYPE_METHOD_BASETYPE (type);
11331             }
11332           if (ctype)
11333             {
11334               tree dummy = build_decl (TYPE_DECL, declarator, type);
11335               grok_method_quals (ctype, dummy, quals);
11336               type = TREE_TYPE (dummy);
11337             }
11338         }
11339
11340       return type;
11341     }
11342   else if (declarator == NULL_TREE && decl_context != PARM
11343            && decl_context != CATCHPARM
11344            && TREE_CODE (type) != UNION_TYPE
11345            && ! bitfield)
11346     {
11347       error ("abstract declarator `%T' used as declaration", type);
11348       declarator = make_anon_name ();
11349     }
11350
11351   /* `void' at top level (not within pointer)
11352      is allowed only in typedefs or type names.
11353      We don't complain about parms either, but that is because
11354      a better error message can be made later.  */
11355
11356   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11357     {
11358       if (! declarator)
11359         error ("unnamed variable or field declared void");
11360       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11361         {
11362           if (IDENTIFIER_OPNAME_P (declarator))
11363             abort ();
11364           else
11365             error ("variable or field `%s' declared void", name);
11366         }
11367       else
11368         error ("variable or field declared void");
11369       type = integer_type_node;
11370     }
11371
11372   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11373      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11374
11375   if (decl_context == PARM || decl_context == CATCHPARM)
11376     {
11377       if (ctype || in_namespace)
11378         error ("cannot use `::' in parameter declaration");
11379
11380       /* A parameter declared as an array of T is really a pointer to T.
11381          One declared as a function is really a pointer to a function.
11382          One declared as a member is really a pointer to member.  */
11383
11384       if (TREE_CODE (type) == ARRAY_TYPE)
11385         {
11386           /* Transfer const-ness of array into that of type pointed to.  */
11387           type = build_pointer_type (TREE_TYPE (type));
11388           type_quals = TYPE_UNQUALIFIED;
11389         }
11390       else if (TREE_CODE (type) == FUNCTION_TYPE)
11391         type = build_pointer_type (type);
11392       else if (TREE_CODE (type) == OFFSET_TYPE)
11393         type = build_pointer_type (type);
11394     }
11395
11396   {
11397     register tree decl;
11398
11399     if (decl_context == PARM)
11400       {
11401         decl = cp_build_parm_decl (declarator, type);
11402
11403         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11404                         inlinep, friendp, raises != NULL_TREE);
11405       }
11406     else if (decl_context == FIELD)
11407       {
11408         if (type == error_mark_node)
11409           {
11410             /* Happens when declaring arrays of sizes which
11411                are error_mark_node, for example.  */
11412             decl = NULL_TREE;
11413           }
11414         else if (in_namespace && !friendp)
11415           {
11416             /* Something like struct S { int N::j; };  */
11417             error ("invalid use of `::'");
11418             decl = NULL_TREE;
11419           }
11420         else if (TREE_CODE (type) == FUNCTION_TYPE)
11421           {
11422             int publicp = 0;
11423             tree function_context;
11424
11425             /* We catch the others as conflicts with the builtin
11426                typedefs.  */
11427             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11428               {
11429                 error ("function `%D' cannot be declared friend",
11430                           declarator);
11431                 friendp = 0;
11432               }
11433
11434             if (friendp == 0)
11435               {
11436                 if (ctype == NULL_TREE)
11437                   ctype = current_class_type;
11438
11439                 if (ctype == NULL_TREE)
11440                   {
11441                     error ("can't make `%D' into a method -- not in a class",
11442                               declarator);
11443                     return void_type_node;
11444                   }
11445
11446                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11447                    ARM 9.5 */
11448                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11449                   {
11450                     error ("function `%D' declared virtual inside a union",
11451                               declarator);
11452                     return void_type_node;
11453                   }
11454
11455                 if (declarator == ansi_opname (NEW_EXPR)
11456                     || declarator == ansi_opname (VEC_NEW_EXPR)
11457                     || declarator == ansi_opname (DELETE_EXPR)
11458                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11459                   {
11460                     if (virtualp)
11461                       {
11462                         error ("`%D' cannot be declared virtual, since it is always static",
11463                                   declarator);
11464                         virtualp = 0;
11465                       }
11466                   }
11467                 else if (staticp < 2)
11468                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11469                                                   TYPE_ARG_TYPES (type));
11470               }
11471
11472             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11473             function_context = (ctype != NULL_TREE) ?
11474               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11475             publicp = (! friendp || ! staticp)
11476               && function_context == NULL_TREE;
11477             decl = grokfndecl (ctype, type,
11478                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11479                                ? declarator : dname,
11480                                declarator,
11481                                virtualp, flags, quals, raises,
11482                                friendp ? -1 : 0, friendp, publicp, inlinep,
11483                                funcdef_flag, template_count, in_namespace);
11484             if (decl == NULL_TREE)
11485               return decl;
11486 #if 0
11487             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11488             /* The decl and setting of decl_attr is also turned off.  */
11489             decl = build_decl_attribute_variant (decl, decl_attr);
11490 #endif
11491
11492             /* [class.conv.ctor]
11493
11494                A constructor declared without the function-specifier
11495                explicit that can be called with a single parameter
11496                specifies a conversion from the type of its first
11497                parameter to the type of its class.  Such a constructor
11498                is called a converting constructor.  */
11499             if (explicitp == 2)
11500               DECL_NONCONVERTING_P (decl) = 1;
11501             else if (DECL_CONSTRUCTOR_P (decl))
11502               {
11503                 /* The constructor can be called with exactly one
11504                    parameter if there is at least one parameter, and
11505                    any subsequent parameters have default arguments.
11506                    Ignore any compiler-added parms.  */
11507                 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
11508
11509                 if (arg_types == void_list_node
11510                     || (arg_types
11511                         && TREE_CHAIN (arg_types)
11512                         && TREE_CHAIN (arg_types) != void_list_node
11513                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11514                   DECL_NONCONVERTING_P (decl) = 1;
11515               }
11516           }
11517         else if (TREE_CODE (type) == METHOD_TYPE)
11518           {
11519             /* We only get here for friend declarations of
11520                members of other classes.  */
11521             /* All method decls are public, so tell grokfndecl to set
11522                TREE_PUBLIC, also.  */
11523             decl = grokfndecl (ctype, type, declarator, declarator,
11524                                virtualp, flags, quals, raises,
11525                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11526                                template_count, in_namespace);
11527             if (decl == NULL_TREE)
11528               return NULL_TREE;
11529           }
11530         else if (!staticp && ! processing_template_decl
11531                  && !COMPLETE_TYPE_P (complete_type (type))
11532                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11533           {
11534             if (declarator)
11535               error ("field `%D' has incomplete type", declarator);
11536             else
11537               error ("name `%T' has incomplete type", type);
11538
11539             /* If we're instantiating a template, tell them which
11540                instantiation made the field's type be incomplete.  */
11541             if (current_class_type
11542                 && TYPE_NAME (current_class_type)
11543                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11544                 && declspecs && TREE_VALUE (declspecs)
11545                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11546               error ("  in instantiation of template `%T'",
11547                         current_class_type);
11548
11549             type = error_mark_node;
11550             decl = NULL_TREE;
11551           }
11552         else
11553           {
11554             if (friendp)
11555               {
11556                 error ("`%s' is neither function nor member function; cannot be declared friend",
11557                        IDENTIFIER_POINTER (declarator));
11558                 friendp = 0;
11559               }
11560             decl = NULL_TREE;
11561           }
11562
11563         if (friendp)
11564           {
11565             /* Friends are treated specially.  */
11566             if (ctype == current_class_type)
11567               warning ("member functions are implicitly friends of their class");
11568             else
11569               {
11570                 tree t = NULL_TREE;
11571                 if (decl && DECL_NAME (decl))
11572                   {
11573                     if (template_class_depth (current_class_type) == 0)
11574                       {
11575                         decl
11576                           = check_explicit_specialization
11577                           (declarator, decl,
11578                            template_count, 2 * (funcdef_flag != 0) + 4);
11579                         if (decl == error_mark_node)
11580                           return error_mark_node;
11581                       }
11582
11583                     t = do_friend (ctype, declarator, decl,
11584                                    last_function_parms, *attrlist,
11585                                    flags, quals, funcdef_flag);
11586                   }
11587                 if (t && funcdef_flag)
11588                   return t;
11589
11590                 return void_type_node;
11591               }
11592           }
11593
11594         /* Structure field.  It may not be a function, except for C++ */
11595
11596         if (decl == NULL_TREE)
11597           {
11598             if (initialized)
11599               {
11600                 if (!staticp)
11601                   {
11602                     /* An attempt is being made to initialize a non-static
11603                        member.  But, from [class.mem]:
11604
11605                        4 A member-declarator can contain a
11606                        constant-initializer only if it declares a static
11607                        member (_class.static_) of integral or enumeration
11608                        type, see _class.static.data_.
11609
11610                        This used to be relatively common practice, but
11611                        the rest of the compiler does not correctly
11612                        handle the initialization unless the member is
11613                        static so we make it static below.  */
11614                     pedwarn ("ISO C++ forbids initialization of member `%D'",
11615                                 declarator);
11616                     pedwarn ("making `%D' static", declarator);
11617                     staticp = 1;
11618                   }
11619
11620                 if (uses_template_parms (type))
11621                   /* We'll check at instantiation time.  */
11622                   ;
11623                 else if (check_static_variable_definition (declarator,
11624                                                            type))
11625                   /* If we just return the declaration, crashes
11626                      will sometimes occur.  We therefore return
11627                      void_type_node, as if this was a friend
11628                      declaration, to cause callers to completely
11629                      ignore this declaration.  */
11630                   return void_type_node;
11631               }
11632
11633             /* 9.2p13 [class.mem] */
11634             if (constructor_name_p (declarator, current_class_type)
11635                 /* The standard does not allow non-static data members
11636                    here either, but we agreed at the 10/99 meeting
11637                    to change that in TC 1 so that they are allowed in
11638                    classes with no user-defined constructors.  */
11639                 && staticp)
11640               pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11641                           declarator);
11642
11643             if (staticp)
11644               {
11645                 /* C++ allows static class members.  All other work
11646                    for this is done by grokfield.  */
11647                 decl = build_lang_decl (VAR_DECL, declarator, type);
11648                 TREE_STATIC (decl) = 1;
11649                 /* In class context, 'static' means public access.  */
11650                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11651               }
11652             else
11653               {
11654                 decl = build_decl (FIELD_DECL, declarator, type);
11655                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11656                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11657                   {
11658                     DECL_MUTABLE_P (decl) = 1;
11659                     RIDBIT_RESET (RID_MUTABLE, specbits);
11660                   }
11661               }
11662
11663             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11664                             inlinep, friendp, raises != NULL_TREE);
11665           }
11666       }
11667     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11668       {
11669         tree original_name;
11670         int publicp = 0;
11671
11672         if (! declarator)
11673           return NULL_TREE;
11674
11675         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11676           original_name = dname;
11677         else
11678           original_name = declarator;
11679
11680         if (RIDBIT_SETP (RID_AUTO, specbits))
11681           error ("storage class `auto' invalid for function `%s'", name);
11682         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11683           error ("storage class `register' invalid for function `%s'", name);
11684         else if (RIDBIT_SETP (RID_THREAD, specbits))
11685           error ("storage class `__thread' invalid for function `%s'", name);
11686
11687         /* Function declaration not at top level.
11688            Storage classes other than `extern' are not allowed
11689            and `extern' makes no difference.  */
11690         if (! toplevel_bindings_p ()
11691             && (RIDBIT_SETP (RID_STATIC, specbits)
11692                 || RIDBIT_SETP (RID_INLINE, specbits))
11693             && pedantic)
11694           {
11695             if (RIDBIT_SETP (RID_STATIC, specbits))
11696               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11697             else
11698               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11699           }
11700
11701         if (ctype == NULL_TREE)
11702           {
11703             if (virtualp)
11704               {
11705                 error ("virtual non-class function `%s'", name);
11706                 virtualp = 0;
11707               }
11708           }
11709         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11710           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11711                                           TYPE_ARG_TYPES (type));
11712
11713         /* Record presence of `static'.  */
11714         publicp = (ctype != NULL_TREE
11715                    || RIDBIT_SETP (RID_EXTERN, specbits)
11716                    || !RIDBIT_SETP (RID_STATIC, specbits));
11717
11718         decl = grokfndecl (ctype, type, original_name, declarator,
11719                            virtualp, flags, quals, raises,
11720                            1, friendp,
11721                            publicp, inlinep, funcdef_flag,
11722                            template_count, in_namespace);
11723         if (decl == NULL_TREE)
11724           return NULL_TREE;
11725
11726         if (staticp == 1)
11727           {
11728             int invalid_static = 0;
11729
11730             /* Don't allow a static member function in a class, and forbid
11731                declaring main to be static.  */
11732             if (TREE_CODE (type) == METHOD_TYPE)
11733               {
11734                 pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11735                 invalid_static = 1;
11736               }
11737             else if (current_function_decl)
11738               {
11739                 /* FIXME need arm citation */
11740                 error ("cannot declare static function inside another function");
11741                 invalid_static = 1;
11742               }
11743
11744             if (invalid_static)
11745               {
11746                 staticp = 0;
11747                 RIDBIT_RESET (RID_STATIC, specbits);
11748               }
11749           }
11750       }
11751     else
11752       {
11753         /* It's a variable.  */
11754
11755         /* An uninitialized decl with `extern' is a reference.  */
11756         decl = grokvardecl (type, declarator, &specbits,
11757                             initialized,
11758                             (type_quals & TYPE_QUAL_CONST) != 0,
11759                             ctype ? ctype : in_namespace);
11760         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11761                         inlinep, friendp, raises != NULL_TREE);
11762
11763         if (ctype)
11764           {
11765             DECL_CONTEXT (decl) = ctype;
11766             if (staticp == 1)
11767               {
11768                 pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
11769                 staticp = 0;
11770                 RIDBIT_RESET (RID_STATIC, specbits);
11771               }
11772             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11773               {
11774                 error ("static member `%D' declared `register'", decl);
11775                 RIDBIT_RESET (RID_REGISTER, specbits);
11776               }
11777             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11778               {
11779                 pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11780                             decl);
11781                 RIDBIT_RESET (RID_EXTERN, specbits);
11782               }
11783           }
11784       }
11785
11786     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11787
11788     /* Record `register' declaration for warnings on &
11789        and in case doing stupid register allocation.  */
11790
11791     if (RIDBIT_SETP (RID_REGISTER, specbits))
11792       DECL_REGISTER (decl) = 1;
11793
11794     if (RIDBIT_SETP (RID_EXTERN, specbits))
11795       DECL_THIS_EXTERN (decl) = 1;
11796
11797     if (RIDBIT_SETP (RID_STATIC, specbits))
11798       DECL_THIS_STATIC (decl) = 1;
11799
11800     /* Record constancy and volatility.  There's no need to do this
11801        when processing a template; we'll do this for the instantiated
11802        declaration based on the type of DECL.  */
11803     if (!processing_template_decl)
11804       c_apply_type_quals_to_decl (type_quals, decl);
11805
11806     return decl;
11807   }
11808 }
11809 \f
11810 /* Subroutine of start_function.  Ensure that each of the parameter
11811    types (as listed in PARMS) is complete, as is required for a
11812    function definition.  */
11813
11814 static void
11815 require_complete_types_for_parms (tree parms)
11816 {
11817   for (; parms; parms = TREE_CHAIN (parms))
11818     {
11819       if (VOID_TYPE_P (TREE_TYPE (parms)))
11820         /* grokparms will have already issued an error */
11821         TREE_TYPE (parms) = error_mark_node;
11822       else if (complete_type_or_else (TREE_TYPE (parms), parms))
11823         {
11824           layout_decl (parms, 0);
11825           DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
11826         }
11827       else
11828         TREE_TYPE (parms) = error_mark_node;
11829     }
11830 }
11831
11832 /* Returns nonzero if T is a local variable.  */
11833
11834 int
11835 local_variable_p (tree t)
11836 {
11837   if ((TREE_CODE (t) == VAR_DECL
11838        /* A VAR_DECL with a context that is a _TYPE is a static data
11839           member.  */
11840        && !TYPE_P (CP_DECL_CONTEXT (t))
11841        /* Any other non-local variable must be at namespace scope.  */
11842        && !DECL_NAMESPACE_SCOPE_P (t))
11843       || (TREE_CODE (t) == PARM_DECL))
11844     return 1;
11845
11846   return 0;
11847 }
11848
11849 /* Returns nonzero if T is an automatic local variable or a label.
11850    (These are the declarations that need to be remapped when the code
11851    containing them is duplicated.)  */
11852
11853 int
11854 nonstatic_local_decl_p (tree t)
11855 {
11856   return ((local_variable_p (t) && !TREE_STATIC (t))
11857           || TREE_CODE (t) == LABEL_DECL
11858           || TREE_CODE (t) == RESULT_DECL);
11859 }
11860
11861 /* Like local_variable_p, but suitable for use as a tree-walking
11862    function.  */
11863
11864 static tree
11865 local_variable_p_walkfn (tree* tp,
11866                          int* walk_subtrees ATTRIBUTE_UNUSED ,
11867                          void* data ATTRIBUTE_UNUSED )
11868 {
11869   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11870           ? *tp : NULL_TREE);
11871 }
11872
11873 /* Check that ARG, which is a default-argument expression for a
11874    parameter DECL, is valid.  Returns ARG, or ERROR_MARK_NODE, if
11875    something goes wrong.  DECL may also be a _TYPE node, rather than a
11876    DECL, if there is no DECL available.  */
11877
11878 tree
11879 check_default_argument (tree decl, tree arg)
11880 {
11881   tree var;
11882   tree decl_type;
11883
11884   if (TREE_CODE (arg) == DEFAULT_ARG)
11885     /* We get a DEFAULT_ARG when looking at an in-class declaration
11886        with a default argument.  Ignore the argument for now; we'll
11887        deal with it after the class is complete.  */
11888     return arg;
11889
11890   if (processing_template_decl || uses_template_parms (arg))
11891     /* We don't do anything checking until instantiation-time.  Note
11892        that there may be uninstantiated arguments even for an
11893        instantiated function, since default arguments are not
11894        instantiated until they are needed.  */
11895     return arg;
11896
11897   if (TYPE_P (decl))
11898     {
11899       decl_type = decl;
11900       decl = NULL_TREE;
11901     }
11902   else
11903     decl_type = TREE_TYPE (decl);
11904
11905   if (arg == error_mark_node
11906       || decl == error_mark_node
11907       || TREE_TYPE (arg) == error_mark_node
11908       || decl_type == error_mark_node)
11909     /* Something already went wrong.  There's no need to check
11910        further.  */
11911     return error_mark_node;
11912
11913   /* [dcl.fct.default]
11914
11915      A default argument expression is implicitly converted to the
11916      parameter type.  */
11917   if (!TREE_TYPE (arg)
11918       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11919     {
11920       if (decl)
11921         error ("default argument for `%#D' has type `%T'",
11922                   decl, TREE_TYPE (arg));
11923       else
11924         error ("default argument for parameter of type `%T' has type `%T'",
11925                   decl_type, TREE_TYPE (arg));
11926
11927       return error_mark_node;
11928     }
11929
11930   /* [dcl.fct.default]
11931
11932      Local variables shall not be used in default argument
11933      expressions.
11934
11935      The keyword `this' shall not be used in a default argument of a
11936      member function.  */
11937   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
11938                                       NULL);
11939   if (var)
11940     {
11941       error ("default argument `%E' uses local variable `%D'",
11942                 arg, var);
11943       return error_mark_node;
11944     }
11945
11946   /* All is well.  */
11947   return arg;
11948 }
11949
11950 /* Decode the list of parameter types for a function type.
11951    Given the list of things declared inside the parens,
11952    return a list of types.
11953
11954    We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
11955    flag. If unset, we append void_list_node. A parmlist declared
11956    as `(void)' is accepted as the empty parmlist.
11957
11958    Also set last_function_parms to the chain of PARM_DECLs.  */
11959
11960 static tree
11961 grokparms (tree first_parm)
11962 {
11963   tree result = NULL_TREE;
11964   tree decls = NULL_TREE;
11965   int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
11966   tree parm, chain;
11967   int any_error = 0;
11968
11969   my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
11970
11971   for (parm = first_parm; parm != NULL_TREE; parm = chain)
11972     {
11973       tree type = NULL_TREE;
11974       tree decl = TREE_VALUE (parm);
11975       tree init = TREE_PURPOSE (parm);
11976       tree specs, attrs;
11977
11978       chain = TREE_CHAIN (parm);
11979       /* @@ weak defense against parse errors.  */
11980       if (TREE_CODE (decl) != VOID_TYPE
11981           && TREE_CODE (decl) != TREE_LIST)
11982         {
11983           /* Give various messages as the need arises.  */
11984           if (TREE_CODE (decl) == STRING_CST)
11985             error ("invalid string constant `%E'", decl);
11986           else if (TREE_CODE (decl) == INTEGER_CST)
11987             error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11988           continue;
11989         }
11990
11991       if (parm == void_list_node)
11992         break;
11993
11994       split_specs_attrs (TREE_PURPOSE (decl), &specs, &attrs);
11995       decl = grokdeclarator (TREE_VALUE (decl), specs,
11996                              PARM, init != NULL_TREE, &attrs);
11997       if (! decl || TREE_TYPE (decl) == error_mark_node)
11998         continue;
11999
12000       if (attrs)
12001         cplus_decl_attributes (&decl, attrs, 0);
12002
12003       type = TREE_TYPE (decl);
12004       if (VOID_TYPE_P (type))
12005         {
12006           if (same_type_p (type, void_type_node)
12007               && !DECL_NAME (decl) && !result && !chain && !ellipsis)
12008             /* this is a parmlist of `(void)', which is ok.  */
12009             break;
12010           cxx_incomplete_type_error (decl, type);
12011           /* It's not a good idea to actually create parameters of
12012              type `void'; other parts of the compiler assume that a
12013              void type terminates the parameter list.  */
12014           type = error_mark_node;
12015           TREE_TYPE (decl) = error_mark_node;
12016         }
12017
12018       if (type != error_mark_node)
12019         {
12020           /* Top-level qualifiers on the parameters are
12021              ignored for function types.  */
12022           type = TYPE_MAIN_VARIANT (type);
12023           if (TREE_CODE (type) == METHOD_TYPE)
12024             {
12025               error ("parameter `%D' invalidly declared method type", decl);
12026               type = build_pointer_type (type);
12027               TREE_TYPE (decl) = type;
12028             }
12029           else if (TREE_CODE (type) == OFFSET_TYPE)
12030             {
12031               error ("parameter `%D' invalidly declared offset type", decl);
12032               type = build_pointer_type (type);
12033               TREE_TYPE (decl) = type;
12034             }
12035           else if (abstract_virtuals_error (decl, type))
12036             any_error = 1;  /* Seems like a good idea.  */
12037           else if (POINTER_TYPE_P (type))
12038             {
12039               /* [dcl.fct]/6, parameter types cannot contain pointers
12040                  (references) to arrays of unknown bound.  */
12041               tree t = TREE_TYPE (type);
12042               int ptr = TYPE_PTR_P (type);
12043
12044               while (1)
12045                 {
12046                   if (TYPE_PTR_P (t))
12047                     ptr = 1;
12048                   else if (TREE_CODE (t) != ARRAY_TYPE)
12049                     break;
12050                   else if (!TYPE_DOMAIN (t))
12051                     break;
12052                   t = TREE_TYPE (t);
12053                 }
12054               if (TREE_CODE (t) == ARRAY_TYPE)
12055                 error ("parameter `%D' includes %s to array of unknown bound `%T'",
12056                           decl, ptr ? "pointer" : "reference", t);
12057             }
12058
12059           if (!any_error && init)
12060             init = check_default_argument (decl, init);
12061           else
12062             init = NULL_TREE;
12063         }
12064
12065       TREE_CHAIN (decl) = decls;
12066       decls = decl;
12067       result = tree_cons (init, type, result);
12068     }
12069   decls = nreverse (decls);
12070   result = nreverse (result);
12071   if (!ellipsis)
12072     result = chainon (result, void_list_node);
12073   last_function_parms = decls;
12074
12075   return result;
12076 }
12077
12078 \f
12079 /* D is a constructor or overloaded `operator='.
12080
12081    Let T be the class in which D is declared. Then, this function
12082    returns:
12083
12084    -1 if D's is an ill-formed constructor or copy assignment operator
12085       whose first parameter is of type `T'.
12086    0  if D is not a copy constructor or copy assignment
12087       operator.
12088    1  if D is a copy constructor or copy assignment operator whose
12089       first parameter is a reference to const qualified T.
12090    2  if D is a copy constructor or copy assignment operator whose
12091       first parameter is a reference to non-const qualified T.
12092
12093    This function can be used as a predicate. Positive values indicate
12094    a copy constructor and nonzero values indicate a copy assignment
12095    operator.  */
12096
12097 int
12098 copy_fn_p (tree d)
12099 {
12100   tree args;
12101   tree arg_type;
12102   int result = 1;
12103
12104   my_friendly_assert (DECL_FUNCTION_MEMBER_P (d), 20011208);
12105
12106   if (DECL_TEMPLATE_INFO (d) && is_member_template (DECL_TI_TEMPLATE (d)))
12107     /* Instantiations of template member functions are never copy
12108        functions.  Note that member functions of templated classes are
12109        represented as template functions internally, and we must
12110        accept those as copy functions.  */
12111     return 0;
12112
12113   args = FUNCTION_FIRST_USER_PARMTYPE (d);
12114   if (!args)
12115     return 0;
12116
12117   arg_type = TREE_VALUE (args);
12118
12119   if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
12120     {
12121       /* Pass by value copy assignment operator.  */
12122       result = -1;
12123     }
12124   else if (TREE_CODE (arg_type) == REFERENCE_TYPE
12125            && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
12126     {
12127       if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
12128         result = 2;
12129     }
12130   else
12131     return 0;
12132
12133   args = TREE_CHAIN (args);
12134
12135   if (args && args != void_list_node && !TREE_PURPOSE (args))
12136     /* There are more non-optional args.  */
12137     return 0;
12138
12139   return result;
12140 }
12141
12142 /* Remember any special properties of member function DECL.  */
12143
12144 void grok_special_member_properties (tree decl)
12145 {
12146   if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl))
12147     ; /* Not special.  */
12148   else if (DECL_CONSTRUCTOR_P (decl))
12149     {
12150       int ctor = copy_fn_p (decl);
12151
12152       if (ctor > 0)
12153         {
12154           /* [class.copy]
12155
12156              A non-template constructor for class X is a copy
12157              constructor if its first parameter is of type X&, const
12158              X&, volatile X& or const volatile X&, and either there
12159              are no other parameters or else all other parameters have
12160              default arguments.  */
12161           TYPE_HAS_INIT_REF (DECL_CONTEXT (decl)) = 1;
12162           if (ctor > 1)
12163             TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl)) = 1;
12164         }
12165       else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
12166         TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl)) = 1;
12167     }
12168   else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
12169     {
12170       /* [class.copy]
12171
12172          A non-template assignment operator for class X is a copy
12173          assignment operator if its parameter is of type X, X&, const
12174          X&, volatile X& or const volatile X&.  */
12175
12176       int assop = copy_fn_p (decl);
12177
12178       if (assop)
12179         {
12180           TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12181           if (assop != 1)
12182             TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12183           if (DECL_PURE_VIRTUAL_P (decl))
12184             TYPE_HAS_ABSTRACT_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12185         }
12186     }
12187 }
12188
12189 /* Check a constructor DECL has the correct form.  Complains
12190    if the class has a constructor of the form X(X).  */
12191
12192 int
12193 grok_ctor_properties (tree ctype, tree decl)
12194 {
12195   int ctor_parm = copy_fn_p (decl);
12196
12197   if (ctor_parm < 0)
12198     {
12199       /* [class.copy]
12200
12201          A declaration of a constructor for a class X is ill-formed if
12202          its first parameter is of type (optionally cv-qualified) X
12203          and either there are no other parameters or else all other
12204          parameters have default arguments.
12205
12206          We *don't* complain about member template instantiations that
12207          have this form, though; they can occur as we try to decide
12208          what constructor to use during overload resolution.  Since
12209          overload resolution will never prefer such a constructor to
12210          the non-template copy constructor (which is either explicitly
12211          or implicitly defined), there's no need to worry about their
12212          existence.  Theoretically, they should never even be
12213          instantiated, but that's hard to forestall.  */
12214       error ("invalid constructor; you probably meant `%T (const %T&)'",
12215                 ctype, ctype);
12216       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12217       return 0;
12218     }
12219
12220   return 1;
12221 }
12222
12223 /* An operator with this code is unary, but can also be binary.  */
12224
12225 static int
12226 ambi_op_p (enum tree_code code)
12227 {
12228   return (code == INDIRECT_REF
12229           || code == ADDR_EXPR
12230           || code == CONVERT_EXPR
12231           || code == NEGATE_EXPR
12232           || code == PREINCREMENT_EXPR
12233           || code == PREDECREMENT_EXPR);
12234 }
12235
12236 /* An operator with this name can only be unary.  */
12237
12238 static int
12239 unary_op_p (enum tree_code code)
12240 {
12241   return (code == TRUTH_NOT_EXPR
12242           || code == BIT_NOT_EXPR
12243           || code == COMPONENT_REF
12244           || code == TYPE_EXPR);
12245 }
12246
12247 /* Do a little sanity-checking on how they declared their operator.  */
12248
12249 void
12250 grok_op_properties (tree decl, int friendp)
12251 {
12252   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12253   tree argtype;
12254   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12255   tree name = DECL_NAME (decl);
12256   enum tree_code operator_code;
12257   int arity;
12258
12259   /* Count the number of arguments.  */
12260   for (argtype = argtypes, arity = 0;
12261        argtype && argtype != void_list_node;
12262        argtype = TREE_CHAIN (argtype))
12263     ++arity;
12264
12265   if (current_class_type == NULL_TREE)
12266     friendp = 1;
12267
12268   if (DECL_CONV_FN_P (decl))
12269     operator_code = TYPE_EXPR;
12270   else
12271     do
12272       {
12273 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)       \
12274         if (ansi_opname (CODE) == name)                         \
12275           {                                                     \
12276             operator_code = (CODE);                             \
12277             break;                                              \
12278           }                                                     \
12279         else if (ansi_assopname (CODE) == name)                 \
12280           {                                                     \
12281             operator_code = (CODE);                             \
12282             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;              \
12283             break;                                              \
12284           }
12285
12286 #include "operators.def"
12287 #undef DEF_OPERATOR
12288
12289         abort ();
12290       }
12291     while (0);
12292   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12293   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12294
12295   if (! friendp)
12296     {
12297       switch (operator_code)
12298         {
12299         case CALL_EXPR:
12300           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12301           break;
12302
12303         case ARRAY_REF:
12304           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12305           break;
12306
12307         case COMPONENT_REF:
12308         case MEMBER_REF:
12309           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12310           break;
12311
12312         case NEW_EXPR:
12313           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12314           break;
12315
12316         case DELETE_EXPR:
12317           TYPE_GETS_DELETE (current_class_type) |= 1;
12318           break;
12319
12320         case VEC_NEW_EXPR:
12321           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12322           break;
12323
12324         case VEC_DELETE_EXPR:
12325           TYPE_GETS_DELETE (current_class_type) |= 2;
12326           break;
12327
12328         default:
12329           break;
12330         }
12331     }
12332
12333   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12334     {
12335       /* When the compiler encounters the definition of A::operator new, it
12336          doesn't look at the class declaration to find out if it's static.  */
12337       if (methodp)
12338         revert_static_member_fn (decl);
12339
12340       TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12341     }
12342   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12343     {
12344       if (methodp)
12345         revert_static_member_fn (decl);
12346
12347       TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12348     }
12349   else
12350     {
12351       /* An operator function must either be a non-static member function
12352          or have at least one parameter of a class, a reference to a class,
12353          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12354       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12355         {
12356           if (operator_code == TYPE_EXPR
12357               || operator_code == CALL_EXPR
12358               || operator_code == COMPONENT_REF
12359               || operator_code == ARRAY_REF
12360               || operator_code == NOP_EXPR)
12361             error ("`%D' must be a nonstatic member function", decl);
12362           else
12363             {
12364               tree p = argtypes;
12365
12366               if (DECL_STATIC_FUNCTION_P (decl))
12367                 error ("`%D' must be either a non-static member function or a non-member function", decl);
12368
12369               if (p)
12370                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12371                   {
12372                     tree arg = TREE_VALUE (p);
12373                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12374                       arg = TREE_TYPE (arg);
12375
12376                     /* This lets bad template code slip through.  */
12377                     if (IS_AGGR_TYPE (arg)
12378                         || TREE_CODE (arg) == ENUMERAL_TYPE
12379                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12380                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12381                       goto foundaggr;
12382                   }
12383               error
12384                 ("`%D' must have an argument of class or enumerated type",
12385                  decl);
12386             foundaggr:
12387               ;
12388             }
12389         }
12390
12391       if (operator_code == CALL_EXPR)
12392         return;                 /* No restrictions on args.  */
12393
12394       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12395         {
12396           tree t = TREE_TYPE (name);
12397           if (! friendp)
12398             {
12399               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12400               const char *what = 0;
12401
12402               if (ref)
12403                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12404
12405               if (TREE_CODE (t) == VOID_TYPE)
12406                 what = "void";
12407               else if (t == current_class_type)
12408                 what = "the same type";
12409               /* Don't force t to be complete here.  */
12410               else if (IS_AGGR_TYPE (t)
12411                        && COMPLETE_TYPE_P (t)
12412                        && DERIVED_FROM_P (t, current_class_type))
12413                 what = "a base class";
12414
12415               if (what)
12416                 warning ("conversion to %s%s will never use a type conversion operator",
12417                          ref ? "a reference to " : "", what);
12418             }
12419         }
12420       if (operator_code == COND_EXPR)
12421         {
12422           /* 13.4.0.3 */
12423           error ("ISO C++ prohibits overloading operator ?:");
12424         }
12425       else if (ambi_op_p (operator_code))
12426         {
12427           if (arity == 1)
12428             /* We pick the one-argument operator codes by default, so
12429                we don't have to change anything.  */
12430             ;
12431           else if (arity == 2)
12432             {
12433               /* If we thought this was a unary operator, we now know
12434                  it to be a binary operator.  */
12435               switch (operator_code)
12436                 {
12437                 case INDIRECT_REF:
12438                   operator_code = MULT_EXPR;
12439                   break;
12440
12441                 case ADDR_EXPR:
12442                   operator_code = BIT_AND_EXPR;
12443                   break;
12444
12445                 case CONVERT_EXPR:
12446                   operator_code = PLUS_EXPR;
12447                   break;
12448
12449                 case NEGATE_EXPR:
12450                   operator_code = MINUS_EXPR;
12451                   break;
12452
12453                 case PREINCREMENT_EXPR:
12454                   operator_code = POSTINCREMENT_EXPR;
12455                   break;
12456
12457                 case PREDECREMENT_EXPR:
12458                   operator_code = POSTDECREMENT_EXPR;
12459                   break;
12460
12461                 default:
12462                   abort ();
12463                 }
12464
12465               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12466
12467               if ((operator_code == POSTINCREMENT_EXPR
12468                    || operator_code == POSTDECREMENT_EXPR)
12469                   && ! processing_template_decl
12470                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12471                 {
12472                   if (methodp)
12473                     error ("postfix `%D' must take `int' as its argument",
12474                               decl);
12475                   else
12476                     error
12477                       ("postfix `%D' must take `int' as its second argument",
12478                        decl);
12479                 }
12480             }
12481           else
12482             {
12483               if (methodp)
12484                 error ("`%D' must take either zero or one argument", decl);
12485               else
12486                 error ("`%D' must take either one or two arguments", decl);
12487             }
12488
12489           /* More Effective C++ rule 6.  */
12490           if (warn_ecpp
12491               && (operator_code == POSTINCREMENT_EXPR
12492                   || operator_code == POSTDECREMENT_EXPR
12493                   || operator_code == PREINCREMENT_EXPR
12494                   || operator_code == PREDECREMENT_EXPR))
12495             {
12496               tree arg = TREE_VALUE (argtypes);
12497               tree ret = TREE_TYPE (TREE_TYPE (decl));
12498               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12499                 arg = TREE_TYPE (arg);
12500               arg = TYPE_MAIN_VARIANT (arg);
12501               if (operator_code == PREINCREMENT_EXPR
12502                   || operator_code == PREDECREMENT_EXPR)
12503                 {
12504                   if (TREE_CODE (ret) != REFERENCE_TYPE
12505                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12506                                        arg))
12507                     warning ("prefix `%D' should return `%T'", decl,
12508                                 build_reference_type (arg));
12509                 }
12510               else
12511                 {
12512                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12513                     warning ("postfix `%D' should return `%T'", decl, arg);
12514                 }
12515             }
12516         }
12517       else if (unary_op_p (operator_code))
12518         {
12519           if (arity != 1)
12520             {
12521               if (methodp)
12522                 error ("`%D' must take `void'", decl);
12523               else
12524                 error ("`%D' must take exactly one argument", decl);
12525             }
12526         }
12527       else /* if (binary_op_p (operator_code)) */
12528         {
12529           if (arity != 2)
12530             {
12531               if (methodp)
12532                 error ("`%D' must take exactly one argument", decl);
12533               else
12534                 error ("`%D' must take exactly two arguments", decl);
12535             }
12536
12537           /* More Effective C++ rule 7.  */
12538           if (warn_ecpp
12539               && (operator_code == TRUTH_ANDIF_EXPR
12540                   || operator_code == TRUTH_ORIF_EXPR
12541                   || operator_code == COMPOUND_EXPR))
12542             warning ("user-defined `%D' always evaluates both arguments",
12543                         decl);
12544         }
12545
12546       /* Effective C++ rule 23.  */
12547       if (warn_ecpp
12548           && arity == 2
12549           && !DECL_ASSIGNMENT_OPERATOR_P (decl)
12550           && (operator_code == PLUS_EXPR
12551               || operator_code == MINUS_EXPR
12552               || operator_code == TRUNC_DIV_EXPR
12553               || operator_code == MULT_EXPR
12554               || operator_code == TRUNC_MOD_EXPR)
12555           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12556         warning ("`%D' should return by value", decl);
12557
12558       /* [over.oper]/8 */
12559       for (; argtypes && argtypes != void_list_node;
12560           argtypes = TREE_CHAIN (argtypes))
12561         if (TREE_PURPOSE (argtypes))
12562           {
12563             TREE_PURPOSE (argtypes) = NULL_TREE;
12564             if (operator_code == POSTINCREMENT_EXPR
12565                 || operator_code == POSTDECREMENT_EXPR)
12566               {
12567                 if (pedantic)
12568                   pedwarn ("`%D' cannot have default arguments", decl);
12569               }
12570             else
12571               error ("`%D' cannot have default arguments", decl);
12572           }
12573
12574     }
12575 }
12576 \f
12577 static const char *
12578 tag_name (enum tag_types code)
12579 {
12580   switch (code)
12581     {
12582     case record_type:
12583       return "struct";
12584     case class_type:
12585       return "class";
12586     case union_type:
12587       return "union ";
12588     case enum_type:
12589       return "enum";
12590     default:
12591       abort ();
12592     }
12593 }
12594
12595 /* Get the struct, enum or union (CODE says which) with tag NAME.
12596    Define the tag as a forward-reference if it is not defined.
12597
12598    C++: If a class derivation is given, process it here, and report
12599    an error if multiple derivation declarations are not identical.
12600
12601    If this is a definition, come in through xref_tag and only look in
12602    the current frame for the name (since C++ allows new names in any
12603    scope.)  */
12604
12605 tree
12606 xref_tag (enum tag_types tag_code, tree name, tree attributes,
12607           bool globalize)
12608 {
12609   enum tree_code code;
12610   register tree ref, t;
12611   struct cp_binding_level *b = current_binding_level;
12612   tree context = NULL_TREE;
12613
12614   timevar_push (TV_NAME_LOOKUP);
12615   switch (tag_code)
12616     {
12617     case record_type:
12618     case class_type:
12619       code = RECORD_TYPE;
12620       break;
12621     case union_type:
12622       code = UNION_TYPE;
12623       break;
12624     case enum_type:
12625       code = ENUMERAL_TYPE;
12626       break;
12627     default:
12628       abort ();
12629     }
12630
12631   /* If a cross reference is requested, look up the type
12632      already defined for this tag and return it.  */
12633   if (TYPE_P (name))
12634     {
12635       t = name;
12636       name = TYPE_IDENTIFIER (t);
12637     }
12638   else
12639     t = IDENTIFIER_TYPE_VALUE (name);
12640
12641   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12642   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12643     {
12644       static int explained;
12645       tree shadowed;
12646
12647       warning ("`%s %T' declares a new type at namespace scope",
12648                   tag_name (tag_code), name);
12649       if (!explained++)
12650         warning ("  names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'",
12651                     tag_name (tag_code),
12652                     constructor_name (current_class_type),
12653                     TYPE_IDENTIFIER (t));
12654
12655       /* We need to remove the class scope binding for the
12656          TYPENAME_TYPE as otherwise poplevel_class gets confused.  */
12657       for (shadowed = b->class_shadowed;
12658            shadowed;
12659            shadowed = TREE_CHAIN (shadowed))
12660         if (TREE_TYPE (shadowed) == TYPE_NAME (t))
12661           {
12662             TREE_PURPOSE (shadowed) = NULL_TREE;
12663             break;
12664           }
12665     }
12666
12667   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12668       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12669     t = NULL_TREE;
12670
12671   if (! globalize)
12672     {
12673       /* If we know we are defining this tag, only look it up in
12674          this scope and don't try to find it as a type.  */
12675       ref = lookup_tag (code, name, b, 1);
12676     }
12677   else
12678     {
12679       if (t)
12680         {
12681           ref = follow_tag_typedef (t);
12682
12683           /* [dcl.type.elab] If the identifier resolves to a
12684              typedef-name or a template type-parameter, the
12685              elaborated-type-specifier is ill-formed.  */
12686           if (!ref)
12687             {
12688               pedwarn ("using typedef-name `%D' after `%s'",
12689                        TYPE_NAME (t), tag_name (tag_code));
12690               ref = t;
12691             }
12692           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12693             error ("using template type parameter `%T' after `%s'",
12694                    t, tag_name (tag_code));
12695         }
12696       else
12697         ref = lookup_tag (code, name, b, 0);
12698
12699       if (! ref)
12700         {
12701           /* Try finding it as a type declaration.  If that wins,
12702              use it.  */
12703           ref = lookup_name (name, 1);
12704
12705           if (ref != NULL_TREE
12706               && processing_template_decl
12707               && DECL_CLASS_TEMPLATE_P (ref)
12708               && template_class_depth (current_class_type) == 0)
12709             /* Since GLOBALIZE is true, we're declaring a global
12710                template, so we want this type.  */
12711             ref = DECL_TEMPLATE_RESULT (ref);
12712
12713           if (ref && TREE_CODE (ref) == TYPE_DECL
12714               && TREE_CODE (TREE_TYPE (ref)) == code)
12715             ref = TREE_TYPE (ref);
12716           else
12717             ref = NULL_TREE;
12718         }
12719
12720       if (ref && current_class_type
12721           && template_class_depth (current_class_type)
12722           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12723         {
12724           /* Since GLOBALIZE is nonzero, we are not looking at a
12725              definition of this tag.  Since, in addition, we are currently
12726              processing a (member) template declaration of a template
12727              class, we must be very careful; consider:
12728
12729                template <class X>
12730                struct S1
12731
12732                template <class U>
12733                struct S2
12734                { template <class V>
12735                friend struct S1; };
12736
12737              Here, the S2::S1 declaration should not be confused with the
12738              outer declaration.  In particular, the inner version should
12739              have a template parameter of level 2, not level 1.  This
12740              would be particularly important if the member declaration
12741              were instead:
12742
12743                template <class V = U> friend struct S1;
12744
12745              say, when we should tsubst into `U' when instantiating
12746              S2.  On the other hand, when presented with:
12747
12748                  template <class T>
12749                  struct S1 {
12750                    template <class U>
12751                    struct S2 {};
12752                    template <class U>
12753                    friend struct S2;
12754                  };
12755
12756               we must find the inner binding eventually.  We
12757               accomplish this by making sure that the new type we
12758               create to represent this declaration has the right
12759               TYPE_CONTEXT.  */
12760           context = TYPE_CONTEXT (ref);
12761           ref = NULL_TREE;
12762         }
12763     }
12764
12765   if (! ref)
12766     {
12767       /* If no such tag is yet defined, create a forward-reference node
12768          and record it as the "definition".
12769          When a real declaration of this type is found,
12770          the forward-reference will be altered into a real type.  */
12771       if (code == ENUMERAL_TYPE)
12772         {
12773           error ("use of enum `%#D' without previous declaration", name);
12774
12775           ref = make_node (ENUMERAL_TYPE);
12776
12777           /* Give the type a default layout like unsigned int
12778              to avoid crashing if it does not get defined.  */
12779           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12780           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12781           TYPE_USER_ALIGN (ref) = 0;
12782           TREE_UNSIGNED (ref) = 1;
12783           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12784           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12785           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12786
12787           /* Enable us to recognize when a type is created in class context.
12788              To do nested classes correctly, this should probably be cleared
12789              out when we leave this classes scope.  Currently this in only
12790              done in `start_enum'.  */
12791
12792           pushtag (name, ref, globalize);
12793         }
12794       else
12795         {
12796           struct cp_binding_level *old_b = class_binding_level;
12797
12798           ref = make_aggr_type (code);
12799           TYPE_CONTEXT (ref) = context;
12800
12801 #ifdef NONNESTED_CLASSES
12802           /* Class types don't nest the way enums do.  */
12803           class_binding_level = (struct cp_binding_level *)0;
12804 #endif
12805           pushtag (name, ref, globalize);
12806           class_binding_level = old_b;
12807         }
12808     }
12809   else
12810     {
12811       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12812         redeclare_class_template (ref, current_template_parms);
12813     }
12814
12815   TYPE_ATTRIBUTES (ref) = attributes;
12816
12817   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ref);
12818 }
12819
12820 tree
12821 xref_tag_from_type (tree old, tree id, int globalize)
12822 {
12823   enum tag_types tag_kind;
12824
12825   if (TREE_CODE (old) == RECORD_TYPE)
12826     tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
12827   else
12828     tag_kind  = union_type;
12829
12830   if (id == NULL_TREE)
12831     id = TYPE_IDENTIFIER (old);
12832
12833   return xref_tag (tag_kind, id, /*attributes=*/NULL_TREE, globalize);
12834 }
12835
12836 /* REF is a type (named NAME), for which we have just seen some
12837    baseclasses.  BINFO is a list of those baseclasses; the
12838    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12839    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12840    struct, or union.  */
12841
12842 void
12843 xref_basetypes (tree ref, tree binfo)
12844 {
12845   /* In the declaration `A : X, Y, ... Z' we mark all the types
12846      (A, X, Y, ..., Z) so we can check for duplicates.  */
12847   tree binfos;
12848   tree *basep;
12849
12850   int i;
12851   enum tag_types tag_code;
12852
12853   if (TREE_CODE (ref) == UNION_TYPE)
12854     {
12855       error ("derived union `%T' invalid", ref);
12856       return;
12857     }
12858
12859   tag_code = (CLASSTYPE_DECLARED_CLASS (ref) ? class_type : record_type);
12860
12861   /* First, make sure that any templates in base-classes are
12862      instantiated.  This ensures that if we call ourselves recursively
12863      we do not get confused about which classes are marked and which
12864      are not.  */
12865   basep = &binfo;
12866   while (*basep)
12867     {
12868       tree basetype = TREE_VALUE (*basep);
12869       if (!(processing_template_decl && uses_template_parms (basetype))
12870           && !complete_type_or_else (basetype, NULL))
12871         /* An incomplete type.  Remove it form the list.  */
12872         *basep = TREE_CHAIN (*basep);
12873       else
12874         basep = &TREE_CHAIN (*basep);
12875     }
12876
12877   SET_CLASSTYPE_MARKED (ref);
12878   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos
12879     = make_tree_vec (list_length (binfo));
12880
12881   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12882     {
12883       /* The base of a derived struct is public by default.  */
12884       int via_public
12885         = (TREE_PURPOSE (binfo) == access_public_node
12886            || TREE_PURPOSE (binfo) == access_public_virtual_node
12887            || (tag_code != class_type
12888                && (TREE_PURPOSE (binfo) == access_default_node
12889                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12890       int via_protected
12891         = (TREE_PURPOSE (binfo) == access_protected_node
12892            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12893       int via_virtual
12894         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12895            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12896            || TREE_PURPOSE (binfo) == access_public_virtual_node
12897            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12898       tree basetype = TREE_VALUE (binfo);
12899       tree base_binfo;
12900
12901       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12902         basetype = TREE_TYPE (basetype);
12903       if (!basetype
12904           || (TREE_CODE (basetype) != RECORD_TYPE
12905               && TREE_CODE (basetype) != TYPENAME_TYPE
12906               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12907               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
12908         {
12909           error ("base type `%T' fails to be a struct or class type",
12910                     TREE_VALUE (binfo));
12911           continue;
12912         }
12913
12914       if (CLASSTYPE_MARKED (basetype))
12915         {
12916           if (basetype == ref)
12917             error ("recursive type `%T' undefined", basetype);
12918           else
12919             error ("duplicate base type `%T' invalid", basetype);
12920           continue;
12921         }
12922
12923       if (TYPE_FOR_JAVA (basetype)
12924           && (current_lang_depth () == 0))
12925         TYPE_FOR_JAVA (ref) = 1;
12926
12927       /* Note that the BINFO records which describe individual
12928          inheritances are *not* shared in the lattice!  They
12929          cannot be shared because a given baseclass may be
12930          inherited with different `accessibility' by different
12931          derived classes.  (Each BINFO record describing an
12932          individual inheritance contains flags which say what
12933          the `accessibility' of that particular inheritance is.)  */
12934
12935       base_binfo
12936         = make_binfo (size_zero_node, basetype,
12937                       CLASS_TYPE_P (basetype)
12938                       ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12939                       CLASS_TYPE_P (basetype)
12940                       ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12941
12942       TREE_VEC_ELT (binfos, i) = base_binfo;
12943       TREE_VIA_PUBLIC (base_binfo) = via_public;
12944       TREE_VIA_PROTECTED (base_binfo) = via_protected;
12945       TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12946       BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12947
12948       /* We need to unshare the binfos now so that lookups during class
12949          definition work.  */
12950       unshare_base_binfos (base_binfo);
12951
12952       SET_CLASSTYPE_MARKED (basetype);
12953
12954       /* We are free to modify these bits because they are meaningless
12955          at top level, and BASETYPE is a top-level type.  */
12956       if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12957         {
12958           TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12959           /* Converting to a virtual base class requires looking
12960              up the offset of the virtual base.  */
12961           TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12962         }
12963
12964       if (CLASS_TYPE_P (basetype))
12965         {
12966           TYPE_HAS_NEW_OPERATOR (ref)
12967             |= TYPE_HAS_NEW_OPERATOR (basetype);
12968           TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12969             |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12970           TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12971           /* If the base-class uses multiple inheritance, so do we.  */
12972           TYPE_USES_MULTIPLE_INHERITANCE (ref)
12973             |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12974           /* Likewise, if converting to a base of the base may require
12975              code, then we may need to generate code to convert to a
12976              base as well.  */
12977           TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12978             |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12979         }
12980
12981       i += 1;
12982     }
12983   if (i)
12984     TREE_VEC_LENGTH (binfos) = i;
12985   else
12986     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12987
12988   if (i > 1)
12989     {
12990       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12991       /* If there is more than one non-empty they cannot be at the same
12992          address.  */
12993       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12994     }
12995
12996   /* Unmark all the types.  */
12997   while (--i >= 0)
12998     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12999   CLEAR_CLASSTYPE_MARKED (ref);
13000
13001   /* Now that we know all the base-classes, set up the list of virtual
13002      bases.  */
13003   get_vbase_types (ref);
13004 }
13005
13006 \f
13007 /* Begin compiling the definition of an enumeration type.
13008    NAME is its name (or null if anonymous).
13009    Returns the type object, as yet incomplete.
13010    Also records info about it so that build_enumerator
13011    may be used to declare the individual values as they are read.  */
13012
13013 tree
13014 start_enum (tree name)
13015 {
13016   register tree enumtype = NULL_TREE;
13017   struct cp_binding_level *b = current_binding_level;
13018
13019   /* If this is the real definition for a previous forward reference,
13020      fill in the contents in the same object that used to be the
13021      forward reference.  */
13022
13023   if (name != NULL_TREE)
13024     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13025
13026   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13027     {
13028       error ("multiple definition of `%#T'", enumtype);
13029       cp_error_at ("previous definition here", enumtype);
13030       /* Clear out TYPE_VALUES, and start again.  */
13031       TYPE_VALUES (enumtype) = NULL_TREE;
13032     }
13033   else
13034     {
13035       enumtype = make_node (ENUMERAL_TYPE);
13036       pushtag (name, enumtype, 0);
13037     }
13038
13039   return enumtype;
13040 }
13041
13042 /* After processing and defining all the values of an enumeration type,
13043    install their decls in the enumeration type and finish it off.
13044    ENUMTYPE is the type object and VALUES a list of name-value pairs.  */
13045
13046 void
13047 finish_enum (tree enumtype)
13048 {
13049   tree pair;
13050   tree minnode;
13051   tree maxnode;
13052   tree t;
13053   bool unsignedp;
13054   int lowprec;
13055   int highprec;
13056   int precision;
13057
13058   /* We built up the VALUES in reverse order.  */
13059   TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
13060
13061   /* [dcl.enum]
13062
13063      Following the closing brace of an enum-specifier, each
13064      enumerator has the type of its enumeration.  Prior to the
13065      closing brace, the type of each enumerator is the type of
13066      its initializing value.  */
13067   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13068     TREE_TYPE (TREE_VALUE (pair)) = enumtype;
13069
13070   /* For an enum defined in a template, all further processing is
13071      postponed until the template is instantiated.  */
13072   if (processing_template_decl)
13073     {
13074       if (at_function_scope_p ())
13075         add_stmt (build_min (TAG_DEFN, enumtype));
13076       return;
13077     }
13078
13079   /* Figure out what the minimum and maximum values of the enumerators
13080      are.  */
13081   if (TYPE_VALUES (enumtype))
13082     {
13083       minnode = maxnode = NULL_TREE;
13084
13085       for (pair = TYPE_VALUES (enumtype);
13086            pair;
13087            pair = TREE_CHAIN (pair))
13088         {
13089           tree value;
13090
13091           value = DECL_INITIAL (TREE_VALUE (pair));
13092
13093           if (!minnode)
13094             minnode = maxnode = value;
13095           else if (tree_int_cst_lt (maxnode, value))
13096             maxnode = value;
13097           else if (tree_int_cst_lt (value, minnode))
13098             minnode = value;
13099         }
13100     }
13101   else
13102     minnode = maxnode = integer_zero_node;
13103
13104   /* Compute the number of bits require to represent all values of the
13105      enumeration.  We must do this before the type of MINNODE and
13106      MAXNODE are transformed, since min_precision relies on the
13107      TREE_TYPE of the value it is passed.  */
13108   unsignedp = tree_int_cst_sgn (minnode) >= 0;
13109   lowprec = min_precision (minnode, unsignedp);
13110   highprec = min_precision (maxnode, unsignedp);
13111   precision = MAX (lowprec, highprec);
13112
13113   /* Set the TREE_TYPE for the values as well.  That's so that when we
13114      call decl_constant_value we get an entity of the right type (but
13115      with the constant value).  In addition, transform the TYPE_VALUES
13116      list to contain the values, rather than the CONST_DECLs for them.  */
13117   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13118     {
13119       tree value = DECL_INITIAL (TREE_VALUE (pair));
13120
13121       TREE_TYPE (value) = enumtype;
13122       TREE_VALUE (pair) = value;
13123     }
13124
13125   /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13126   TYPE_SIZE (enumtype) = NULL_TREE;
13127   TYPE_PRECISION (enumtype) = precision;
13128   if (unsignedp)
13129     fixup_unsigned_type (enumtype);
13130   else
13131     fixup_signed_type (enumtype);
13132
13133   if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13134     /* Use the width of the narrowest normal C type which is wide
13135        enough.  */
13136     TYPE_PRECISION (enumtype) = TYPE_PRECISION (c_common_type_for_size
13137                                                 (precision, 1));
13138   else
13139     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13140
13141   TYPE_SIZE (enumtype) = NULL_TREE;
13142   layout_type (enumtype);
13143
13144   /* Fix up all variant types of this enum type.  */
13145   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13146     {
13147       TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13148       TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
13149       TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
13150       TYPE_SIZE (t) = TYPE_SIZE (enumtype);
13151       TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
13152       TYPE_MODE (t) = TYPE_MODE (enumtype);
13153       TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
13154       TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
13155       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
13156       TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype);
13157     }
13158
13159   /* Finish debugging output for this type.  */
13160   rest_of_type_compilation (enumtype, namespace_bindings_p ());
13161 }
13162
13163 /* Build and install a CONST_DECL for an enumeration constant of the
13164    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13165    Assignment of sequential values by default is handled here.  */
13166
13167 void
13168 build_enumerator (tree name, tree value, tree enumtype)
13169 {
13170   tree decl;
13171   tree context;
13172   tree type;
13173   tree values;
13174
13175   /* Remove no-op casts from the value.  */
13176   if (value)
13177     STRIP_TYPE_NOPS (value);
13178
13179   if (! processing_template_decl)
13180     {
13181       /* Validate and default VALUE.  */
13182       if (value != NULL_TREE)
13183         {
13184           value = decl_constant_value (value);
13185
13186           if (TREE_CODE (value) == INTEGER_CST)
13187             {
13188               value = default_conversion (value);
13189               constant_expression_warning (value);
13190             }
13191           else
13192             {
13193               error ("enumerator value for `%D' not integer constant", name);
13194               value = NULL_TREE;
13195             }
13196         }
13197
13198       /* Default based on previous value.  */
13199       if (value == NULL_TREE)
13200         {
13201           tree prev_value;
13202
13203           if (TYPE_VALUES (enumtype))
13204             {
13205               /* The next value is the previous value ...  */
13206               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13207               /* ... plus one.  */
13208               value = cp_build_binary_op (PLUS_EXPR,
13209                                           prev_value,
13210                                           integer_one_node);
13211
13212               if (tree_int_cst_lt (value, prev_value))
13213                 error ("overflow in enumeration values at `%D'", name);
13214             }
13215           else
13216             value = integer_zero_node;
13217         }
13218
13219       /* Remove no-op casts from the value.  */
13220       if (value)
13221         STRIP_TYPE_NOPS (value);
13222 #if 0
13223       /* To fix MAX_VAL enum consts. (bkoz)  */
13224       TREE_TYPE (value) = integer_type_node;
13225 #endif
13226     }
13227
13228   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13229      Even in other cases, we will later (in finish_enum) be setting
13230      the type of VALUE.  But, we don't need to make a copy if this
13231      VALUE is one of the enumeration constants for this same
13232      enumeration type.  */
13233   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13234     if (TREE_VALUE (values) == value)
13235       break;
13236   /* If we didn't break out of the loop, then we do need a copy.  */
13237   if (!values && value)
13238     value = copy_node (value);
13239
13240   /* C++ associates enums with global, function, or class declarations.  */
13241   context = current_scope ();
13242
13243   /* Build the actual enumeration constant.  Note that the enumeration
13244     constants have the type of their initializers until the
13245     enumeration is complete:
13246
13247       [ dcl.enum ]
13248
13249       Following the closing brace of an enum-specifier, each enumer-
13250       ator has the type of its enumeration.  Prior to the closing
13251       brace, the type of each enumerator is the type of its
13252       initializing value.
13253
13254     In finish_enum we will reset the type.  Of course, if we're
13255     processing a template, there may be no value.  */
13256   type = value ? TREE_TYPE (value) : NULL_TREE;
13257
13258   if (context && context == current_class_type)
13259     /* This enum declaration is local to the class.  We need the full
13260        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13261     decl = build_lang_decl (CONST_DECL, name, type);
13262   else
13263     /* It's a global enum, or it's local to a function.  (Note local to
13264       a function could mean local to a class method.  */
13265     decl = build_decl (CONST_DECL, name, type);
13266
13267   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13268   DECL_INITIAL (decl) = value;
13269   TREE_READONLY (decl) = 1;
13270
13271   if (context && context == current_class_type)
13272     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13273       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13274       things like `S::i' later.)  */
13275     finish_member_declaration (decl);
13276   else
13277     pushdecl (decl);
13278
13279   /* Add this enumeration constant to the list for this type.  */
13280   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13281 }
13282
13283 \f
13284 /* We're defining DECL.  Make sure that it's type is OK.  */
13285
13286 static void
13287 check_function_type (tree decl, tree current_function_parms)
13288 {
13289   tree fntype = TREE_TYPE (decl);
13290   tree return_type = complete_type (TREE_TYPE (fntype));
13291
13292   /* In a function definition, arg types must be complete.  */
13293   require_complete_types_for_parms (current_function_parms);
13294
13295   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13296     {
13297       error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13298
13299       /* Make it return void instead, but don't change the
13300          type of the DECL_RESULT, in case we have a named return value.  */
13301       if (TREE_CODE (fntype) == METHOD_TYPE)
13302         {
13303           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13304           TREE_TYPE (decl)
13305             = build_cplus_method_type (ctype,
13306                                        void_type_node,
13307                                        FUNCTION_ARG_CHAIN (decl));
13308         }
13309       else
13310         TREE_TYPE (decl)
13311           = build_function_type (void_type_node,
13312                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13313       TREE_TYPE (decl)
13314         = build_exception_variant (fntype,
13315                                    TYPE_RAISES_EXCEPTIONS (fntype));
13316     }
13317   else
13318     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13319 }
13320
13321 /* Create the FUNCTION_DECL for a function definition.
13322    DECLSPECS and DECLARATOR are the parts of the declaration;
13323    they describe the function's name and the type it returns,
13324    but twisted together in a fashion that parallels the syntax of C.
13325
13326    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13327    DECLARATOR is really the DECL for the function we are about to
13328    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13329    indicating that the function is an inline defined in-class.
13330
13331    This function creates a binding context for the function body
13332    as well as setting up the FUNCTION_DECL in current_function_decl.
13333
13334    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13335    (it defines a datum instead), we return 0, which tells
13336    yyparse to report a parse error.
13337
13338    For C++, we must first check whether that datum makes any sense.
13339    For example, "class A local_a(1,2);" means that variable local_a
13340    is an aggregate of type A, which should have a constructor
13341    applied to it with the argument list [1, 2].  */
13342
13343 int
13344 start_function (tree declspecs, tree declarator, tree attrs, int flags)
13345 {
13346   tree decl1;
13347   tree ctype = NULL_TREE;
13348   tree fntype;
13349   tree restype;
13350   int doing_friend = 0;
13351   struct cp_binding_level *bl;
13352   tree current_function_parms;
13353
13354   /* Sanity check.  */
13355   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13356   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13357
13358   /* This should only be done once on the top most decl.  */
13359   if (have_extern_spec)
13360     {
13361       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13362       have_extern_spec = false;
13363     }
13364
13365   if (flags & SF_PRE_PARSED)
13366     {
13367       decl1 = declarator;
13368
13369       fntype = TREE_TYPE (decl1);
13370       if (TREE_CODE (fntype) == METHOD_TYPE)
13371         ctype = TYPE_METHOD_BASETYPE (fntype);
13372
13373       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13374          the (lexical) scope of the class in which it is defined.  */
13375       if (!ctype && DECL_FRIEND_P (decl1))
13376         {
13377           ctype = DECL_FRIEND_CONTEXT (decl1);
13378
13379           /* CTYPE could be null here if we're dealing with a template;
13380              for example, `inline friend float foo()' inside a template
13381              will have no CTYPE set.  */
13382           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13383             ctype = NULL_TREE;
13384           else
13385             doing_friend = 1;
13386         }
13387
13388       last_function_parms = DECL_ARGUMENTS (decl1);
13389     }
13390   else
13391     {
13392       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL);
13393       /* If the declarator is not suitable for a function definition,
13394          cause a syntax error.  */
13395       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
13396         return 0;
13397
13398       cplus_decl_attributes (&decl1, attrs, 0);
13399
13400       /* If #pragma weak was used, mark the decl weak now.  */
13401       if (current_binding_level == global_binding_level)
13402         maybe_apply_pragma_weak (decl1);
13403
13404       fntype = TREE_TYPE (decl1);
13405
13406       restype = TREE_TYPE (fntype);
13407       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13408         {
13409           error ("semicolon missing after declaration of `%#T'", restype);
13410           shadow_tag (build_tree_list (NULL_TREE, restype));
13411           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13412           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13413             fntype = build_function_type (integer_type_node,
13414                                           TYPE_ARG_TYPES (fntype));
13415           else
13416             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13417                                               integer_type_node,
13418                                               TYPE_ARG_TYPES (fntype));
13419           TREE_TYPE (decl1) = fntype;
13420         }
13421
13422       if (TREE_CODE (fntype) == METHOD_TYPE)
13423         ctype = TYPE_METHOD_BASETYPE (fntype);
13424       else if (DECL_MAIN_P (decl1))
13425         {
13426           /* If this doesn't return integer_type, complain.  */
13427           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13428             {
13429               if (pedantic || warn_return_type)
13430                 pedwarn ("return type for `main' changed to `int'");
13431               TREE_TYPE (decl1) = fntype = default_function_type;
13432             }
13433         }
13434     }
13435
13436   if (DECL_DECLARED_INLINE_P (decl1)
13437       && lookup_attribute ("noinline", attrs))
13438     warning_with_decl (decl1,
13439                        "inline function `%s' given attribute noinline");
13440
13441   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13442     /* This is a constructor, we must ensure that any default args
13443        introduced by this definition are propagated to the clones
13444        now. The clones are used directly in overload resolution.  */
13445     adjust_clone_args (decl1);
13446
13447   /* Sometimes we don't notice that a function is a static member, and
13448      build a METHOD_TYPE for it.  Fix that up now.  */
13449   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13450       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13451     {
13452       revert_static_member_fn (decl1);
13453       last_function_parms = TREE_CHAIN (last_function_parms);
13454       ctype = NULL_TREE;
13455     }
13456
13457   /* Warn if function was previously implicitly declared
13458      (but not if we warned then).  */
13459   if (! warn_implicit
13460       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13461     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13462
13463   /* Set up current_class_type, and enter the scope of the class, if
13464      appropriate.  */
13465   if (ctype)
13466     push_nested_class (ctype);
13467   else if (DECL_STATIC_FUNCTION_P (decl1))
13468     push_nested_class (DECL_CONTEXT (decl1));
13469
13470   /* Now that we have entered the scope of the class, we must restore
13471      the bindings for any template parameters surrounding DECL1, if it
13472      is an inline member template.  (Order is important; consider the
13473      case where a template parameter has the same name as a field of
13474      the class.)  It is not until after this point that
13475      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13476   if (flags & SF_INCLASS_INLINE)
13477     maybe_begin_member_template_processing (decl1);
13478
13479   /* Effective C++ rule 15.  */
13480   if (warn_ecpp
13481       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13482       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13483     warning ("`operator=' should return a reference to `*this'");
13484
13485   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13486      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13487   if (!DECL_INITIAL (decl1))
13488     DECL_INITIAL (decl1) = error_mark_node;
13489
13490   /* This function exists in static storage.
13491      (This does not mean `static' in the C sense!)  */
13492   TREE_STATIC (decl1) = 1;
13493
13494   /* We must call push_template_decl after current_class_type is set
13495      up.  (If we are processing inline definitions after exiting a
13496      class scope, current_class_type will be NULL_TREE until set above
13497      by push_nested_class.)  */
13498   if (processing_template_decl)
13499     decl1 = push_template_decl (decl1);
13500
13501   /* We are now in the scope of the function being defined.  */
13502   current_function_decl = decl1;
13503
13504   /* Save the parm names or decls from this function's declarator
13505      where store_parm_decls will find them.  */
13506   current_function_parms = last_function_parms;
13507
13508   /* Make sure the parameter and return types are reasonable.  When
13509      you declare a function, these types can be incomplete, but they
13510      must be complete when you define the function.  */
13511   if (! processing_template_decl)
13512     check_function_type (decl1, current_function_parms);
13513
13514   /* Build the return declaration for the function.  */
13515   restype = TREE_TYPE (fntype);
13516   /* Promote the value to int before returning it.  */
13517   if (c_promoting_integer_type_p (restype))
13518     restype = type_promotes_to (restype);
13519   if (DECL_RESULT (decl1) == NULL_TREE)
13520     {
13521       DECL_RESULT (decl1)
13522         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13523       c_apply_type_quals_to_decl (cp_type_quals (restype),
13524                                   DECL_RESULT (decl1));
13525     }
13526
13527   /* Initialize RTL machinery.  We cannot do this until
13528      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13529      even when processing a template; this is how we get
13530      CFUN set up, and our per-function variables initialized.
13531      FIXME factor out the non-RTL stuff.  */
13532   bl = current_binding_level;
13533   init_function_start (decl1, input_filename, lineno);
13534   current_binding_level = bl;
13535
13536   /* Even though we're inside a function body, we still don't want to
13537      call expand_expr to calculate the size of a variable-sized array.
13538      We haven't necessarily assigned RTL to all variables yet, so it's
13539      not safe to try to expand expressions involving them.  */
13540   immediate_size_expand = 0;
13541   cfun->x_dont_save_pending_sizes_p = 1;
13542
13543   /* Start the statement-tree, start the tree now.  */
13544   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13545
13546   /* Let the user know we're compiling this function.  */
13547   announce_function (decl1);
13548
13549   /* Record the decl so that the function name is defined.
13550      If we already have a decl for this name, and it is a FUNCTION_DECL,
13551      use the old decl.  */
13552   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13553     {
13554       /* A specialization is not used to guide overload resolution.  */
13555       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13556           && ! DECL_FUNCTION_MEMBER_P (decl1))
13557         decl1 = pushdecl (decl1);
13558       else
13559         {
13560           /* We need to set the DECL_CONTEXT.  */
13561           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13562             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13563           /* And make sure we have enough default args.  */
13564           check_default_args (decl1);
13565         }
13566       fntype = TREE_TYPE (decl1);
13567     }
13568
13569   /* Reset these in case the call to pushdecl changed them.  */
13570   current_function_decl = decl1;
13571   cfun->decl = decl1;
13572
13573   /* If we are (erroneously) defining a function that we have already
13574      defined before, wipe out what we knew before.  */
13575   if (!DECL_PENDING_INLINE_P (decl1))
13576     DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13577
13578   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13579     {
13580       /* We know that this was set up by `grokclassfn'.  We do not
13581          wait until `store_parm_decls', since evil parse errors may
13582          never get us to that point.  Here we keep the consistency
13583          between `current_class_type' and `current_class_ptr'.  */
13584       tree t = DECL_ARGUMENTS (decl1);
13585
13586       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13587                           162);
13588       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13589                           19990811);
13590
13591       cp_function_chain->x_current_class_ref
13592         = build_indirect_ref (t, NULL);
13593       cp_function_chain->x_current_class_ptr = t;
13594
13595       /* Constructors and destructors need to know whether they're "in
13596          charge" of initializing virtual base classes.  */
13597       t = TREE_CHAIN (t);
13598       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13599         {
13600           current_in_charge_parm = t;
13601           t = TREE_CHAIN (t);
13602         }
13603       if (DECL_HAS_VTT_PARM_P (decl1))
13604         {
13605           if (DECL_NAME (t) != vtt_parm_identifier)
13606             abort ();
13607           current_vtt_parm = t;
13608         }
13609     }
13610
13611   if (DECL_INTERFACE_KNOWN (decl1))
13612     {
13613       tree ctx = decl_function_context (decl1);
13614
13615       if (DECL_NOT_REALLY_EXTERN (decl1))
13616         DECL_EXTERNAL (decl1) = 0;
13617
13618       if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
13619           && TREE_PUBLIC (ctx))
13620         /* This is a function in a local class in an extern inline
13621            function.  */
13622         comdat_linkage (decl1);
13623     }
13624   /* If this function belongs to an interface, it is public.
13625      If it belongs to someone else's interface, it is also external.
13626      This only affects inlines and template instantiations.  */
13627   else if (interface_unknown == 0
13628            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13629                || flag_alt_external_templates))
13630     {
13631       if (DECL_DECLARED_INLINE_P (decl1)
13632           || DECL_TEMPLATE_INSTANTIATION (decl1)
13633           || processing_template_decl)
13634         {
13635           DECL_EXTERNAL (decl1)
13636             = (interface_only
13637                || (DECL_DECLARED_INLINE_P (decl1)
13638                    && ! flag_implement_inlines
13639                    && !DECL_VINDEX (decl1)));
13640
13641           /* For WIN32 we also want to put these in linkonce sections.  */
13642           maybe_make_one_only (decl1);
13643         }
13644       else
13645         DECL_EXTERNAL (decl1) = 0;
13646       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13647       DECL_INTERFACE_KNOWN (decl1) = 1;
13648     }
13649   else if (interface_unknown && interface_only
13650            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13651                || flag_alt_external_templates))
13652     {
13653       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13654          interface, we will have interface_only set but not
13655          interface_known.  In that case, we don't want to use the normal
13656          heuristics because someone will supply a #pragma implementation
13657          elsewhere, and deducing it here would produce a conflict.  */
13658       comdat_linkage (decl1);
13659       DECL_EXTERNAL (decl1) = 0;
13660       DECL_INTERFACE_KNOWN (decl1) = 1;
13661       DECL_DEFER_OUTPUT (decl1) = 1;
13662     }
13663   else
13664     {
13665       /* This is a definition, not a reference.
13666          So clear DECL_EXTERNAL.  */
13667       DECL_EXTERNAL (decl1) = 0;
13668
13669       if ((DECL_DECLARED_INLINE_P (decl1)
13670            || DECL_TEMPLATE_INSTANTIATION (decl1))
13671           && ! DECL_INTERFACE_KNOWN (decl1)
13672           /* Don't try to defer nested functions for now.  */
13673           && ! decl_function_context (decl1))
13674         DECL_DEFER_OUTPUT (decl1) = 1;
13675       else
13676         DECL_INTERFACE_KNOWN (decl1) = 1;
13677     }
13678
13679   pushlevel (0);
13680   current_binding_level->parm_flag = 1;
13681
13682   ++function_depth;
13683
13684   if (DECL_DESTRUCTOR_P (decl1))
13685     {
13686       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13687       DECL_CONTEXT (dtor_label) = current_function_decl;
13688     }
13689
13690   start_fname_decls ();
13691
13692   store_parm_decls (current_function_parms);
13693
13694   return 1;
13695 }
13696 \f
13697 /* Store the parameter declarations into the current function declaration.
13698    This is called after parsing the parameter declarations, before
13699    digesting the body of the function.
13700
13701    Also install to binding contour return value identifier, if any.  */
13702
13703 static void
13704 store_parm_decls (tree current_function_parms)
13705 {
13706   register tree fndecl = current_function_decl;
13707   register tree parm;
13708
13709   /* This is a chain of any other decls that came in among the parm
13710      declarations.  If a parm is declared with  enum {foo, bar} x;
13711      then CONST_DECLs for foo and bar are put here.  */
13712   tree nonparms = NULL_TREE;
13713
13714   if (current_function_parms)
13715     {
13716       /* This case is when the function was defined with an ANSI prototype.
13717          The parms already have decls, so we need not do anything here
13718          except record them as in effect
13719          and complain if any redundant old-style parm decls were written.  */
13720
13721       tree specparms = current_function_parms;
13722       tree next;
13723
13724       /* Must clear this because it might contain TYPE_DECLs declared
13725              at class level.  */
13726       storedecls (NULL_TREE);
13727
13728       /* If we're doing semantic analysis, then we'll call pushdecl
13729              for each of these.  We must do them in reverse order so that
13730              they end in the correct forward order.  */
13731       specparms = nreverse (specparms);
13732
13733       for (parm = specparms; parm; parm = next)
13734         {
13735           next = TREE_CHAIN (parm);
13736           if (TREE_CODE (parm) == PARM_DECL)
13737             {
13738               if (DECL_NAME (parm) == NULL_TREE
13739                   || TREE_CODE (parm) != VOID_TYPE)
13740                 pushdecl (parm);
13741               else
13742                 error ("parameter `%D' declared void", parm);
13743             }
13744           else
13745             {
13746               /* If we find an enum constant or a type tag,
13747                  put it aside for the moment.  */
13748               TREE_CHAIN (parm) = NULL_TREE;
13749               nonparms = chainon (nonparms, parm);
13750             }
13751         }
13752
13753       /* Get the decls in their original chain order and record in the
13754          function.  This is all and only the PARM_DECLs that were
13755          pushed into scope by the loop above.  */
13756       DECL_ARGUMENTS (fndecl) = getdecls ();
13757       storetags (gettags ());
13758     }
13759   else
13760     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13761
13762   /* Now store the final chain of decls for the arguments
13763      as the decl-chain of the current lexical scope.
13764      Put the enumerators in as well, at the front so that
13765      DECL_ARGUMENTS is not modified.  */
13766   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13767
13768   /* Do the starting of the exception specifications, if we have any.  */
13769   if (flag_exceptions && !processing_template_decl
13770       && flag_enforce_eh_specs
13771       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13772     current_eh_spec_block = begin_eh_spec_block ();
13773 }
13774
13775 \f
13776 /* We have finished doing semantic analysis on DECL, but have not yet
13777    generated RTL for its body.  Save away our current state, so that
13778    when we want to generate RTL later we know what to do.  */
13779
13780 static void
13781 save_function_data (tree decl)
13782 {
13783   struct language_function *f;
13784
13785   /* Save the language-specific per-function data so that we can
13786      get it back when we really expand this function.  */
13787   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13788                       19990908);
13789
13790   /* Make a copy.  */
13791   f = ((struct language_function *)
13792        ggc_alloc (sizeof (struct language_function)));
13793   memcpy (f, cp_function_chain, sizeof (struct language_function));
13794   DECL_SAVED_FUNCTION_DATA (decl) = f;
13795
13796   /* Clear out the bits we don't need.  */
13797   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
13798   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
13799   f->x_named_label_uses = NULL;
13800   f->bindings = NULL;
13801   f->x_local_names = NULL;
13802
13803   /* When we get back here again, we will be expanding.  */
13804   f->x_expanding_p = 1;
13805
13806   /* If we've already decided that we cannot inline this function, we
13807      must remember that fact when we actually go to expand the
13808      function.  */
13809   if (current_function_cannot_inline)
13810     {
13811       f->cannot_inline = current_function_cannot_inline;
13812       DECL_INLINE (decl) = 0;
13813     }
13814 }
13815
13816 /* Add a note to mark the beginning of the main body of the constructor.
13817    This is used to set up the data structures for the cleanup regions for
13818    fully-constructed bases and members.  */
13819
13820 static void
13821 begin_constructor_body (void)
13822 {
13823 }
13824
13825 /* Add a note to mark the end of the main body of the constructor.  This is
13826    used to end the cleanup regions for fully-constructed bases and
13827    members.  */
13828
13829 static void
13830 finish_constructor_body (void)
13831 {
13832 }
13833
13834 /* Do all the processing for the beginning of a destructor; set up the
13835    vtable pointers and cleanups for bases and members.  */
13836
13837 static void
13838 begin_destructor_body (void)
13839 {
13840   tree if_stmt;
13841   tree compound_stmt;
13842
13843   /* If the dtor is empty, and we know there is not any possible
13844      way we could use any vtable entries, before they are possibly
13845      set by a base class dtor, we don't have to setup the vtables,
13846      as we know that any base class dtor will set up any vtables
13847      it needs.  We avoid MI, because one base class dtor can do a
13848      virtual dispatch to an overridden function that would need to
13849      have a non-related vtable set up, we cannot avoid setting up
13850      vtables in that case.  We could change this to see if there
13851      is just one vtable.
13852
13853      ??? In the destructor for a class, the vtables are set
13854      appropriately for that class.  There will be no non-related
13855      vtables.  jason 2001-12-11.  */
13856   if_stmt = begin_if_stmt ();
13857
13858   /* If it is not safe to avoid setting up the vtables, then
13859      someone will change the condition to be boolean_true_node.
13860      (Actually, for now, we do not have code to set the condition
13861      appropriately, so we just assume that we always need to
13862      initialize the vtables.)  */
13863   finish_if_stmt_cond (boolean_true_node, if_stmt);
13864
13865   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13866
13867   /* Make all virtual function table pointers in non-virtual base
13868      classes point to CURRENT_CLASS_TYPE's virtual function
13869      tables.  */
13870   initialize_vtbl_ptrs (current_class_ptr);
13871
13872   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13873   finish_then_clause (if_stmt);
13874   finish_if_stmt ();
13875
13876   /* And insert cleanups for our bases and members so that they
13877      will be properly destroyed if we throw.  */
13878   push_base_cleanups ();
13879 }
13880
13881 /* At the end of every destructor we generate code to delete the object if
13882    necessary.  Do that now.  */
13883
13884 static void
13885 finish_destructor_body (void)
13886 {
13887   tree exprstmt;
13888
13889   /* Any return from a destructor will end up here; that way all base
13890      and member cleanups will be run when the function returns.  */
13891   add_stmt (build_stmt (LABEL_STMT, dtor_label));
13892
13893   /* In a virtual destructor, we must call delete.  */
13894   if (DECL_VIRTUAL_P (current_function_decl))
13895     {
13896       tree if_stmt;
13897       tree virtual_size = cxx_sizeof (current_class_type);
13898
13899       /* [class.dtor]
13900
13901       At the point of definition of a virtual destructor (including
13902       an implicit definition), non-placement operator delete shall
13903       be looked up in the scope of the destructor's class and if
13904       found shall be accessible and unambiguous.  */
13905       exprstmt = build_op_delete_call
13906         (DELETE_EXPR, current_class_ptr, virtual_size,
13907          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13908
13909       if_stmt = begin_if_stmt ();
13910       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13911                                   current_in_charge_parm,
13912                                   integer_one_node),
13913                            if_stmt);
13914       finish_expr_stmt (exprstmt);
13915       finish_then_clause (if_stmt);
13916       finish_if_stmt ();
13917     }
13918 }
13919
13920 /* Do the necessary processing for the beginning of a function body, which
13921    in this case includes member-initializers, but not the catch clauses of
13922    a function-try-block.  Currently, this means opening a binding level
13923    for the member-initializers (in a ctor) and member cleanups (in a dtor).
13924    In other functions, this isn't necessary, but it doesn't hurt.  */
13925
13926 tree
13927 begin_function_body (void)
13928 {
13929   tree stmt;
13930
13931   if (processing_template_decl)
13932     /* Do nothing now.  */;
13933   else
13934     /* Always keep the BLOCK node associated with the outermost pair of
13935        curly braces of a function.  These are needed for correct
13936        operation of dwarfout.c.  */
13937     keep_next_level (1);
13938
13939   stmt = begin_compound_stmt (0);
13940   COMPOUND_STMT_BODY_BLOCK (stmt) = 1;
13941
13942   if (processing_template_decl)
13943     /* Do nothing now.  */;
13944   else if (DECL_CONSTRUCTOR_P (current_function_decl))
13945     begin_constructor_body ();
13946   else if (DECL_DESTRUCTOR_P (current_function_decl))
13947     begin_destructor_body ();
13948
13949   return stmt;
13950 }
13951
13952 /* Do the processing for the end of a function body.  Currently, this means
13953    closing out the cleanups for fully-constructed bases and members, and in
13954    the case of the destructor, deleting the object if desired.  Again, this
13955    is only meaningful for [cd]tors, since they are the only functions where
13956    there is a significant distinction between the main body and any
13957    function catch clauses.  Handling, say, main() return semantics here
13958    would be wrong, as flowing off the end of a function catch clause for
13959    main() would also need to return 0.  */
13960
13961 void
13962 finish_function_body (tree compstmt)
13963 {
13964   /* Close the block.  */
13965   finish_compound_stmt (0, compstmt);
13966
13967   if (processing_template_decl)
13968     /* Do nothing now.  */;
13969   else if (DECL_CONSTRUCTOR_P (current_function_decl))
13970     finish_constructor_body ();
13971   else if (DECL_DESTRUCTOR_P (current_function_decl))
13972     finish_destructor_body ();
13973 }
13974
13975 /* Finish up a function declaration and compile that function
13976    all the way to assembler language output.  The free the storage
13977    for the function definition.
13978
13979    FLAGS is a bitwise or of the following values:
13980      2 - INCLASS_INLINE
13981        We just finished processing the body of an in-class inline
13982        function definition.  (This processing will have taken place
13983        after the class definition is complete.)  */
13984
13985 tree
13986 finish_function (int flags)
13987 {
13988   register tree fndecl = current_function_decl;
13989   tree fntype, ctype = NULL_TREE;
13990   int inclass_inline = (flags & 2) != 0;
13991   int nested;
13992
13993   /* When we get some parse errors, we can end up without a
13994      current_function_decl, so cope.  */
13995   if (fndecl == NULL_TREE)
13996     return error_mark_node;
13997
13998   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
13999       && DECL_VIRTUAL_P (fndecl)
14000       && !processing_template_decl)
14001     {
14002       tree fnclass = DECL_CONTEXT (fndecl);
14003       if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
14004         keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
14005     }
14006
14007   nested = function_depth > 1;
14008   fntype = TREE_TYPE (fndecl);
14009
14010   /*  TREE_READONLY (fndecl) = 1;
14011       This caused &foo to be of type ptr-to-const-function
14012       which then got a warning when stored in a ptr-to-function variable.  */
14013
14014   my_friendly_assert (building_stmt_tree (), 20000911);
14015
14016   finish_fname_decls ();
14017
14018   /* For a cloned function, we've already got all the code we need;
14019      there's no need to add any extra bits.  */
14020   if (!DECL_CLONED_FUNCTION_P (fndecl))
14021     {
14022       if (DECL_MAIN_P (current_function_decl))
14023         {
14024           /* Make it so that `main' always returns 0 by default.  */
14025 #if VMS_TARGET
14026           finish_return_stmt (integer_one_node);
14027 #else
14028           finish_return_stmt (integer_zero_node);
14029 #endif
14030         }
14031
14032       /* Finish dealing with exception specifiers.  */
14033       if (flag_exceptions && !processing_template_decl
14034           && flag_enforce_eh_specs
14035           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14036         finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14037                               (TREE_TYPE (current_function_decl)),
14038                               current_eh_spec_block);
14039     }
14040
14041   /* If we're saving up tree structure, tie off the function now.  */
14042   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14043
14044   /* This must come after expand_function_end because cleanups might
14045      have declarations (from inline functions) that need to go into
14046      this function's blocks.  */
14047
14048   /* If the current binding level isn't the outermost binding level
14049      for this function, either there is a bug, or we have experienced
14050      syntax errors and the statement tree is malformed.  */
14051   if (current_binding_level->parm_flag != 1)
14052     {
14053       /* Make sure we have already experienced errors.  */
14054       if (errorcount == 0)
14055         abort ();
14056
14057       /* Throw away the broken statement tree and extra binding
14058          levels.  */
14059       DECL_SAVED_TREE (fndecl) = build_stmt (COMPOUND_STMT, NULL_TREE);
14060
14061       while (current_binding_level->parm_flag != 1)
14062         {
14063           if (current_binding_level->parm_flag == 2)
14064             pop_nested_class ();
14065           else
14066             poplevel (0, 0, 0);
14067         }
14068     }
14069   poplevel (1, 0, 1);
14070
14071   /* Set up the named return value optimization, if we can.  Here, we
14072      eliminate the copy from the nrv into the RESULT_DECL and any cleanup
14073      for the nrv.  genrtl_start_function and declare_return_variable
14074      handle making the nrv and RESULT_DECL share space.  */
14075   if (current_function_return_value)
14076     {
14077       tree r = current_function_return_value;
14078       /* This is only worth doing for fns that return in memory--and
14079          simpler, since we don't have to worry about promoted modes.  */
14080       if (r != error_mark_node
14081           && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl))))
14082         {
14083           DECL_ALIGN (r) = DECL_ALIGN (DECL_RESULT (fndecl));
14084           walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl),
14085                                         nullify_returns_r, r);
14086         }
14087       else
14088         /* Clear it so genrtl_start_function and declare_return_variable
14089            know we're not optimizing.  */
14090         current_function_return_value = NULL_TREE;
14091     }
14092
14093   /* Remember that we were in class scope.  */
14094   if (current_class_name)
14095     ctype = current_class_type;
14096
14097   /* Must mark the RESULT_DECL as being in this function.  */
14098   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14099
14100   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14101      to the FUNCTION_DECL node itself.  */
14102   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14103
14104   /* Save away current state, if appropriate.  */
14105   if (!processing_template_decl)
14106     save_function_data (fndecl);
14107
14108   /* If this function calls `setjmp' it cannot be inlined.  When
14109      `longjmp' is called it is not guaranteed to restore the value of
14110      local variables that have been modified since the call to
14111      `setjmp'.  So, if were to inline this function into some caller
14112      `c', then when we `longjmp', we might not restore all variables
14113      in `c'.  (It might seem, at first blush, that there's no way for
14114      this function to modify local variables in `c', but their
14115      addresses may have been stored somewhere accessible to this
14116      function.)  */
14117   if (!processing_template_decl && calls_setjmp_p (fndecl))
14118     DECL_UNINLINABLE (fndecl) = 1;
14119
14120   /* Complain if there's just no return statement.  */
14121   if (warn_return_type
14122       && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
14123       && !current_function_returns_value && !current_function_returns_null
14124       /* Don't complain if we abort or throw.  */
14125       && !current_function_returns_abnormally
14126       && !DECL_NAME (DECL_RESULT (fndecl))
14127       /* Normally, with -Wreturn-type, flow will complain.  Unless we're an
14128          inline function, as we might never be compiled separately.  */
14129       && (DECL_INLINE (fndecl) || processing_template_decl))
14130     warning ("no return statement in function returning non-void");
14131
14132   /* Clear out memory we no longer need.  */
14133   free_after_parsing (cfun);
14134   /* Since we never call rest_of_compilation, we never clear
14135      CFUN.  Do so explicitly.  */
14136   free_after_compilation (cfun);
14137   cfun = NULL;
14138
14139   /* If this is an in-class inline definition, we may have to pop the
14140      bindings for the template parameters that we added in
14141      maybe_begin_member_template_processing when start_function was
14142      called.  */
14143   if (inclass_inline)
14144     maybe_end_member_template_processing ();
14145
14146   /* Leave the scope of the class.  */
14147   if (ctype)
14148     pop_nested_class ();
14149
14150   --function_depth;
14151
14152   /* Clean up.  */
14153   if (! nested)
14154     /* Let the error reporting routines know that we're outside a
14155        function.  For a nested function, this value is used in
14156        cxx_pop_function_context and then reset via pop_function_context.  */
14157     current_function_decl = NULL_TREE;
14158
14159   return fndecl;
14160 }
14161 \f
14162 /* Create the FUNCTION_DECL for a function definition.
14163    DECLSPECS and DECLARATOR are the parts of the declaration;
14164    they describe the return type and the name of the function,
14165    but twisted together in a fashion that parallels the syntax of C.
14166
14167    This function creates a binding context for the function body
14168    as well as setting up the FUNCTION_DECL in current_function_decl.
14169
14170    Returns a FUNCTION_DECL on success.
14171
14172    If the DECLARATOR is not suitable for a function (it defines a datum
14173    instead), we return 0, which tells yyparse to report a parse error.
14174
14175    May return void_type_node indicating that this method is actually
14176    a friend.  See grokfield for more details.
14177
14178    Came here with a `.pushlevel' .
14179
14180    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14181    CHANGES TO CODE IN `grokfield'.  */
14182
14183 tree
14184 start_method (tree declspecs, tree declarator, tree attrlist)
14185 {
14186   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14187                                 &attrlist);
14188
14189   if (fndecl == error_mark_node)
14190     return error_mark_node;
14191
14192   if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
14193     {
14194       error ("invalid member function declaration");
14195       return error_mark_node;
14196     }
14197
14198   if (attrlist)
14199     cplus_decl_attributes (&fndecl, attrlist, 0);
14200
14201   /* Pass friends other than inline friend functions back.  */
14202   if (fndecl == void_type_node)
14203     return fndecl;
14204
14205   if (DECL_IN_AGGR_P (fndecl))
14206     {
14207       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14208         {
14209           if (DECL_CONTEXT (fndecl)
14210               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14211             error ("`%D' is already defined in class `%T'", fndecl,
14212                       DECL_CONTEXT (fndecl));
14213         }
14214       return void_type_node;
14215     }
14216
14217   check_template_shadow (fndecl);
14218
14219   DECL_DECLARED_INLINE_P (fndecl) = 1;
14220
14221   if (flag_default_inline)
14222     DECL_INLINE (fndecl) = 1;
14223
14224   /* We process method specializations in finish_struct_1.  */
14225   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14226     fndecl = push_template_decl (fndecl);
14227
14228   if (! DECL_FRIEND_P (fndecl))
14229     {
14230       if (TREE_CHAIN (fndecl))
14231         {
14232           fndecl = copy_node (fndecl);
14233           TREE_CHAIN (fndecl) = NULL_TREE;
14234         }
14235       grok_special_member_properties (fndecl);
14236     }
14237
14238   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14239
14240   /* Make a place for the parms */
14241   pushlevel (0);
14242   current_binding_level->parm_flag = 1;
14243
14244   DECL_IN_AGGR_P (fndecl) = 1;
14245   return fndecl;
14246 }
14247
14248 /* Go through the motions of finishing a function definition.
14249    We don't compile this method until after the whole class has
14250    been processed.
14251
14252    FINISH_METHOD must return something that looks as though it
14253    came from GROKFIELD (since we are defining a method, after all).
14254
14255    This is called after parsing the body of the function definition.
14256    STMTS is the chain of statements that makes up the function body.
14257
14258    DECL is the ..._DECL that `start_method' provided.  */
14259
14260 tree
14261 finish_method (tree decl)
14262 {
14263   register tree fndecl = decl;
14264   tree old_initial;
14265
14266   register tree link;
14267
14268   if (decl == void_type_node)
14269     return decl;
14270
14271   old_initial = DECL_INITIAL (fndecl);
14272
14273   /* Undo the level for the parms (from start_method).
14274      This is like poplevel, but it causes nothing to be
14275      saved.  Saving information here confuses symbol-table
14276      output routines.  Besides, this information will
14277      be correctly output when this method is actually
14278      compiled.  */
14279
14280   /* Clear out the meanings of the local variables of this level;
14281      also record in each decl which block it belongs to.  */
14282
14283   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14284     {
14285       if (DECL_NAME (link) != NULL_TREE)
14286         pop_binding (DECL_NAME (link), link);
14287       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14288       DECL_CONTEXT (link) = NULL_TREE;
14289     }
14290
14291   poplevel (0, 0, 0);
14292
14293   DECL_INITIAL (fndecl) = old_initial;
14294
14295   /* We used to check if the context of FNDECL was different from
14296      current_class_type as another way to get inside here.  This didn't work
14297      for String.cc in libg++.  */
14298   if (DECL_FRIEND_P (fndecl))
14299     {
14300       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14301         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14302       decl = void_type_node;
14303     }
14304
14305   return decl;
14306 }
14307 \f
14308
14309 /* VAR is a VAR_DECL.  If its type is incomplete, remember VAR so that
14310    we can lay it out later, when and if its type becomes complete.  */
14311
14312 void
14313 maybe_register_incomplete_var (tree var)
14314 {
14315   my_friendly_assert (TREE_CODE (var) == VAR_DECL, 20020406);
14316
14317   /* Keep track of variables with incomplete types.  */
14318   if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
14319       && DECL_EXTERNAL (var))
14320     {
14321       tree inner_type = TREE_TYPE (var);
14322
14323       while (TREE_CODE (inner_type) == ARRAY_TYPE)
14324         inner_type = TREE_TYPE (inner_type);
14325       inner_type = TYPE_MAIN_VARIANT (inner_type);
14326
14327       if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
14328           /* RTTI TD entries are created while defining the type_info.  */
14329           || (TYPE_LANG_SPECIFIC (inner_type)
14330               && TYPE_BEING_DEFINED (inner_type)))
14331         incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
14332     }
14333 }
14334
14335 /* Called when a class type (given by TYPE) is defined.  If there are
14336    any existing VAR_DECLs whose type hsa been completed by this
14337    declaration, update them now.  */
14338
14339 void
14340 complete_vars (tree type)
14341 {
14342   tree *list = &incomplete_vars;
14343
14344   my_friendly_assert (CLASS_TYPE_P (type), 20020406);
14345   while (*list)
14346     {
14347       if (same_type_p (type, TREE_PURPOSE (*list)))
14348         {
14349           tree var = TREE_VALUE (*list);
14350           /* Complete the type of the variable.  The VAR_DECL itself
14351              will be laid out in expand_expr.  */
14352           complete_type (TREE_TYPE (var));
14353           /* Remove this entry from the list.  */
14354           *list = TREE_CHAIN (*list);
14355         }
14356       else
14357         list = &TREE_CHAIN (*list);
14358     }
14359 }
14360
14361 /* If DECL is of a type which needs a cleanup, build that cleanup
14362    here.  */
14363
14364 tree
14365 cxx_maybe_build_cleanup (tree decl)
14366 {
14367   tree type = TREE_TYPE (decl);
14368
14369   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14370     {
14371       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14372       tree rval;
14373
14374       if (TREE_CODE (type) == ARRAY_TYPE)
14375         rval = decl;
14376       else
14377         {
14378           cxx_mark_addressable (decl);
14379           rval = build_unary_op (ADDR_EXPR, decl, 0);
14380         }
14381
14382       /* Optimize for space over speed here.  */
14383       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14384           || flag_expensive_optimizations)
14385         flags |= LOOKUP_NONVIRTUAL;
14386
14387       rval = build_delete (TREE_TYPE (rval), rval,
14388                            sfk_complete_destructor, flags, 0);
14389
14390       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14391           && ! TYPE_HAS_DESTRUCTOR (type))
14392         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14393                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14394
14395       return rval;
14396     }
14397   return NULL_TREE;
14398 }
14399 \f
14400 /* When a stmt has been parsed, this function is called.  */
14401
14402 void
14403 finish_stmt (void)
14404 {
14405   /* Always assume this statement was not an expression statement.  If
14406      it actually was an expression statement, its our callers
14407      responsibility to fix this up.  */
14408   last_expr_type = NULL_TREE;
14409 }
14410
14411 /* DECL was originally constructed as a non-static member function,
14412    but turned out to be static.  Update it accordingly.  */
14413
14414 void
14415 revert_static_member_fn (tree decl)
14416 {
14417   tree tmp;
14418   tree function = TREE_TYPE (decl);
14419   tree args = TYPE_ARG_TYPES (function);
14420
14421   if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
14422       != TYPE_UNQUALIFIED)
14423     error ("static member function `%#D' declared with type qualifiers",
14424               decl);
14425
14426   args = TREE_CHAIN (args);
14427   tmp = build_function_type (TREE_TYPE (function), args);
14428   tmp = build_qualified_type (tmp, cp_type_quals (function));
14429   tmp = build_exception_variant (tmp,
14430                                  TYPE_RAISES_EXCEPTIONS (function));
14431   TREE_TYPE (decl) = tmp;
14432   if (DECL_ARGUMENTS (decl))
14433     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14434   DECL_STATIC_FUNCTION_P (decl) = 1;
14435 }
14436
14437 /* Initialize the variables used during compilation of a C++
14438    function.  */
14439
14440 void
14441 cxx_push_function_context (struct function * f)
14442 {
14443   struct language_function *p
14444     = ((struct language_function *)
14445        ggc_alloc_cleared (sizeof (struct language_function)));
14446   f->language = p;
14447
14448   /* It takes an explicit call to expand_body to generate RTL for a
14449      function.  */
14450   expanding_p = 0;
14451
14452   /* Whenever we start a new function, we destroy temporaries in the
14453      usual way.  */
14454   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14455 }
14456
14457 /* Free the language-specific parts of F, now that we've finished
14458    compiling the function.  */
14459
14460 void
14461 cxx_pop_function_context (struct function * f)
14462 {
14463   f->language = 0;
14464 }
14465
14466 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
14467    one of the language-independent trees.  */
14468
14469 enum cp_tree_node_structure_enum
14470 cp_tree_node_structure (union lang_tree_node * t)
14471 {
14472   switch (TREE_CODE (&t->generic))
14473     {
14474     case DEFAULT_ARG:           return TS_CP_DEFAULT_ARG;
14475     case IDENTIFIER_NODE:       return TS_CP_IDENTIFIER;
14476     case CPLUS_BINDING:         return TS_CP_BINDING;
14477     case OVERLOAD:              return TS_CP_OVERLOAD;
14478     case TEMPLATE_PARM_INDEX:   return TS_CP_TPI;
14479     case PTRMEM_CST:            return TS_CP_PTRMEM;
14480     case BASELINK:              return TS_CP_BASELINK;
14481     case WRAPPER:               return TS_CP_WRAPPER;
14482     case SRCLOC:                return TS_CP_SRCLOC;
14483     default:                    return TS_CP_GENERIC;
14484     }
14485 }
14486
14487 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14488    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
14489
14490 tree
14491 identifier_global_value (tree t)
14492 {
14493   return IDENTIFIER_GLOBAL_VALUE (t);
14494 }
14495
14496 /* Build the void_list_node (void_type_node having been created).  */
14497 tree
14498 build_void_list_node (void)
14499 {
14500   tree t = build_tree_list (NULL_TREE, void_type_node);
14501   TREE_PARMLIST (t) = 1;
14502   return t;
14503 }
14504
14505 static int
14506 cp_missing_noreturn_ok_p (tree decl)
14507 {
14508   /* A missing noreturn is ok for the `main' function.  */
14509   return DECL_MAIN_P (decl);
14510 }
14511
14512 #include "gt-cp-decl.h"
14513 #include "gtype-cp.h"