gcc/cp/decl.c

   1 /* Process declarations and variables for C compiler.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001  Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* Process declarations and symbol lookup for C front end.
  25    Also constructs types; the standard scalar types at initialization,
  26    and structure, union, array and enum types when they are declared.  */
  27
  28 /* ??? not all decl nodes are given the most useful possible
  29    line numbers.  For example, the CONST_DECLs for enum values.  */
  30
  31 #include "config.h"
  32 #include "system.h"
  33 #include "tree.h"
  34 #include "rtl.h"
  35 #include "expr.h"
  36 #include "flags.h"
  37 #include "cp-tree.h"
  38 #include "decl.h"
  39 #include "lex.h"
  40 #include "output.h"
  41 #include "except.h"
  42 #include "toplev.h"
  43 #include "../hash.h"
  44 #include "ggc.h"
  45 #include "tm_p.h"
  46 #include "target.h"
  47
  48 extern const struct attribute_spec *lang_attribute_table;
  49
  50 #ifndef BOOL_TYPE_SIZE
  51 /* `bool' has size and alignment `1', on all platforms.  */
  52 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  53 #endif
  54
  55 static tree grokparms                           PARAMS ((tree));
  56 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  57
  58 static void push_binding_level PARAMS ((struct binding_level *, int,
  59                                       int));
  60 static void pop_binding_level PARAMS ((void));
  61 static void suspend_binding_level PARAMS ((void));
  62 static void resume_binding_level PARAMS ((struct binding_level *));
  63 static struct binding_level *make_binding_level PARAMS ((void));
  64 static void declare_namespace_level PARAMS ((void));
  65 static int decl_jump_unsafe PARAMS ((tree));
  66 static void storedecls PARAMS ((tree));
  67 static void require_complete_types_for_parms PARAMS ((tree));
  68 static int ambi_op_p PARAMS ((enum tree_code));
  69 static int unary_op_p PARAMS ((enum tree_code));
  70 static tree store_bindings PARAMS ((tree, tree));
  71 static tree lookup_tag_reverse PARAMS ((tree, tree));
  72 static tree obscure_complex_init PARAMS ((tree, tree));
  73 static tree lookup_name_real PARAMS ((tree, int, int, int));
  74 static void push_local_name PARAMS ((tree));
  75 static void warn_extern_redeclared_static PARAMS ((tree, tree));
  76 static tree grok_reference_init PARAMS ((tree, tree, tree));
  77 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
  78                               enum overload_flags, tree,
  79                               tree, int, int, int, int, int, int, tree));
  80 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
  81 static tree lookup_tag PARAMS ((enum tree_code, tree,
  82                               struct binding_level *, int));
  83 static void set_identifier_type_value_with_scope
  84         PARAMS ((tree, tree, struct binding_level *));
  85 static void record_unknown_type PARAMS ((tree, const char *));
  86 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
  87 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
  88 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
  89                                   int));
  90 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
  91 static void check_for_uninitialized_const_var PARAMS ((tree));
  92 static unsigned long typename_hash PARAMS ((hash_table_key));
  93 static bool typename_compare PARAMS ((hash_table_key, hash_table_key));
  94 static void push_binding PARAMS ((tree, tree, struct binding_level*));
  95 static int add_binding PARAMS ((tree, tree));
  96 static void pop_binding PARAMS ((tree, tree));
  97 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
  98 static tree find_binding PARAMS ((tree, tree));
  99 static tree select_decl PARAMS ((tree, int));
 100 static int lookup_flags PARAMS ((int, int));
 101 static tree qualify_lookup PARAMS ((tree, int));
 102 static tree record_builtin_java_type PARAMS ((const char *, int));
 103 static const char *tag_name PARAMS ((enum tag_types code));
 104 static void find_class_binding_level PARAMS ((void));
 105 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 106 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 107 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 108 static int walk_globals_r PARAMS ((tree, void *));
 109 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 110 static tree make_label_decl PARAMS ((tree, int));
 111 static void use_label PARAMS ((tree));
 112 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 113                                            const char *, int));
 114 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 115 static void check_switch_goto PARAMS ((struct binding_level *));
 116 static void check_previous_gotos PARAMS ((tree));
 117 static void pop_label PARAMS ((tree, tree));
 118 static void pop_labels PARAMS ((tree));
 119 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 120 static void layout_var_decl PARAMS ((tree));
 121 static void maybe_commonize_var PARAMS ((tree));
 122 static tree check_initializer PARAMS ((tree, tree));
 123 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 124 static void push_cp_function_context PARAMS ((struct function *));
 125 static void pop_cp_function_context PARAMS ((struct function *));
 126 static void mark_binding_level PARAMS ((void *));
 127 static void mark_named_label_lists PARAMS ((void *, void *));
 128 static void mark_cp_function_context PARAMS ((struct function *));
 129 static void mark_saved_scope PARAMS ((void *));
 130 static void mark_lang_function PARAMS ((struct cp_language_function *));
 131 static void save_function_data PARAMS ((tree));
 132 static void check_function_type PARAMS ((tree, tree));
 133 static void destroy_local_var PARAMS ((tree));
 134 static void finish_constructor_body PARAMS ((void));
 135 static void finish_destructor_body PARAMS ((void));
 136 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 137 static tree get_atexit_node PARAMS ((void));
 138 static tree get_dso_handle_node PARAMS ((void));
 139 static tree start_cleanup_fn PARAMS ((void));
 140 static void end_cleanup_fn PARAMS ((void));
 141 static tree cp_make_fname_decl PARAMS ((tree, int));
 142 static void initialize_predefined_identifiers PARAMS ((void));
 143 static tree check_special_function_return_type
 144   PARAMS ((special_function_kind, tree, tree));
 145 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 146 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 147 static void store_parm_decls PARAMS ((tree));
 148 static int cp_missing_noreturn_ok_p PARAMS ((tree));
 149
 150 #if defined (DEBUG_CP_BINDING_LEVELS)
 151 static void indent PARAMS ((void));
 152 #endif
 153
 154 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 155 tree error_mark_list;
 156
 157 /* The following symbols are subsumed in the cp_global_trees array, and
 158    listed here individually for documentation purposes.
 159
 160    C++ extensions
 161         tree wchar_decl_node;
 162
 163         tree vtable_entry_type;
 164         tree delta_type_node;
 165         tree __t_desc_type_node;
 166         tree ti_desc_type_node;
 167         tree bltn_desc_type_node, ptr_desc_type_node;
 168         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 169         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 170         tree ptm_desc_type_node;
 171         tree base_desc_type_node;
 172
 173         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 174         tree unknown_type_node;
 175
 176    Array type `vtable_entry_type[]'
 177
 178         tree vtbl_type_node;
 179         tree vtbl_ptr_type_node;
 180
 181    Namespaces,
 182
 183         tree std_node;
 184         tree abi_node;
 185
 186    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 187    one that the user will declare, but sufficient to be called
 188    by routines that want to abort the program.
 189
 190         tree abort_fndecl;
 191
 192    The FUNCTION_DECL for the default `::operator delete'.
 193
 194         tree global_delete_fndecl;
 195
 196    Used by RTTI
 197         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 198         tree tinfo_var_id;
 199
 200 */
 201
 202 tree cp_global_trees[CPTI_MAX];
 203
 204 /* Indicates that there is a type value in some namespace, although
 205    that is not necessarily in scope at the moment.  */
 206
 207 static tree global_type_node;
 208
 209 /* Expect only namespace names now. */
 210 static int only_namespace_names;
 211
 212 /* Used only for jumps to as-yet undefined labels, since jumps to
 213    defined labels can have their validity checked immediately.  */
 214
 215 struct named_label_use_list
 216 {
 217   struct binding_level *binding_level;
 218   tree names_in_scope;
 219   tree label_decl;
 220   const char *filename_o_goto;
 221   int lineno_o_goto;
 222   struct named_label_use_list *next;
 223 };
 224
 225 #define named_label_uses cp_function_chain->x_named_label_uses
 226
 227 #define local_names cp_function_chain->x_local_names
 228
 229 /* A list of objects which have constructors or destructors
 230    which reside in the global scope.  The decl is stored in
 231    the TREE_VALUE slot and the initializer is stored
 232    in the TREE_PURPOSE slot.  */
 233 tree static_aggregates;
 234
 235 /* -- end of C++ */
 236
 237 /* A node for the integer constants 2, and 3.  */
 238
 239 tree integer_two_node, integer_three_node;
 240
 241 /* Similar, for last_function_parm_tags.  */
 242 tree last_function_parms;
 243
 244 /* A list of all LABEL_DECLs in the function that have names.  Here so
 245    we can clear out their names' definitions at the end of the
 246    function, and so we can check the validity of jumps to these labels.  */
 247
 248 struct named_label_list
 249 {
 250   struct binding_level *binding_level;
 251   tree names_in_scope;
 252   tree old_value;
 253   tree label_decl;
 254   tree bad_decls;
 255   struct named_label_list *next;
 256   unsigned int in_try_scope : 1;
 257   unsigned int in_catch_scope : 1;
 258 };
 259
 260 #define named_labels cp_function_chain->x_named_labels
 261
 262 /* Nonzero means use the ISO C94 dialect of C.  */
 263
 264 int flag_isoc94;
 265
 266 /* Nonzero means use the ISO C99 dialect of C.  */
 267
 268 int flag_isoc99;
 269
 270 /* Nonzero means we are a hosted implementation for code shared with C.  */
 271
 272 int flag_hosted = 1;
 273
 274 /* Nonzero means add default format_arg attributes for functions not
 275    in ISO C.  */
 276
 277 int flag_noniso_default_format_attributes = 1;
 278
 279 /* Nonzero if we want to conserve space in the .o files.  We do this
 280    by putting uninitialized data and runtime initialized data into
 281    .common instead of .data at the expense of not flagging multiple
 282    definitions.  */
 283 extern int flag_conserve_space;
 284 \f
 285 /* C and C++ flags are in decl2.c.  */
 286
 287 /* Flag used when debugging spew.c */
 288
 289 extern int spew_debug;
 290
 291 /* A expression of value 0 with the same precision as a sizetype
 292    node, but signed.  */
 293 tree signed_size_zero_node;
 294
 295 /* The name of the anonymous namespace, throughout this translation
 296    unit.  */
 297 tree anonymous_namespace_name;
 298
 299 /* The number of function bodies which we are currently processing.
 300    (Zero if we are at namespace scope, one inside the body of a
 301    function, two inside the body of a function in a local class, etc.)  */
 302 int function_depth;
 303 \f
 304 /* For each binding contour we allocate a binding_level structure
 305    which records the names defined in that contour.
 306    Contours include:
 307     0) the global one
 308     1) one for each function definition,
 309        where internal declarations of the parameters appear.
 310     2) one for each compound statement,
 311        to record its declarations.
 312
 313    The current meaning of a name can be found by searching the levels
 314    from the current one out to the global one.
 315
 316    Off to the side, may be the class_binding_level.  This exists only
 317    to catch class-local declarations.  It is otherwise nonexistent.
 318
 319    Also there may be binding levels that catch cleanups that must be
 320    run when exceptions occur.  Thus, to see whether a name is bound in
 321    the current scope, it is not enough to look in the
 322    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 323    instead.  */
 324
 325 /* Note that the information in the `names' component of the global contour
 326    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 327
 328 struct binding_level
 329   {
 330     /* A chain of _DECL nodes for all variables, constants, functions,
 331        and typedef types.  These are in the reverse of the order
 332        supplied.  There may be OVERLOADs on this list, too, but they
 333        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 334     tree names;
 335
 336     /* A list of structure, union and enum definitions, for looking up
 337        tag names.
 338        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 339        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 340        or ENUMERAL_TYPE node.
 341
 342        C++: the TREE_VALUE nodes can be simple types for
 343        component_bindings.  */
 344     tree tags;
 345
 346     /* A list of USING_DECL nodes. */
 347     tree usings;
 348
 349     /* A list of used namespaces. PURPOSE is the namespace,
 350        VALUE the common ancestor with this binding_level's namespace. */
 351     tree using_directives;
 352
 353     /* If this binding level is the binding level for a class, then
 354        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 355        is the name of an entity bound in the class.  The TREE_TYPE is
 356        the DECL bound by this name in the class.  */
 357     tree class_shadowed;
 358
 359     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 360        is used for all binding levels. In addition the TREE_VALUE is the
 361        IDENTIFIER_TYPE_VALUE before we entered the class.  */
 362     tree type_shadowed;
 363
 364     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 365        label in this scope.  The TREE_PURPOSE is the previous value of
 366        the IDENTIFIER_LABEL VALUE.  */
 367     tree shadowed_labels;
 368
 369     /* For each level (except not the global one),
 370        a chain of BLOCK nodes for all the levels
 371        that were entered and exited one level down.  */
 372     tree blocks;
 373
 374     /* The _TYPE node for this level, if parm_flag == 2.  */
 375     tree this_class;
 376
 377     /* The binding level which this one is contained in (inherits from).  */
 378     struct binding_level *level_chain;
 379
 380     /* List of decls in `names' that have incomplete
 381        structure or union types.  */
 382     tree incomplete;
 383
 384     /* List of VAR_DECLS saved from a previous for statement.
 385        These would be dead in ISO-conforming code, but might
 386        be referenced in ARM-era code.  These are stored in a
 387        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 388     tree dead_vars_from_for;
 389
 390     /* 1 for the level that holds the parameters of a function.
 391        2 for the level that holds a class declaration.  */
 392     unsigned parm_flag : 2;
 393
 394     /* 1 means make a BLOCK for this level regardless of all else.
 395        2 for temporary binding contours created by the compiler.  */
 396     unsigned keep : 2;
 397
 398     /* Nonzero if this level "doesn't exist" for tags.  */
 399     unsigned tag_transparent : 1;
 400
 401     /* Nonzero if this level can safely have additional
 402        cleanup-needing variables added to it.  */
 403     unsigned more_cleanups_ok : 1;
 404     unsigned have_cleanups : 1;
 405
 406     /* Nonzero if this scope is for storing the decls for template
 407        parameters and generic decls; these decls will be discarded and
 408        replaced with a TEMPLATE_DECL.  */
 409     unsigned template_parms_p : 1;
 410
 411     /* Nonzero if this scope corresponds to the `<>' in a
 412        `template <>' clause.  Whenever this flag is set,
 413        TEMPLATE_PARMS_P will be set as well.  */
 414     unsigned template_spec_p : 1;
 415
 416     /* This is set for a namespace binding level.  */
 417     unsigned namespace_p : 1;
 418
 419     /* True if this level is that of a for-statement where we need to
 420        worry about ambiguous (ARM or ISO) scope rules.  */
 421     unsigned is_for_scope : 1;
 422
 423     /* True if this level corresponds to a TRY block.  Currently this
 424        information is only available while building the tree structure.  */
 425     unsigned is_try_scope : 1;
 426
 427     /* True if this level corresponds to a CATCH block.  Currently this
 428        information is only available while building the tree structure.  */
 429     unsigned is_catch_scope : 1;
 430
 431     /* Three bits left for this word.  */
 432
 433 #if defined(DEBUG_CP_BINDING_LEVELS)
 434     /* Binding depth at which this level began.  */
 435     unsigned binding_depth;
 436 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 437   };
 438
 439 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 440
 441 /* The binding level currently in effect.  */
 442
 443 #define current_binding_level                   \
 444   (cfun && cp_function_chain->bindings          \
 445    ? cp_function_chain->bindings                \
 446    : scope_chain->bindings)
 447
 448 /* The binding level of the current class, if any.  */
 449
 450 #define class_binding_level scope_chain->class_bindings
 451
 452 /* A chain of binding_level structures awaiting reuse.  */
 453
 454 static struct binding_level *free_binding_level;
 455
 456 /* The outermost binding level, for names of file scope.
 457    This is created when the compiler is started and exists
 458    through the entire run.  */
 459
 460 static struct binding_level *global_binding_level;
 461
 462 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 463
 464 static int keep_next_level_flag;
 465
 466 #if defined(DEBUG_CP_BINDING_LEVELS)
 467 static int binding_depth = 0;
 468 static int is_class_level = 0;
 469
 470 static void
 471 indent ()
 472 {
 473   register unsigned i;
 474
 475   for (i = 0; i < binding_depth*2; i++)
 476     putc (' ', stderr);
 477 }
 478 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 479
 480 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 481
 482 static void
 483 push_binding_level (newlevel, tag_transparent, keep)
 484      struct binding_level *newlevel;
 485      int tag_transparent, keep;
 486 {
 487   /* Add this level to the front of the chain (stack) of levels that
 488      are active.  */
 489   memset ((char*) newlevel, 0, sizeof (struct binding_level));
 490   newlevel->level_chain = current_binding_level;
 491   current_binding_level = newlevel;
 492   newlevel->tag_transparent = tag_transparent;
 493   newlevel->more_cleanups_ok = 1;
 494
 495   newlevel->keep = keep;
 496 #if defined(DEBUG_CP_BINDING_LEVELS)
 497   newlevel->binding_depth = binding_depth;
 498   indent ();
 499   fprintf (stderr, "push %s level 0x%08x line %d\n",
 500            (is_class_level) ? "class" : "block", newlevel, lineno);
 501   is_class_level = 0;
 502   binding_depth++;
 503 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 504 }
 505
 506 /* Find the innermost enclosing class scope, and reset
 507    CLASS_BINDING_LEVEL appropriately.  */
 508
 509 static void
 510 find_class_binding_level ()
 511 {
 512   struct binding_level *level = current_binding_level;
 513
 514   while (level && level->parm_flag != 2)
 515     level = level->level_chain;
 516   if (level && level->parm_flag == 2)
 517     class_binding_level = level;
 518   else
 519     class_binding_level = 0;
 520 }
 521
 522 static void
 523 pop_binding_level ()
 524 {
 525   if (global_binding_level)
 526     {
 527       /* Cannot pop a level, if there are none left to pop.  */
 528       if (current_binding_level == global_binding_level)
 529         my_friendly_abort (123);
 530     }
 531   /* Pop the current level, and free the structure for reuse.  */
 532 #if defined(DEBUG_CP_BINDING_LEVELS)
 533   binding_depth--;
 534   indent ();
 535   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 536           (is_class_level) ? "class" : "block",
 537           current_binding_level, lineno);
 538   if (is_class_level != (current_binding_level == class_binding_level))
 539     {
 540       indent ();
 541       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 542     }
 543   is_class_level = 0;
 544 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 545   {
 546     register struct binding_level *level = current_binding_level;
 547     current_binding_level = current_binding_level->level_chain;
 548     level->level_chain = free_binding_level;
 549 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 550     if (level->binding_depth != binding_depth)
 551       abort ();
 552 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 553     free_binding_level = level;
 554     find_class_binding_level ();
 555   }
 556 }
 557
 558 static void
 559 suspend_binding_level ()
 560 {
 561   if (class_binding_level)
 562     current_binding_level = class_binding_level;
 563
 564   if (global_binding_level)
 565     {
 566       /* Cannot suspend a level, if there are none left to suspend.  */
 567       if (current_binding_level == global_binding_level)
 568         my_friendly_abort (123);
 569     }
 570   /* Suspend the current level.  */
 571 #if defined(DEBUG_CP_BINDING_LEVELS)
 572   binding_depth--;
 573   indent ();
 574   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 575           (is_class_level) ? "class" : "block",
 576           current_binding_level, lineno);
 577   if (is_class_level != (current_binding_level == class_binding_level))
 578     {
 579       indent ();
 580       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 581     }
 582   is_class_level = 0;
 583 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 584   current_binding_level = current_binding_level->level_chain;
 585   find_class_binding_level ();
 586 }
 587
 588 static void
 589 resume_binding_level (b)
 590      struct binding_level *b;
 591 {
 592   /* Resuming binding levels is meant only for namespaces,
 593      and those cannot nest into classes. */
 594   my_friendly_assert(!class_binding_level, 386);
 595   /* Also, resuming a non-directly nested namespace is a no-no.  */
 596   my_friendly_assert(b->level_chain == current_binding_level, 386);
 597   current_binding_level = b;
 598 #if defined(DEBUG_CP_BINDING_LEVELS)
 599   b->binding_depth = binding_depth;
 600   indent ();
 601   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 602            (is_class_level) ? "class" : "block", b, lineno);
 603   is_class_level = 0;
 604   binding_depth++;
 605 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 606 }
 607 \f
 608 /* Create a new `struct binding_level'.  */
 609
 610 static
 611 struct binding_level *
 612 make_binding_level ()
 613 {
 614   /* NOSTRICT */
 615   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 616 }
 617
 618 /* Nonzero if we are currently in the global binding level.  */
 619
 620 int
 621 global_bindings_p ()
 622 {
 623   return current_binding_level == global_binding_level;
 624 }
 625
 626 /* Return the innermost binding level that is not for a class scope.  */
 627
 628 static struct binding_level *
 629 innermost_nonclass_level ()
 630 {
 631   struct binding_level *b;
 632
 633   b = current_binding_level;
 634   while (b->parm_flag == 2)
 635     b = b->level_chain;
 636
 637   return b;
 638 }
 639
 640 /* Nonzero if we are currently in a toplevel binding level.  This
 641    means either the global binding level or a namespace in a toplevel
 642    binding level.  Since there are no non-toplevel namespace levels,
 643    this really means any namespace or template parameter level.  We
 644    also include a class whose context is toplevel.  */
 645
 646 int
 647 toplevel_bindings_p ()
 648 {
 649   struct binding_level *b = innermost_nonclass_level ();
 650
 651   return b->namespace_p || b->template_parms_p;
 652 }
 653
 654 /* Nonzero if this is a namespace scope, or if we are defining a class
 655    which is itself at namespace scope, or whose enclosing class is
 656    such a class, etc.  */
 657
 658 int
 659 namespace_bindings_p ()
 660 {
 661   struct binding_level *b = innermost_nonclass_level ();
 662
 663   return b->namespace_p;
 664 }
 665
 666 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 667    unconditionally.  Otherwise, use the normal logic to decide whether
 668    or not to create a BLOCK.  */
 669
 670 void
 671 keep_next_level (keep)
 672      int keep;
 673 {
 674   keep_next_level_flag = keep;
 675 }
 676
 677 /* Nonzero if the current level needs to have a BLOCK made.  */
 678
 679 int
 680 kept_level_p ()
 681 {
 682   return (current_binding_level->blocks != NULL_TREE
 683           || current_binding_level->keep
 684           || current_binding_level->names != NULL_TREE
 685           || (current_binding_level->tags != NULL_TREE
 686               && !current_binding_level->tag_transparent));
 687 }
 688
 689 static void
 690 declare_namespace_level ()
 691 {
 692   current_binding_level->namespace_p = 1;
 693 }
 694
 695 /* Returns non-zero if this scope was created to store template
 696    parameters.  */
 697
 698 int
 699 template_parm_scope_p ()
 700 {
 701   return current_binding_level->template_parms_p;
 702 }
 703
 704 /* Returns the kind of template specialization we are currently
 705    processing, given that it's declaration contained N_CLASS_SCOPES
 706    explicit scope qualifications.  */
 707
 708 tmpl_spec_kind
 709 current_tmpl_spec_kind (n_class_scopes)
 710      int n_class_scopes;
 711 {
 712   int n_template_parm_scopes = 0;
 713   int seen_specialization_p = 0;
 714   int innermost_specialization_p = 0;
 715   struct binding_level *b;
 716
 717   /* Scan through the template parameter scopes.  */
 718   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 719     {
 720       /* If we see a specialization scope inside a parameter scope,
 721          then something is wrong.  That corresponds to a declaration
 722          like:
 723
 724             template <class T> template <> ...
 725
 726          which is always illegal since [temp.expl.spec] forbids the
 727          specialization of a class member template if the enclosing
 728          class templates are not explicitly specialized as well.  */
 729       if (b->template_spec_p)
 730         {
 731           if (n_template_parm_scopes == 0)
 732             innermost_specialization_p = 1;
 733           else
 734             seen_specialization_p = 1;
 735         }
 736       else if (seen_specialization_p == 1)
 737         return tsk_invalid_member_spec;
 738
 739       ++n_template_parm_scopes;
 740     }
 741
 742   /* Handle explicit instantiations.  */
 743   if (processing_explicit_instantiation)
 744     {
 745       if (n_template_parm_scopes != 0)
 746         /* We've seen a template parameter list during an explicit
 747            instantiation.  For example:
 748
 749              template <class T> template void f(int);
 750
 751            This is erroneous.  */
 752         return tsk_invalid_expl_inst;
 753       else
 754         return tsk_expl_inst;
 755     }
 756
 757   if (n_template_parm_scopes < n_class_scopes)
 758     /* We've not seen enough template headers to match all the
 759        specialized classes present.  For example:
 760
 761          template <class T> void R<T>::S<T>::f(int);
 762
 763        This is illegal; there needs to be one set of template
 764        parameters for each class.  */
 765     return tsk_insufficient_parms;
 766   else if (n_template_parm_scopes == n_class_scopes)
 767     /* We're processing a non-template declaration (even though it may
 768        be a member of a template class.)  For example:
 769
 770          template <class T> void S<T>::f(int);
 771
 772        The `class T' maches the `S<T>', leaving no template headers
 773        corresponding to the `f'.  */
 774     return tsk_none;
 775   else if (n_template_parm_scopes > n_class_scopes + 1)
 776     /* We've got too many template headers.  For example:
 777
 778          template <> template <class T> void f (T);
 779
 780        There need to be more enclosing classes.  */
 781     return tsk_excessive_parms;
 782   else
 783     /* This must be a template.  It's of the form:
 784
 785          template <class T> template <class U> void S<T>::f(U);
 786
 787        This is a specialization if the innermost level was a
 788        specialization; otherwise it's just a definition of the
 789        template.  */
 790     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 791 }
 792
 793 void
 794 set_class_shadows (shadows)
 795      tree shadows;
 796 {
 797   class_binding_level->class_shadowed = shadows;
 798 }
 799
 800 /* Enter a new binding level.
 801    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 802    not for that of tags.  */
 803
 804 void
 805 pushlevel (tag_transparent)
 806      int tag_transparent;
 807 {
 808   struct binding_level *newlevel;
 809
 810   if (cfun && !doing_semantic_analysis_p ())
 811     return;
 812
 813   /* Reuse or create a struct for this binding level.  */
 814 #if defined(DEBUG_CP_BINDING_LEVELS)
 815   if (0)
 816 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 817   if (free_binding_level)
 818 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 819     {
 820       newlevel = free_binding_level;
 821       free_binding_level = free_binding_level->level_chain;
 822     }
 823   else
 824     newlevel = make_binding_level ();
 825
 826   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 827   GNU_xref_start_scope ((size_t) newlevel);
 828   keep_next_level_flag = 0;
 829 }
 830
 831 /* We're defining an object of type TYPE.  If it needs a cleanup, but
 832    we're not allowed to add any more objects with cleanups to the current
 833    scope, create a new binding level.  */
 834
 835 void
 836 maybe_push_cleanup_level (type)
 837      tree type;
 838 {
 839   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
 840       && current_binding_level->more_cleanups_ok == 0)
 841     {
 842       keep_next_level (2);
 843       pushlevel (1);
 844       clear_last_expr ();
 845       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
 846     }
 847 }
 848
 849 /* Enter a new scope.  The KIND indicates what kind of scope is being
 850    created.  */
 851
 852 void
 853 begin_scope (sk)
 854      scope_kind sk;
 855 {
 856   pushlevel (0);
 857
 858   switch (sk)
 859     {
 860     case sk_template_spec:
 861       current_binding_level->template_spec_p = 1;
 862       /* Fall through.  */
 863
 864     case sk_template_parms:
 865       current_binding_level->template_parms_p = 1;
 866       break;
 867
 868     default:
 869       my_friendly_abort (20000309);
 870     }
 871 }
 872
 873 /* Exit the current scope.  */
 874
 875 void
 876 finish_scope ()
 877 {
 878   poplevel (0, 0, 0);
 879 }
 880
 881 void
 882 note_level_for_for ()
 883 {
 884   current_binding_level->is_for_scope = 1;
 885 }
 886
 887 /* Record that the current binding level represents a try block.  */
 888
 889 void
 890 note_level_for_try ()
 891 {
 892   current_binding_level->is_try_scope = 1;
 893 }
 894
 895 /* Record that the current binding level represents a catch block.  */
 896
 897 void
 898 note_level_for_catch ()
 899 {
 900   current_binding_level->is_catch_scope = 1;
 901 }
 902
 903 /* For a binding between a name and an entity at a block scope,
 904    this is the `struct binding_level' for the block.  */
 905 #define BINDING_LEVEL(NODE) \
 906    (((struct tree_binding*)NODE)->scope.level)
 907
 908 /* A free list of CPLUS_BINDING nodes, connected by their
 909    TREE_CHAINs.  */
 910
 911 static tree free_bindings;
 912
 913 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 914    level at which this declaration is being bound.  */
 915
 916 static void
 917 push_binding (id, decl, level)
 918      tree id;
 919      tree decl;
 920      struct binding_level* level;
 921 {
 922   tree binding;
 923
 924   if (free_bindings)
 925     {
 926       binding = free_bindings;
 927       free_bindings = TREE_CHAIN (binding);
 928     }
 929   else
 930     binding = make_node (CPLUS_BINDING);
 931
 932   /* Now, fill in the binding information.  */
 933   BINDING_VALUE (binding) = decl;
 934   BINDING_TYPE (binding) = NULL_TREE;
 935   BINDING_LEVEL (binding) = level;
 936   INHERITED_VALUE_BINDING_P (binding) = 0;
 937   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 938   BINDING_HAS_LEVEL_P (binding) = 1;
 939
 940   /* And put it on the front of the list of bindings for ID.  */
 941   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 942   IDENTIFIER_BINDING (id) = binding;
 943 }
 944
 945 /* ID is already bound in the current scope.  But, DECL is an
 946    additional binding for ID in the same scope.  This is the `struct
 947    stat' hack whereby a non-typedef class-name or enum-name can be
 948    bound at the same level as some other kind of entity.  It's the
 949    responsibility of the caller to check that inserting this name is
 950    legal here.  Returns nonzero if the new binding was successful.  */
 951 static int
 952 add_binding (id, decl)
 953      tree id;
 954      tree decl;
 955 {
 956   tree binding = IDENTIFIER_BINDING (id);
 957   int ok = 1;
 958
 959   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 960     /* The new name is the type name.  */
 961     BINDING_TYPE (binding) = decl;
 962   else if (!BINDING_VALUE (binding))
 963     /* This situation arises when push_class_level_binding moves an
 964        inherited type-binding out of the way to make room for a new
 965        value binding.  */
 966     BINDING_VALUE (binding) = decl;
 967   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 968            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 969     {
 970       /* The old binding was a type name.  It was placed in
 971          BINDING_VALUE because it was thought, at the point it was
 972          declared, to be the only entity with such a name.  Move the
 973          type name into the type slot; it is now hidden by the new
 974          binding.  */
 975       BINDING_TYPE (binding) = BINDING_VALUE (binding);
 976       BINDING_VALUE (binding) = decl;
 977       INHERITED_VALUE_BINDING_P (binding) = 0;
 978     }
 979   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 980            && TREE_CODE (decl) == TYPE_DECL
 981            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
 982            && same_type_p (TREE_TYPE (decl),
 983                            TREE_TYPE (BINDING_VALUE (binding))))
 984     /* We have two typedef-names, both naming the same type to have
 985        the same name.  This is OK because of:
 986
 987          [dcl.typedef]
 988
 989          In a given scope, a typedef specifier can be used to redefine
 990          the name of any type declared in that scope to refer to the
 991          type to which it already refers.  */
 992     ok = 0;
 993   /* There can be two block-scope declarations of the same variable,
 994      so long as they are `extern' declarations.  */
 995   else if (TREE_CODE (decl) == VAR_DECL
 996            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
 997            && DECL_EXTERNAL (decl)
 998            && DECL_EXTERNAL (BINDING_VALUE (binding)))
 999     {
1000       duplicate_decls (decl, BINDING_VALUE (binding));
1001       ok = 0;
1002     }
1003   else
1004     {
1005       cp_error ("declaration of `%#D'", decl);
1006       cp_error_at ("conflicts with previous declaration `%#D'",
1007                    BINDING_VALUE (binding));
1008       ok = 0;
1009     }
1010
1011   return ok;
1012 }
1013
1014 /* Add DECL to the list of things declared in B.  */
1015
1016 static void
1017 add_decl_to_level (decl, b)
1018      tree decl;
1019      struct binding_level *b;
1020 {
1021   /* We build up the list in reverse order, and reverse it later if
1022      necessary.  */
1023   TREE_CHAIN (decl) = b->names;
1024   b->names = decl;
1025 }
1026
1027 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1028    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1029    doesn't really belong to this binding level, that it got here
1030    through a using-declaration.  */
1031
1032 void
1033 push_local_binding (id, decl, flags)
1034      tree id;
1035      tree decl;
1036      int flags;
1037 {
1038   struct binding_level *b;
1039
1040   /* Skip over any local classes.  This makes sense if we call
1041      push_local_binding with a friend decl of a local class.  */
1042   b = current_binding_level;
1043   while (b->parm_flag == 2)
1044     b = b->level_chain;
1045
1046   if (lookup_name_current_level (id))
1047     {
1048       /* Supplement the existing binding.  */
1049       if (!add_binding (id, decl))
1050         /* It didn't work.  Something else must be bound at this
1051            level.  Do not add DECL to the list of things to pop
1052            later.  */
1053         return;
1054     }
1055   else
1056     /* Create a new binding.  */
1057     push_binding (id, decl, b);
1058
1059   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1060     /* We must put the OVERLOAD into a TREE_LIST since the
1061        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1062        decls that got here through a using-declaration.  */
1063     decl = build_tree_list (NULL_TREE, decl);
1064
1065   /* And put DECL on the list of things declared by the current
1066      binding level.  */
1067   add_decl_to_level (decl, b);
1068 }
1069
1070 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1071    binding was successful.  */
1072
1073 int
1074 push_class_binding (id, decl)
1075      tree id;
1076      tree decl;
1077 {
1078   int result = 1;
1079   tree binding = IDENTIFIER_BINDING (id);
1080   tree context;
1081
1082   /* Note that we declared this value so that we can issue an error if
1083      this an illegal redeclaration of a name already used for some
1084      other purpose.  */
1085   note_name_declared_in_class (id, decl);
1086
1087   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1088     /* Supplement the existing binding.  */
1089     result = add_binding (id, decl);
1090   else
1091     /* Create a new binding.  */
1092     push_binding (id, decl, class_binding_level);
1093
1094   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1095      class-level declaration.  Note that we do not use DECL here
1096      because of the possibility of the `struct stat' hack; if DECL is
1097      a class-name or enum-name we might prefer a field-name, or some
1098      such.  */
1099   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1100
1101   /* If this is a binding from a base class, mark it as such.  */
1102   binding = IDENTIFIER_BINDING (id);
1103   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1104     {
1105       /* Any implicit typename must be from a base-class.  The
1106          context for an implicit typename declaration is always
1107          the derived class in which the lookup was done, so the checks
1108          based on the context of DECL below will not trigger.  */
1109       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1110         INHERITED_VALUE_BINDING_P (binding) = 1;
1111       else
1112         {
1113           if (TREE_CODE (decl) == OVERLOAD)
1114             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1115           else
1116             {
1117               my_friendly_assert (DECL_P (decl), 0);
1118               context = context_for_name_lookup (decl);
1119             }
1120
1121           if (is_properly_derived_from (current_class_type, context))
1122             INHERITED_VALUE_BINDING_P (binding) = 1;
1123           else
1124             INHERITED_VALUE_BINDING_P (binding) = 0;
1125         }
1126     }
1127   else if (BINDING_VALUE (binding) == decl)
1128     /* We only encounter a TREE_LIST when push_class_decls detects an
1129        ambiguity.  Such an ambiguity can be overridden by a definition
1130        in this class.  */
1131     INHERITED_VALUE_BINDING_P (binding) = 1;
1132
1133   return result;
1134 }
1135
1136 /* Remove the binding for DECL which should be the innermost binding
1137    for ID.  */
1138
1139 static void
1140 pop_binding (id, decl)
1141      tree id;
1142      tree decl;
1143 {
1144   tree binding;
1145
1146   if (id == NULL_TREE)
1147     /* It's easiest to write the loops that call this function without
1148        checking whether or not the entities involved have names.  We
1149        get here for such an entity.  */
1150     return;
1151
1152   /* Get the innermost binding for ID.  */
1153   binding = IDENTIFIER_BINDING (id);
1154
1155   /* The name should be bound.  */
1156   my_friendly_assert (binding != NULL_TREE, 0);
1157
1158   /* The DECL will be either the ordinary binding or the type
1159      binding for this identifier.  Remove that binding.  */
1160   if (BINDING_VALUE (binding) == decl)
1161     BINDING_VALUE (binding) = NULL_TREE;
1162   else if (BINDING_TYPE (binding) == decl)
1163     BINDING_TYPE (binding) = NULL_TREE;
1164   else
1165     my_friendly_abort (0);
1166
1167   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1168     {
1169       /* We're completely done with the innermost binding for this
1170          identifier.  Unhook it from the list of bindings.  */
1171       IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1172
1173       /* Add it to the free list.  */
1174       TREE_CHAIN (binding) = free_bindings;
1175       free_bindings = binding;
1176
1177       /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
1178          it.  */
1179       BINDING_LEVEL (binding) = NULL;
1180     }
1181 }
1182
1183 /* When a label goes out of scope, check to see if that label was used
1184    in a valid manner, and issue any appropriate warnings or errors.  */
1185
1186 static void
1187 pop_label (label, old_value)
1188      tree label;
1189      tree old_value;
1190 {
1191   if (!processing_template_decl && doing_semantic_analysis_p ())
1192     {
1193       if (DECL_INITIAL (label) == NULL_TREE)
1194         {
1195           cp_error_at ("label `%D' used but not defined", label);
1196           /* Avoid crashing later.  */
1197           define_label (input_filename, 1, DECL_NAME (label));
1198         }
1199       else if (warn_unused_label && !TREE_USED (label))
1200         cp_warning_at ("label `%D' defined but not used", label);
1201     }
1202
1203   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1204 }
1205
1206 /* At the end of a function, all labels declared within the function
1207    go out of scope.  BLOCK is the top-level block for the
1208    function.  */
1209
1210 static void
1211 pop_labels (block)
1212      tree block;
1213 {
1214   struct named_label_list *link;
1215
1216   /* Clear out the definitions of all label names, since their scopes
1217      end here.  */
1218   for (link = named_labels; link; link = link->next)
1219     {
1220       pop_label (link->label_decl, link->old_value);
1221       /* Put the labels into the "variables" of the top-level block,
1222          so debugger can see them.  */
1223       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1224       BLOCK_VARS (block) = link->label_decl;
1225     }
1226
1227   named_labels = NULL;
1228 }
1229
1230 /* Exit a binding level.
1231    Pop the level off, and restore the state of the identifier-decl mappings
1232    that were in effect when this level was entered.
1233
1234    If KEEP == 1, this level had explicit declarations, so
1235    and create a "block" (a BLOCK node) for the level
1236    to record its declarations and subblocks for symbol table output.
1237
1238    If FUNCTIONBODY is nonzero, this level is the body of a function,
1239    so create a block as if KEEP were set and also clear out all
1240    label names.
1241
1242    If REVERSE is nonzero, reverse the order of decls before putting
1243    them into the BLOCK.  */
1244
1245 tree
1246 poplevel (keep, reverse, functionbody)
1247      int keep;
1248      int reverse;
1249      int functionbody;
1250 {
1251   register tree link;
1252   /* The chain of decls was accumulated in reverse order.
1253      Put it into forward order, just for cleanliness.  */
1254   tree decls;
1255   int tmp = functionbody;
1256   int real_functionbody;
1257   tree tags;
1258   tree subblocks;
1259   tree block = NULL_TREE;
1260   tree decl;
1261   int leaving_for_scope;
1262
1263   if (cfun && !doing_semantic_analysis_p ())
1264     return NULL_TREE;
1265
1266   my_friendly_assert (current_binding_level->parm_flag != 2,
1267                       19990916);
1268
1269   real_functionbody = (current_binding_level->keep == 2
1270                        ? ((functionbody = 0), tmp) : functionbody);
1271   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1272   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1273
1274   my_friendly_assert (!current_binding_level->class_shadowed,
1275                       19990414);
1276
1277   /* We used to use KEEP == 2 to indicate that the new block should go
1278      at the beginning of the list of blocks at this binding level,
1279      rather than the end.  This hack is no longer used.  */
1280   my_friendly_assert (keep == 0 || keep == 1, 0);
1281
1282   GNU_xref_end_scope ((size_t) current_binding_level,
1283                       (size_t) current_binding_level->level_chain,
1284                       current_binding_level->parm_flag,
1285                       current_binding_level->keep);
1286
1287   if (current_binding_level->keep == 1)
1288     keep = 1;
1289
1290   /* Any uses of undefined labels, and any defined labels, now operate
1291      under constraints of next binding contour.  */
1292   if (cfun && !functionbody)
1293     {
1294       struct binding_level *level_chain;
1295       level_chain = current_binding_level->level_chain;
1296       if (level_chain)
1297         {
1298           struct named_label_use_list *uses;
1299           struct named_label_list *labels;
1300           for (labels = named_labels; labels; labels = labels->next)
1301             if (labels->binding_level == current_binding_level)
1302               {
1303                 tree decl;
1304                 if (current_binding_level->is_try_scope)
1305                   labels->in_try_scope = 1;
1306                 if (current_binding_level->is_catch_scope)
1307                   labels->in_catch_scope = 1;
1308                 for (decl = labels->names_in_scope; decl;
1309                      decl = TREE_CHAIN (decl))
1310                   if (decl_jump_unsafe (decl))
1311                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1312                                                    labels->bad_decls);
1313                 labels->binding_level = level_chain;
1314                 labels->names_in_scope = level_chain->names;
1315               }
1316
1317           for (uses = named_label_uses; uses; uses = uses->next)
1318             if (uses->binding_level == current_binding_level)
1319               {
1320                 uses->binding_level = level_chain;
1321                 uses->names_in_scope = level_chain->names;
1322               }
1323         }
1324     }
1325
1326   /* Get the decls in the order they were written.
1327      Usually current_binding_level->names is in reverse order.
1328      But parameter decls were previously put in forward order.  */
1329
1330   if (reverse)
1331     current_binding_level->names
1332       = decls = nreverse (current_binding_level->names);
1333   else
1334     decls = current_binding_level->names;
1335
1336   /* Output any nested inline functions within this block
1337      if they weren't already output.  */
1338   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1339     if (TREE_CODE (decl) == FUNCTION_DECL
1340         && ! TREE_ASM_WRITTEN (decl)
1341         && DECL_INITIAL (decl) != NULL_TREE
1342         && TREE_ADDRESSABLE (decl)
1343         && decl_function_context (decl) == current_function_decl)
1344       {
1345         /* If this decl was copied from a file-scope decl
1346            on account of a block-scope extern decl,
1347            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1348         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1349           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1350         else
1351           {
1352             push_function_context ();
1353             output_inline_function (decl);
1354             pop_function_context ();
1355           }
1356       }
1357
1358   /* When not in function-at-a-time mode, expand_end_bindings will
1359      warn about unused variables.  But, in function-at-a-time mode
1360      expand_end_bindings is not passed the list of variables in the
1361      current scope, and therefore no warning is emitted.  So, we
1362      explicitly warn here.  */
1363   if (!processing_template_decl)
1364     warn_about_unused_variables (getdecls ());
1365
1366   /* If there were any declarations or structure tags in that level,
1367      or if this level is a function body,
1368      create a BLOCK to record them for the life of this function.  */
1369   block = NULL_TREE;
1370   if (keep == 1 || functionbody)
1371     block = make_node (BLOCK);
1372   if (block != NULL_TREE)
1373     {
1374       BLOCK_VARS (block) = decls;
1375       BLOCK_SUBBLOCKS (block) = subblocks;
1376     }
1377
1378   /* In each subblock, record that this is its superior.  */
1379   if (keep >= 0)
1380     for (link = subblocks; link; link = TREE_CHAIN (link))
1381       BLOCK_SUPERCONTEXT (link) = block;
1382
1383   /* We still support the old for-scope rules, whereby the variables
1384      in a for-init statement were in scope after the for-statement
1385      ended.  We only use the new rules in flag_new_for_scope is
1386      nonzero.  */
1387   leaving_for_scope
1388     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1389
1390   /* Remove declarations for all the DECLs in this level.  */
1391   for (link = decls; link; link = TREE_CHAIN (link))
1392     {
1393       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1394           && DECL_NAME (link))
1395         {
1396           tree outer_binding
1397             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1398           tree ns_binding;
1399
1400           if (!outer_binding)
1401             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1402           else
1403             ns_binding = NULL_TREE;
1404
1405           if (outer_binding
1406               && (BINDING_LEVEL (outer_binding)
1407                   == current_binding_level->level_chain))
1408             /* We have something like:
1409
1410                  int i;
1411                  for (int i; ;);
1412
1413                and we are leaving the `for' scope.  There's no reason to
1414                keep the binding of the inner `i' in this case.  */
1415             pop_binding (DECL_NAME (link), link);
1416           else if ((outer_binding
1417                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1418                         == TYPE_DECL))
1419                    || (ns_binding
1420                        && TREE_CODE (ns_binding) == TYPE_DECL))
1421             /* Here, we have something like:
1422
1423                  typedef int I;
1424
1425                  void f () {
1426                    for (int I; ;);
1427                  }
1428
1429                We must pop the for-scope binding so we know what's a
1430                type and what isn't.  */
1431             pop_binding (DECL_NAME (link), link);
1432           else
1433             {
1434               /* Mark this VAR_DECL as dead so that we can tell we left it
1435                  there only for backward compatibility.  */
1436               DECL_DEAD_FOR_LOCAL (link) = 1;
1437
1438               /* Keep track of what should of have happenned when we
1439                  popped the binding.  */
1440               if (outer_binding && BINDING_VALUE (outer_binding))
1441                 DECL_SHADOWED_FOR_VAR (link)
1442                   = BINDING_VALUE (outer_binding);
1443
1444               /* Add it to the list of dead variables in the next
1445                  outermost binding to that we can remove these when we
1446                  leave that binding.  */
1447               current_binding_level->level_chain->dead_vars_from_for
1448                 = tree_cons (NULL_TREE, link,
1449                              current_binding_level->level_chain->
1450                              dead_vars_from_for);
1451
1452               /* Although we don't pop the CPLUS_BINDING, we do clear
1453                  its BINDING_LEVEL since the level is going away now.  */
1454               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1455                 = 0;
1456             }
1457         }
1458       else
1459         {
1460           /* Remove the binding.  */
1461           decl = link;
1462           if (TREE_CODE (decl) == TREE_LIST)
1463             decl = TREE_VALUE (decl);
1464           if (DECL_P (decl))
1465             pop_binding (DECL_NAME (decl), decl);
1466           else if (TREE_CODE (decl) == OVERLOAD)
1467             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1468           else
1469             my_friendly_abort (0);
1470         }
1471     }
1472
1473   /* Remove declarations for any `for' variables from inner scopes
1474      that we kept around.  */
1475   for (link = current_binding_level->dead_vars_from_for;
1476        link; link = TREE_CHAIN (link))
1477     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1478
1479   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1480   for (link = current_binding_level->type_shadowed;
1481        link; link = TREE_CHAIN (link))
1482     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1483
1484   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1485   for (link = current_binding_level->shadowed_labels;
1486        link;
1487        link = TREE_CHAIN (link))
1488     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1489
1490   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1491      list if a `using' declaration put them there.  The debugging
1492      back-ends won't understand OVERLOAD, so we remove them here.
1493      Because the BLOCK_VARS are (temporarily) shared with
1494      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1495      popped all the bindings.  */
1496   if (block)
1497     {
1498       tree* d;
1499
1500       for (d = &BLOCK_VARS (block); *d; )
1501         {
1502           if (TREE_CODE (*d) == TREE_LIST)
1503             *d = TREE_CHAIN (*d);
1504           else
1505             d = &TREE_CHAIN (*d);
1506         }
1507     }
1508
1509   /* If the level being exited is the top level of a function,
1510      check over all the labels.  */
1511   if (functionbody)
1512     {
1513       /* Since this is the top level block of a function, the vars are
1514          the function's parameters.  Don't leave them in the BLOCK
1515          because they are found in the FUNCTION_DECL instead.  */
1516       BLOCK_VARS (block) = 0;
1517       pop_labels (block);
1518     }
1519
1520   tmp = current_binding_level->keep;
1521
1522   pop_binding_level ();
1523   if (functionbody)
1524     DECL_INITIAL (current_function_decl) = block;
1525   else if (block)
1526     current_binding_level->blocks
1527       = chainon (current_binding_level->blocks, block);
1528
1529   /* If we did not make a block for the level just exited,
1530      any blocks made for inner levels
1531      (since they cannot be recorded as subblocks in that level)
1532      must be carried forward so they will later become subblocks
1533      of something else.  */
1534   else if (subblocks)
1535     current_binding_level->blocks
1536       = chainon (current_binding_level->blocks, subblocks);
1537
1538   /* Each and every BLOCK node created here in `poplevel' is important
1539      (e.g. for proper debugging information) so if we created one
1540      earlier, mark it as "used".  */
1541   if (block)
1542     TREE_USED (block) = 1;
1543
1544   /* Take care of compiler's internal binding structures.  */
1545   if (tmp == 2)
1546     {
1547       tree scope_stmts;
1548
1549       scope_stmts
1550         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1551       if (block)
1552         {
1553           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1554           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1555         }
1556
1557       block = poplevel (keep, reverse, functionbody);
1558     }
1559
1560   return block;
1561 }
1562
1563 /* Delete the node BLOCK from the current binding level.
1564    This is used for the block inside a stmt expr ({...})
1565    so that the block can be reinserted where appropriate.  */
1566
1567 void
1568 delete_block (block)
1569      tree block;
1570 {
1571   tree t;
1572   if (current_binding_level->blocks == block)
1573     current_binding_level->blocks = TREE_CHAIN (block);
1574   for (t = current_binding_level->blocks; t;)
1575     {
1576       if (TREE_CHAIN (t) == block)
1577         TREE_CHAIN (t) = TREE_CHAIN (block);
1578       else
1579         t = TREE_CHAIN (t);
1580     }
1581   TREE_CHAIN (block) = NULL_TREE;
1582   /* Clear TREE_USED which is always set by poplevel.
1583      The flag is set again if insert_block is called.  */
1584   TREE_USED (block) = 0;
1585 }
1586
1587 /* Insert BLOCK at the end of the list of subblocks of the
1588    current binding level.  This is used when a BIND_EXPR is expanded,
1589    to handle the BLOCK node inside the BIND_EXPR.  */
1590
1591 void
1592 insert_block (block)
1593      tree block;
1594 {
1595   TREE_USED (block) = 1;
1596   current_binding_level->blocks
1597     = chainon (current_binding_level->blocks, block);
1598 }
1599
1600 /* Set the BLOCK node for the innermost scope
1601    (the one we are currently in).  */
1602
1603 void
1604 set_block (block)
1605     tree block ATTRIBUTE_UNUSED;
1606 {
1607   /* The RTL expansion machinery requires us to provide this callback,
1608      but it is not applicable in function-at-a-time mode.  */
1609   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1610 }
1611
1612 /* Do a pushlevel for class declarations.  */
1613
1614 void
1615 pushlevel_class ()
1616 {
1617   register struct binding_level *newlevel;
1618
1619   /* Reuse or create a struct for this binding level.  */
1620 #if defined(DEBUG_CP_BINDING_LEVELS)
1621   if (0)
1622 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1623   if (free_binding_level)
1624 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1625     {
1626       newlevel = free_binding_level;
1627       free_binding_level = free_binding_level->level_chain;
1628     }
1629   else
1630     newlevel = make_binding_level ();
1631
1632 #if defined(DEBUG_CP_BINDING_LEVELS)
1633   is_class_level = 1;
1634 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1635
1636   push_binding_level (newlevel, 0, 0);
1637
1638   class_binding_level = current_binding_level;
1639   class_binding_level->parm_flag = 2;
1640   class_binding_level->this_class = current_class_type;
1641 }
1642
1643 /* ...and a poplevel for class declarations.  */
1644
1645 void
1646 poplevel_class ()
1647 {
1648   register struct binding_level *level = class_binding_level;
1649   tree shadowed;
1650
1651   my_friendly_assert (level != 0, 354);
1652
1653   /* If we're leaving a toplevel class, don't bother to do the setting
1654      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1655      shouldn't even be used when current_class_type isn't set, and second,
1656      if we don't touch it here, we're able to use the cache effect if the
1657      next time we're entering a class scope, it is the same class.  */
1658   if (current_class_depth != 1)
1659     {
1660       struct binding_level* b;
1661
1662       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1663       for (shadowed = level->class_shadowed;
1664            shadowed;
1665            shadowed = TREE_CHAIN (shadowed))
1666         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1667
1668       /* Find the next enclosing class, and recreate
1669          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1670       b = level->level_chain;
1671       while (b && b->parm_flag != 2)
1672         b = b->level_chain;
1673
1674       if (b)
1675         for (shadowed = b->class_shadowed;
1676              shadowed;
1677              shadowed = TREE_CHAIN (shadowed))
1678           {
1679             tree t;
1680
1681             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1682             while (t && BINDING_LEVEL (t) != b)
1683               t = TREE_CHAIN (t);
1684
1685             if (t)
1686               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1687                 = BINDING_VALUE (t);
1688           }
1689     }
1690   else
1691     /* Remember to save what IDENTIFIER's were bound in this scope so we
1692        can recover from cache misses.  */
1693     {
1694       previous_class_type = current_class_type;
1695       previous_class_values = class_binding_level->class_shadowed;
1696     }
1697   for (shadowed = level->type_shadowed;
1698        shadowed;
1699        shadowed = TREE_CHAIN (shadowed))
1700     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1701
1702   /* Remove the bindings for all of the class-level declarations.  */
1703   for (shadowed = level->class_shadowed;
1704        shadowed;
1705        shadowed = TREE_CHAIN (shadowed))
1706     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1707
1708   GNU_xref_end_scope ((size_t) class_binding_level,
1709                       (size_t) class_binding_level->level_chain,
1710                       class_binding_level->parm_flag,
1711                       class_binding_level->keep);
1712
1713   /* Now, pop out of the binding level which we created up in the
1714      `pushlevel_class' routine.  */
1715 #if defined(DEBUG_CP_BINDING_LEVELS)
1716   is_class_level = 1;
1717 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1718
1719   pop_binding_level ();
1720 }
1721
1722 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1723    for any names in enclosing classes.  */
1724
1725 void
1726 clear_identifier_class_values ()
1727 {
1728   tree t;
1729
1730   if (!class_binding_level)
1731     return;
1732
1733   for (t = class_binding_level->class_shadowed;
1734        t;
1735        t = TREE_CHAIN (t))
1736     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1737 }
1738
1739 /* Returns non-zero if T is a virtual function table.  */
1740
1741 int
1742 vtable_decl_p (t, data)
1743      tree t;
1744      void *data ATTRIBUTE_UNUSED;
1745 {
1746   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1747 }
1748
1749 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1750    functions.  */
1751
1752 int
1753 vtype_decl_p (t, data)
1754      tree t;
1755      void *data ATTRIBUTE_UNUSED;
1756 {
1757   return (TREE_CODE (t) == TYPE_DECL
1758           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1759           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1760 }
1761
1762 /* Return the declarations that are members of the namespace NS.  */
1763
1764 tree
1765 cp_namespace_decls (ns)
1766      tree ns;
1767 {
1768   return NAMESPACE_LEVEL (ns)->names;
1769 }
1770
1771 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1772    itself, calling F for each.  The DATA is passed to F as well.  */
1773
1774 static int
1775 walk_namespaces_r (namespace, f, data)
1776      tree namespace;
1777      walk_namespaces_fn f;
1778      void *data;
1779 {
1780   tree current;
1781   int result = 0;
1782
1783   result |= (*f) (namespace, data);
1784
1785   for (current = cp_namespace_decls (namespace);
1786        current;
1787        current = TREE_CHAIN (current))
1788     {
1789       if (TREE_CODE (current) != NAMESPACE_DECL
1790           || DECL_NAMESPACE_ALIAS (current))
1791         continue;
1792
1793       /* We found a namespace.  */
1794       result |= walk_namespaces_r (current, f, data);
1795     }
1796
1797   return result;
1798 }
1799
1800 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1801    F as well.  */
1802
1803 int
1804 walk_namespaces (f, data)
1805      walk_namespaces_fn f;
1806      void *data;
1807 {
1808   return walk_namespaces_r (global_namespace, f, data);
1809 }
1810
1811 struct walk_globals_data {
1812   walk_globals_pred p;
1813   walk_globals_fn f;
1814   void *data;
1815 };
1816
1817 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1818    for which P returns non-zero, call F with its address.  If any call
1819    to F returns a non-zero value, return a non-zero value.  */
1820
1821 static int
1822 walk_globals_r (namespace, data)
1823      tree namespace;
1824      void *data;
1825 {
1826   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1827   walk_globals_pred p = wgd->p;
1828   walk_globals_fn f = wgd->f;
1829   void *d = wgd->data;
1830   tree *t;
1831   int result = 0;
1832
1833   t = &NAMESPACE_LEVEL (namespace)->names;
1834
1835   while (*t)
1836     {
1837       tree glbl = *t;
1838
1839       if ((*p) (glbl, d))
1840         result |= (*f) (t, d);
1841
1842       /* If F changed *T, then *T still points at the next item to
1843          examine.  */
1844       if (*t == glbl)
1845         t = &TREE_CHAIN (*t);
1846     }
1847
1848   return result;
1849 }
1850
1851 /* Walk the global declarations.  Whenever one is found for which P
1852    returns non-zero, call F with its address.  If any call to F
1853    returns a non-zero value, return a non-zero value.  */
1854
1855 int
1856 walk_globals (p, f, data)
1857      walk_globals_pred p;
1858      walk_globals_fn f;
1859      void *data;
1860 {
1861   struct walk_globals_data wgd;
1862   wgd.p = p;
1863   wgd.f = f;
1864   wgd.data = data;
1865
1866   return walk_namespaces (walk_globals_r, &wgd);
1867 }
1868
1869 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1870    DATA is non-NULL, this is the last time we will call
1871    wrapup_global_declarations for this NAMESPACE.  */
1872
1873 int
1874 wrapup_globals_for_namespace (namespace, data)
1875      tree namespace;
1876      void *data;
1877 {
1878   tree globals = cp_namespace_decls (namespace);
1879   int len = list_length (globals);
1880   tree *vec = (tree *) alloca (sizeof (tree) * len);
1881   int i;
1882   int result;
1883   tree decl;
1884   int last_time = (data != 0);
1885
1886   if (last_time && namespace == global_namespace)
1887     /* Let compile_file handle the global namespace.  */
1888     return 0;
1889
1890   /* Process the decls in reverse order--earliest first.
1891      Put them into VEC from back to front, then take out from front.  */
1892   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1893     vec[len - i - 1] = decl;
1894
1895   if (last_time)
1896     {
1897       check_global_declarations (vec, len);
1898       return 0;
1899     }
1900
1901   /* Temporarily mark vtables as external.  That prevents
1902      wrapup_global_declarations from writing them out; we must process
1903      them ourselves in finish_vtable_vardecl.  */
1904   for (i = 0; i < len; ++i)
1905     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1906       {
1907         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1908         DECL_EXTERNAL (vec[i]) = 1;
1909       }
1910
1911   /* Write out any globals that need to be output.  */
1912   result = wrapup_global_declarations (vec, len);
1913
1914   /* Undo the hack to DECL_EXTERNAL above.  */
1915   for (i = 0; i < len; ++i)
1916     if (vtable_decl_p (vec[i], /*data=*/0)
1917         && DECL_NOT_REALLY_EXTERN (vec[i]))
1918       {
1919         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1920         DECL_EXTERNAL (vec[i]) = 0;
1921       }
1922
1923   return result;
1924 }
1925
1926 \f
1927 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1928
1929 static void
1930 mark_binding_level (arg)
1931      void *arg;
1932 {
1933   struct binding_level *lvl = *(struct binding_level **)arg;
1934
1935   for (; lvl; lvl = lvl->level_chain)
1936     {
1937       ggc_mark_tree (lvl->names);
1938       ggc_mark_tree (lvl->tags);
1939       ggc_mark_tree (lvl->usings);
1940       ggc_mark_tree (lvl->using_directives);
1941       ggc_mark_tree (lvl->class_shadowed);
1942       ggc_mark_tree (lvl->type_shadowed);
1943       ggc_mark_tree (lvl->shadowed_labels);
1944       ggc_mark_tree (lvl->blocks);
1945       ggc_mark_tree (lvl->this_class);
1946       ggc_mark_tree (lvl->incomplete);
1947       ggc_mark_tree (lvl->dead_vars_from_for);
1948     }
1949 }
1950
1951 static void
1952 mark_named_label_lists (labs, uses)
1953      void *labs;
1954      void *uses;
1955 {
1956   struct named_label_list *l = *(struct named_label_list **)labs;
1957   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
1958
1959   for (; l; l = l->next)
1960     {
1961       ggc_mark (l);
1962       mark_binding_level (l->binding_level);
1963       ggc_mark_tree (l->old_value);
1964       ggc_mark_tree (l->label_decl);
1965       ggc_mark_tree (l->bad_decls);
1966     }
1967
1968   for (; u; u = u->next)
1969     ggc_mark (u);
1970 }
1971 \f
1972 /* For debugging.  */
1973 static int no_print_functions = 0;
1974 static int no_print_builtins = 0;
1975
1976 void
1977 print_binding_level (lvl)
1978      struct binding_level *lvl;
1979 {
1980   tree t;
1981   int i = 0, len;
1982   fprintf (stderr, " blocks=");
1983   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1984   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
1985            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
1986   if (lvl->tag_transparent)
1987     fprintf (stderr, " tag-transparent");
1988   if (lvl->more_cleanups_ok)
1989     fprintf (stderr, " more-cleanups-ok");
1990   if (lvl->have_cleanups)
1991     fprintf (stderr, " have-cleanups");
1992   fprintf (stderr, "\n");
1993   if (lvl->names)
1994     {
1995       fprintf (stderr, " names:\t");
1996       /* We can probably fit 3 names to a line?  */
1997       for (t = lvl->names; t; t = TREE_CHAIN (t))
1998         {
1999           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2000             continue;
2001           if (no_print_builtins
2002               && (TREE_CODE (t) == TYPE_DECL)
2003               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2004             continue;
2005
2006           /* Function decls tend to have longer names.  */
2007           if (TREE_CODE (t) == FUNCTION_DECL)
2008             len = 3;
2009           else
2010             len = 2;
2011           i += len;
2012           if (i > 6)
2013             {
2014               fprintf (stderr, "\n\t");
2015               i = len;
2016             }
2017           print_node_brief (stderr, "", t, 0);
2018           if (t == error_mark_node)
2019             break;
2020         }
2021       if (i)
2022         fprintf (stderr, "\n");
2023     }
2024   if (lvl->tags)
2025     {
2026       fprintf (stderr, " tags:\t");
2027       i = 0;
2028       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2029         {
2030           if (TREE_PURPOSE (t) == NULL_TREE)
2031             len = 3;
2032           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2033             len = 2;
2034           else
2035             len = 4;
2036           i += len;
2037           if (i > 5)
2038             {
2039               fprintf (stderr, "\n\t");
2040               i = len;
2041             }
2042           if (TREE_PURPOSE (t) == NULL_TREE)
2043             {
2044               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2045               fprintf (stderr, ">");
2046             }
2047           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2048             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2049           else
2050             {
2051               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2052               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2053               fprintf (stderr, ">");
2054             }
2055         }
2056       if (i)
2057         fprintf (stderr, "\n");
2058     }
2059   if (lvl->class_shadowed)
2060     {
2061       fprintf (stderr, " class-shadowed:");
2062       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2063         {
2064           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2065         }
2066       fprintf (stderr, "\n");
2067     }
2068   if (lvl->type_shadowed)
2069     {
2070       fprintf (stderr, " type-shadowed:");
2071       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2072         {
2073           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2074         }
2075       fprintf (stderr, "\n");
2076     }
2077 }
2078
2079 void
2080 print_other_binding_stack (stack)
2081      struct binding_level *stack;
2082 {
2083   struct binding_level *level;
2084   for (level = stack; level != global_binding_level; level = level->level_chain)
2085     {
2086       fprintf (stderr, "binding level ");
2087       fprintf (stderr, HOST_PTR_PRINTF, level);
2088       fprintf (stderr, "\n");
2089       print_binding_level (level);
2090     }
2091 }
2092
2093 void
2094 print_binding_stack ()
2095 {
2096   struct binding_level *b;
2097   fprintf (stderr, "current_binding_level=");
2098   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2099   fprintf (stderr, "\nclass_binding_level=");
2100   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2101   fprintf (stderr, "\nglobal_binding_level=");
2102   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2103   fprintf (stderr, "\n");
2104   if (class_binding_level)
2105     {
2106       for (b = class_binding_level; b; b = b->level_chain)
2107         if (b == current_binding_level)
2108           break;
2109       if (b)
2110         b = class_binding_level;
2111       else
2112         b = current_binding_level;
2113     }
2114   else
2115     b = current_binding_level;
2116   print_other_binding_stack (b);
2117   fprintf (stderr, "global:\n");
2118   print_binding_level (global_binding_level);
2119 }
2120
2121 /* Namespace binding access routines: The namespace_bindings field of
2122    the identifier is polymorphic, with three possible values:
2123    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2124    indicating the BINDING_VALUE of global_namespace. */
2125
2126 /* Check whether the a binding for the name to scope is known.
2127    Assumes that the bindings of the name are already a list
2128    of bindings. Returns the binding found, or NULL_TREE. */
2129
2130 static tree
2131 find_binding (name, scope)
2132      tree name;
2133      tree scope;
2134 {
2135   tree iter, prev = NULL_TREE;
2136
2137   scope = ORIGINAL_NAMESPACE (scope);
2138
2139   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2140        iter = TREE_CHAIN (iter))
2141     {
2142       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2143       if (BINDING_SCOPE (iter) == scope)
2144         {
2145           /* Move binding found to the front of the list, so
2146              subsequent lookups will find it faster. */
2147           if (prev)
2148             {
2149               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2150               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2151               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2152             }
2153           return iter;
2154         }
2155       prev = iter;
2156     }
2157   return NULL_TREE;
2158 }
2159
2160 /* Always returns a binding for name in scope. If the
2161    namespace_bindings is not a list, convert it to one first.
2162    If no binding is found, make a new one. */
2163
2164 tree
2165 binding_for_name (name, scope)
2166      tree name;
2167      tree scope;
2168 {
2169   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2170   tree result;
2171
2172   scope = ORIGINAL_NAMESPACE (scope);
2173
2174   if (b && TREE_CODE (b) != CPLUS_BINDING)
2175     {
2176       /* Get rid of optimization for global scope. */
2177       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2178       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2179       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2180     }
2181   if (b && (result = find_binding (name, scope)))
2182     return result;
2183   /* Not found, make a new one. */
2184   result = make_node (CPLUS_BINDING);
2185   TREE_CHAIN (result) = b;
2186   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2187   BINDING_SCOPE (result) = scope;
2188   BINDING_TYPE (result) = NULL_TREE;
2189   BINDING_VALUE (result) = NULL_TREE;
2190   return result;
2191 }
2192
2193 /* Return the binding value for name in scope, considering that
2194    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2195
2196 tree
2197 namespace_binding (name, scope)
2198      tree name;
2199      tree scope;
2200 {
2201   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2202   if (b == NULL_TREE)
2203     return NULL_TREE;
2204   if (scope == NULL_TREE)
2205     scope = global_namespace;
2206   if (TREE_CODE (b) != CPLUS_BINDING)
2207     return (scope == global_namespace) ? b : NULL_TREE;
2208   name = find_binding (name,scope);
2209   if (name == NULL_TREE)
2210     return name;
2211   return BINDING_VALUE (name);
2212 }
2213
2214 /* Set the binding value for name in scope. If modifying the binding
2215    of global_namespace is attempted, try to optimize it. */
2216
2217 void
2218 set_namespace_binding (name, scope, val)
2219      tree name;
2220      tree scope;
2221      tree val;
2222 {
2223   tree b;
2224
2225   if (scope == NULL_TREE)
2226     scope = global_namespace;
2227
2228   if (scope == global_namespace)
2229     {
2230       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2231       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2232         {
2233           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2234           return;
2235         }
2236     }
2237   b = binding_for_name (name, scope);
2238   BINDING_VALUE (b) = val;
2239 }
2240
2241 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2242    select a name that is unique to this compilation unit.  */
2243
2244 void
2245 push_namespace (name)
2246      tree name;
2247 {
2248   tree d = NULL_TREE;
2249   int need_new = 1;
2250   int implicit_use = 0;
2251   int global = 0;
2252   if (!global_namespace)
2253     {
2254       /* This must be ::. */
2255       my_friendly_assert (name == get_identifier ("::"), 377);
2256       global = 1;
2257     }
2258   else if (!name)
2259     {
2260       /* The name of anonymous namespace is unique for the translation
2261          unit.  */
2262       if (!anonymous_namespace_name)
2263         anonymous_namespace_name = get_file_function_name ('N');
2264       name = anonymous_namespace_name;
2265       d = IDENTIFIER_NAMESPACE_VALUE (name);
2266       if (d)
2267         /* Reopening anonymous namespace.  */
2268         need_new = 0;
2269       implicit_use = 1;
2270     }
2271   else
2272     {
2273       /* Check whether this is an extended namespace definition. */
2274       d = IDENTIFIER_NAMESPACE_VALUE (name);
2275       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2276         {
2277           need_new = 0;
2278           if (DECL_NAMESPACE_ALIAS (d))
2279             {
2280               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2281                         d, DECL_NAMESPACE_ALIAS (d));
2282               d = DECL_NAMESPACE_ALIAS (d);
2283             }
2284         }
2285     }
2286
2287   if (need_new)
2288     {
2289       /* Make a new namespace, binding the name to it. */
2290       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2291       /* The global namespace is not pushed, and the global binding
2292          level is set elsewhere.  */
2293       if (!global)
2294         {
2295           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2296           d = pushdecl (d);
2297           pushlevel (0);
2298           declare_namespace_level ();
2299           NAMESPACE_LEVEL (d) = current_binding_level;
2300         }
2301     }
2302   else
2303     resume_binding_level (NAMESPACE_LEVEL (d));
2304
2305   if (implicit_use)
2306     do_using_directive (d);
2307   /* Enter the name space. */
2308   current_namespace = d;
2309 }
2310
2311 /* Pop from the scope of the current namespace.  */
2312
2313 void
2314 pop_namespace ()
2315 {
2316   my_friendly_assert (current_namespace != global_namespace, 20010801);
2317   current_namespace = CP_DECL_CONTEXT (current_namespace);
2318   /* The binding level is not popped, as it might be re-opened later.  */
2319   suspend_binding_level ();
2320 }
2321
2322 /* Push into the scope of the namespace NS, even if it is deeply
2323    nested within another namespace.  */
2324
2325 void
2326 push_nested_namespace (ns)
2327      tree ns;
2328 {
2329   if (ns == global_namespace)
2330     push_to_top_level ();
2331   else
2332     {
2333       push_nested_namespace (CP_DECL_CONTEXT (ns));
2334       push_namespace (DECL_NAME (ns));
2335     }
2336 }
2337
2338 /* Pop back from the scope of the namespace NS, which was previously
2339    entered with push_nested_namespace.  */
2340
2341 void
2342 pop_nested_namespace (ns)
2343      tree ns;
2344 {
2345   while (ns != global_namespace)
2346     {
2347       pop_namespace ();
2348       ns = CP_DECL_CONTEXT (ns);
2349     }
2350
2351   pop_from_top_level ();
2352 }
2353
2354 \f
2355 /* Subroutines for reverting temporarily to top-level for instantiation
2356    of templates and such.  We actually need to clear out the class- and
2357    local-value slots of all identifiers, so that only the global values
2358    are at all visible.  Simply setting current_binding_level to the global
2359    scope isn't enough, because more binding levels may be pushed.  */
2360 struct saved_scope *scope_chain;
2361
2362 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2363
2364 static void
2365 mark_saved_scope (arg)
2366      void *arg;
2367 {
2368   struct saved_scope *t = *(struct saved_scope **)arg;
2369   while (t)
2370     {
2371       mark_binding_level (&t->class_bindings);
2372       ggc_mark_tree (t->old_bindings);
2373       ggc_mark_tree (t->old_namespace);
2374       ggc_mark_tree (t->decl_ns_list);
2375       ggc_mark_tree (t->class_name);
2376       ggc_mark_tree (t->class_type);
2377       ggc_mark_tree (t->access_specifier);
2378       ggc_mark_tree (t->function_decl);
2379       if (t->lang_base)
2380         ggc_mark_tree_varray (t->lang_base);
2381       ggc_mark_tree (t->lang_name);
2382       ggc_mark_tree (t->template_parms);
2383       ggc_mark_tree (t->x_previous_class_type);
2384       ggc_mark_tree (t->x_previous_class_values);
2385       ggc_mark_tree (t->x_saved_tree);
2386       ggc_mark_tree (t->incomplete);
2387       ggc_mark_tree (t->lookups);
2388
2389       mark_stmt_tree (&t->x_stmt_tree);
2390       mark_binding_level (&t->bindings);
2391       t = t->prev;
2392     }
2393 }
2394
2395 static tree
2396 store_bindings (names, old_bindings)
2397      tree names, old_bindings;
2398 {
2399   tree t;
2400   tree search_bindings = old_bindings;
2401
2402   for (t = names; t; t = TREE_CHAIN (t))
2403     {
2404       tree binding, t1, id;
2405
2406       if (TREE_CODE (t) == TREE_LIST)
2407         id = TREE_PURPOSE (t);
2408       else
2409         id = DECL_NAME (t);
2410
2411       if (!id
2412           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2413              we have no IDENTIFIER_BINDING if we have left the class
2414              scope, but cached the class-level declarations.  */
2415           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2416         continue;
2417
2418       for (t1 = search_bindings; t1; t1 = TREE_CHAIN (t1))
2419         if (TREE_VEC_ELT (t1, 0) == id)
2420           goto skip_it;
2421
2422       my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2423       binding = make_tree_vec (4);
2424       TREE_VEC_ELT (binding, 0) = id;
2425       TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2426       TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2427       TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2428       IDENTIFIER_BINDING (id) = NULL_TREE;
2429       IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2430       TREE_CHAIN (binding) = old_bindings;
2431       old_bindings = binding;
2432     skip_it:
2433       ;
2434     }
2435   return old_bindings;
2436 }
2437
2438 void
2439 maybe_push_to_top_level (pseudo)
2440      int pseudo;
2441 {
2442   struct saved_scope *s;
2443   struct binding_level *b;
2444   tree old_bindings;
2445   int need_pop;
2446
2447   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2448
2449   b = scope_chain ? current_binding_level : 0;
2450
2451   /* If we're in the middle of some function, save our state.  */
2452   if (cfun)
2453     {
2454       need_pop = 1;
2455       push_function_context_to (NULL_TREE);
2456     }
2457   else
2458     need_pop = 0;
2459
2460   old_bindings = NULL_TREE;
2461   if (scope_chain && previous_class_type)
2462     old_bindings = store_bindings (previous_class_values, old_bindings);
2463
2464   /* Have to include global_binding_level, because class-level decls
2465      aren't listed anywhere useful.  */
2466   for (; b; b = b->level_chain)
2467     {
2468       tree t;
2469
2470       /* Template IDs are inserted into the global level. If they were
2471          inserted into namespace level, finish_file wouldn't find them
2472          when doing pending instantiations. Therefore, don't stop at
2473          namespace level, but continue until :: .  */
2474       if (b == global_binding_level || (pseudo && b->template_parms_p))
2475         break;
2476
2477       old_bindings = store_bindings (b->names, old_bindings);
2478       /* We also need to check class_shadowed to save class-level type
2479          bindings, since pushclass doesn't fill in b->names.  */
2480       if (b->parm_flag == 2)
2481         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2482
2483       /* Unwind type-value slots back to top level.  */
2484       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2485         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2486     }
2487   s->prev = scope_chain;
2488   s->old_bindings = old_bindings;
2489   s->bindings = b;
2490   s->need_pop_function_context = need_pop;
2491   s->function_decl = current_function_decl;
2492
2493   scope_chain = s;
2494   current_function_decl = NULL_TREE;
2495   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2496   current_lang_name = lang_name_cplusplus;
2497   current_namespace = global_namespace;
2498 }
2499
2500 void
2501 push_to_top_level ()
2502 {
2503   maybe_push_to_top_level (0);
2504 }
2505
2506 void
2507 pop_from_top_level ()
2508 {
2509   struct saved_scope *s = scope_chain;
2510   tree t;
2511
2512   /* Clear out class-level bindings cache.  */
2513   if (previous_class_type)
2514     invalidate_class_lookup_cache ();
2515
2516   VARRAY_FREE (current_lang_base);
2517
2518   scope_chain = s->prev;
2519   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2520     {
2521       tree id = TREE_VEC_ELT (t, 0);
2522
2523       SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2524       IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2525       IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2526     }
2527
2528   /* If we were in the middle of compiling a function, restore our
2529      state.  */
2530   if (s->need_pop_function_context)
2531     pop_function_context_from (NULL_TREE);
2532   current_function_decl = s->function_decl;
2533
2534   free (s);
2535 }
2536 \f
2537 /* Push a definition of struct, union or enum tag "name".
2538    into binding_level "b".   "type" should be the type node,
2539    We assume that the tag "name" is not already defined.
2540
2541    Note that the definition may really be just a forward reference.
2542    In that case, the TYPE_SIZE will be a NULL_TREE.
2543
2544    C++ gratuitously puts all these tags in the name space.  */
2545
2546 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2547    record the shadowed value for this binding contour.  TYPE is
2548    the type that ID maps to.  */
2549
2550 static void
2551 set_identifier_type_value_with_scope (id, type, b)
2552      tree id;
2553      tree type;
2554      struct binding_level *b;
2555 {
2556   if (!b->namespace_p)
2557     {
2558       /* Shadow the marker, not the real thing, so that the marker
2559          gets restored later. */
2560       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2561       b->type_shadowed
2562         = tree_cons (id, old_type_value, b->type_shadowed);
2563     }
2564   else
2565     {
2566       tree binding = binding_for_name (id, current_namespace);
2567       BINDING_TYPE (binding) = type;
2568       /* Store marker instead of real type. */
2569       type = global_type_node;
2570     }
2571   SET_IDENTIFIER_TYPE_VALUE (id, type);
2572 }
2573
2574 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2575
2576 void
2577 set_identifier_type_value (id, type)
2578      tree id;
2579      tree type;
2580 {
2581   set_identifier_type_value_with_scope (id, type, current_binding_level);
2582 }
2583
2584 /* Return the type associated with id. */
2585
2586 tree
2587 identifier_type_value (id)
2588      tree id;
2589 {
2590   /* There is no type with that name, anywhere. */
2591   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2592     return NULL_TREE;
2593   /* This is not the type marker, but the real thing. */
2594   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2595     return REAL_IDENTIFIER_TYPE_VALUE (id);
2596   /* Have to search for it. It must be on the global level, now.
2597      Ask lookup_name not to return non-types. */
2598   id = lookup_name_real (id, 2, 1, 0);
2599   if (id)
2600     return TREE_TYPE (id);
2601   return NULL_TREE;
2602 }
2603
2604 /* Pop off extraneous binding levels left over due to syntax errors.
2605
2606    We don't pop past namespaces, as they might be valid.  */
2607
2608 void
2609 pop_everything ()
2610 {
2611 #ifdef DEBUG_CP_BINDING_LEVELS
2612   fprintf (stderr, "XXX entering pop_everything ()\n");
2613 #endif
2614   while (!toplevel_bindings_p ())
2615     {
2616       if (current_binding_level->parm_flag == 2)
2617         pop_nested_class ();
2618       else
2619         poplevel (0, 0, 0);
2620     }
2621 #ifdef DEBUG_CP_BINDING_LEVELS
2622   fprintf (stderr, "XXX leaving pop_everything ()\n");
2623 #endif
2624 }
2625
2626 /* The type TYPE is being declared.  If it is a class template, or a
2627    specialization of a class template, do any processing required and
2628    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2629    being declared a friend.  B is the binding level at which this TYPE
2630    should be bound.
2631
2632    Returns the TYPE_DECL for TYPE, which may have been altered by this
2633    processing.  */
2634
2635 static tree
2636 maybe_process_template_type_declaration (type, globalize, b)
2637      tree type;
2638      int globalize;
2639      struct binding_level* b;
2640 {
2641   tree decl = TYPE_NAME (type);
2642
2643   if (processing_template_parmlist)
2644     /* You can't declare a new template type in a template parameter
2645        list.  But, you can declare a non-template type:
2646
2647          template <class A*> struct S;
2648
2649        is a forward-declaration of `A'.  */
2650     ;
2651   else
2652     {
2653       maybe_check_template_type (type);
2654
2655       my_friendly_assert (IS_AGGR_TYPE (type)
2656                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2657
2658
2659       if (processing_template_decl)
2660         {
2661           /* This may change after the call to
2662              push_template_decl_real, but we want the original value.  */
2663           tree name = DECL_NAME (decl);
2664
2665           decl = push_template_decl_real (decl, globalize);
2666           /* If the current binding level is the binding level for the
2667              template parameters (see the comment in
2668              begin_template_parm_list) and the enclosing level is a class
2669              scope, and we're not looking at a friend, push the
2670              declaration of the member class into the class scope.  In the
2671              friend case, push_template_decl will already have put the
2672              friend into global scope, if appropriate.  */
2673           if (TREE_CODE (type) != ENUMERAL_TYPE
2674               && !globalize && b->template_parms_p
2675               && b->level_chain->parm_flag == 2)
2676             {
2677               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2678               /* Put this tag on the list of tags for the class, since
2679                  that won't happen below because B is not the class
2680                  binding level, but is instead the pseudo-global level.  */
2681               b->level_chain->tags =
2682                 tree_cons (name, type, b->level_chain->tags);
2683               if (!COMPLETE_TYPE_P (current_class_type))
2684                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2685             }
2686         }
2687     }
2688
2689   return decl;
2690 }
2691
2692 /* In C++, you don't have to write `struct S' to refer to `S'; you
2693    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2694    if the user had written `typedef struct S S'.  Create and return
2695    the TYPE_DECL for TYPE.  */
2696
2697 tree
2698 create_implicit_typedef (name, type)
2699      tree name;
2700      tree type;
2701 {
2702   tree decl;
2703
2704   decl = build_decl (TYPE_DECL, name, type);
2705   DECL_ARTIFICIAL (decl) = 1;
2706   /* There are other implicit type declarations, like the one *within*
2707      a class that allows you to write `S::S'.  We must distinguish
2708      amongst these.  */
2709   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2710   TYPE_NAME (type) = decl;
2711
2712   return decl;
2713 }
2714
2715 /* Remember a local name for name-mangling purposes.  */
2716
2717 static void
2718 push_local_name (decl)
2719      tree decl;
2720 {
2721   size_t i, nelts;
2722   tree t, name;
2723
2724   if (!local_names)
2725     VARRAY_TREE_INIT (local_names, 8, "local_names");
2726
2727   name = DECL_NAME (decl);
2728
2729   nelts = VARRAY_ACTIVE_SIZE (local_names);
2730   for (i = 0; i < nelts; i++)
2731     {
2732       t = VARRAY_TREE (local_names, i);
2733       if (DECL_NAME (t) == name)
2734         {
2735           if (!DECL_LANG_SPECIFIC (decl))
2736             retrofit_lang_decl (decl);
2737           if (DECL_LANG_SPECIFIC (t))
2738             DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
2739           else
2740             DECL_DISCRIMINATOR (decl) = 1;
2741
2742           VARRAY_TREE (local_names, i) = decl;
2743           return;
2744         }
2745     }
2746
2747   VARRAY_PUSH_TREE (local_names, decl);
2748 }
2749
2750 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2751    Normally put it into the inner-most non-tag-transparent scope,
2752    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2753    The latter is needed for implicit declarations.  */
2754
2755 void
2756 pushtag (name, type, globalize)
2757      tree name, type;
2758      int globalize;
2759 {
2760   register struct binding_level *b;
2761
2762   b = current_binding_level;
2763   while (b->tag_transparent
2764          || (b->parm_flag == 2
2765              && (globalize
2766                  /* We may be defining a new type in the initializer
2767                     of a static member variable. We allow this when
2768                     not pedantic, and it is particularly useful for
2769                     type punning via an anonymous union. */
2770                  || COMPLETE_TYPE_P (b->this_class))))
2771     b = b->level_chain;
2772
2773   b->tags = tree_cons (name, type, b->tags);
2774
2775   if (name)
2776     {
2777       /* Do C++ gratuitous typedefing.  */
2778       if (IDENTIFIER_TYPE_VALUE (name) != type)
2779         {
2780           register tree d = NULL_TREE;
2781           int in_class = 0;
2782           tree context = TYPE_CONTEXT (type);
2783
2784           if (! context)
2785             {
2786               tree cs = current_scope ();
2787
2788               if (! globalize)
2789                 context = cs;
2790               else if (cs != NULL_TREE && TYPE_P (cs))
2791                 /* When declaring a friend class of a local class, we want
2792                    to inject the newly named class into the scope
2793                    containing the local class, not the namespace scope.  */
2794                 context = decl_function_context (get_type_decl (cs));
2795             }
2796           if (!context)
2797             context = current_namespace;
2798
2799           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2800               || b->parm_flag == 2)
2801             in_class = 1;
2802
2803           if (current_lang_name == lang_name_java)
2804             TYPE_FOR_JAVA (type) = 1;
2805
2806           d = create_implicit_typedef (name, type);
2807           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2808           if (! in_class)
2809             set_identifier_type_value_with_scope (name, type, b);
2810
2811           d = maybe_process_template_type_declaration (type,
2812                                                        globalize, b);
2813
2814           if (b->parm_flag == 2)
2815             {
2816               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2817                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2818                    class.  But if it's a member template class, we
2819                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2820                    is done later.  */
2821                 finish_member_declaration (d);
2822               else
2823                 pushdecl_class_level (d);
2824             }
2825           else
2826             d = pushdecl_with_scope (d, b);
2827
2828           /* FIXME what if it gets a name from typedef?  */
2829           if (ANON_AGGRNAME_P (name))
2830             DECL_IGNORED_P (d) = 1;
2831
2832           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2833
2834           /* If this is a local class, keep track of it.  We need this
2835              information for name-mangling, and so that it is possible to find
2836              all function definitions in a translation unit in a convenient
2837              way.  (It's otherwise tricky to find a member function definition
2838              it's only pointed to from within a local class.)  */
2839           if (TYPE_CONTEXT (type)
2840               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2841               && !processing_template_decl)
2842             VARRAY_PUSH_TREE (local_classes, type);
2843         }
2844       if (b->parm_flag == 2)
2845         {
2846           if (!COMPLETE_TYPE_P (current_class_type))
2847             CLASSTYPE_TAGS (current_class_type) = b->tags;
2848         }
2849     }
2850
2851   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2852     /* Use the canonical TYPE_DECL for this node.  */
2853     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2854   else
2855     {
2856       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2857          will be the tagged type we just added to the current
2858          binding level.  This fake NULL-named TYPE_DECL node helps
2859          dwarfout.c to know when it needs to output a
2860          representation of a tagged type, and it also gives us a
2861          convenient place to record the "scope start" address for
2862          the tagged type.  */
2863
2864       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2865       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2866     }
2867 }
2868
2869 /* Counter used to create anonymous type names.  */
2870
2871 static int anon_cnt = 0;
2872
2873 /* Return an IDENTIFIER which can be used as a name for
2874    anonymous structs and unions.  */
2875
2876 tree
2877 make_anon_name ()
2878 {
2879   char buf[32];
2880
2881   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2882   return get_identifier (buf);
2883 }
2884
2885 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2886    This keeps dbxout from getting confused.  */
2887
2888 void
2889 clear_anon_tags ()
2890 {
2891   register struct binding_level *b;
2892   register tree tags;
2893   static int last_cnt = 0;
2894
2895   /* Fast out if no new anon names were declared.  */
2896   if (last_cnt == anon_cnt)
2897     return;
2898
2899   b = current_binding_level;
2900   while (b->tag_transparent)
2901     b = b->level_chain;
2902   tags = b->tags;
2903   while (tags)
2904     {
2905       /* A NULL purpose means we have already processed all tags
2906          from here to the end of the list.  */
2907       if (TREE_PURPOSE (tags) == NULL_TREE)
2908         break;
2909       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2910         TREE_PURPOSE (tags) = NULL_TREE;
2911       tags = TREE_CHAIN (tags);
2912     }
2913   last_cnt = anon_cnt;
2914 }
2915 \f
2916 /* Subroutine of duplicate_decls: return truthvalue of whether
2917    or not types of these decls match.
2918
2919    For C++, we must compare the parameter list so that `int' can match
2920    `int&' in a parameter position, but `int&' is not confused with
2921    `const int&'.  */
2922
2923 int
2924 decls_match (newdecl, olddecl)
2925      tree newdecl, olddecl;
2926 {
2927   int types_match;
2928
2929   if (newdecl == olddecl)
2930     return 1;
2931
2932   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2933     /* If the two DECLs are not even the same kind of thing, we're not
2934        interested in their types.  */
2935     return 0;
2936
2937   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2938     {
2939       tree f1 = TREE_TYPE (newdecl);
2940       tree f2 = TREE_TYPE (olddecl);
2941       tree p1 = TYPE_ARG_TYPES (f1);
2942       tree p2 = TYPE_ARG_TYPES (f2);
2943
2944       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2945           && ! (DECL_EXTERN_C_P (newdecl)
2946                 && DECL_EXTERN_C_P (olddecl)))
2947         return 0;
2948
2949       if (TREE_CODE (f1) != TREE_CODE (f2))
2950         return 0;
2951
2952       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2953         {
2954           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
2955               && (DECL_BUILT_IN (olddecl)
2956 #ifndef NO_IMPLICIT_EXTERN_C
2957                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
2958                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
2959 #endif
2960               ))
2961             {
2962               types_match = self_promoting_args_p (p1);
2963               if (p1 == void_list_node)
2964                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2965             }
2966 #ifndef NO_IMPLICIT_EXTERN_C
2967           else if (p1 == NULL_TREE
2968                    && (DECL_EXTERN_C_P (olddecl)
2969                        && DECL_IN_SYSTEM_HEADER (olddecl)
2970                        && !DECL_CLASS_SCOPE_P (olddecl))
2971                    && (DECL_EXTERN_C_P (newdecl)
2972                        && DECL_IN_SYSTEM_HEADER (newdecl)
2973                        && !DECL_CLASS_SCOPE_P (newdecl)))
2974             {
2975               types_match = self_promoting_args_p (p2);
2976               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2977             }
2978 #endif
2979           else
2980             types_match = compparms (p1, p2);
2981         }
2982       else
2983         types_match = 0;
2984     }
2985   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2986     {
2987       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2988                                 DECL_TEMPLATE_PARMS (olddecl)))
2989         return 0;
2990
2991       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
2992           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
2993         return 0;
2994
2995       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2996         types_match = 1;
2997       else
2998         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2999                                    DECL_TEMPLATE_RESULT (newdecl));
3000     }
3001   else
3002     {
3003       if (TREE_TYPE (newdecl) == error_mark_node)
3004         types_match = TREE_TYPE (olddecl) == error_mark_node;
3005       else if (TREE_TYPE (olddecl) == NULL_TREE)
3006         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3007       else if (TREE_TYPE (newdecl) == NULL_TREE)
3008         types_match = 0;
3009       else
3010         types_match = comptypes (TREE_TYPE (newdecl),
3011                                  TREE_TYPE (olddecl),
3012                                  COMPARE_REDECLARATION);
3013     }
3014
3015   return types_match;
3016 }
3017
3018 /* If NEWDECL is `static' and an `extern' was seen previously,
3019    warn about it.  OLDDECL is the previous declaration.
3020
3021    Note that this does not apply to the C++ case of declaring
3022    a variable `extern const' and then later `const'.
3023
3024    Don't complain about built-in functions, since they are beyond
3025    the user's control.  */
3026
3027 static void
3028 warn_extern_redeclared_static (newdecl, olddecl)
3029      tree newdecl, olddecl;
3030 {
3031   static const char *const explicit_extern_static_warning
3032     = "`%D' was declared `extern' and later `static'";
3033   static const char *const implicit_extern_static_warning
3034     = "`%D' was declared implicitly `extern' and later `static'";
3035
3036   tree name;
3037
3038   if (TREE_CODE (newdecl) == TYPE_DECL
3039       || TREE_CODE (newdecl) == TEMPLATE_DECL
3040       || TREE_CODE (newdecl) == CONST_DECL)
3041     return;
3042
3043   /* Don't get confused by static member functions; that's a different
3044      use of `static'.  */
3045   if (TREE_CODE (newdecl) == FUNCTION_DECL
3046       && DECL_STATIC_FUNCTION_P (newdecl))
3047     return;
3048
3049   /* If the old declaration was `static', or the new one isn't, then
3050      then everything is OK.  */
3051   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3052     return;
3053
3054   /* It's OK to declare a builtin function as `static'.  */
3055   if (TREE_CODE (olddecl) == FUNCTION_DECL
3056       && DECL_ARTIFICIAL (olddecl))
3057     return;
3058
3059   name = DECL_ASSEMBLER_NAME (newdecl);
3060   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3061               ? implicit_extern_static_warning
3062               : explicit_extern_static_warning, newdecl);
3063   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3064 }
3065
3066 /* Handle when a new declaration NEWDECL has the same name as an old
3067    one OLDDECL in the same binding contour.  Prints an error message
3068    if appropriate.
3069
3070    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3071    Otherwise, return 0.  */
3072
3073 int
3074 duplicate_decls (newdecl, olddecl)
3075      tree newdecl, olddecl;
3076 {
3077   unsigned olddecl_uid = DECL_UID (olddecl);
3078   int olddecl_friend = 0, types_match = 0;
3079   int new_defines_function = 0;
3080
3081   if (newdecl == olddecl)
3082     return 1;
3083
3084   types_match = decls_match (newdecl, olddecl);
3085
3086   /* If either the type of the new decl or the type of the old decl is an
3087      error_mark_node, then that implies that we have already issued an
3088      error (earlier) for some bogus type specification, and in that case,
3089      it is rather pointless to harass the user with yet more error message
3090      about the same declaration, so just pretend the types match here.  */
3091   if (TREE_TYPE (newdecl) == error_mark_node
3092       || TREE_TYPE (olddecl) == error_mark_node)
3093     types_match = 1;
3094
3095   /* Check for redeclaration and other discrepancies. */
3096   if (TREE_CODE (olddecl) == FUNCTION_DECL
3097       && DECL_ARTIFICIAL (olddecl))
3098     {
3099       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3100         {
3101           /* If you declare a built-in or predefined function name as static,
3102              the old definition is overridden, but optionally warn this was a
3103              bad choice of name.  */
3104           if (! TREE_PUBLIC (newdecl))
3105             {
3106               if (warn_shadow)
3107                 cp_warning ("shadowing %s function `%#D'",
3108                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3109                             olddecl);
3110               /* Discard the old built-in function.  */
3111               return 0;
3112             }
3113           /* If the built-in is not ansi, then programs can override
3114              it even globally without an error.  */
3115           else if (! DECL_BUILT_IN (olddecl))
3116             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3117                         olddecl, newdecl);
3118           else
3119             {
3120               cp_error ("declaration of `%#D'", newdecl);
3121               cp_error ("conflicts with built-in declaration `%#D'",
3122                         olddecl);
3123             }
3124           return 0;
3125         }
3126       else if (!types_match)
3127         {
3128           if ((DECL_EXTERN_C_P (newdecl)
3129                && DECL_EXTERN_C_P (olddecl))
3130               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3131                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3132             {
3133               /* A near match; override the builtin.  */
3134
3135               if (TREE_PUBLIC (newdecl))
3136                 {
3137                   cp_warning ("new declaration `%#D'", newdecl);
3138                   cp_warning ("ambiguates built-in declaration `%#D'",
3139                               olddecl);
3140                 }
3141               else if (warn_shadow)
3142                 cp_warning ("shadowing %s function `%#D'",
3143                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3144                             olddecl);
3145             }
3146           else
3147             /* Discard the old built-in function.  */
3148             return 0;
3149         }
3150
3151       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3152         {
3153           /* If a builtin function is redeclared as `static', merge
3154              the declarations, but make the original one static.  */
3155           DECL_THIS_STATIC (olddecl) = 1;
3156           TREE_PUBLIC (olddecl) = 0;
3157
3158           /* Make the old declaration consistent with the new one so
3159              that all remnants of the builtin-ness of this function
3160              will be banished.  */
3161           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3162           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3163           COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3164           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3165                                        newdecl);
3166         }
3167     }
3168   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3169     {
3170       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3171            && TREE_CODE (newdecl) != TYPE_DECL
3172            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3173                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3174           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3175               && TREE_CODE (olddecl) != TYPE_DECL
3176               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3177                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3178                         == TYPE_DECL))))
3179         {
3180           /* We do nothing special here, because C++ does such nasty
3181              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3182              get shadowed, and know that if we need to find a TYPE_DECL
3183              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3184              slot of the identifier.  */
3185           return 0;
3186         }
3187
3188       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3189            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3190           || (TREE_CODE (olddecl) == FUNCTION_DECL
3191               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3192         return 0;
3193
3194       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3195       if (TREE_CODE (olddecl) == TREE_LIST)
3196         olddecl = TREE_VALUE (olddecl);
3197       cp_error_at ("previous declaration of `%#D'", olddecl);
3198
3199       /* New decl is completely inconsistent with the old one =>
3200          tell caller to replace the old one.  */
3201
3202       return 0;
3203     }
3204   else if (!types_match)
3205     {
3206       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3207         /* These are certainly not duplicate declarations; they're
3208            from different scopes.  */
3209         return 0;
3210
3211       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3212         {
3213           /* The name of a class template may not be declared to refer to
3214              any other template, class, function, object, namespace, value,
3215              or type in the same scope.  */
3216           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3217               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3218             {
3219               cp_error ("declaration of template `%#D'", newdecl);
3220               cp_error_at ("conflicts with previous declaration `%#D'",
3221                            olddecl);
3222             }
3223           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3224                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3225                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3226                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3227                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3228                                            DECL_TEMPLATE_PARMS (olddecl)))
3229             {
3230               cp_error ("new declaration `%#D'", newdecl);
3231               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3232             }
3233           return 0;
3234         }
3235       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3236         {
3237           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3238             {
3239               cp_error ("declaration of C function `%#D' conflicts with",
3240                         newdecl);
3241               cp_error_at ("previous declaration `%#D' here", olddecl);
3242             }
3243           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3244                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3245             {
3246               cp_error ("new declaration `%#D'", newdecl);
3247               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3248             }
3249           else
3250             return 0;
3251         }
3252
3253       /* Already complained about this, so don't do so again.  */
3254       else if (current_class_type == NULL_TREE
3255           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3256         {
3257           cp_error ("conflicting types for `%#D'", newdecl);
3258           cp_error_at ("previous declaration as `%#D'", olddecl);
3259         }
3260     }
3261   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3262             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3263                  && (!DECL_TEMPLATE_INFO (newdecl)
3264                      || (DECL_TI_TEMPLATE (newdecl)
3265                          != DECL_TI_TEMPLATE (olddecl))))
3266                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3267                     && (!DECL_TEMPLATE_INFO (olddecl)
3268                         || (DECL_TI_TEMPLATE (olddecl)
3269                             != DECL_TI_TEMPLATE (newdecl))))))
3270     /* It's OK to have a template specialization and a non-template
3271        with the same type, or to have specializations of two
3272        different templates with the same type.  Note that if one is a
3273        specialization, and the other is an instantiation of the same
3274        template, that we do not exit at this point.  That situation
3275        can occur if we instantiate a template class, and then
3276        specialize one of its methods.  This situation is legal, but
3277        the declarations must be merged in the usual way.  */
3278     return 0;
3279   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3280            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3281                 && !DECL_USE_TEMPLATE (newdecl))
3282                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3283                    && !DECL_USE_TEMPLATE (olddecl))))
3284     /* One of the declarations is a template instantiation, and the
3285        other is not a template at all.  That's OK.  */
3286     return 0;
3287   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3288            && DECL_NAMESPACE_ALIAS (newdecl)
3289            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3290     /* Redeclaration of namespace alias, ignore it. */
3291     return 1;
3292   else
3293     {
3294       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3295       if (errmsg)
3296         {
3297           cp_error (errmsg, newdecl);
3298           if (DECL_NAME (olddecl) != NULL_TREE)
3299             cp_error_at ((DECL_INITIAL (olddecl)
3300                           && namespace_bindings_p ())
3301                          ? "`%#D' previously defined here"
3302                          : "`%#D' previously declared here", olddecl);
3303         }
3304       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3305                && DECL_INITIAL (olddecl) != NULL_TREE
3306                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3307                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3308         {
3309           /* Prototype decl follows defn w/o prototype.  */
3310           cp_warning_at ("prototype for `%#D'", newdecl);
3311           cp_warning_at ("follows non-prototype definition here", olddecl);
3312         }
3313       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3314                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3315         {
3316           /* extern "C" int foo ();
3317              int foo () { bar (); }
3318              is OK.  */
3319           if (current_lang_depth () == 0)
3320             SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3321           else
3322             {
3323               cp_error_at ("previous declaration of `%#D' with %L linkage",
3324                            olddecl, DECL_LANGUAGE (olddecl));
3325               cp_error ("conflicts with new declaration with %L linkage",
3326                         DECL_LANGUAGE (newdecl));
3327             }
3328         }
3329
3330       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3331         ;
3332       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3333         {
3334           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3335           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3336           int i = 1;
3337
3338           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3339             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3340
3341           for (; t1 && t1 != void_list_node;
3342                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3343             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3344               {
3345                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3346                                            TREE_PURPOSE (t2)))
3347                   {
3348                     if (pedantic)
3349                       {
3350                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3351                                     i, newdecl);
3352                         cp_pedwarn_at ("after previous specification in `%#D'",
3353                                        olddecl);
3354                       }
3355                   }
3356                 else
3357                   {
3358                     cp_error ("default argument given for parameter %d of `%#D'",
3359                               i, newdecl);
3360                     cp_error_at ("after previous specification in `%#D'",
3361                                  olddecl);
3362                   }
3363               }
3364
3365           if (DECL_DECLARED_INLINE_P (newdecl)
3366               && ! DECL_DECLARED_INLINE_P (olddecl)
3367               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3368             {
3369               cp_warning ("`%#D' was used before it was declared inline",
3370                           newdecl);
3371               cp_warning_at ("previous non-inline declaration here",
3372                              olddecl);
3373             }
3374         }
3375     }
3376
3377   /* If new decl is `static' and an `extern' was seen previously,
3378      warn about it.  */
3379   warn_extern_redeclared_static (newdecl, olddecl);
3380
3381   /* We have committed to returning 1 at this point.  */
3382   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3383     {
3384       /* Now that functions must hold information normally held
3385          by field decls, there is extra work to do so that
3386          declaration information does not get destroyed during
3387          definition.  */
3388       if (DECL_VINDEX (olddecl))
3389         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3390       if (DECL_VIRTUAL_CONTEXT (olddecl))
3391         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3392       if (DECL_CONTEXT (olddecl))
3393         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3394       if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3395         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3396       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3397       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3398       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3399       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3400       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3401       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3402       if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
3403         SET_OVERLOADED_OPERATOR_CODE
3404           (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
3405       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3406
3407       /* Optionally warn about more than one declaration for the same
3408          name, but don't warn about a function declaration followed by a
3409          definition.  */
3410       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3411           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3412           /* Don't warn about extern decl followed by definition. */
3413           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3414           /* Don't warn about friends, let add_friend take care of it. */
3415           && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
3416         {
3417           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3418           cp_warning_at ("previous declaration of `%D'", olddecl);
3419         }
3420     }
3421
3422   /* Deal with C++: must preserve virtual function table size.  */
3423   if (TREE_CODE (olddecl) == TYPE_DECL)
3424     {
3425       register tree newtype = TREE_TYPE (newdecl);
3426       register tree oldtype = TREE_TYPE (olddecl);
3427
3428       if (newtype != error_mark_node && oldtype != error_mark_node
3429           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3430         {
3431           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3432           CLASSTYPE_FRIEND_CLASSES (newtype)
3433             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3434         }
3435
3436       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3437     }
3438
3439   /* Copy all the DECL_... slots specified in the new decl
3440      except for any that we copy here from the old type.  */
3441   DECL_ATTRIBUTES (newdecl)
3442     = (*targetm.merge_decl_attributes) (olddecl, newdecl);
3443
3444   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3445     {
3446       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3447       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3448         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3449                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3450
3451       /* If the new declaration is a definition, update the file and
3452          line information on the declaration.  */
3453       if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
3454           && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
3455         {
3456           DECL_SOURCE_LINE (olddecl)
3457             = DECL_SOURCE_LINE (DECL_TEMPLATE_RESULT (olddecl))
3458             = DECL_SOURCE_LINE (newdecl);
3459           DECL_SOURCE_FILE (olddecl)
3460             = DECL_SOURCE_FILE (DECL_TEMPLATE_RESULT (olddecl))
3461             = DECL_SOURCE_FILE (newdecl);
3462         }
3463
3464       return 1;
3465     }
3466
3467   if (types_match)
3468     {
3469       /* Automatically handles default parameters.  */
3470       tree oldtype = TREE_TYPE (olddecl);
3471       tree newtype;
3472
3473       /* Merge the data types specified in the two decls.  */
3474       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3475
3476       /* If common_type produces a non-typedef type, just use the old type.  */
3477       if (TREE_CODE (newdecl) == TYPE_DECL
3478           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3479         newtype = oldtype;
3480
3481       if (TREE_CODE (newdecl) == VAR_DECL)
3482         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3483       /* Do this after calling `common_type' so that default
3484          parameters don't confuse us.  */
3485       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3486           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3487               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3488         {
3489           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3490                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3491           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3492                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3493
3494           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3495               && DECL_SOURCE_LINE (olddecl) != 0
3496               && flag_exceptions
3497               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3498                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3499             {
3500               cp_error ("declaration of `%F' throws different exceptions",
3501                         newdecl);
3502               cp_error_at ("than previous declaration `%F'", olddecl);
3503             }
3504         }
3505       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3506
3507       /* Lay the type out, unless already done.  */
3508       if (! same_type_p (newtype, oldtype)
3509           && TREE_TYPE (newdecl) != error_mark_node
3510           && !(processing_template_decl && uses_template_parms (newdecl)))
3511         layout_type (TREE_TYPE (newdecl));
3512
3513       if ((TREE_CODE (newdecl) == VAR_DECL
3514            || TREE_CODE (newdecl) == PARM_DECL
3515            || TREE_CODE (newdecl) == RESULT_DECL
3516            || TREE_CODE (newdecl) == FIELD_DECL
3517            || TREE_CODE (newdecl) == TYPE_DECL)
3518           && !(processing_template_decl && uses_template_parms (newdecl)))
3519         layout_decl (newdecl, 0);
3520
3521       /* Merge the type qualifiers.  */
3522       if (TREE_READONLY (newdecl))
3523         TREE_READONLY (olddecl) = 1;
3524       if (TREE_THIS_VOLATILE (newdecl))
3525         TREE_THIS_VOLATILE (olddecl) = 1;
3526
3527       /* Merge the initialization information.  */
3528       if (DECL_INITIAL (newdecl) == NULL_TREE
3529           && DECL_INITIAL (olddecl) != NULL_TREE)
3530         {
3531           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3532           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3533           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3534           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3535               && DECL_LANG_SPECIFIC (newdecl)
3536               && DECL_LANG_SPECIFIC (olddecl))
3537             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3538         }
3539
3540       /* Merge the section attribute.
3541          We want to issue an error if the sections conflict but that must be
3542          done later in decl_attributes since we are called before attributes
3543          are assigned.  */
3544       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3545         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3546
3547       /* Keep the old rtl since we can safely use it.  */
3548       COPY_DECL_RTL (olddecl, newdecl);
3549
3550       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3551         {
3552           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3553             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3554           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3555             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3556           DECL_NO_LIMIT_STACK (newdecl)
3557             |= DECL_NO_LIMIT_STACK (olddecl);
3558         }
3559     }
3560   /* If cannot merge, then use the new type and qualifiers,
3561      and don't preserve the old rtl.  */
3562   else
3563     {
3564       /* Clean out any memory we had of the old declaration.  */
3565       tree oldstatic = value_member (olddecl, static_aggregates);
3566       if (oldstatic)
3567         TREE_VALUE (oldstatic) = error_mark_node;
3568
3569       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3570       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3571       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3572       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3573     }
3574
3575   /* Merge the storage class information.  */
3576   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3577   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3578   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3579   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3580   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3581   if (! DECL_EXTERNAL (olddecl))
3582     DECL_EXTERNAL (newdecl) = 0;
3583
3584   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3585     {
3586       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3587       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3588       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3589       DECL_TEMPLATE_INSTANTIATED (newdecl)
3590         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3591       /* Don't really know how much of the language-specific
3592          values we should copy from old to new.  */
3593       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3594       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3595       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3596       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3597       DECL_INITIALIZED_IN_CLASS_P (newdecl)
3598         |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
3599       olddecl_friend = DECL_FRIEND_P (olddecl);
3600
3601       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3602       if (TREE_CODE (newdecl) == FUNCTION_DECL
3603           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3604         DECL_BEFRIENDING_CLASSES (newdecl)
3605           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3606                      DECL_BEFRIENDING_CLASSES (olddecl));
3607     }
3608
3609   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3610     {
3611       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3612           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3613         {
3614           /* If newdecl is not a specialization, then it is not a
3615              template-related function at all.  And that means that we
3616              shoud have exited above, returning 0.  */
3617           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3618                               0);
3619
3620           if (TREE_USED (olddecl))
3621             /* From [temp.expl.spec]:
3622
3623                If a template, a member template or the member of a class
3624                template is explicitly specialized then that
3625                specialization shall be declared before the first use of
3626                that specialization that would cause an implicit
3627                instantiation to take place, in every translation unit in
3628                which such a use occurs.  */
3629             cp_error ("explicit specialization of %D after first use",
3630                       olddecl);
3631
3632           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3633         }
3634       DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
3635
3636       /* If either decl says `inline', this fn is inline, unless its
3637          definition was passed already.  */
3638       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3639         DECL_INLINE (olddecl) = 1;
3640       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3641
3642       /* Preserve abstractness on cloned [cd]tors.  */
3643       DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
3644
3645       if (! types_match)
3646         {
3647           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3648           COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
3649           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3650         }
3651       if (! types_match || new_defines_function)
3652         {
3653           /* These need to be copied so that the names are available.
3654              Note that if the types do match, we'll preserve inline
3655              info and other bits, but if not, we won't.  */
3656           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3657           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3658         }
3659       if (new_defines_function)
3660         /* If defining a function declared with other language
3661            linkage, use the previously declared language linkage.  */
3662         SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3663       else if (types_match)
3664         {
3665           /* If redeclaring a builtin function, and not a definition,
3666              it stays built in.  */
3667           if (DECL_BUILT_IN (olddecl))
3668             {
3669               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3670               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3671               /* If we're keeping the built-in definition, keep the rtl,
3672                  regardless of declaration matches.  */
3673               SET_DECL_RTL (newdecl, DECL_RTL (olddecl));
3674             }
3675           else
3676             DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
3677
3678           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3679           /* Don't clear out the arguments if we're redefining a function.  */
3680           if (DECL_ARGUMENTS (olddecl))
3681             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3682         }
3683     }
3684   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3685     NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3686
3687   /* Now preserve various other info from the definition.  */
3688   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3689   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3690   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3691   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3692
3693   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3694     {
3695       int function_size;
3696
3697       function_size = sizeof (struct tree_decl);
3698
3699       memcpy ((char *) olddecl + sizeof (struct tree_common),
3700               (char *) newdecl + sizeof (struct tree_common),
3701               function_size - sizeof (struct tree_common));
3702
3703       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3704         {
3705           /* If newdecl is a template instantiation, it is possible that
3706              the following sequence of events has occurred:
3707
3708              o A friend function was declared in a class template.  The
3709              class template was instantiated.
3710
3711              o The instantiation of the friend declaration was
3712              recorded on the instantiation list, and is newdecl.
3713
3714              o Later, however, instantiate_class_template called pushdecl
3715              on the newdecl to perform name injection.  But, pushdecl in
3716              turn called duplicate_decls when it discovered that another
3717              declaration of a global function with the same name already
3718              existed.
3719
3720              o Here, in duplicate_decls, we decided to clobber newdecl.
3721
3722              If we're going to do that, we'd better make sure that
3723              olddecl, and not newdecl, is on the list of
3724              instantiations so that if we try to do the instantiation
3725              again we won't get the clobbered declaration.  */
3726
3727           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3728           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3729
3730           for (; decls; decls = TREE_CHAIN (decls))
3731             if (TREE_VALUE (decls) == newdecl)
3732               TREE_VALUE (decls) = olddecl;
3733         }
3734     }
3735   else
3736     {
3737       memcpy ((char *) olddecl + sizeof (struct tree_common),
3738               (char *) newdecl + sizeof (struct tree_common),
3739               sizeof (struct tree_decl) - sizeof (struct tree_common)
3740               + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3741     }
3742
3743   DECL_UID (olddecl) = olddecl_uid;
3744   if (olddecl_friend)
3745     DECL_FRIEND_P (olddecl) = 1;
3746
3747   /* NEWDECL contains the merged attribute lists.
3748      Update OLDDECL to be the same.  */
3749   DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
3750
3751   return 1;
3752 }
3753
3754 /* Record a decl-node X as belonging to the current lexical scope.
3755    Check for errors (such as an incompatible declaration for the same
3756    name already seen in the same scope).
3757
3758    Returns either X or an old decl for the same name.
3759    If an old decl is returned, it may have been smashed
3760    to agree with what X says.  */
3761
3762 tree
3763 pushdecl (x)
3764      tree x;
3765 {
3766   register tree t;
3767   register tree name;
3768   int need_new_binding;
3769
3770   /* We shouldn't be calling pushdecl when we're generating RTL for a
3771      function that we already did semantic analysis on previously.  */
3772   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3773                       19990913);
3774
3775   need_new_binding = 1;
3776
3777   if (DECL_TEMPLATE_PARM_P (x))
3778     /* Template parameters have no context; they are not X::T even
3779        when declared within a class or namespace.  */
3780     ;
3781   else
3782     {
3783       if (current_function_decl && x != current_function_decl
3784           /* A local declaration for a function doesn't constitute
3785              nesting.  */
3786           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3787           /* A local declaration for an `extern' variable is in the
3788              scope of the current namespace, not the current
3789              function.  */
3790           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3791           && !DECL_CONTEXT (x))
3792         DECL_CONTEXT (x) = current_function_decl;
3793
3794       /* If this is the declaration for a namespace-scope function,
3795          but the declaration itself is in a local scope, mark the
3796          declaration.  */
3797       if (TREE_CODE (x) == FUNCTION_DECL
3798           && DECL_NAMESPACE_SCOPE_P (x)
3799           && current_function_decl
3800           && x != current_function_decl)
3801         DECL_LOCAL_FUNCTION_P (x) = 1;
3802     }
3803
3804   name = DECL_NAME (x);
3805   if (name)
3806     {
3807       int different_binding_level = 0;
3808
3809       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3810         name = TREE_OPERAND (name, 0);
3811
3812       /* In case this decl was explicitly namespace-qualified, look it
3813          up in its namespace context.  */
3814       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3815           && namespace_bindings_p ())
3816         t = namespace_binding (name, DECL_CONTEXT (x));
3817       else
3818         t = lookup_name_current_level (name);
3819
3820       /* [basic.link] If there is a visible declaration of an entity
3821          with linkage having the same name and type, ignoring entities
3822          declared outside the innermost enclosing namespace scope, the
3823          block scope declaration declares that same entity and
3824          receives the linkage of the previous declaration.  */
3825       if (! t && current_function_decl && x != current_function_decl
3826           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3827           && DECL_EXTERNAL (x))
3828         {
3829           /* Look in block scope.  */
3830           t = IDENTIFIER_VALUE (name);
3831           /* Or in the innermost namespace.  */
3832           if (! t)
3833             t = namespace_binding (name, DECL_CONTEXT (x));
3834           /* Does it have linkage?  Note that if this isn't a DECL, it's an
3835              OVERLOAD, which is OK.  */
3836           if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3837             t = NULL_TREE;
3838           if (t)
3839             different_binding_level = 1;
3840         }
3841
3842       /* If we are declaring a function, and the result of name-lookup
3843          was an OVERLOAD, look for an overloaded instance that is
3844          actually the same as the function we are declaring.  (If
3845          there is one, we have to merge our declaration with the
3846          previous declaration.)  */
3847       if (t && TREE_CODE (t) == OVERLOAD)
3848         {
3849           tree match;
3850
3851           if (TREE_CODE (x) == FUNCTION_DECL)
3852             for (match = t; match; match = OVL_NEXT (match))
3853               {
3854                 if (decls_match (OVL_CURRENT (match), x))
3855                   break;
3856               }
3857           else
3858             /* Just choose one.  */
3859             match = t;
3860
3861           if (match)
3862             t = OVL_CURRENT (match);
3863           else
3864             t = NULL_TREE;
3865         }
3866
3867       if (t == error_mark_node)
3868         {
3869           /* error_mark_node is 0 for a while during initialization!  */
3870           t = NULL_TREE;
3871           cp_error_at ("`%#D' used prior to declaration", x);
3872         }
3873       else if (t != NULL_TREE)
3874         {
3875           if (different_binding_level)
3876             {
3877               if (decls_match (x, t))
3878                 /* The standard only says that the local extern
3879                    inherits linkage from the previous decl; in
3880                    particular, default args are not shared.  It would
3881                    be nice to propagate inlining info, though.  FIXME.  */
3882                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3883             }
3884           else if (TREE_CODE (t) == PARM_DECL)
3885             {
3886               if (DECL_CONTEXT (t) == NULL_TREE)
3887                 /* This is probaby caused by too many errors, but calling
3888                    abort will say that if errors have occurred.  */
3889                 abort ();
3890
3891               /* Check for duplicate params.  */
3892               if (duplicate_decls (x, t))
3893                 return t;
3894             }
3895           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3896                     || DECL_FUNCTION_TEMPLATE_P (x))
3897                    && is_overloaded_fn (t))
3898             /* Don't do anything just yet. */;
3899           else if (t == wchar_decl_node)
3900             {
3901               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3902                 cp_pedwarn ("redeclaration of `wchar_t' as `%T'",
3903                             TREE_TYPE (x));
3904
3905               /* Throw away the redeclaration.  */
3906               return t;
3907             }
3908           else if (TREE_CODE (t) != TREE_CODE (x))
3909             {
3910               if (duplicate_decls (x, t))
3911                 return t;
3912             }
3913           else if (duplicate_decls (x, t))
3914             {
3915               if (TREE_CODE (t) == TYPE_DECL)
3916                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3917               else if (TREE_CODE (t) == FUNCTION_DECL)
3918                 check_default_args (t);
3919
3920               return t;
3921             }
3922           else if (DECL_MAIN_P (x))
3923             {
3924               /* A redeclaration of main, but not a duplicate of the
3925                  previous one.
3926
3927                  [basic.start.main]
3928
3929                  This function shall not be overloaded.  */
3930               cp_error_at ("invalid redeclaration of `%D'", t);
3931               cp_error ("as `%D'", x);
3932               /* We don't try to push this declaration since that
3933                  causes a crash.  */
3934               return x;
3935             }
3936         }
3937
3938       check_template_shadow (x);
3939
3940       /* If this is a function conjured up by the backend, massage it
3941          so it looks friendly.  */
3942       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3943         {
3944           retrofit_lang_decl (x);
3945           SET_DECL_LANGUAGE (x, lang_c);
3946         }
3947
3948       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3949         {
3950           t = push_overloaded_decl (x, PUSH_LOCAL);
3951           if (t != x)
3952             return t;
3953           if (!namespace_bindings_p ())
3954             /* We do not need to create a binding for this name;
3955                push_overloaded_decl will have already done so if
3956                necessary.  */
3957             need_new_binding = 0;
3958         }
3959       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3960         {
3961           t = push_overloaded_decl (x, PUSH_GLOBAL);
3962           if (t == x)
3963             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3964           return t;
3965         }
3966
3967       /* If declaring a type as a typedef, copy the type (unless we're
3968          at line 0), and install this TYPE_DECL as the new type's typedef
3969          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3970       if (TREE_CODE (x) == TYPE_DECL)
3971         {
3972           tree type = TREE_TYPE (x);
3973           if (DECL_SOURCE_LINE (x) == 0)
3974             {
3975               if (TYPE_NAME (type) == 0)
3976                 TYPE_NAME (type) = x;
3977             }
3978           else if (type != error_mark_node && TYPE_NAME (type) != x
3979                    /* We don't want to copy the type when all we're
3980                       doing is making a TYPE_DECL for the purposes of
3981                       inlining.  */
3982                    && (!TYPE_NAME (type)
3983                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3984             {
3985               DECL_ORIGINAL_TYPE (x) = type;
3986               type = build_type_copy (type);
3987               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3988               TYPE_NAME (type) = x;
3989               TREE_TYPE (x) = type;
3990             }
3991
3992           if (type != error_mark_node
3993               && TYPE_NAME (type)
3994               && TYPE_IDENTIFIER (type))
3995             set_identifier_type_value_with_scope (DECL_NAME (x), type,
3996                                                   current_binding_level);
3997
3998         }
3999
4000       /* Multiple external decls of the same identifier ought to match.
4001
4002          We get warnings about inline functions where they are defined.
4003          We get warnings about other functions from push_overloaded_decl.
4004
4005          Avoid duplicate warnings where they are used.  */
4006       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4007         {
4008           tree decl;
4009
4010           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4011           if (decl && TREE_CODE (decl) == OVERLOAD)
4012             decl = OVL_FUNCTION (decl);
4013
4014           if (decl && decl != error_mark_node
4015               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4016               /* If different sort of thing, we already gave an error.  */
4017               && TREE_CODE (decl) == TREE_CODE (x)
4018               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4019             {
4020               cp_pedwarn ("type mismatch with previous external decl", x);
4021               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4022             }
4023         }
4024
4025       /* This name is new in its binding level.
4026          Install the new declaration and return it.  */
4027       if (namespace_bindings_p ())
4028         {
4029           /* Install a global value.  */
4030
4031           /* If the first global decl has external linkage,
4032              warn if we later see static one.  */
4033           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4034             TREE_PUBLIC (name) = 1;
4035
4036           /* Bind the name for the entity.  */
4037           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4038                 && t != NULL_TREE)
4039               && (TREE_CODE (x) == TYPE_DECL
4040                   || TREE_CODE (x) == VAR_DECL
4041                   || TREE_CODE (x) == NAMESPACE_DECL
4042                   || TREE_CODE (x) == CONST_DECL
4043                   || TREE_CODE (x) == TEMPLATE_DECL))
4044             SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
4045
4046           /* Don't forget if the function was used via an implicit decl.  */
4047           if (IDENTIFIER_IMPLICIT_DECL (name)
4048               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4049             TREE_USED (x) = 1;
4050
4051           /* Don't forget if its address was taken in that way.  */
4052           if (IDENTIFIER_IMPLICIT_DECL (name)
4053               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4054             TREE_ADDRESSABLE (x) = 1;
4055
4056           /* Warn about mismatches against previous implicit decl.  */
4057           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4058               /* If this real decl matches the implicit, don't complain.  */
4059               && ! (TREE_CODE (x) == FUNCTION_DECL
4060                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4061             cp_warning
4062               ("`%D' was previously implicitly declared to return `int'", x);
4063
4064           /* If new decl is `static' and an `extern' was seen previously,
4065              warn about it.  */
4066           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4067             warn_extern_redeclared_static (x, t);
4068         }
4069       else
4070         {
4071           /* Here to install a non-global value.  */
4072           tree oldlocal = IDENTIFIER_VALUE (name);
4073           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4074
4075           if (need_new_binding)
4076             {
4077               push_local_binding (name, x, 0);
4078               /* Because push_local_binding will hook X on to the
4079                  current_binding_level's name list, we don't want to
4080                  do that again below.  */
4081               need_new_binding = 0;
4082             }
4083
4084           /* If this is a TYPE_DECL, push it into the type value slot.  */
4085           if (TREE_CODE (x) == TYPE_DECL)
4086             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4087                                                   current_binding_level);
4088
4089           /* Clear out any TYPE_DECL shadowed by a namespace so that
4090              we won't think this is a type.  The C struct hack doesn't
4091              go through namespaces.  */
4092           if (TREE_CODE (x) == NAMESPACE_DECL)
4093             set_identifier_type_value_with_scope (name, NULL_TREE,
4094                                                   current_binding_level);
4095
4096           if (oldlocal)
4097             {
4098               tree d = oldlocal;
4099
4100               while (oldlocal
4101                      && TREE_CODE (oldlocal) == VAR_DECL
4102                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4103                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4104
4105               if (oldlocal == NULL_TREE)
4106                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4107             }
4108
4109           /* If this is an extern function declaration, see if we
4110              have a global definition or declaration for the function.  */
4111           if (oldlocal == NULL_TREE
4112               && DECL_EXTERNAL (x)
4113               && oldglobal != NULL_TREE
4114               && TREE_CODE (x) == FUNCTION_DECL
4115               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4116             {
4117               /* We have one.  Their types must agree.  */
4118               if (decls_match (x, oldglobal))
4119                 /* OK */;
4120               else
4121                 {
4122                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4123                   cp_warning_at ("global declaration `%#D'", oldglobal);
4124                 }
4125             }
4126           /* If we have a local external declaration,
4127              and no file-scope declaration has yet been seen,
4128              then if we later have a file-scope decl it must not be static.  */
4129           if (oldlocal == NULL_TREE
4130               && oldglobal == NULL_TREE
4131               && DECL_EXTERNAL (x)
4132               && TREE_PUBLIC (x))
4133             TREE_PUBLIC (name) = 1;
4134
4135           /* Warn if shadowing an argument at the top level of the body.  */
4136           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4137               /* Inline decls shadow nothing.  */
4138               && !DECL_FROM_INLINE (x)
4139               && TREE_CODE (oldlocal) == PARM_DECL
4140               /* Don't complain if it's from an enclosing function.  */
4141               && DECL_CONTEXT (oldlocal) == current_function_decl
4142               && TREE_CODE (x) != PARM_DECL)
4143             {
4144               /* Go to where the parms should be and see if we
4145                  find them there.  */
4146               struct binding_level *b = current_binding_level->level_chain;
4147
4148               if (cleanup_label)
4149                 b = b->level_chain;
4150
4151               /* ARM $8.3 */
4152               if (b->parm_flag == 1)
4153                 cp_error ("declaration of `%#D' shadows a parameter", name);
4154             }
4155
4156           /* Maybe warn if shadowing something else.  */
4157           if (warn_shadow && !DECL_EXTERNAL (x)
4158               /* Inline decls shadow nothing.  */
4159               && !DECL_FROM_INLINE (x)
4160               /* No shadow warnings for internally generated vars.  */
4161               && ! DECL_ARTIFICIAL (x)
4162               /* No shadow warnings for vars made for inlining.  */
4163               && ! DECL_FROM_INLINE (x))
4164             {
4165               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4166                 warning ("declaration of `%s' shadows a parameter",
4167                         IDENTIFIER_POINTER (name));
4168               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4169                        && current_class_ptr
4170                        && !TREE_STATIC (name))
4171                 warning ("declaration of `%s' shadows a member of `this'",
4172                         IDENTIFIER_POINTER (name));
4173               else if (oldlocal != NULL_TREE)
4174                 warning ("declaration of `%s' shadows previous local",
4175                         IDENTIFIER_POINTER (name));
4176               else if (oldglobal != NULL_TREE)
4177                 /* XXX shadow warnings in outer-more namespaces */
4178                 warning ("declaration of `%s' shadows global declaration",
4179                         IDENTIFIER_POINTER (name));
4180             }
4181         }
4182
4183       if (TREE_CODE (x) == FUNCTION_DECL)
4184         check_default_args (x);
4185
4186       /* Keep count of variables in this level with incomplete type.  */
4187       if (TREE_CODE (x) == VAR_DECL
4188           && TREE_TYPE (x) != error_mark_node
4189           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4190                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4191               /* RTTI TD entries are created while defining the type_info.  */
4192               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4193                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4194         {
4195           if (namespace_bindings_p ())
4196             namespace_scope_incomplete
4197               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4198           else
4199             current_binding_level->incomplete
4200               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4201         }
4202     }
4203
4204   if (need_new_binding)
4205     add_decl_to_level (x,
4206                        DECL_NAMESPACE_SCOPE_P (x)
4207                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4208                        : current_binding_level);
4209
4210   return x;
4211 }
4212
4213 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4214    caller to set DECL_CONTEXT properly.  */
4215
4216 static tree
4217 pushdecl_with_scope (x, level)
4218      tree x;
4219      struct binding_level *level;
4220 {
4221   register struct binding_level *b;
4222   tree function_decl = current_function_decl;
4223
4224   current_function_decl = NULL_TREE;
4225   if (level->parm_flag == 2)
4226     {
4227       b = class_binding_level;
4228       class_binding_level = level;
4229       pushdecl_class_level (x);
4230       class_binding_level = b;
4231     }
4232   else
4233     {
4234       b = current_binding_level;
4235       current_binding_level = level;
4236       x = pushdecl (x);
4237       current_binding_level = b;
4238     }
4239   current_function_decl = function_decl;
4240   return x;
4241 }
4242
4243 /* Like pushdecl, only it places X in the current namespace,
4244    if appropriate.  */
4245
4246 tree
4247 pushdecl_namespace_level (x)
4248      tree x;
4249 {
4250   register struct binding_level *b = current_binding_level;
4251   register tree t;
4252
4253   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4254
4255   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4256      what we want.  */
4257   if (TREE_CODE (x) == TYPE_DECL)
4258     {
4259       tree name = DECL_NAME (x);
4260       tree newval;
4261       tree *ptr = (tree *)0;
4262       for (; b != global_binding_level; b = b->level_chain)
4263         {
4264           tree shadowed = b->type_shadowed;
4265           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4266             if (TREE_PURPOSE (shadowed) == name)
4267               {
4268                 ptr = &TREE_VALUE (shadowed);
4269                 /* Can't break out of the loop here because sometimes
4270                    a binding level will have duplicate bindings for
4271                    PT names.  It's gross, but I haven't time to fix it.  */
4272               }
4273         }
4274       newval = TREE_TYPE (x);
4275       if (ptr == (tree *)0)
4276         {
4277           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4278              up here if this is changed to an assertion.  --KR  */
4279           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4280         }
4281       else
4282         {
4283           *ptr = newval;
4284         }
4285     }
4286   return t;
4287 }
4288
4289 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4290    if appropriate.  */
4291
4292 tree
4293 pushdecl_top_level (x)
4294      tree x;
4295 {
4296   push_to_top_level ();
4297   x = pushdecl_namespace_level (x);
4298   pop_from_top_level ();
4299   return x;
4300 }
4301
4302 /* Make the declaration of X appear in CLASS scope.  */
4303
4304 void
4305 pushdecl_class_level (x)
4306      tree x;
4307 {
4308   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4309      scope looks for the pre-mangled name.  */
4310   register tree name;
4311
4312   if (TREE_CODE (x) == OVERLOAD)
4313     x = OVL_CURRENT (x);
4314   name = DECL_NAME (x);
4315
4316   if (name)
4317     {
4318       push_class_level_binding (name, x);
4319       if (TREE_CODE (x) == TYPE_DECL)
4320         set_identifier_type_value (name, TREE_TYPE (x));
4321     }
4322   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4323     {
4324       tree f;
4325
4326       for (f = TYPE_FIELDS (TREE_TYPE (x));
4327            f;
4328            f = TREE_CHAIN (f))
4329         pushdecl_class_level (f);
4330     }
4331 }
4332
4333 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4334    DECL, or a modified version thereof.  */
4335
4336 tree
4337 maybe_push_decl (decl)
4338      tree decl;
4339 {
4340   tree type = TREE_TYPE (decl);
4341
4342   /* Add this decl to the current binding level, but not if it comes
4343      from another scope, e.g. a static member variable.  TEM may equal
4344      DECL or it may be a previous decl of the same name.  */
4345   if (decl == error_mark_node
4346       || (TREE_CODE (decl) != PARM_DECL
4347           && DECL_CONTEXT (decl) != NULL_TREE
4348           /* Definitions of namespace members outside their namespace are
4349              possible. */
4350           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4351       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4352       || TREE_CODE (type) == UNKNOWN_TYPE
4353       /* The declaration of a template specialization does not affect
4354          the functions available for overload resolution, so we do not
4355          call pushdecl.  */
4356       || (TREE_CODE (decl) == FUNCTION_DECL
4357           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4358     return decl;
4359   else
4360     return pushdecl (decl);
4361 }
4362
4363 /* Make the declaration(s) of X appear in CLASS scope
4364    under the name NAME.  */
4365
4366 void
4367 push_class_level_binding (name, x)
4368      tree name;
4369      tree x;
4370 {
4371   tree binding;
4372   /* The class_binding_level will be NULL if x is a template
4373      parameter name in a member template.  */
4374   if (!class_binding_level)
4375     return;
4376
4377   /* Make sure that this new member does not have the same name
4378      as a template parameter.  */
4379   if (TYPE_BEING_DEFINED (current_class_type))
4380     check_template_shadow (x);
4381
4382   /* If this declaration shadows a declaration from an enclosing
4383      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4384      we leave this class.  Record the shadowed declaration here.  */
4385   binding = IDENTIFIER_BINDING (name);
4386   if (binding
4387       && ((TREE_CODE (x) == OVERLOAD
4388            && BINDING_VALUE (binding)
4389            && is_overloaded_fn (BINDING_VALUE (binding)))
4390           || INHERITED_VALUE_BINDING_P (binding)))
4391     {
4392       tree shadow;
4393       tree old_decl;
4394
4395       /* If the old binding was from a base class, and was for a tag
4396          name, slide it over to make room for the new binding.  The
4397          old binding is still visible if explicitly qualified with a
4398          class-key.  */
4399       if (INHERITED_VALUE_BINDING_P (binding)
4400           && BINDING_VALUE (binding)
4401           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4402           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4403           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4404         {
4405           old_decl = BINDING_TYPE (binding);
4406           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4407           BINDING_VALUE (binding) = NULL_TREE;
4408           INHERITED_VALUE_BINDING_P (binding) = 0;
4409         }
4410       else
4411         old_decl = BINDING_VALUE (binding);
4412
4413       /* Find the previous binding of name on the class-shadowed
4414          list, and update it.  */
4415       for (shadow = class_binding_level->class_shadowed;
4416            shadow;
4417            shadow = TREE_CHAIN (shadow))
4418         if (TREE_PURPOSE (shadow) == name
4419             && TREE_TYPE (shadow) == old_decl)
4420           {
4421             BINDING_VALUE (binding) = x;
4422             INHERITED_VALUE_BINDING_P (binding) = 0;
4423             TREE_TYPE (shadow) = x;
4424             IDENTIFIER_CLASS_VALUE (name) = x;
4425             return;
4426           }
4427     }
4428
4429   /* If we didn't replace an existing binding, put the binding on the
4430      stack of bindings for the identifier, and update the shadowed list.  */
4431   if (push_class_binding (name, x))
4432     {
4433       class_binding_level->class_shadowed
4434         = tree_cons (name, NULL,
4435                      class_binding_level->class_shadowed);
4436       /* Record the value we are binding NAME to so that we can know
4437          what to pop later.  */
4438       TREE_TYPE (class_binding_level->class_shadowed) = x;
4439     }
4440 }
4441
4442 /* Insert another USING_DECL into the current binding level, returning
4443    this declaration. If this is a redeclaration, do nothing, and
4444    return NULL_TREE if this not in namespace scope (in namespace
4445    scope, a using decl might extend any previous bindings).  */
4446
4447 tree
4448 push_using_decl (scope, name)
4449      tree scope;
4450      tree name;
4451 {
4452   tree decl;
4453
4454   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4455   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4456   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4457     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4458       break;
4459   if (decl)
4460     return namespace_bindings_p () ? decl : NULL_TREE;
4461   decl = build_lang_decl (USING_DECL, name, void_type_node);
4462   DECL_INITIAL (decl) = scope;
4463   TREE_CHAIN (decl) = current_binding_level->usings;
4464   current_binding_level->usings = decl;
4465   return decl;
4466 }
4467
4468 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4469    changed (i.e. there was already a directive), or the fresh
4470    TREE_LIST otherwise.  */
4471
4472 tree
4473 push_using_directive (used)
4474      tree used;
4475 {
4476   tree ud = current_binding_level->using_directives;
4477   tree iter, ancestor;
4478
4479   /* Check if we already have this. */
4480   if (purpose_member (used, ud) != NULL_TREE)
4481     return NULL_TREE;
4482
4483   /* Recursively add all namespaces used. */
4484   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4485     push_using_directive (TREE_PURPOSE (iter));
4486
4487   ancestor = namespace_ancestor (current_decl_namespace (), used);
4488   ud = current_binding_level->using_directives;
4489   ud = tree_cons (used, ancestor, ud);
4490   current_binding_level->using_directives = ud;
4491   return ud;
4492 }
4493
4494 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4495    other definitions already in place.  We get around this by making
4496    the value of the identifier point to a list of all the things that
4497    want to be referenced by that name.  It is then up to the users of
4498    that name to decide what to do with that list.
4499
4500    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4501    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4502
4503    FLAGS is a bitwise-or of the following values:
4504      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4505                  namespace scope.
4506      PUSH_USING: DECL is being pushed as the result of a using
4507                  declaration.
4508
4509    The value returned may be a previous declaration if we guessed wrong
4510    about what language DECL should belong to (C or C++).  Otherwise,
4511    it's always DECL (and never something that's not a _DECL).  */
4512
4513 tree
4514 push_overloaded_decl (decl, flags)
4515      tree decl;
4516      int flags;
4517 {
4518   tree name = DECL_NAME (decl);
4519   tree old;
4520   tree new_binding;
4521   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4522
4523   if (doing_global)
4524     old = namespace_binding (name, DECL_CONTEXT (decl));
4525   else
4526     old = lookup_name_current_level (name);
4527
4528   if (old)
4529     {
4530       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4531         {
4532           tree t = TREE_TYPE (old);
4533           if (IS_AGGR_TYPE (t) && warn_shadow
4534               && (! DECL_IN_SYSTEM_HEADER (decl)
4535                   || ! DECL_IN_SYSTEM_HEADER (old)))
4536             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4537           old = NULL_TREE;
4538         }
4539       else if (is_overloaded_fn (old))
4540         {
4541           tree tmp;
4542
4543           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4544             {
4545               tree fn = OVL_CURRENT (tmp);
4546
4547               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4548                   && !(flags & PUSH_USING)
4549                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4550                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4551                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4552                           decl, fn);
4553
4554               if (duplicate_decls (decl, fn))
4555                 return fn;
4556             }
4557         }
4558       else if (old == error_mark_node)
4559         /* Ignore the undefined symbol marker.  */
4560         old = NULL_TREE;
4561       else
4562         {
4563           cp_error_at ("previous non-function declaration `%#D'", old);
4564           cp_error ("conflicts with function declaration `%#D'", decl);
4565           return decl;
4566         }
4567     }
4568
4569   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4570     {
4571       if (old && TREE_CODE (old) != OVERLOAD)
4572         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4573       else
4574         new_binding = ovl_cons (decl, old);
4575       if (flags & PUSH_USING)
4576         OVL_USED (new_binding) = 1;
4577     }
4578   else
4579     /* NAME is not ambiguous.  */
4580     new_binding = decl;
4581
4582   if (doing_global)
4583     set_namespace_binding (name, current_namespace, new_binding);
4584   else
4585     {
4586       /* We only create an OVERLOAD if there was a previous binding at
4587          this level, or if decl is a template. In the former case, we
4588          need to remove the old binding and replace it with the new
4589          binding.  We must also run through the NAMES on the binding
4590          level where the name was bound to update the chain.  */
4591
4592       if (TREE_CODE (new_binding) == OVERLOAD && old)
4593         {
4594           tree *d;
4595
4596           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4597                *d;
4598                d = &TREE_CHAIN (*d))
4599             if (*d == old
4600                 || (TREE_CODE (*d) == TREE_LIST
4601                     && TREE_VALUE (*d) == old))
4602               {
4603                 if (TREE_CODE (*d) == TREE_LIST)
4604                   /* Just replace the old binding with the new.  */
4605                   TREE_VALUE (*d) = new_binding;
4606                 else
4607                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4608                   *d = tree_cons (NULL_TREE, new_binding,
4609                                   TREE_CHAIN (*d));
4610
4611                 /* And update the CPLUS_BINDING node.  */
4612                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4613                   = new_binding;
4614                 return decl;
4615               }
4616
4617           /* We should always find a previous binding in this case.  */
4618           my_friendly_abort (0);
4619         }
4620
4621       /* Install the new binding.  */
4622       push_local_binding (name, new_binding, flags);
4623     }
4624
4625   return decl;
4626 }
4627 \f
4628 /* Generate an implicit declaration for identifier FUNCTIONID
4629    as a function of type int ().  Print a warning if appropriate.  */
4630
4631 tree
4632 implicitly_declare (functionid)
4633      tree functionid;
4634 {
4635   register tree decl;
4636
4637   /* We used to reuse an old implicit decl here,
4638      but this loses with inline functions because it can clobber
4639      the saved decl chains.  */
4640   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4641
4642   DECL_EXTERNAL (decl) = 1;
4643   TREE_PUBLIC (decl) = 1;
4644
4645   /* ISO standard says implicit declarations are in the innermost block.
4646      So we record the decl in the standard fashion.  */
4647   pushdecl (decl);
4648   rest_of_decl_compilation (decl, NULL, 0, 0);
4649
4650   if (warn_implicit
4651       /* Only one warning per identifier.  */
4652       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4653     {
4654       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4655     }
4656
4657   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4658
4659   return decl;
4660 }
4661
4662 /* Return zero if the declaration NEWDECL is valid
4663    when the declaration OLDDECL (assumed to be for the same name)
4664    has already been seen.
4665    Otherwise return an error message format string with a %s
4666    where the identifier should go.  */
4667
4668 static const char *
4669 redeclaration_error_message (newdecl, olddecl)
4670      tree newdecl, olddecl;
4671 {
4672   if (TREE_CODE (newdecl) == TYPE_DECL)
4673     {
4674       /* Because C++ can put things into name space for free,
4675          constructs like "typedef struct foo { ... } foo"
4676          would look like an erroneous redeclaration.  */
4677       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4678         return 0;
4679       else
4680         return "redefinition of `%#D'";
4681     }
4682   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4683     {
4684       /* If this is a pure function, its olddecl will actually be
4685          the original initialization to `0' (which we force to call
4686          abort()).  Don't complain about redefinition in this case.  */
4687       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4688         return 0;
4689
4690       /* If both functions come from different namespaces, this is not
4691          a redeclaration - this is a conflict with a used function. */
4692       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4693           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4694         return "`%D' conflicts with used function";
4695
4696       /* We'll complain about linkage mismatches in
4697          warn_extern_redeclared_static.  */
4698
4699       /* Defining the same name twice is no good.  */
4700       if (DECL_INITIAL (olddecl) != NULL_TREE
4701           && DECL_INITIAL (newdecl) != NULL_TREE)
4702         {
4703           if (DECL_NAME (olddecl) == NULL_TREE)
4704             return "`%#D' not declared in class";
4705           else
4706             return "redefinition of `%#D'";
4707         }
4708       return 0;
4709     }
4710   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4711     {
4712       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4713            && (DECL_TEMPLATE_RESULT (newdecl)
4714                != DECL_TEMPLATE_RESULT (olddecl))
4715            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4716            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4717           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4718               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4719               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4720         return "redefinition of `%#D'";
4721       return 0;
4722     }
4723   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4724     {
4725       /* Objects declared at top level:  */
4726       /* If at least one is a reference, it's ok.  */
4727       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4728         return 0;
4729       /* Reject two definitions.  */
4730       return "redefinition of `%#D'";
4731     }
4732   else
4733     {
4734       /* Objects declared with block scope:  */
4735       /* Reject two definitions, and reject a definition
4736          together with an external reference.  */
4737       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4738         return "redeclaration of `%#D'";
4739       return 0;
4740     }
4741 }
4742 \f
4743 /* Create a new label, named ID.  */
4744
4745 static tree
4746 make_label_decl (id, local_p)
4747      tree id;
4748      int local_p;
4749 {
4750   tree decl;
4751
4752   decl = build_decl (LABEL_DECL, id, void_type_node);
4753   if (expanding_p)
4754     /* Make sure every label has an rtx.  */
4755     label_rtx (decl);
4756
4757   DECL_CONTEXT (decl) = current_function_decl;
4758   DECL_MODE (decl) = VOIDmode;
4759   C_DECLARED_LABEL_FLAG (decl) = local_p;
4760
4761   /* Say where one reference is to the label, for the sake of the
4762      error if it is not defined.  */
4763   DECL_SOURCE_LINE (decl) = lineno;
4764   DECL_SOURCE_FILE (decl) = input_filename;
4765
4766   /* Record the fact that this identifier is bound to this label.  */
4767   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4768
4769   return decl;
4770 }
4771
4772 /* Record this label on the list of used labels so that we can check
4773    at the end of the function to see whether or not the label was
4774    actually defined, and so we can check when the label is defined whether
4775    this use is valid.  */
4776
4777 static void
4778 use_label (decl)
4779      tree decl;
4780 {
4781   if (named_label_uses == NULL
4782       || named_label_uses->names_in_scope != current_binding_level->names
4783       || named_label_uses->label_decl != decl)
4784     {
4785       struct named_label_use_list *new_ent;
4786       new_ent = ((struct named_label_use_list *)
4787                  ggc_alloc (sizeof (struct named_label_use_list)));
4788       new_ent->label_decl = decl;
4789       new_ent->names_in_scope = current_binding_level->names;
4790       new_ent->binding_level = current_binding_level;
4791       new_ent->lineno_o_goto = lineno;
4792       new_ent->filename_o_goto = input_filename;
4793       new_ent->next = named_label_uses;
4794       named_label_uses = new_ent;
4795     }
4796 }
4797
4798 /* Look for a label named ID in the current function.  If one cannot
4799    be found, create one.  (We keep track of used, but undefined,
4800    labels, and complain about them at the end of a function.)  */
4801
4802 tree
4803 lookup_label (id)
4804      tree id;
4805 {
4806   tree decl;
4807   struct named_label_list *ent;
4808
4809   /* You can't use labels at global scope.  */
4810   if (current_function_decl == NULL_TREE)
4811     {
4812       error ("label `%s' referenced outside of any function",
4813              IDENTIFIER_POINTER (id));
4814       return NULL_TREE;
4815     }
4816
4817   /* See if we've already got this label.  */
4818   decl = IDENTIFIER_LABEL_VALUE (id);
4819   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4820     return decl;
4821
4822   /* Record this label on the list of labels used in this function.
4823      We do this before calling make_label_decl so that we get the
4824      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4825   ent = ((struct named_label_list *)
4826          ggc_alloc_cleared (sizeof (struct named_label_list)));
4827   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4828   ent->next = named_labels;
4829   named_labels = ent;
4830
4831   /* We need a new label.  */
4832   decl = make_label_decl (id, /*local_p=*/0);
4833
4834   /* Now fill in the information we didn't have before.  */
4835   ent->label_decl = decl;
4836
4837   return decl;
4838 }
4839
4840 /* Declare a local label named ID.  */
4841
4842 tree
4843 declare_local_label (id)
4844      tree id;
4845 {
4846   tree decl;
4847
4848   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4849      this scope we can restore the old value of
4850      IDENTIFIER_TYPE_VALUE.  */
4851   current_binding_level->shadowed_labels
4852     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4853                  current_binding_level->shadowed_labels);
4854   /* Look for the label.  */
4855   decl = make_label_decl (id, /*local_p=*/1);
4856   /* Now fill in the information we didn't have before.  */
4857   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4858
4859   return decl;
4860 }
4861
4862 /* Returns nonzero if it is ill-formed to jump past the declaration of
4863    DECL.  Returns 2 if it's also a real problem.  */
4864
4865 static int
4866 decl_jump_unsafe (decl)
4867      tree decl;
4868 {
4869   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4870     return 0;
4871
4872   if (DECL_INITIAL (decl) == NULL_TREE
4873       && pod_type_p (TREE_TYPE (decl)))
4874     return 0;
4875
4876   /* This is really only important if we're crossing an initialization.
4877      The POD stuff is just pedantry; why should it matter if the class
4878      contains a field of pointer to member type?  */
4879   if (DECL_INITIAL (decl)
4880       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4881     return 2;
4882   return 1;
4883 }
4884
4885 /* Check that a single previously seen jump to a newly defined label
4886    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4887    the jump context; NAMES are the names in scope in LEVEL at the jump
4888    context; FILE and LINE are the source position of the jump or 0.  */
4889
4890 static void
4891 check_previous_goto_1 (decl, level, names, file, line)
4892      tree decl;
4893      struct binding_level *level;
4894      tree names;
4895      const char *file;
4896      int line;
4897 {
4898   int identified = 0;
4899   int saw_eh = 0;
4900   struct binding_level *b = current_binding_level;
4901   for (; b; b = b->level_chain)
4902     {
4903       tree new_decls = b->names;
4904       tree old_decls = (b == level ? names : NULL_TREE);
4905       for (; new_decls != old_decls;
4906            new_decls = TREE_CHAIN (new_decls))
4907         {
4908           int problem = decl_jump_unsafe (new_decls);
4909           if (! problem)
4910             continue;
4911
4912           if (! identified)
4913             {
4914               if (decl)
4915                 cp_pedwarn ("jump to label `%D'", decl);
4916               else
4917                 pedwarn ("jump to case label");
4918
4919               if (file)
4920                 pedwarn_with_file_and_line (file, line, "  from here");
4921               identified = 1;
4922             }
4923
4924           if (problem > 1)
4925             cp_error_at ("  crosses initialization of `%#D'",
4926                          new_decls);
4927           else
4928             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4929                            new_decls);
4930         }
4931
4932       if (b == level)
4933         break;
4934       if ((b->is_try_scope || b->is_catch_scope) && ! saw_eh)
4935         {
4936           if (! identified)
4937             {
4938               if (decl)
4939                 cp_pedwarn ("jump to label `%D'", decl);
4940               else
4941                 pedwarn ("jump to case label");
4942
4943               if (file)
4944                 pedwarn_with_file_and_line (file, line, "  from here");
4945               identified = 1;
4946             }
4947           if (b->is_try_scope)
4948             error ("  enters try block");
4949           else
4950             error ("  enters catch block");
4951           saw_eh = 1;
4952         }
4953     }
4954 }
4955
4956 static void
4957 check_previous_goto (use)
4958      struct named_label_use_list *use;
4959 {
4960   check_previous_goto_1 (use->label_decl, use->binding_level,
4961                          use->names_in_scope, use->filename_o_goto,
4962                          use->lineno_o_goto);
4963 }
4964
4965 static void
4966 check_switch_goto (level)
4967      struct binding_level *level;
4968 {
4969   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
4970 }
4971
4972 /* Check that any previously seen jumps to a newly defined label DECL
4973    are OK.  Called by define_label.  */
4974
4975 static void
4976 check_previous_gotos (decl)
4977      tree decl;
4978 {
4979   struct named_label_use_list **usep;
4980
4981   if (! TREE_USED (decl))
4982     return;
4983
4984   for (usep = &named_label_uses; *usep; )
4985     {
4986       struct named_label_use_list *use = *usep;
4987       if (use->label_decl == decl)
4988         {
4989           check_previous_goto (use);
4990           *usep = use->next;
4991         }
4992       else
4993         usep = &(use->next);
4994     }
4995 }
4996
4997 /* Check that a new jump to a label DECL is OK.  Called by
4998    finish_goto_stmt.  */
4999
5000 void
5001 check_goto (decl)
5002      tree decl;
5003 {
5004   int identified = 0;
5005   tree bad;
5006   struct named_label_list *lab;
5007
5008   /* We can't know where a computed goto is jumping.  So we assume
5009      that it's OK.  */
5010   if (! DECL_P (decl))
5011     return;
5012
5013   /* If the label hasn't been defined yet, defer checking.  */
5014   if (! DECL_INITIAL (decl))
5015     {
5016       use_label (decl);
5017       return;
5018     }
5019
5020   for (lab = named_labels; lab; lab = lab->next)
5021     if (decl == lab->label_decl)
5022       break;
5023
5024   /* If the label is not on named_labels it's a gcc local label, so
5025      it must be in an outer scope, so jumping to it is always OK.  */
5026   if (lab == 0)
5027     return;
5028
5029   if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
5030       && !identified)
5031     {
5032       cp_pedwarn_at ("jump to label `%D'", decl);
5033       pedwarn ("  from here");
5034       identified = 1;
5035     }
5036
5037   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5038     {
5039       tree b = TREE_VALUE (bad);
5040       int u = decl_jump_unsafe (b);
5041
5042       if (u > 1 && DECL_ARTIFICIAL (b))
5043         /* Can't skip init of __exception_info.  */
5044         cp_error_at ("  enters catch block", b);
5045       else if (u > 1)
5046         cp_error_at ("  skips initialization of `%#D'", b);
5047       else
5048         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5049     }
5050
5051   if (lab->in_try_scope)
5052     error ("  enters try block");
5053   else if (lab->in_catch_scope)
5054     error ("  enters catch block");
5055 }
5056
5057 /* Define a label, specifying the location in the source file.
5058    Return the LABEL_DECL node for the label, if the definition is valid.
5059    Otherwise return 0.  */
5060
5061 tree
5062 define_label (filename, line, name)
5063      const char *filename;
5064      int line;
5065      tree name;
5066 {
5067   tree decl = lookup_label (name);
5068   struct named_label_list *ent;
5069   register struct binding_level *p;
5070
5071   for (ent = named_labels; ent; ent = ent->next)
5072     if (ent->label_decl == decl)
5073       break;
5074
5075   /* After labels, make any new cleanups in the function go into their
5076      own new (temporary) binding contour.  */
5077   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5078     p->more_cleanups_ok = 0;
5079
5080   if (name == get_identifier ("wchar_t"))
5081     cp_pedwarn ("label named wchar_t");
5082
5083   if (DECL_INITIAL (decl) != NULL_TREE)
5084     {
5085       cp_error ("duplicate label `%D'", decl);
5086       return 0;
5087     }
5088   else
5089     {
5090       /* Mark label as having been defined.  */
5091       DECL_INITIAL (decl) = error_mark_node;
5092       /* Say where in the source.  */
5093       DECL_SOURCE_FILE (decl) = filename;
5094       DECL_SOURCE_LINE (decl) = line;
5095       if (ent)
5096         {
5097           ent->names_in_scope = current_binding_level->names;
5098           ent->binding_level = current_binding_level;
5099         }
5100       check_previous_gotos (decl);
5101       return decl;
5102     }
5103 }
5104
5105 struct cp_switch
5106 {
5107   struct binding_level *level;
5108   struct cp_switch *next;
5109   /* The SWITCH_STMT being built.  */
5110   tree switch_stmt;
5111   /* A splay-tree mapping the low element of a case range to the high
5112      element, or NULL_TREE if there is no high element.  Used to
5113      determine whether or not a new case label duplicates an old case
5114      label.  We need a tree, rather than simply a hash table, because
5115      of the GNU case range extension.  */
5116   splay_tree cases;
5117 };
5118
5119 /* A stack of the currently active switch statements.  The innermost
5120    switch statement is on the top of the stack.  There is no need to
5121    mark the stack for garbage collection because it is only active
5122    during the processing of the body of a function, and we never
5123    collect at that point.  */
5124
5125 static struct cp_switch *switch_stack;
5126
5127 /* Called right after a switch-statement condition is parsed.
5128    SWITCH_STMT is the switch statement being parsed.  */
5129
5130 void
5131 push_switch (switch_stmt)
5132      tree switch_stmt;
5133 {
5134   struct cp_switch *p
5135     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5136   p->level = current_binding_level;
5137   p->next = switch_stack;
5138   p->switch_stmt = switch_stmt;
5139   p->cases = splay_tree_new (case_compare, NULL, NULL);
5140   switch_stack = p;
5141 }
5142
5143 void
5144 pop_switch ()
5145 {
5146   struct cp_switch *cs;
5147
5148   cs = switch_stack;
5149   splay_tree_delete (cs->cases);
5150   switch_stack = switch_stack->next;
5151   free (cs);
5152 }
5153
5154 /* Note that we've seen a definition of a case label, and complain if this
5155    is a bad place for one.  */
5156
5157 tree
5158 finish_case_label (low_value, high_value)
5159      tree low_value;
5160      tree high_value;
5161 {
5162   tree cond, r;
5163   register struct binding_level *p;
5164
5165   if (! switch_stack)
5166     {
5167       if (high_value)
5168         error ("case label not within a switch statement");
5169       else if (low_value)
5170         cp_error ("case label `%E' not within a switch statement",
5171                   low_value);
5172       else
5173         error ("`default' label not within a switch statement");
5174       return NULL_TREE;
5175     }
5176
5177   if (processing_template_decl)
5178     {
5179       tree label;
5180
5181       /* For templates, just add the case label; we'll do semantic
5182          analysis at instantiation-time.  */
5183       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5184       return add_stmt (build_case_label (low_value, high_value, label));
5185     }
5186
5187   /* Find the condition on which this switch statement depends.  */
5188   cond = SWITCH_COND (switch_stack->switch_stmt);
5189   if (cond && TREE_CODE (cond) == TREE_LIST)
5190     cond = TREE_VALUE (cond);
5191
5192   r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5193   if (r == error_mark_node)
5194     r = NULL_TREE;
5195
5196   check_switch_goto (switch_stack->level);
5197
5198   /* After labels, make any new cleanups in the function go into their
5199      own new (temporary) binding contour.  */
5200   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5201     p->more_cleanups_ok = 0;
5202
5203   return r;
5204 }
5205 \f
5206 /* Return the list of declarations of the current level.
5207    Note that this list is in reverse order unless/until
5208    you nreverse it; and when you do nreverse it, you must
5209    store the result back using `storedecls' or you will lose.  */
5210
5211 tree
5212 getdecls ()
5213 {
5214   return current_binding_level->names;
5215 }
5216
5217 /* Return the list of type-tags (for structs, etc) of the current level.  */
5218
5219 tree
5220 gettags ()
5221 {
5222   return current_binding_level->tags;
5223 }
5224
5225 /* Store the list of declarations of the current level.
5226    This is done for the parameter declarations of a function being defined,
5227    after they are modified in the light of any missing parameters.  */
5228
5229 static void
5230 storedecls (decls)
5231      tree decls;
5232 {
5233   current_binding_level->names = decls;
5234 }
5235
5236 /* Similarly, store the list of tags of the current level.  */
5237
5238 void
5239 storetags (tags)
5240      tree tags;
5241 {
5242   current_binding_level->tags = tags;
5243 }
5244 \f
5245 /* Given NAME, an IDENTIFIER_NODE,
5246    return the structure (or union or enum) definition for that name.
5247    Searches binding levels from BINDING_LEVEL up to the global level.
5248    If THISLEVEL_ONLY is nonzero, searches only the specified context
5249    (but skips any tag-transparent contexts to find one that is
5250    meaningful for tags).
5251    FORM says which kind of type the caller wants;
5252    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5253    If the wrong kind of type is found, and it's not a template, an error is
5254    reported.  */
5255
5256 static tree
5257 lookup_tag (form, name, binding_level, thislevel_only)
5258      enum tree_code form;
5259      tree name;
5260      struct binding_level *binding_level;
5261      int thislevel_only;
5262 {
5263   register struct binding_level *level;
5264   /* Non-zero if, we should look past a template parameter level, even
5265      if THISLEVEL_ONLY.  */
5266   int allow_template_parms_p = 1;
5267
5268   for (level = binding_level; level; level = level->level_chain)
5269     {
5270       register tree tail;
5271       if (ANON_AGGRNAME_P (name))
5272         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5273           {
5274             /* There's no need for error checking here, because
5275                anon names are unique throughout the compilation.  */
5276             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5277               return TREE_VALUE (tail);
5278           }
5279       else if (level->namespace_p)
5280         /* Do namespace lookup. */
5281         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5282           {
5283             tree old = binding_for_name (name, tail);
5284
5285             /* If we just skipped past a template parameter level,
5286                even though THISLEVEL_ONLY, and we find a template
5287                class declaration, then we use the _TYPE node for the
5288                template.  See the example below.  */
5289             if (thislevel_only && !allow_template_parms_p
5290                 && old && BINDING_VALUE (old)
5291                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5292               old = TREE_TYPE (BINDING_VALUE (old));
5293             else
5294               old = BINDING_TYPE (old);
5295
5296             /* If it has an original type, it is a typedef, and we
5297                should not return it.  */
5298             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5299               old = NULL_TREE;
5300             if (old && TREE_CODE (old) != form
5301                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5302               {
5303                 cp_error ("`%#D' redeclared as %C", old, form);
5304                 return NULL_TREE;
5305               }
5306             if (old)
5307               return old;
5308             if (thislevel_only || tail == global_namespace)
5309               return NULL_TREE;
5310           }
5311       else
5312         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5313           {
5314             if (TREE_PURPOSE (tail) == name)
5315               {
5316                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5317                 /* Should tighten this up; it'll probably permit
5318                    UNION_TYPE and a struct template, for example.  */
5319                 if (code != form
5320                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5321                   {
5322                     /* Definition isn't the kind we were looking for.  */
5323                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5324                               form);
5325                     return NULL_TREE;
5326                   }
5327                 return TREE_VALUE (tail);
5328               }
5329           }
5330       if (thislevel_only && ! level->tag_transparent)
5331         {
5332           if (level->template_parms_p && allow_template_parms_p)
5333             {
5334               /* We must deal with cases like this:
5335
5336                    template <class T> struct S;
5337                    template <class T> struct S {};
5338
5339                  When looking up `S', for the second declaration, we
5340                  would like to find the first declaration.  But, we
5341                  are in the pseudo-global level created for the
5342                  template parameters, rather than the (surrounding)
5343                  namespace level.  Thus, we keep going one more level,
5344                  even though THISLEVEL_ONLY is non-zero.  */
5345               allow_template_parms_p = 0;
5346               continue;
5347             }
5348           else
5349             return NULL_TREE;
5350         }
5351     }
5352   return NULL_TREE;
5353 }
5354
5355 #if 0
5356 void
5357 set_current_level_tags_transparency (tags_transparent)
5358      int tags_transparent;
5359 {
5360   current_binding_level->tag_transparent = tags_transparent;
5361 }
5362 #endif
5363
5364 /* Given a type, find the tag that was defined for it and return the tag name.
5365    Otherwise return 0.  However, the value can never be 0
5366    in the cases in which this is used.
5367
5368    C++: If NAME is non-zero, this is the new name to install.  This is
5369    done when replacing anonymous tags with real tag names.  */
5370
5371 static tree
5372 lookup_tag_reverse (type, name)
5373      tree type;
5374      tree name;
5375 {
5376   register struct binding_level *level;
5377
5378   for (level = current_binding_level; level; level = level->level_chain)
5379     {
5380       register tree tail;
5381       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5382         {
5383           if (TREE_VALUE (tail) == type)
5384             {
5385               if (name)
5386                 TREE_PURPOSE (tail) = name;
5387               return TREE_PURPOSE (tail);
5388             }
5389         }
5390     }
5391   return NULL_TREE;
5392 }
5393 \f
5394 /* Look up NAME in the NAMESPACE.  */
5395
5396 tree
5397 lookup_namespace_name (namespace, name)
5398      tree namespace, name;
5399 {
5400   tree val;
5401   tree template_id = NULL_TREE;
5402
5403   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5404
5405   if (TREE_CODE (name) == NAMESPACE_DECL)
5406     /* This happens for A::B<int> when B is a namespace. */
5407     return name;
5408   else if (TREE_CODE (name) == TEMPLATE_DECL)
5409     {
5410       /* This happens for A::B where B is a template, and there are no
5411          template arguments.  */
5412       cp_error ("invalid use of `%D'", name);
5413       return error_mark_node;
5414     }
5415
5416   namespace = ORIGINAL_NAMESPACE (namespace);
5417
5418   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5419     {
5420       template_id = name;
5421       name = TREE_OPERAND (name, 0);
5422       if (TREE_CODE (name) == OVERLOAD)
5423         name = DECL_NAME (OVL_CURRENT (name));
5424       else if (DECL_P (name))
5425         name = DECL_NAME (name);
5426     }
5427
5428   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5429
5430   val = make_node (CPLUS_BINDING);
5431   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5432     return error_mark_node;
5433
5434   if (BINDING_VALUE (val))
5435     {
5436       val = BINDING_VALUE (val);
5437
5438       if (template_id)
5439         {
5440           if (DECL_CLASS_TEMPLATE_P (val))
5441             val = lookup_template_class (val,
5442                                          TREE_OPERAND (template_id, 1),
5443                                          /*in_decl=*/NULL_TREE,
5444                                          /*context=*/NULL_TREE,
5445                                          /*entering_scope=*/0,
5446                                          /*complain=*/1);
5447           else if (DECL_FUNCTION_TEMPLATE_P (val)
5448                    || TREE_CODE (val) == OVERLOAD)
5449             val = lookup_template_function (val,
5450                                             TREE_OPERAND (template_id, 1));
5451           else
5452             {
5453               cp_error ("`%D::%D' is not a template",
5454                         namespace, name);
5455               return error_mark_node;
5456             }
5457         }
5458
5459       /* If we have a single function from a using decl, pull it out.  */
5460       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5461         val = OVL_FUNCTION (val);
5462       return val;
5463     }
5464
5465   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5466   return error_mark_node;
5467 }
5468
5469 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5470
5471 static unsigned long
5472 typename_hash (k)
5473      hash_table_key k;
5474 {
5475   unsigned long hash;
5476   tree t;
5477
5478   t = (tree) k;
5479   hash = (((unsigned long) TYPE_CONTEXT (t))
5480           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5481
5482   return hash;
5483 }
5484
5485 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5486
5487 static bool
5488 typename_compare (k1, k2)
5489      hash_table_key k1;
5490      hash_table_key k2;
5491 {
5492   tree t1;
5493   tree t2;
5494   tree d1;
5495   tree d2;
5496
5497   t1 = (tree) k1;
5498   t2 = (tree) k2;
5499   d1 = TYPE_NAME (t1);
5500   d2 = TYPE_NAME (t2);
5501
5502   return (DECL_NAME (d1) == DECL_NAME (d2)
5503           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5504           && ((TREE_TYPE (t1) != NULL_TREE)
5505               == (TREE_TYPE (t2) != NULL_TREE))
5506           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5507           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5508 }
5509
5510 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5511    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5512    is non-NULL, this type is being created by the implicit typename
5513    extension, and BASE_TYPE is a type named `t' in some base class of
5514    `T' which depends on template parameters.
5515
5516    Returns the new TYPENAME_TYPE.  */
5517
5518 tree
5519 build_typename_type (context, name, fullname, base_type)
5520      tree context;
5521      tree name;
5522      tree fullname;
5523      tree base_type;
5524 {
5525   tree t;
5526   tree d;
5527   struct hash_entry *e;
5528
5529   static struct hash_table ht;
5530
5531   if (!ht.table)
5532     {
5533       static struct hash_table *h = &ht;
5534
5535       hash_table_init (&ht, &hash_newfunc, &typename_hash, &typename_compare);
5536       ggc_add_tree_hash_table_root (&h, 1);
5537     }
5538
5539   /* Build the TYPENAME_TYPE.  */
5540   t = make_aggr_type (TYPENAME_TYPE);
5541   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5542   TYPENAME_TYPE_FULLNAME (t) = fullname;
5543   TREE_TYPE (t) = base_type;
5544
5545   /* Build the corresponding TYPE_DECL.  */
5546   d = build_decl (TYPE_DECL, name, t);
5547   TYPE_NAME (TREE_TYPE (d)) = d;
5548   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5549   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5550   DECL_ARTIFICIAL (d) = 1;
5551
5552   /* See if we already have this type.  */
5553   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5554   if (e)
5555     t = (tree) e->key;
5556   else
5557     /* Insert the type into the table.  */
5558     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5559
5560   return t;
5561 }
5562
5563 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5564    unless an error occurs, in which case error_mark_node is returned.
5565    If COMPLAIN zero, don't complain about any errors that occur.  */
5566
5567 tree
5568 make_typename_type (context, name, complain)
5569      tree context, name;
5570      int complain;
5571 {
5572   tree fullname;
5573
5574   if (TYPE_P (name))
5575     {
5576       if (!(TYPE_LANG_SPECIFIC (name)
5577             && (CLASSTYPE_IS_TEMPLATE (name)
5578                 || CLASSTYPE_USE_TEMPLATE (name))))
5579         name = TYPE_IDENTIFIER (name);
5580       else
5581         /* Create a TEMPLATE_ID_EXPR for the type.  */
5582         name = build_nt (TEMPLATE_ID_EXPR,
5583                          CLASSTYPE_TI_TEMPLATE (name),
5584                          CLASSTYPE_TI_ARGS (name));
5585     }
5586   else if (TREE_CODE (name) == TYPE_DECL)
5587     name = DECL_NAME (name);
5588
5589   fullname = name;
5590
5591   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5592     {
5593       name = TREE_OPERAND (name, 0);
5594       if (TREE_CODE (name) == TEMPLATE_DECL)
5595         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5596     }
5597   if (TREE_CODE (name) != IDENTIFIER_NODE)
5598     my_friendly_abort (2000);
5599
5600   if (TREE_CODE (context) == NAMESPACE_DECL)
5601     {
5602       /* We can get here from typename_sub0 in the explicit_template_type
5603          expansion.  Just fail.  */
5604       if (complain)
5605         cp_error ("no class template named `%#T' in `%#T'",
5606                   name, context);
5607       return error_mark_node;
5608     }
5609
5610   if (! uses_template_parms (context)
5611       || currently_open_class (context))
5612     {
5613       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5614         {
5615           tree tmpl = NULL_TREE;
5616           if (IS_AGGR_TYPE (context))
5617             tmpl = lookup_field (context, name, 0, 0);
5618           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5619             {
5620               if (complain)
5621                 cp_error ("no class template named `%#T' in `%#T'",
5622                           name, context);
5623               return error_mark_node;
5624             }
5625
5626           return lookup_template_class (tmpl,
5627                                         TREE_OPERAND (fullname, 1),
5628                                         NULL_TREE, context,
5629                                         /*entering_scope=*/0,
5630                                         /*complain=*/1);
5631         }
5632       else
5633         {
5634           tree t;
5635
5636           if (!IS_AGGR_TYPE (context))
5637             {
5638               if (complain)
5639                 cp_error ("no type named `%#T' in `%#T'", name, context);
5640               return error_mark_node;
5641             }
5642
5643           t = lookup_field (context, name, 0, 1);
5644           if (t)
5645             return TREE_TYPE (t);
5646         }
5647     }
5648
5649   /* If the CONTEXT is not a template type, then either the field is
5650      there now or its never going to be.  */
5651   if (!uses_template_parms (context))
5652     {
5653       if (complain)
5654         cp_error ("no type named `%#T' in `%#T'", name, context);
5655       return error_mark_node;
5656     }
5657
5658
5659   return build_typename_type (context, name, fullname,  NULL_TREE);
5660 }
5661
5662 /* Select the right _DECL from multiple choices. */
5663
5664 static tree
5665 select_decl (binding, flags)
5666      tree binding;
5667      int flags;
5668 {
5669   tree val;
5670   val = BINDING_VALUE (binding);
5671
5672   /* When we implicitly declare some builtin entity, we mark it
5673      DECL_ANTICIPATED, so that we know to ignore it until it is
5674      really declared.  */
5675   if (val && DECL_P (val)
5676       && DECL_LANG_SPECIFIC (val)
5677       && DECL_ANTICIPATED (val))
5678     return NULL_TREE;
5679
5680   if (LOOKUP_NAMESPACES_ONLY (flags))
5681     {
5682       /* We are not interested in types. */
5683       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5684         return val;
5685       return NULL_TREE;
5686     }
5687
5688   /* If we could have a type and
5689      we have nothing or we need a type and have none.  */
5690   if (BINDING_TYPE (binding)
5691       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5692                    && TREE_CODE (val) != TYPE_DECL)))
5693     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5694   /* Don't return non-types if we really prefer types. */
5695   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5696            && (TREE_CODE (val) != TEMPLATE_DECL
5697                || !DECL_CLASS_TEMPLATE_P (val)))
5698     val = NULL_TREE;
5699
5700   return val;
5701 }
5702
5703 /* Unscoped lookup of a global: iterate over current namespaces,
5704    considering using-directives.  If SPACESP is non-NULL, store a list
5705    of the namespaces we've considered in it.  */
5706
5707 tree
5708 unqualified_namespace_lookup (name, flags, spacesp)
5709      tree name;
5710      int flags;
5711      tree *spacesp;
5712 {
5713   tree b = make_node (CPLUS_BINDING);
5714   tree initial = current_decl_namespace ();
5715   tree scope = initial;
5716   tree siter;
5717   struct binding_level *level;
5718   tree val = NULL_TREE;
5719
5720   if (spacesp)
5721     *spacesp = NULL_TREE;
5722
5723   for (; !val; scope = CP_DECL_CONTEXT (scope))
5724     {
5725       if (spacesp)
5726         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5727       val = binding_for_name (name, scope);
5728
5729       /* Initialize binding for this context. */
5730       BINDING_VALUE (b) = BINDING_VALUE (val);
5731       BINDING_TYPE (b) = BINDING_TYPE (val);
5732
5733       /* Add all _DECLs seen through local using-directives. */
5734       for (level = current_binding_level;
5735            !level->namespace_p;
5736            level = level->level_chain)
5737         if (!lookup_using_namespace (name, b, level->using_directives,
5738                                      scope, flags, spacesp))
5739           /* Give up because of error. */
5740           return error_mark_node;
5741
5742       /* Add all _DECLs seen through global using-directives. */
5743       /* XXX local and global using lists should work equally. */
5744       siter = initial;
5745       while (1)
5746         {
5747           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5748                                        scope, flags, spacesp))
5749             /* Give up because of error. */
5750             return error_mark_node;
5751           if (siter == scope) break;
5752           siter = CP_DECL_CONTEXT (siter);
5753         }
5754
5755       val = select_decl (b, flags);
5756       if (scope == global_namespace)
5757         break;
5758     }
5759   return val;
5760 }
5761
5762 /* Combine prefer_type and namespaces_only into flags.  */
5763
5764 static int
5765 lookup_flags (prefer_type, namespaces_only)
5766   int prefer_type, namespaces_only;
5767 {
5768   if (namespaces_only)
5769     return LOOKUP_PREFER_NAMESPACES;
5770   if (prefer_type > 1)
5771     return LOOKUP_PREFER_TYPES;
5772   if (prefer_type > 0)
5773     return LOOKUP_PREFER_BOTH;
5774   return 0;
5775 }
5776
5777 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5778    ignore it or not.  Subroutine of lookup_name_real.  */
5779
5780 static tree
5781 qualify_lookup (val, flags)
5782      tree val;
5783      int flags;
5784 {
5785   if (val == NULL_TREE)
5786     return val;
5787   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5788     return val;
5789   if ((flags & LOOKUP_PREFER_TYPES)
5790       && (TREE_CODE (val) == TYPE_DECL
5791           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5792               && DECL_CLASS_TEMPLATE_P (val))))
5793     return val;
5794   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5795     return NULL_TREE;
5796   return val;
5797 }
5798
5799 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5800    that.  */
5801
5802 static void
5803 warn_about_implicit_typename_lookup (typename, binding)
5804      tree typename;
5805      tree binding;
5806 {
5807   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5808   tree name = DECL_NAME (typename);
5809
5810   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5811          && CLASSTYPE_TEMPLATE_INFO (subtype)
5812          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5813       && ! (TREE_CODE (binding) == TYPE_DECL
5814             && same_type_p (TREE_TYPE (binding), subtype)))
5815     {
5816       cp_warning ("lookup of `%D' finds `%#D'",
5817                   name, binding);
5818       cp_warning ("  instead of `%D' from dependent base class",
5819                   typename);
5820       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5821                   constructor_name (current_class_type), name);
5822     }
5823 }
5824
5825 /* Look up NAME in the current binding level and its superiors in the
5826    namespace of variables, functions and typedefs.  Return a ..._DECL
5827    node of some kind representing its definition if there is only one
5828    such declaration, or return a TREE_LIST with all the overloaded
5829    definitions if there are many, or return 0 if it is undefined.
5830
5831    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5832    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5833    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5834    Otherwise we prefer non-TYPE_DECLs.
5835
5836    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5837    using IDENTIFIER_CLASS_VALUE.  */
5838
5839 static tree
5840 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5841      tree name;
5842      int prefer_type, nonclass, namespaces_only;
5843 {
5844   tree t;
5845   tree val = NULL_TREE;
5846   int yylex = 0;
5847   tree from_obj = NULL_TREE;
5848   int flags;
5849   int val_is_implicit_typename = 0;
5850
5851   /* Hack: copy flag set by parser, if set. */
5852   if (only_namespace_names)
5853     namespaces_only = 1;
5854
5855   if (prefer_type == -2)
5856     {
5857       extern int looking_for_typename;
5858       tree type = NULL_TREE;
5859
5860       yylex = 1;
5861       prefer_type = looking_for_typename;
5862
5863       flags = lookup_flags (prefer_type, namespaces_only);
5864       /* If the next thing is '<', class templates are types. */
5865       if (looking_for_template)
5866         flags |= LOOKUP_TEMPLATES_EXPECTED;
5867
5868       if (got_scope)
5869         type = got_scope;
5870       else if (got_object != error_mark_node)
5871         type = got_object;
5872
5873       if (type)
5874         {
5875           if (type == error_mark_node)
5876             return error_mark_node;
5877           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5878             type = TREE_TYPE (type);
5879
5880           if (TYPE_P (type))
5881             type = complete_type (type);
5882
5883           if (TREE_CODE (type) == VOID_TYPE)
5884             type = global_namespace;
5885           if (TREE_CODE (type) == NAMESPACE_DECL)
5886             {
5887               val = make_node (CPLUS_BINDING);
5888               flags |= LOOKUP_COMPLAIN;
5889               if (!qualified_lookup_using_namespace (name, type, val, flags))
5890                 return NULL_TREE;
5891               val = select_decl (val, flags);
5892             }
5893           else if (! IS_AGGR_TYPE (type)
5894                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5895                    || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
5896                    || TREE_CODE (type) == TYPENAME_TYPE)
5897             /* Someone else will give an error about this if needed.  */
5898             val = NULL_TREE;
5899           else if (type == current_class_type)
5900             val = IDENTIFIER_CLASS_VALUE (name);
5901           else
5902             {
5903               val = lookup_member (type, name, 0, prefer_type);
5904               type_access_control (type, val);
5905
5906               /* Restore the containing TYPENAME_TYPE if we looked
5907                  through it before.  */
5908               if (got_scope && got_scope != type
5909                   && val && TREE_CODE (val) == TYPE_DECL
5910                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
5911                 TYPE_CONTEXT (TREE_TYPE (val)) = got_scope;
5912             }
5913         }
5914       else
5915         val = NULL_TREE;
5916
5917       if (got_scope)
5918         goto done;
5919       else if (got_object && val)
5920         {
5921           from_obj = val;
5922           val = NULL_TREE;
5923         }
5924     }
5925   else
5926     {
5927       flags = lookup_flags (prefer_type, namespaces_only);
5928       /* If we're not parsing, we need to complain. */
5929       flags |= LOOKUP_COMPLAIN;
5930     }
5931
5932   /* First, look in non-namespace scopes.  */
5933
5934   if (current_class_type == NULL_TREE)
5935     nonclass = 1;
5936
5937   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5938     {
5939       tree binding;
5940
5941       if (!LOCAL_BINDING_P (t) && nonclass)
5942         /* We're not looking for class-scoped bindings, so keep going.  */
5943         continue;
5944
5945       /* If this is the kind of thing we're looking for, we're done.  */
5946       if (qualify_lookup (BINDING_VALUE (t), flags))
5947         binding = BINDING_VALUE (t);
5948       else if ((flags & LOOKUP_PREFER_TYPES)
5949                && qualify_lookup (BINDING_TYPE (t), flags))
5950         binding = BINDING_TYPE (t);
5951       else
5952         binding = NULL_TREE;
5953
5954       /* Handle access control on types from enclosing or base classes.  */
5955       if (binding && ! yylex
5956           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5957         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5958
5959       if (binding
5960           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5961         {
5962           if (val_is_implicit_typename && !yylex)
5963             warn_about_implicit_typename_lookup (val, binding);
5964           val = binding;
5965           val_is_implicit_typename
5966             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5967           if (!val_is_implicit_typename)
5968             break;
5969         }
5970     }
5971
5972   /* Now lookup in namespace scopes.  */
5973   if (!val || val_is_implicit_typename)
5974     {
5975       t = unqualified_namespace_lookup (name, flags, 0);
5976       if (t)
5977         {
5978           if (val_is_implicit_typename && !yylex)
5979             warn_about_implicit_typename_lookup (val, t);
5980           val = t;
5981         }
5982     }
5983
5984  done:
5985   if (val)
5986     {
5987       /* This should only warn about types used in qualified-ids.  */
5988       if (from_obj && from_obj != val)
5989         {
5990           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5991               && TREE_CODE (val) == TYPE_DECL
5992               && ! same_type_p (TREE_TYPE (from_obj), TREE_TYPE (val)))
5993             cp_pedwarn ("\
5994 lookup of `%D' in the scope of `%#T' (`%#D') \
5995 does not match lookup in the current scope (`%#D')",
5996                         name, got_object, from_obj, val);
5997
5998           /* We don't change val to from_obj if got_object depends on
5999              template parms because that breaks implicit typename for
6000              destructor calls.  */
6001           if (! uses_template_parms (got_object))
6002             val = from_obj;
6003         }
6004
6005       /* If we have a single function from a using decl, pull it out.  */
6006       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6007         val = OVL_FUNCTION (val);
6008     }
6009   else if (from_obj)
6010     val = from_obj;
6011
6012   return val;
6013 }
6014
6015 tree
6016 lookup_name_nonclass (name)
6017      tree name;
6018 {
6019   return lookup_name_real (name, 0, 1, 0);
6020 }
6021
6022 tree
6023 lookup_function_nonclass (name, args)
6024      tree name;
6025      tree args;
6026 {
6027   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6028 }
6029
6030 tree
6031 lookup_name_namespace_only (name)
6032      tree name;
6033 {
6034   /* type-or-namespace, nonclass, namespace_only */
6035   return lookup_name_real (name, 1, 1, 1);
6036 }
6037
6038 tree
6039 lookup_name (name, prefer_type)
6040      tree name;
6041      int prefer_type;
6042 {
6043   return lookup_name_real (name, prefer_type, 0, 0);
6044 }
6045
6046 /* Similar to `lookup_name' but look only in the innermost non-class
6047    binding level.  */
6048
6049 tree
6050 lookup_name_current_level (name)
6051      tree name;
6052 {
6053   struct binding_level *b;
6054   tree t = NULL_TREE;
6055
6056   b = current_binding_level;
6057   while (b->parm_flag == 2)
6058     b = b->level_chain;
6059
6060   if (b->namespace_p)
6061     {
6062       t = IDENTIFIER_NAMESPACE_VALUE (name);
6063
6064       /* extern "C" function() */
6065       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6066         t = TREE_VALUE (t);
6067     }
6068   else if (IDENTIFIER_BINDING (name)
6069            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6070     {
6071       while (1)
6072         {
6073           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6074             return IDENTIFIER_VALUE (name);
6075
6076           if (b->keep == 2)
6077             b = b->level_chain;
6078           else
6079             break;
6080         }
6081     }
6082
6083   return t;
6084 }
6085
6086 /* Like lookup_name_current_level, but for types.  */
6087
6088 tree
6089 lookup_type_current_level (name)
6090      tree name;
6091 {
6092   register tree t = NULL_TREE;
6093
6094   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6095
6096   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6097       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6098     {
6099       struct binding_level *b = current_binding_level;
6100       while (1)
6101         {
6102           if (purpose_member (name, b->type_shadowed))
6103             return REAL_IDENTIFIER_TYPE_VALUE (name);
6104           if (b->keep == 2)
6105             b = b->level_chain;
6106           else
6107             break;
6108         }
6109     }
6110
6111   return t;
6112 }
6113
6114 void
6115 begin_only_namespace_names ()
6116 {
6117   only_namespace_names = 1;
6118 }
6119
6120 void
6121 end_only_namespace_names ()
6122 {
6123   only_namespace_names = 0;
6124 }
6125 \f
6126 /* Push the declarations of builtin types into the namespace.
6127    RID_INDEX is the index of the builtin type
6128    in the array RID_POINTERS.  NAME is the name used when looking
6129    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6130
6131 void
6132 record_builtin_type (rid_index, name, type)
6133      enum rid rid_index;
6134      const char *name;
6135      tree type;
6136 {
6137   tree rname = NULL_TREE, tname = NULL_TREE;
6138   tree tdecl = NULL_TREE;
6139
6140   if ((int) rid_index < (int) RID_MAX)
6141     rname = ridpointers[(int) rid_index];
6142   if (name)
6143     tname = get_identifier (name);
6144
6145   TYPE_BUILT_IN (type) = 1;
6146
6147   if (tname)
6148     {
6149       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6150       set_identifier_type_value (tname, NULL_TREE);
6151       if ((int) rid_index < (int) RID_MAX)
6152         /* Built-in types live in the global namespace. */
6153         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6154     }
6155   if (rname != NULL_TREE)
6156     {
6157       if (tname != NULL_TREE)
6158         {
6159           set_identifier_type_value (rname, NULL_TREE);
6160           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6161         }
6162       else
6163         {
6164           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6165           set_identifier_type_value (rname, NULL_TREE);
6166         }
6167     }
6168 }
6169
6170 /* Record one of the standard Java types.
6171  * Declare it as having the given NAME.
6172  * If SIZE > 0, it is the size of one of the integral types;
6173  * otherwise it is the negative of the size of one of the other types.  */
6174
6175 static tree
6176 record_builtin_java_type (name, size)
6177      const char *name;
6178      int size;
6179 {
6180   tree type, decl;
6181   if (size > 0)
6182     type = make_signed_type (size);
6183   else if (size > -32)
6184     { /* "__java_char" or ""__java_boolean". */
6185       type = make_unsigned_type (-size);
6186       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6187     }
6188   else
6189     { /* "__java_float" or ""__java_double". */
6190       type = make_node (REAL_TYPE);
6191       TYPE_PRECISION (type) = - size;
6192       layout_type (type);
6193     }
6194   record_builtin_type (RID_MAX, name, type);
6195   decl = TYPE_NAME (type);
6196
6197   /* Suppress generate debug symbol entries for these types,
6198      since for normal C++ they are just clutter.
6199      However, push_lang_context undoes this if extern "Java" is seen. */
6200   DECL_IGNORED_P (decl) = 1;
6201
6202   TYPE_FOR_JAVA (type) = 1;
6203   return type;
6204 }
6205
6206 /* Push a type into the namespace so that the back-ends ignore it. */
6207
6208 static void
6209 record_unknown_type (type, name)
6210      tree type;
6211      const char *name;
6212 {
6213   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6214   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6215   DECL_IGNORED_P (decl) = 1;
6216   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6217   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6218   TYPE_ALIGN (type) = 1;
6219   TYPE_USER_ALIGN (type) = 0;
6220   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6221 }
6222
6223 /* An string for which we should create an IDENTIFIER_NODE at
6224    startup.  */
6225
6226 typedef struct predefined_identifier
6227 {
6228   /* The name of the identifier.  */
6229   const char *name;
6230   /* The place where the IDENTIFIER_NODE should be stored.  */
6231   tree *node;
6232   /* Non-zero if this is the name of a constructor or destructor.  */
6233   int ctor_or_dtor_p;
6234 } predefined_identifier;
6235
6236 /* Create all the predefined identifiers.  */
6237
6238 static void
6239 initialize_predefined_identifiers ()
6240 {
6241   struct predefined_identifier *pid;
6242
6243   /* A table of identifiers to create at startup.  */
6244   static predefined_identifier predefined_identifiers[] = {
6245     { "C++", &lang_name_cplusplus, 0 },
6246     { "C", &lang_name_c, 0 },
6247     { "Java", &lang_name_java, 0 },
6248     { CTOR_NAME, &ctor_identifier, 1 },
6249     { "__base_ctor", &base_ctor_identifier, 1 },
6250     { "__comp_ctor", &complete_ctor_identifier, 1 },
6251     { DTOR_NAME, &dtor_identifier, 1 },
6252     { "__comp_dtor", &complete_dtor_identifier, 1 },
6253     { "__base_dtor", &base_dtor_identifier, 1 },
6254     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6255     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6256     { "nelts", &nelts_identifier, 0 },
6257     { THIS_NAME, &this_identifier, 0 },
6258     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6259     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6260     { "_vptr", &vptr_identifier, 0 },
6261     { "__vtt_parm", &vtt_parm_identifier, 0 },
6262     { "std", &std_identifier, 0 },
6263     { NULL, NULL, 0 }
6264   };
6265
6266   for (pid = predefined_identifiers; pid->name; ++pid)
6267     {
6268       *pid->node = get_identifier (pid->name);
6269       if (pid->ctor_or_dtor_p)
6270         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6271     }
6272 }
6273
6274 /* Create the predefined scalar types of C,
6275    and some nodes representing standard constants (0, 1, (void *)0).
6276    Initialize the global binding level.
6277    Make definitions for built-in primitive functions.  */
6278
6279 void
6280 init_decl_processing ()
6281 {
6282   tree void_ftype;
6283   tree void_ftype_ptr;
6284
6285   /* Create all the identifiers we need.  */
6286   initialize_predefined_identifiers ();
6287
6288   /* Fill in back-end hooks.  */
6289   init_lang_status = &push_cp_function_context;
6290   free_lang_status = &pop_cp_function_context;
6291   mark_lang_status = &mark_cp_function_context;
6292   lang_safe_from_p = &c_safe_from_p;
6293   lang_dump_tree = &cp_dump_tree;
6294   lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
6295
6296   cp_parse_init ();
6297   init_decl2 ();
6298   init_pt ();
6299
6300   /* Create the global variables.  */
6301   push_to_top_level ();
6302
6303   /* Enter the global namespace. */
6304   my_friendly_assert (global_namespace == NULL_TREE, 375);
6305   push_namespace (get_identifier ("::"));
6306   global_namespace = current_namespace;
6307   current_lang_name = NULL_TREE;
6308
6309   /* Adjust various flags based on command-line settings.  */
6310   if (! flag_permissive && ! pedantic)
6311     flag_pedantic_errors = 1;
6312   if (!flag_no_inline)
6313     {
6314       flag_inline_trees = 1;
6315       flag_no_inline = 1;
6316     }
6317   if (flag_inline_functions)
6318     {
6319       flag_inline_trees = 2;
6320       flag_inline_functions = 0;
6321     }
6322
6323   /* In C++, we never create builtin functions whose name does not
6324      begin with `__'.  Users should be using headers to get prototypes
6325      in C++.  It would be nice if we could warn when `-fbuiltin' is
6326      used explicitly, but we do not have that information.  */
6327   flag_no_builtin = 1;
6328
6329   /* Initially, C.  */
6330   current_lang_name = lang_name_c;
6331
6332   current_function_decl = NULL_TREE;
6333   current_binding_level = NULL_BINDING_LEVEL;
6334   free_binding_level = NULL_BINDING_LEVEL;
6335
6336   build_common_tree_nodes (flag_signed_char);
6337
6338   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6339   TREE_TYPE (error_mark_list) = error_mark_node;
6340
6341   /* Make the binding_level structure for global names.  */
6342   pushlevel (0);
6343   global_binding_level = current_binding_level;
6344   /* The global level is the namespace level of ::.  */
6345   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6346   declare_namespace_level ();
6347
6348   /* Create the `std' namespace.  */
6349   push_namespace (std_identifier);
6350   std_node = current_namespace;
6351   pop_namespace ();
6352
6353   c_common_nodes_and_builtins ();
6354
6355   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6356   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6357   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6358   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6359   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6360   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6361   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6362   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6363
6364   integer_two_node = build_int_2 (2, 0);
6365   TREE_TYPE (integer_two_node) = integer_type_node;
6366   integer_three_node = build_int_2 (3, 0);
6367   TREE_TYPE (integer_three_node) = integer_type_node;
6368
6369   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6370   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6371   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6372   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6373   TYPE_PRECISION (boolean_type_node) = 1;
6374   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6375   boolean_false_node = build_int_2 (0, 0);
6376   TREE_TYPE (boolean_false_node) = boolean_type_node;
6377   boolean_true_node = build_int_2 (1, 0);
6378   TREE_TYPE (boolean_true_node) = boolean_type_node;
6379
6380   signed_size_zero_node = build_int_2 (0, 0);
6381   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6382
6383   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6384
6385 #if 0
6386   record_builtin_type (RID_MAX, NULL, string_type_node);
6387 #endif
6388
6389   delta_type_node = ptrdiff_type_node;
6390   vtable_index_type = ptrdiff_type_node;
6391
6392   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6393   lang_type_promotes_to = convert_type_from_ellipsis;
6394
6395   void_ftype = build_function_type (void_type_node, void_list_node);
6396   void_ftype_ptr = build_function_type (void_type_node,
6397                                         tree_cons (NULL_TREE,
6398                                                    ptr_type_node,
6399                                                    void_list_node));
6400   void_ftype_ptr
6401     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6402
6403   /* C++ extensions */
6404
6405   unknown_type_node = make_node (UNKNOWN_TYPE);
6406   record_unknown_type (unknown_type_node, "unknown type");
6407
6408   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6409   TREE_TYPE (unknown_type_node) = unknown_type_node;
6410
6411   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6412
6413   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6414      result.  */
6415   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6416   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6417
6418   {
6419     /* Make sure we get a unique function type, so we can give
6420        its pointer type a name.  (This wins for gdb.) */
6421     tree vfunc_type = make_node (FUNCTION_TYPE);
6422     TREE_TYPE (vfunc_type) = integer_type_node;
6423     TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6424     layout_type (vfunc_type);
6425
6426     vtable_entry_type = build_pointer_type (vfunc_type);
6427   }
6428   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6429
6430   vtbl_type_node
6431     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6432   layout_type (vtbl_type_node);
6433   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6434   record_builtin_type (RID_MAX, NULL, vtbl_type_node);
6435   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6436   layout_type (vtbl_ptr_type_node);
6437   record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
6438
6439   push_namespace (get_identifier ("__cxxabiv1"));
6440   abi_node = current_namespace;
6441   pop_namespace ();
6442
6443   global_type_node = make_node (LANG_TYPE);
6444   record_unknown_type (global_type_node, "global type");
6445
6446   /* Now, C++.  */
6447   current_lang_name = lang_name_cplusplus;
6448
6449   {
6450     tree bad_alloc_type_node, newtype, deltype;
6451     tree ptr_ftype_sizetype;
6452
6453     push_namespace (std_identifier);
6454     bad_alloc_type_node = xref_tag
6455       (class_type_node, get_identifier ("bad_alloc"), 1);
6456     pop_namespace ();
6457     ptr_ftype_sizetype
6458       = build_function_type (ptr_type_node,
6459                              tree_cons (NULL_TREE,
6460                                         c_size_type_node,
6461                                         void_list_node));
6462     newtype = build_exception_variant
6463       (ptr_ftype_sizetype, add_exception_specifier
6464        (NULL_TREE, bad_alloc_type_node, -1));
6465     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6466     push_cp_library_fn (NEW_EXPR, newtype);
6467     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6468     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6469     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6470   }
6471
6472   abort_fndecl
6473     = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
6474
6475   /* Perform other language dependent initializations.  */
6476   init_class_processing ();
6477   init_init_processing ();
6478   init_search_processing ();
6479   init_rtti_processing ();
6480
6481   if (flag_exceptions)
6482     init_exception_processing ();
6483
6484   if (! supports_one_only ())
6485     flag_weak = 0;
6486
6487   make_fname_decl = cp_make_fname_decl;
6488   start_fname_decls ();
6489
6490   /* Prepare to check format strings against argument lists.  */
6491   init_function_format_info ();
6492
6493   /* Show we use EH for cleanups.  */
6494   using_eh_for_cleanups ();
6495
6496   lang_attribute_table = cp_attribute_table;
6497
6498   /* Maintain consistency.  Perhaps we should just complain if they
6499      say -fwritable-strings?  */
6500   if (flag_writable_strings)
6501     flag_const_strings = 0;
6502
6503   /* Add GC roots for all of our global variables.  */
6504   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6505   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6506   ggc_add_tree_root (&integer_three_node, 1);
6507   ggc_add_tree_root (&integer_two_node, 1);
6508   ggc_add_tree_root (&signed_size_zero_node, 1);
6509   ggc_add_tree_root (&size_one_node, 1);
6510   ggc_add_tree_root (&size_zero_node, 1);
6511   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6512                 mark_binding_level);
6513   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6514   ggc_add_tree_root (&static_ctors, 1);
6515   ggc_add_tree_root (&static_dtors, 1);
6516   ggc_add_tree_root (&lastiddecl, 1);
6517
6518   ggc_add_tree_root (&last_function_parms, 1);
6519   ggc_add_tree_root (&error_mark_list, 1);
6520
6521   ggc_add_tree_root (&global_namespace, 1);
6522   ggc_add_tree_root (&global_type_node, 1);
6523   ggc_add_tree_root (&anonymous_namespace_name, 1);
6524
6525   ggc_add_tree_root (&got_object, 1);
6526   ggc_add_tree_root (&got_scope, 1);
6527
6528   ggc_add_tree_root (&current_lang_name, 1);
6529   ggc_add_tree_root (&static_aggregates, 1);
6530   ggc_add_tree_root (&free_bindings, 1);
6531 }
6532
6533 /* Generate an initializer for a function naming variable from
6534    NAME. NAME may be NULL, in which case we generate a special
6535    ERROR_MARK node which should be replaced later. */
6536
6537 tree
6538 cp_fname_init (name)
6539      const char *name;
6540 {
6541   tree domain = NULL_TREE;
6542   tree type;
6543   tree init = NULL_TREE;
6544   size_t length = 0;
6545
6546   if (name)
6547     {
6548       length = strlen (name);
6549       domain = build_index_type (size_int (length));
6550       init = build_string (length + 1, name);
6551     }
6552
6553   type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
6554   type = build_cplus_array_type (type, domain);
6555
6556   if (init)
6557     TREE_TYPE (init) = type;
6558   else
6559     /* We don't know the value until instantiation time. Make
6560        something which will be digested now, but replaced later. */
6561     init = build (ERROR_MARK, type);
6562
6563   return init;
6564 }
6565
6566 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6567    decl, NAME is the initialization string and TYPE_DEP indicates whether
6568    NAME depended on the type of the function. We make use of that to detect
6569    __PRETTY_FUNCTION__ inside a template fn. This is being done
6570    lazily at the point of first use, so we musn't push the decl now.  */
6571
6572 static tree
6573 cp_make_fname_decl (id, type_dep)
6574      tree id;
6575      int type_dep;
6576 {
6577   const char *const name = (type_dep && processing_template_decl
6578                       ? NULL : fname_as_string (type_dep));
6579   tree init = cp_fname_init (name);
6580   tree decl = build_decl (VAR_DECL, id, TREE_TYPE (init));
6581
6582   /* As we don't push the decl here, we must set the context. */
6583   DECL_CONTEXT (decl) = current_function_decl;
6584   DECL_PRETTY_FUNCTION_P (decl) = type_dep;
6585
6586   TREE_STATIC (decl) = 1;
6587   TREE_READONLY (decl) = 1;
6588   DECL_ARTIFICIAL (decl) = 1;
6589   DECL_INITIAL (decl) = init;
6590
6591   TREE_USED (decl) = 1;
6592
6593   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6594
6595   return decl;
6596 }
6597
6598 /* Entry point for the benefit of c_common_nodes_and_builtins.
6599
6600    Make a definition for a builtin function named NAME and whose data type
6601    is TYPE.  TYPE should be a function type with argument types.
6602
6603    CLASS and CODE tell later passes how to compile calls to this function.
6604    See tree.h for possible values.
6605
6606    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6607    the name to be called if we can't opencode the function.  */
6608
6609 tree
6610 builtin_function (name, type, code, class, libname)
6611      const char *name;
6612      tree type;
6613      int code;
6614      enum built_in_class class;
6615      const char *libname;
6616 {
6617   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6618   DECL_BUILT_IN_CLASS (decl) = class;
6619   DECL_FUNCTION_CODE (decl) = code;
6620
6621   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6622
6623   /* All builtins that don't begin with an `_' should go in the `std'
6624      namespace.  */
6625   if (name[0] != '_')
6626     {
6627       push_namespace (std_identifier);
6628       DECL_CONTEXT (decl) = std_node;
6629     }
6630   pushdecl (decl);
6631   if (name[0] != '_')
6632     pop_namespace ();
6633
6634   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6635      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6636      function in the namespace.  */
6637   if (libname)
6638     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
6639   make_decl_rtl (decl, NULL);
6640
6641   /* Warn if a function in the namespace for users
6642      is used without an occasion to consider it declared.  */
6643   if (name[0] != '_' || name[1] != '_')
6644     DECL_ANTICIPATED (decl) = 1;
6645
6646   return decl;
6647 }
6648
6649 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6650    function.  Not called directly.  */
6651
6652 static tree
6653 build_library_fn_1 (name, operator_code, type)
6654      tree name;
6655      enum tree_code operator_code;
6656      tree type;
6657 {
6658   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6659   DECL_EXTERNAL (fn) = 1;
6660   TREE_PUBLIC (fn) = 1;
6661   DECL_ARTIFICIAL (fn) = 1;
6662   TREE_NOTHROW (fn) = 1;
6663   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6664   SET_DECL_LANGUAGE (fn, lang_c);
6665   return fn;
6666 }
6667
6668 /* Returns the _DECL for a library function with C linkage.
6669    We assume that such functions never throw; if this is incorrect,
6670    callers should unset TREE_NOTHROW.  */
6671
6672 tree
6673 build_library_fn (name, type)
6674      tree name;
6675      tree type;
6676 {
6677   return build_library_fn_1 (name, ERROR_MARK, type);
6678 }
6679
6680 /* Returns the _DECL for a library function with C++ linkage.  */
6681
6682 static tree
6683 build_cp_library_fn (name, operator_code, type)
6684      tree name;
6685      enum tree_code operator_code;
6686      tree type;
6687 {
6688   tree fn = build_library_fn_1 (name, operator_code, type);
6689   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6690   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6691   SET_DECL_LANGUAGE (fn, lang_cplusplus);
6692   set_mangled_name_for_decl (fn);
6693   return fn;
6694 }
6695
6696 /* Like build_library_fn, but takes a C string instead of an
6697    IDENTIFIER_NODE.  */
6698
6699 tree
6700 build_library_fn_ptr (name, type)
6701      const char *name;
6702      tree type;
6703 {
6704   return build_library_fn (get_identifier (name), type);
6705 }
6706
6707 /* Like build_cp_library_fn, but takes a C string instead of an
6708    IDENTIFIER_NODE.  */
6709
6710 tree
6711 build_cp_library_fn_ptr (name, type)
6712      const char *name;
6713      tree type;
6714 {
6715   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6716 }
6717
6718 /* Like build_library_fn, but also pushes the function so that we will
6719    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6720
6721 tree
6722 push_library_fn (name, type)
6723      tree name, type;
6724 {
6725   tree fn = build_library_fn (name, type);
6726   pushdecl_top_level (fn);
6727   return fn;
6728 }
6729
6730 /* Like build_cp_library_fn, but also pushes the function so that it
6731    will be found by normal lookup.  */
6732
6733 static tree
6734 push_cp_library_fn (operator_code, type)
6735      enum tree_code operator_code;
6736      tree type;
6737 {
6738   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6739                                  operator_code,
6740                                  type);
6741   pushdecl (fn);
6742   return fn;
6743 }
6744
6745 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6746    a FUNCTION_TYPE.  */
6747
6748 tree
6749 push_void_library_fn (name, parmtypes)
6750      tree name, parmtypes;
6751 {
6752   tree type = build_function_type (void_type_node, parmtypes);
6753   return push_library_fn (name, type);
6754 }
6755
6756 /* Like push_library_fn, but also note that this function throws
6757    and does not return.  Used for __throw_foo and the like.  */
6758
6759 tree
6760 push_throw_library_fn (name, type)
6761      tree name, type;
6762 {
6763   tree fn = push_library_fn (name, type);
6764   TREE_THIS_VOLATILE (fn) = 1;
6765   TREE_NOTHROW (fn) = 0;
6766   return fn;
6767 }
6768 \f
6769 /* When we call finish_struct for an anonymous union, we create
6770    default copy constructors and such.  But, an anonymous union
6771    shouldn't have such things; this function undoes the damage to the
6772    anonymous union type T.
6773
6774    (The reason that we create the synthesized methods is that we don't
6775    distinguish `union { int i; }' from `typedef union { int i; } U'.
6776    The first is an anonymous union; the second is just an ordinary
6777    union type.)  */
6778
6779 void
6780 fixup_anonymous_aggr (t)
6781      tree t;
6782 {
6783   tree *q;
6784
6785   /* Wipe out memory of synthesized methods */
6786   TYPE_HAS_CONSTRUCTOR (t) = 0;
6787   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6788   TYPE_HAS_INIT_REF (t) = 0;
6789   TYPE_HAS_CONST_INIT_REF (t) = 0;
6790   TYPE_HAS_ASSIGN_REF (t) = 0;
6791   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6792
6793   /* Splice the implicitly generated functions out of the TYPE_METHODS
6794      list.  */
6795   q = &TYPE_METHODS (t);
6796   while (*q)
6797     {
6798       if (DECL_ARTIFICIAL (*q))
6799         *q = TREE_CHAIN (*q);
6800       else
6801         q = &TREE_CHAIN (*q);
6802     }
6803
6804   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6805   if (TYPE_METHODS (t))
6806     cp_error_at ("an anonymous union cannot have function members", t);
6807
6808   /* Anonymous aggregates cannot have fields with ctors, dtors or complex
6809      assignment operators (because they cannot have these methods themselves).
6810      For anonymous unions this is already checked because they are not allowed
6811      in any union, otherwise we have to check it.  */
6812   if (TREE_CODE (t) != UNION_TYPE)
6813     {
6814       tree field, type;
6815
6816       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
6817         if (TREE_CODE (field) == FIELD_DECL)
6818           {
6819             type = TREE_TYPE (field);
6820             if (CLASS_TYPE_P (type))
6821               {
6822                 if (TYPE_NEEDS_CONSTRUCTING (type))
6823                   cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
6824                                field);
6825                 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6826                   cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
6827                                field);
6828                 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
6829                   cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
6830                                field);
6831               }
6832           }
6833     }
6834 }
6835
6836 /* Make sure that a declaration with no declarator is well-formed, i.e.
6837    just defines a tagged type or anonymous union.
6838
6839    Returns the type defined, if any.  */
6840
6841 tree
6842 check_tag_decl (declspecs)
6843      tree declspecs;
6844 {
6845   int found_type = 0;
6846   int saw_friend = 0;
6847   int saw_typedef = 0;
6848   tree ob_modifier = NULL_TREE;
6849   register tree link;
6850   register tree t = NULL_TREE;
6851
6852   for (link = declspecs; link; link = TREE_CHAIN (link))
6853     {
6854       register tree value = TREE_VALUE (link);
6855
6856       if (TYPE_P (value)
6857           || TREE_CODE (value) == TYPE_DECL
6858           || (TREE_CODE (value) == IDENTIFIER_NODE
6859               && IDENTIFIER_GLOBAL_VALUE (value)
6860               && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value)) == TYPE_DECL))
6861         {
6862           ++found_type;
6863
6864           if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
6865             {
6866               if (! in_system_header)
6867                 cp_pedwarn ("redeclaration of C++ built-in type `%T'", value);
6868               return NULL_TREE;
6869             }
6870
6871           if (TYPE_P (value)
6872               && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
6873                   || TREE_CODE (value) == ENUMERAL_TYPE))
6874             {
6875               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6876               t = value;
6877             }
6878         }
6879       else if (value == ridpointers[(int) RID_TYPEDEF])
6880         saw_typedef = 1;
6881       else if (value == ridpointers[(int) RID_FRIEND])
6882         {
6883           if (current_class_type == NULL_TREE
6884               || current_scope () != current_class_type)
6885             ob_modifier = value;
6886           else
6887             saw_friend = 1;
6888         }
6889       else if (value == ridpointers[(int) RID_STATIC]
6890                || value == ridpointers[(int) RID_EXTERN]
6891                || value == ridpointers[(int) RID_AUTO]
6892                || value == ridpointers[(int) RID_REGISTER]
6893                || value == ridpointers[(int) RID_INLINE]
6894                || value == ridpointers[(int) RID_VIRTUAL]
6895                || value == ridpointers[(int) RID_CONST]
6896                || value == ridpointers[(int) RID_VOLATILE]
6897                || value == ridpointers[(int) RID_EXPLICIT])
6898         ob_modifier = value;
6899     }
6900
6901   if (found_type > 1)
6902     error ("multiple types in one declaration");
6903
6904   if (t == NULL_TREE && ! saw_friend)
6905     pedwarn ("declaration does not declare anything");
6906
6907   /* Check for an anonymous union.  */
6908   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
6909            && TYPE_ANONYMOUS_P (t))
6910     {
6911       /* 7/3 In a simple-declaration, the optional init-declarator-list
6912          can be omitted only when declaring a class (clause 9) or
6913          enumeration (7.2), that is, when the decl-specifier-seq contains
6914          either a class-specifier, an elaborated-type-specifier with
6915          a class-key (9.1), or an enum-specifier.  In these cases and
6916          whenever a class-specifier or enum-specifier is present in the
6917          decl-specifier-seq, the identifiers in these specifiers are among
6918          the names being declared by the declaration (as class-name,
6919          enum-names, or enumerators, depending on the syntax).  In such
6920          cases, and except for the declaration of an unnamed bit-field (9.6),
6921          the decl-specifier-seq shall introduce one or more names into the
6922          program, or shall redeclare a name introduced by a previous
6923          declaration.  [Example:
6924              enum { };            // ill-formed
6925              typedef class { };   // ill-formed
6926          --end example]  */
6927       if (saw_typedef)
6928         {
6929           error ("Missing type-name in typedef-declaration.");
6930           return NULL_TREE;
6931         }
6932       /* Anonymous unions are objects, so they can have specifiers.  */;
6933       SET_ANON_AGGR_TYPE_P (t);
6934
6935       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
6936         pedwarn ("ISO C++ prohibits anonymous structs");
6937     }
6938
6939   else if (ob_modifier)
6940     {
6941       if (ob_modifier == ridpointers[(int) RID_INLINE]
6942           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6943         cp_error ("`%D' can only be specified for functions", ob_modifier);
6944       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
6945         cp_error ("`%D' can only be specified inside a class", ob_modifier);
6946       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6947         cp_error ("`%D' can only be specified for constructors",
6948                   ob_modifier);
6949       else
6950         cp_error ("`%D' can only be specified for objects and functions",
6951                   ob_modifier);
6952     }
6953
6954   return t;
6955 }
6956
6957 /* Called when a declaration is seen that contains no names to declare.
6958    If its type is a reference to a structure, union or enum inherited
6959    from a containing scope, shadow that tag name for the current scope
6960    with a forward reference.
6961    If its type defines a new named structure or union
6962    or defines an enum, it is valid but we need not do anything here.
6963    Otherwise, it is an error.
6964
6965    C++: may have to grok the declspecs to learn about static,
6966    complain for anonymous unions.  */
6967
6968 void
6969 shadow_tag (declspecs)
6970      tree declspecs;
6971 {
6972   tree t = check_tag_decl (declspecs);
6973
6974   if (t)
6975     maybe_process_partial_specialization (t);
6976
6977   /* This is where the variables in an anonymous union are
6978      declared.  An anonymous union declaration looks like:
6979      union { ... } ;
6980      because there is no declarator after the union, the parser
6981      sends that declaration here.  */
6982   if (t && ANON_AGGR_TYPE_P (t))
6983     {
6984       fixup_anonymous_aggr (t);
6985
6986       if (TYPE_FIELDS (t))
6987         {
6988           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
6989                                       NULL);
6990           finish_anon_union (decl);
6991         }
6992     }
6993 }
6994 \f
6995 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
6996
6997 tree
6998 groktypename (typename)
6999      tree typename;
7000 {
7001   if (TREE_CODE (typename) != TREE_LIST)
7002     return typename;
7003   return grokdeclarator (TREE_VALUE (typename),
7004                          TREE_PURPOSE (typename),
7005                          TYPENAME, 0, NULL);
7006 }
7007
7008 /* Decode a declarator in an ordinary declaration or data definition.
7009    This is called as soon as the type information and variable name
7010    have been parsed, before parsing the initializer if any.
7011    Here we create the ..._DECL node, fill in its type,
7012    and put it on the list of decls for the current context.
7013    The ..._DECL node is returned as the value.
7014
7015    Exception: for arrays where the length is not specified,
7016    the type is left null, to be filled in by `cp_finish_decl'.
7017
7018    Function definitions do not come here; they go to start_function
7019    instead.  However, external and forward declarations of functions
7020    do go through here.  Structure field declarations are done by
7021    grokfield and not through here.  */
7022
7023 tree
7024 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7025      tree declarator, declspecs;
7026      int initialized;
7027      tree attributes, prefix_attributes;
7028 {
7029   tree decl;
7030   register tree type, tem;
7031   tree context;
7032   extern int have_extern_spec;
7033   extern int used_extern_spec;
7034
7035 #if 0
7036   /* See code below that used this.  */
7037   int init_written = initialized;
7038 #endif
7039
7040   /* This should only be done once on the top most decl.  */
7041   if (have_extern_spec && !used_extern_spec)
7042     {
7043       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7044                              declspecs);
7045       used_extern_spec = 1;
7046     }
7047
7048   attributes = chainon (attributes, prefix_attributes);
7049
7050   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7051                          &attributes);
7052
7053   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7054     return NULL_TREE;
7055
7056   type = TREE_TYPE (decl);
7057
7058   if (type == error_mark_node)
7059     return NULL_TREE;
7060
7061   context = DECL_CONTEXT (decl);
7062
7063   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7064       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7065     {
7066       /* When parsing the initializer, lookup should use the object's
7067          namespace. */
7068       push_decl_namespace (context);
7069     }
7070
7071   /* We are only interested in class contexts, later. */
7072   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7073     context = NULL_TREE;
7074
7075   if (initialized)
7076     /* Is it valid for this decl to have an initializer at all?
7077        If not, set INITIALIZED to zero, which will indirectly
7078        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7079     switch (TREE_CODE (decl))
7080       {
7081       case TYPE_DECL:
7082         /* typedef foo = bar  means give foo the same type as bar.
7083            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7084            Any other case of an initialization in a TYPE_DECL is an error.  */
7085         if (pedantic || list_length (declspecs) > 1)
7086           {
7087             cp_error ("typedef `%D' is initialized", decl);
7088             initialized = 0;
7089           }
7090         break;
7091
7092       case FUNCTION_DECL:
7093         cp_error ("function `%#D' is initialized like a variable", decl);
7094         initialized = 0;
7095         break;
7096
7097       default:
7098         break;
7099       }
7100
7101   if (initialized)
7102     {
7103       if (! toplevel_bindings_p ()
7104           && DECL_EXTERNAL (decl))
7105         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7106                     decl);
7107       DECL_EXTERNAL (decl) = 0;
7108       if (toplevel_bindings_p ())
7109         TREE_STATIC (decl) = 1;
7110
7111       /* Tell `pushdecl' this is an initialized decl
7112          even though we don't yet have the initializer expression.
7113          Also tell `cp_finish_decl' it may store the real initializer.  */
7114       DECL_INITIAL (decl) = error_mark_node;
7115     }
7116
7117   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7118   cplus_decl_attributes (&decl, attributes, 0);
7119
7120   if (context && COMPLETE_TYPE_P (complete_type (context)))
7121     {
7122       push_nested_class (context, 2);
7123
7124       if (TREE_CODE (decl) == VAR_DECL)
7125         {
7126           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7127           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7128             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7129           else
7130             {
7131               if (DECL_CONTEXT (field) != context)
7132                 {
7133                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7134                               DECL_CONTEXT (field), DECL_NAME (decl),
7135                               context, DECL_NAME (decl));
7136                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7137                 }
7138               /* Static data member are tricky; an in-class initialization
7139                  still doesn't provide a definition, so the in-class
7140                  declaration will have DECL_EXTERNAL set, but will have an
7141                  initialization.  Thus, duplicate_decls won't warn
7142                  about this situation, and so we check here.  */
7143               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7144                 cp_error ("duplicate initialization of %D", decl);
7145               if (duplicate_decls (decl, field))
7146                 decl = field;
7147             }
7148         }
7149       else
7150         {
7151           tree field = check_classfn (context, decl);
7152           if (field && duplicate_decls (decl, field))
7153             decl = field;
7154         }
7155
7156       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7157       DECL_IN_AGGR_P (decl) = 0;
7158       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7159           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7160         {
7161           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7162           /* [temp.expl.spec] An explicit specialization of a static data
7163              member of a template is a definition if the declaration
7164              includes an initializer; otherwise, it is a declaration.
7165
7166              We check for processing_specialization so this only applies
7167              to the new specialization syntax.  */
7168           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7169             DECL_EXTERNAL (decl) = 1;
7170         }
7171
7172       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7173         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7174                     decl);
7175     }
7176
7177   /* Enter this declaration into the symbol table.  */
7178   tem = maybe_push_decl (decl);
7179
7180   if (processing_template_decl)
7181     tem = push_template_decl (tem);
7182
7183 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7184   /* Tell the back-end to use or not use .common as appropriate.  If we say
7185      -fconserve-space, we want this to save .data space, at the expense of
7186      wrong semantics.  If we say -fno-conserve-space, we want this to
7187      produce errors about redefs; to do this we force variables into the
7188      data segment.  */
7189   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7190 #endif
7191
7192   if (! processing_template_decl)
7193     start_decl_1 (tem);
7194
7195   return tem;
7196 }
7197
7198 void
7199 start_decl_1 (decl)
7200      tree decl;
7201 {
7202   tree type = TREE_TYPE (decl);
7203   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7204
7205   if (type == error_mark_node)
7206     return;
7207
7208   maybe_push_cleanup_level (type);
7209
7210   if (initialized)
7211     /* Is it valid for this decl to have an initializer at all?
7212        If not, set INITIALIZED to zero, which will indirectly
7213        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7214     {
7215       /* Don't allow initializations for incomplete types except for
7216          arrays which might be completed by the initialization.  */
7217       if (COMPLETE_TYPE_P (complete_type (type)))
7218         ;                       /* A complete type is ok.  */
7219       else if (TREE_CODE (type) != ARRAY_TYPE)
7220         {
7221           cp_error ("variable `%#D' has initializer but incomplete type",
7222                     decl);
7223           initialized = 0;
7224           type = TREE_TYPE (decl) = error_mark_node;
7225         }
7226       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7227         {
7228           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7229             cp_error ("elements of array `%#D' have incomplete type", decl);
7230           /* else we already gave an error in start_decl.  */
7231           initialized = 0;
7232         }
7233     }
7234
7235   if (!initialized
7236       && TREE_CODE (decl) != TYPE_DECL
7237       && TREE_CODE (decl) != TEMPLATE_DECL
7238       && type != error_mark_node
7239       && IS_AGGR_TYPE (type)
7240       && ! DECL_EXTERNAL (decl))
7241     {
7242       if ((! processing_template_decl || ! uses_template_parms (type))
7243           && !COMPLETE_TYPE_P (complete_type (type)))
7244         {
7245           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7246                  decl);
7247           /* Change the type so that assemble_variable will give
7248              DECL an rtl we can live with: (mem (const_int 0)).  */
7249           type = TREE_TYPE (decl) = error_mark_node;
7250         }
7251       else
7252         {
7253           /* If any base type in the hierarchy of TYPE needs a constructor,
7254              then we set initialized to 1.  This way any nodes which are
7255              created for the purposes of initializing this aggregate
7256              will live as long as it does.  This is necessary for global
7257              aggregates which do not have their initializers processed until
7258              the end of the file.  */
7259           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7260         }
7261     }
7262
7263   if (! initialized)
7264     DECL_INITIAL (decl) = NULL_TREE;
7265 }
7266
7267 /* Handle initialization of references.
7268    These three arguments are from `cp_finish_decl', and have the
7269    same meaning here that they do there.
7270
7271    Quotes on semantics can be found in ARM 8.4.3.  */
7272
7273 static tree
7274 grok_reference_init (decl, type, init)
7275      tree decl, type, init;
7276 {
7277   tree tmp;
7278
7279   if (init == NULL_TREE)
7280     {
7281       if ((DECL_LANG_SPECIFIC (decl) == 0
7282            || DECL_IN_AGGR_P (decl) == 0)
7283           && ! DECL_THIS_EXTERN (decl))
7284         cp_error ("`%D' declared as reference but not initialized", decl);
7285       return NULL_TREE;
7286     }
7287
7288   if (init == error_mark_node)
7289     return NULL_TREE;
7290
7291   if (TREE_CODE (init) == CONSTRUCTOR)
7292     {
7293       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7294       return NULL_TREE;
7295     }
7296
7297   if (TREE_CODE (init) == TREE_LIST)
7298     init = build_compound_expr (init);
7299
7300   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7301     init = convert_from_reference (init);
7302
7303   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7304       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7305     {
7306       /* Note: default conversion is only called in very special cases.  */
7307       init = default_conversion (init);
7308     }
7309
7310   /* Convert INIT to the reference type TYPE.  This may involve the
7311      creation of a temporary, whose lifetime must be the same as that
7312      of the reference.  If so, a DECL_STMT for the temporary will be
7313      added just after the DECL_STMT for DECL.  That's why we don't set
7314      DECL_INITIAL for local references (instead assigning to them
7315      explicitly); we need to allow the temporary to be initialized
7316      first.  */
7317   tmp = convert_to_reference
7318     (type, init, CONV_IMPLICIT,
7319      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7320      decl);
7321
7322   if (tmp == error_mark_node)
7323     return NULL_TREE;
7324   else if (tmp == NULL_TREE)
7325     {
7326       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7327       return NULL_TREE;
7328     }
7329
7330   if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
7331     return tmp;
7332
7333   DECL_INITIAL (decl) = tmp;
7334
7335   return NULL_TREE;
7336 }
7337
7338 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7339    mucking with forces it does not comprehend (i.e. initialization with a
7340    constructor).  If we are at global scope and won't go into COMMON, fill
7341    it in with a dummy CONSTRUCTOR to force the variable into .data;
7342    otherwise we can use error_mark_node.  */
7343
7344 static tree
7345 obscure_complex_init (decl, init)
7346      tree decl, init;
7347 {
7348   if (! flag_no_inline && TREE_STATIC (decl))
7349     {
7350       if (extract_init (decl, init))
7351         return NULL_TREE;
7352     }
7353
7354 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7355   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7356     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7357                                  NULL_TREE);
7358   else
7359 #endif
7360     DECL_INITIAL (decl) = error_mark_node;
7361
7362   return init;
7363 }
7364
7365 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7366    array until we finish parsing the initializer.  If that's the
7367    situation we're in, update DECL accordingly.  */
7368
7369 static void
7370 maybe_deduce_size_from_array_init (decl, init)
7371      tree decl;
7372      tree init;
7373 {
7374   tree type = TREE_TYPE (decl);
7375
7376   if (TREE_CODE (type) == ARRAY_TYPE
7377       && TYPE_DOMAIN (type) == NULL_TREE
7378       && TREE_CODE (decl) != TYPE_DECL)
7379     {
7380       /* do_default is really a C-ism to deal with tentative definitions.
7381          But let's leave it here to ease the eventual merge.  */
7382       int do_default = !DECL_EXTERNAL (decl);
7383       tree initializer = init ? init : DECL_INITIAL (decl);
7384       int failure = complete_array_type (type, initializer, do_default);
7385
7386       if (failure == 1)
7387         cp_error ("initializer fails to determine size of `%D'", decl);
7388
7389       if (failure == 2)
7390         {
7391           if (do_default)
7392             cp_error ("array size missing in `%D'", decl);
7393           /* If a `static' var's size isn't known, make it extern as
7394              well as static, so it does not get allocated.  If it's not
7395              `static', then don't mark it extern; finish_incomplete_decl
7396              will give it a default size and it will get allocated.  */
7397           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7398             DECL_EXTERNAL (decl) = 1;
7399         }
7400
7401       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7402           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7403                               integer_zero_node))
7404         cp_error ("zero-size array `%D'", decl);
7405
7406       layout_decl (decl, 0);
7407     }
7408 }
7409
7410 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7411    any appropriate error messages regarding the layout.  */
7412
7413 static void
7414 layout_var_decl (decl)
7415      tree decl;
7416 {
7417   tree type = TREE_TYPE (decl);
7418 #if 0
7419   tree ttype = target_type (type);
7420 #endif
7421
7422   /* If we haven't already layed out this declaration, do so now.
7423      Note that we must not call complete type for an external object
7424      because it's type might involve templates that we are not
7425      supposed to isntantiate yet.  (And it's perfectly legal to say
7426      `extern X x' for some incomplete type `X'.)  */
7427   if (!DECL_EXTERNAL (decl))
7428     complete_type (type);
7429   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7430     layout_decl (decl, 0);
7431
7432   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7433     {
7434       /* An automatic variable with an incomplete type: that is an error.
7435          Don't talk about array types here, since we took care of that
7436          message in grokdeclarator.  */
7437       cp_error ("storage size of `%D' isn't known", decl);
7438       TREE_TYPE (decl) = error_mark_node;
7439     }
7440 #if 0
7441   /* Keep this code around in case we later want to control debug info
7442      based on whether a type is "used".  (jason 1999-11-11) */
7443
7444   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7445     /* Let debugger know it should output info for this type.  */
7446     note_debug_info_needed (ttype);
7447
7448   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7449     note_debug_info_needed (DECL_CONTEXT (decl));
7450 #endif
7451
7452   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7453       && DECL_SIZE (decl) != NULL_TREE
7454       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7455     {
7456       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7457         constant_expression_warning (DECL_SIZE (decl));
7458       else
7459         cp_error ("storage size of `%D' isn't constant", decl);
7460     }
7461
7462   if (TREE_STATIC (decl)
7463       && !DECL_ARTIFICIAL (decl)
7464       && current_function_decl
7465       && DECL_CONTEXT (decl) == current_function_decl)
7466     push_local_name (decl);
7467 }
7468
7469 /* If a local static variable is declared in an inline function, or if
7470    we have a weak definition, we must endeavor to create only one
7471    instance of the variable at link-time.  */
7472
7473 static void
7474 maybe_commonize_var (decl)
7475      tree decl;
7476 {
7477   /* Static data in a function with comdat linkage also has comdat
7478      linkage.  */
7479   if (TREE_STATIC (decl)
7480       /* Don't mess with __FUNCTION__.  */
7481       && ! DECL_ARTIFICIAL (decl)
7482       && current_function_decl
7483       && DECL_CONTEXT (decl) == current_function_decl
7484       && (DECL_DECLARED_INLINE_P (current_function_decl)
7485           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7486       && TREE_PUBLIC (current_function_decl))
7487     {
7488       /* If flag_weak, we don't need to mess with this, as we can just
7489          make the function weak, and let it refer to its unique local
7490          copy.  This works because we don't allow the function to be
7491          inlined.  */
7492       if (! flag_weak)
7493         {
7494           if (DECL_INTERFACE_KNOWN (current_function_decl))
7495             {
7496               TREE_PUBLIC (decl) = 1;
7497               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7498             }
7499           else if (DECL_INITIAL (decl) == NULL_TREE
7500                    || DECL_INITIAL (decl) == error_mark_node)
7501             {
7502               TREE_PUBLIC (decl) = 1;
7503               DECL_COMMON (decl) = 1;
7504             }
7505           /* else we lose. We can only do this if we can use common,
7506              which we can't if it has been initialized.  */
7507
7508           if (!TREE_PUBLIC (decl))
7509             {
7510               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7511               cp_warning_at ("  you can work around this by removing the initializer", decl);
7512             }
7513         }
7514       else
7515         comdat_linkage (decl);
7516     }
7517   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7518     /* Set it up again; we might have set DECL_INITIAL since the last
7519        time.  */
7520     comdat_linkage (decl);
7521 }
7522
7523 /* Issue an error message if DECL is an uninitialized const variable.  */
7524
7525 static void
7526 check_for_uninitialized_const_var (decl)
7527      tree decl;
7528 {
7529   tree type = TREE_TYPE (decl);
7530
7531   /* ``Unless explicitly declared extern, a const object does not have
7532      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7533      7.1.6 */
7534   if (TREE_CODE (decl) == VAR_DECL
7535       && TREE_CODE (type) != REFERENCE_TYPE
7536       && CP_TYPE_CONST_P (type)
7537       && !TYPE_NEEDS_CONSTRUCTING (type)
7538       && !DECL_INITIAL (decl))
7539     cp_error ("uninitialized const `%D'", decl);
7540 }
7541
7542 /* Verify INIT (the initializer for DECL), and record the
7543    initialization in DECL_INITIAL, if appropriate.  Returns a new
7544    value for INIT.  */
7545
7546 static tree
7547 check_initializer (decl, init)
7548      tree decl;
7549      tree init;
7550 {
7551   tree type;
7552
7553   if (TREE_CODE (decl) == FIELD_DECL)
7554     return init;
7555
7556   type = TREE_TYPE (decl);
7557
7558   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7559   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7560     init = NULL_TREE;
7561
7562   /* Check the initializer.  */
7563   if (init)
7564     {
7565       /* Things that are going to be initialized need to have complete
7566          type.  */
7567       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7568
7569       if (type == error_mark_node)
7570         /* We will have already complained.  */
7571         init = NULL_TREE;
7572       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7573         {
7574           cp_error ("variable-sized object `%D' may not be initialized", decl);
7575           init = NULL_TREE;
7576         }
7577       else if (TREE_CODE (type) == ARRAY_TYPE
7578                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7579         {
7580           cp_error ("elements of array `%#D' have incomplete type", decl);
7581           init = NULL_TREE;
7582         }
7583       else if (!COMPLETE_TYPE_P (type))
7584         {
7585           cp_error ("`%D' has incomplete type", decl);
7586           TREE_TYPE (decl) = error_mark_node;
7587           init = NULL_TREE;
7588         }
7589     }
7590
7591   if (TREE_CODE (decl) == CONST_DECL)
7592     {
7593       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7594
7595       DECL_INITIAL (decl) = init;
7596
7597       my_friendly_assert (init != NULL_TREE, 149);
7598       init = NULL_TREE;
7599     }
7600   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7601     {
7602       init = grok_reference_init (decl, type, init);
7603       if (init)
7604         init = obscure_complex_init (decl, init);
7605     }
7606   else if (init)
7607     {
7608       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7609         {
7610           if (TREE_CODE (type) == ARRAY_TYPE)
7611             init = digest_init (type, init, (tree *) 0);
7612           else if (TREE_CODE (init) == CONSTRUCTOR
7613                    && TREE_HAS_CONSTRUCTOR (init))
7614             {
7615               if (TYPE_NON_AGGREGATE_CLASS (type))
7616                 {
7617                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7618                             decl);
7619                   init = error_mark_node;
7620                 }
7621               else
7622                 goto dont_use_constructor;
7623             }
7624         }
7625       else
7626         {
7627         dont_use_constructor:
7628           if (TREE_CODE (init) != TREE_VEC)
7629             init = store_init_value (decl, init);
7630         }
7631
7632       if (init)
7633         /* We must hide the initializer so that expand_decl
7634            won't try to do something it does not understand.  */
7635         init = obscure_complex_init (decl, init);
7636     }
7637   else if (DECL_EXTERNAL (decl))
7638     ;
7639   else if (TYPE_P (type)
7640            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7641     {
7642       tree core_type = strip_array_types (type);
7643
7644       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7645         {
7646           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7647             cp_error ("structure `%D' with uninitialized const members", decl);
7648           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7649             cp_error ("structure `%D' with uninitialized reference members",
7650                       decl);
7651         }
7652
7653       check_for_uninitialized_const_var (decl);
7654
7655       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7656         init = obscure_complex_init (decl, NULL_TREE);
7657
7658     }
7659   else
7660     check_for_uninitialized_const_var (decl);
7661
7662   return init;
7663 }
7664
7665 /* If DECL is not a local variable, give it RTL.  */
7666
7667 static void
7668 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7669      tree decl;
7670      tree init;
7671      const char *asmspec;
7672 {
7673   int toplev = toplevel_bindings_p ();
7674   int defer_p;
7675
7676   /* Handle non-variables up front.  */
7677   if (TREE_CODE (decl) != VAR_DECL)
7678     {
7679       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7680       return;
7681     }
7682
7683   /* If we see a class member here, it should be a static data
7684      member.  */
7685   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7686     {
7687       my_friendly_assert (TREE_STATIC (decl), 19990828);
7688       /* An in-class declaration of a static data member should be
7689          external; it is only a declaration, and not a definition.  */
7690       if (init == NULL_TREE)
7691         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7692     }
7693
7694   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7695   if (asmspec)
7696     {
7697       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
7698       /* The `register' keyword, when used together with an
7699          asm-specification, indicates that the variable should be
7700          placed in a particular register.  */
7701       if (DECL_REGISTER (decl))
7702         DECL_C_HARD_REGISTER (decl) = 1;
7703     }
7704
7705   /* We don't create any RTL for local variables.  */
7706   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7707     return;
7708
7709   /* We defer emission of local statics until the corresponding
7710      DECL_STMT is expanded.  */
7711   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7712
7713   /* We try to defer namespace-scope static constants so that they are
7714      not emitted into the object file unncessarily.  */
7715   if (!DECL_VIRTUAL_P (decl)
7716       && TREE_READONLY (decl)
7717       && DECL_INITIAL (decl) != NULL_TREE
7718       && DECL_INITIAL (decl) != error_mark_node
7719       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7720       && toplev
7721       && !TREE_PUBLIC (decl))
7722     {
7723       /* Fool with the linkage according to #pragma interface.  */
7724       if (!interface_unknown)
7725         {
7726           TREE_PUBLIC (decl) = 1;
7727           DECL_EXTERNAL (decl) = interface_only;
7728         }
7729
7730       defer_p = 1;
7731     }
7732
7733   /* If we're deferring the variable, we only need to make RTL if
7734      there's an ASMSPEC.  Otherwise, we'll lazily create it later when
7735      we need it.  (There's no way to lazily create RTL for things that
7736      have assembly specs because the information about the specifier
7737      isn't stored in the tree, yet)  */
7738   if (defer_p && asmspec)
7739     make_decl_rtl (decl, asmspec);
7740   /* If we're not deferring, go ahead and assemble the variable.  */
7741   else if (!defer_p)
7742     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7743 }
7744
7745 /* The old ARM scoping rules injected variables declared in the
7746    initialization statement of a for-statement into the surrounding
7747    scope.  We support this usage, in order to be backward-compatible.
7748    DECL is a just-declared VAR_DECL; if necessary inject its
7749    declaration into the surrounding scope.  */
7750
7751 void
7752 maybe_inject_for_scope_var (decl)
7753      tree decl;
7754 {
7755   if (!DECL_NAME (decl))
7756     return;
7757
7758   if (current_binding_level->is_for_scope)
7759     {
7760       struct binding_level *outer
7761         = current_binding_level->level_chain;
7762
7763       /* Check to see if the same name is already bound at the outer
7764          level, either because it was directly declared, or because a
7765          dead for-decl got preserved.  In either case, the code would
7766          not have been valid under the ARM scope rules, so clear
7767          is_for_scope for the current_binding_level.
7768
7769          Otherwise, we need to preserve the temp slot for decl to last
7770          into the outer binding level.  */
7771
7772       tree outer_binding
7773         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7774
7775       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7776           && (TREE_CODE (BINDING_VALUE (outer_binding))
7777               == VAR_DECL)
7778           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7779         {
7780           BINDING_VALUE (outer_binding)
7781             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7782           current_binding_level->is_for_scope = 0;
7783         }
7784       else if (DECL_IN_MEMORY_P (decl))
7785         preserve_temp_slots (DECL_RTL (decl));
7786     }
7787 }
7788
7789 /* Generate code to initialize DECL (a local variable).  */
7790
7791 void
7792 initialize_local_var (decl, init, flags)
7793      tree decl;
7794      tree init;
7795      int flags;
7796 {
7797   tree type = TREE_TYPE (decl);
7798
7799   /* If the type is bogus, don't bother initializing the variable.  */
7800   if (type == error_mark_node)
7801     return;
7802
7803   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7804     {
7805       /* If we used it already as memory, it must stay in memory.  */
7806       DECL_INITIAL (decl) = NULL_TREE;
7807       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7808     }
7809
7810   /* Local statics are handled differently from ordinary automatic
7811      variables.  */
7812   if (TREE_STATIC (decl))
7813     {
7814       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7815           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7816         expand_static_init (decl, init);
7817       return;
7818     }
7819
7820   if (DECL_SIZE (decl) && type != error_mark_node)
7821     {
7822       int already_used;
7823
7824       /* Compute and store the initial value.  */
7825       already_used = TREE_USED (decl) || TREE_USED (type);
7826
7827       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7828         {
7829           int saved_stmts_are_full_exprs_p;
7830
7831           my_friendly_assert (building_stmt_tree (), 20000906);
7832           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7833           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
7834           finish_expr_stmt (build_aggr_init (decl, init, flags));
7835           current_stmt_tree ()->stmts_are_full_exprs_p =
7836             saved_stmts_are_full_exprs_p;
7837         }
7838
7839       /* Set this to 0 so we can tell whether an aggregate which was
7840          initialized was ever used.  Don't do this if it has a
7841          destructor, so we don't complain about the 'resource
7842          allocation is initialization' idiom.  Now set
7843          attribute((unused)) on types so decls of that type will be
7844          marked used. (see TREE_USED, above.)  */
7845       if (TYPE_NEEDS_CONSTRUCTING (type)
7846           && ! already_used
7847           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7848           && DECL_NAME (decl))
7849         TREE_USED (decl) = 0;
7850       else if (already_used)
7851         TREE_USED (decl) = 1;
7852     }
7853 }
7854
7855 /* Generate code to destroy DECL (a local variable).  */
7856
7857 static void
7858 destroy_local_var (decl)
7859      tree decl;
7860 {
7861   tree type = TREE_TYPE (decl);
7862   tree cleanup;
7863
7864   /* Only variables get cleaned up.  */
7865   if (TREE_CODE (decl) != VAR_DECL)
7866     return;
7867
7868   /* And only things with destructors need cleaning up.  */
7869   if (type == error_mark_node
7870       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7871     return;
7872
7873   if (TREE_CODE (decl) == VAR_DECL &&
7874       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7875     /* We don't clean up things that aren't defined in this
7876        translation unit, or that need a static cleanup.  The latter
7877        are handled by finish_file.  */
7878     return;
7879
7880   /* Compute the cleanup.  */
7881   cleanup = maybe_build_cleanup (decl);
7882
7883   /* Record the cleanup required for this declaration.  */
7884   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7885       && cleanup)
7886     finish_decl_cleanup (decl, cleanup);
7887 }
7888
7889 /* Finish processing of a declaration;
7890    install its line number and initial value.
7891    If the length of an array type is not known before,
7892    it must be determined now, from the initial value, or it is an error.
7893
7894    INIT holds the value of an initializer that should be allowed to escape
7895    the normal rules.
7896
7897    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
7898    if the (init) syntax was used.  */
7899
7900 void
7901 cp_finish_decl (decl, init, asmspec_tree, flags)
7902      tree decl, init;
7903      tree asmspec_tree;
7904      int flags;
7905 {
7906   register tree type;
7907   tree ttype = NULL_TREE;
7908   const char *asmspec = NULL;
7909   int was_readonly = 0;
7910
7911   if (! decl)
7912     {
7913       if (init)
7914         error ("assignment (not initialization) in declaration");
7915       return;
7916     }
7917
7918   /* If a name was specified, get the string.  */
7919   if (asmspec_tree)
7920       asmspec = TREE_STRING_POINTER (asmspec_tree);
7921
7922   if (init && TREE_CODE (init) == NAMESPACE_DECL)
7923     {
7924       cp_error ("cannot initialize `%D' to namespace `%D'",
7925                 decl, init);
7926       init = NULL_TREE;
7927     }
7928
7929   if (current_class_type
7930       && CP_DECL_CONTEXT (decl) == current_class_type
7931       && TYPE_BEING_DEFINED (current_class_type)
7932       && (DECL_INITIAL (decl) || init))
7933     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
7934
7935   if (TREE_CODE (decl) == VAR_DECL
7936       && DECL_CONTEXT (decl)
7937       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
7938       && DECL_CONTEXT (decl) != current_namespace
7939       && init)
7940     {
7941       /* Leave the namespace of the object. */
7942       pop_decl_namespace ();
7943     }
7944
7945   type = TREE_TYPE (decl);
7946
7947   if (type == error_mark_node)
7948     return;
7949
7950   if (TYPE_HAS_MUTABLE_P (type))
7951     TREE_READONLY (decl) = 0;
7952
7953   if (processing_template_decl)
7954     {
7955       /* Add this declaration to the statement-tree.  */
7956       if (at_function_scope_p ()
7957           && TREE_CODE (decl) != RESULT_DECL)
7958         add_decl_stmt (decl);
7959
7960       if (init && DECL_INITIAL (decl))
7961         DECL_INITIAL (decl) = init;
7962       goto finish_end0;
7963     }
7964
7965   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
7966   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
7967
7968   /* Take care of TYPE_DECLs up front.  */
7969   if (TREE_CODE (decl) == TYPE_DECL)
7970     {
7971       if (init && DECL_INITIAL (decl))
7972         {
7973           /* typedef foo = bar; store the type of bar as the type of foo.  */
7974           TREE_TYPE (decl) = type = TREE_TYPE (init);
7975           DECL_INITIAL (decl) = init = NULL_TREE;
7976         }
7977       if (type != error_mark_node
7978           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
7979         {
7980           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
7981             cp_warning ("shadowing previous type declaration of `%#D'", decl);
7982           set_identifier_type_value (DECL_NAME (decl), type);
7983           CLASSTYPE_GOT_SEMICOLON (type) = 1;
7984         }
7985       GNU_xref_decl (current_function_decl, decl);
7986
7987       /* If we have installed this as the canonical typedef for this
7988          type, and that type has not been defined yet, delay emitting
7989          the debug information for it, as we will emit it later.  */
7990       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
7991           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
7992         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
7993
7994       rest_of_decl_compilation (decl, NULL,
7995                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
7996       goto finish_end;
7997     }
7998
7999   if (TREE_CODE (decl) != FUNCTION_DECL)
8000     ttype = target_type (type);
8001
8002   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8003       && TYPE_NEEDS_CONSTRUCTING (type))
8004     {
8005       /* Currently, GNU C++ puts constants in text space, making them
8006          impossible to initialize.  In the future, one would hope for
8007          an operating system which understood the difference between
8008          initialization and the running of a program.  */
8009       was_readonly = 1;
8010       TREE_READONLY (decl) = 0;
8011     }
8012
8013   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8014     {
8015       /* This must override the asm specifier which was placed by
8016          grokclassfn.  Lay this out fresh.  */
8017       SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
8018       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8019       make_decl_rtl (decl, asmspec);
8020     }
8021
8022   /* Deduce size of array from initialization, if not already known.  */
8023   maybe_deduce_size_from_array_init (decl, init);
8024   init = check_initializer (decl, init);
8025
8026   GNU_xref_decl (current_function_decl, decl);
8027
8028   /* Add this declaration to the statement-tree.  This needs to happen
8029      after the call to check_initializer so that the DECL_STMT for a
8030      reference temp is added before the DECL_STMT for the reference itself.  */
8031   if (building_stmt_tree ()
8032       && at_function_scope_p ()
8033       && TREE_CODE (decl) != RESULT_DECL)
8034     add_decl_stmt (decl);
8035
8036   if (TREE_CODE (decl) == VAR_DECL)
8037     layout_var_decl (decl);
8038
8039   /* Output the assembler code and/or RTL code for variables and functions,
8040      unless the type is an undefined structure or union.
8041      If not, it will get done when the type is completed.  */
8042   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8043       || TREE_CODE (decl) == RESULT_DECL)
8044     {
8045       if (TREE_CODE (decl) == VAR_DECL)
8046         maybe_commonize_var (decl);
8047
8048       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8049
8050       if (TREE_CODE (type) == FUNCTION_TYPE
8051           || TREE_CODE (type) == METHOD_TYPE)
8052         abstract_virtuals_error (decl,
8053                                  strip_array_types (TREE_TYPE (type)));
8054       else
8055         abstract_virtuals_error (decl, strip_array_types (type));
8056
8057       if (TREE_CODE (decl) == FUNCTION_DECL)
8058         ;
8059       else if (DECL_EXTERNAL (decl)
8060                && ! (DECL_LANG_SPECIFIC (decl)
8061                      && DECL_NOT_REALLY_EXTERN (decl)))
8062         {
8063           if (init)
8064             DECL_INITIAL (decl) = init;
8065         }
8066       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8067         {
8068           /* This is a local declaration.  */
8069           if (doing_semantic_analysis_p ())
8070             maybe_inject_for_scope_var (decl);
8071           /* Initialize the local variable.  But, if we're building a
8072              statement-tree, we'll do the initialization when we
8073              expand the tree.  */
8074           if (processing_template_decl)
8075             {
8076               if (init || DECL_INITIAL (decl) == error_mark_node)
8077                 DECL_INITIAL (decl) = init;
8078             }
8079           else
8080             {
8081               /* If we're not building RTL, then we need to do so
8082                  now.  */
8083               my_friendly_assert (building_stmt_tree (), 20000906);
8084               /* Initialize the variable.  */
8085               initialize_local_var (decl, init, flags);
8086               /* Clean up the variable.  */
8087               destroy_local_var (decl);
8088             }
8089         }
8090       else if (TREE_STATIC (decl) && type != error_mark_node)
8091         {
8092           /* Cleanups for static variables are handled by `finish_file'.  */
8093           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8094               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8095             expand_static_init (decl, init);
8096         }
8097     finish_end0:
8098
8099       /* Undo call to `pushclass' that was done in `start_decl'
8100          due to initialization of qualified member variable.
8101          I.e., Foo::x = 10;  */
8102       {
8103         tree context = CP_DECL_CONTEXT (decl);
8104         if (context
8105             && TYPE_P (context)
8106             && (TREE_CODE (decl) == VAR_DECL
8107                 /* We also have a pushclass done that we need to undo here
8108                    if we're at top level and declare a method.  */
8109                 || TREE_CODE (decl) == FUNCTION_DECL)
8110             /* If size hasn't been set, we're still defining it,
8111                and therefore inside the class body; don't pop
8112                the binding level..  */
8113             && COMPLETE_TYPE_P (context)
8114             && context == current_class_type)
8115           pop_nested_class ();
8116       }
8117     }
8118
8119  finish_end:
8120
8121   if (was_readonly)
8122     TREE_READONLY (decl) = 1;
8123 }
8124
8125 /* This is here for a midend callback from c-common.c */
8126
8127 void
8128 finish_decl (decl, init, asmspec_tree)
8129      tree decl, init;
8130      tree asmspec_tree;
8131 {
8132   cp_finish_decl (decl, init, asmspec_tree, 0);
8133 }
8134
8135 /* Returns a declaration for a VAR_DECL as if:
8136
8137      extern "C" TYPE NAME;
8138
8139    had been seen.  Used to create compiler-generated global
8140    variables.  */
8141
8142 tree
8143 declare_global_var (name, type)
8144      tree name;
8145      tree type;
8146 {
8147   tree decl;
8148
8149   push_to_top_level ();
8150   decl = build_decl (VAR_DECL, name, type);
8151   TREE_PUBLIC (decl) = 1;
8152   DECL_EXTERNAL (decl) = 1;
8153   DECL_ARTIFICIAL (decl) = 1;
8154   pushdecl (decl);
8155   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8156   pop_from_top_level ();
8157
8158   return decl;
8159 }
8160
8161 /* Returns a pointer to the `atexit' function.  Note that if
8162    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8163    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8164
8165 static tree
8166 get_atexit_node ()
8167 {
8168   tree atexit_fndecl;
8169   tree arg_types;
8170   tree fn_type;
8171   tree fn_ptr_type;
8172   const char *name;
8173
8174   if (atexit_node)
8175     return atexit_node;
8176
8177   if (flag_use_cxa_atexit)
8178     {
8179       /* The declaration for `__cxa_atexit' is:
8180
8181            int __cxa_atexit (void (*)(void *), void *, void *)
8182
8183          We build up the argument types and then then function type
8184          itself.  */
8185
8186       /* First, build the pointer-to-function type for the first
8187          argument.  */
8188       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8189       fn_type = build_function_type (void_type_node, arg_types);
8190       fn_ptr_type = build_pointer_type (fn_type);
8191       /* Then, build the rest of the argument types.  */
8192       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8193       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8194       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8195       /* And the final __cxa_atexit type.  */
8196       fn_type = build_function_type (integer_type_node, arg_types);
8197       fn_ptr_type = build_pointer_type (fn_type);
8198       name = "__cxa_atexit";
8199     }
8200   else
8201     {
8202       /* The declaration for `atexit' is:
8203
8204            int atexit (void (*)());
8205
8206          We build up the argument types and then then function type
8207          itself.  */
8208       fn_type = build_function_type (void_type_node, void_list_node);
8209       fn_ptr_type = build_pointer_type (fn_type);
8210       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8211       /* Build the final atexit type.  */
8212       fn_type = build_function_type (integer_type_node, arg_types);
8213       name = "atexit";
8214     }
8215
8216   /* Now, build the function declaration.  */
8217   push_lang_context (lang_name_c);
8218   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8219   mark_used (atexit_fndecl);
8220   pop_lang_context ();
8221   atexit_node = default_conversion (atexit_fndecl);
8222
8223   return atexit_node;
8224 }
8225
8226 /* Returns the __dso_handle VAR_DECL.  */
8227
8228 static tree
8229 get_dso_handle_node ()
8230 {
8231   if (dso_handle_node)
8232     return dso_handle_node;
8233
8234   /* Declare the variable.  */
8235   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8236                                         ptr_type_node);
8237
8238   return dso_handle_node;
8239 }
8240
8241 /* Begin a new function with internal linkage whose job will be simply
8242    to destroy some particular variable.  */
8243
8244 static tree
8245 start_cleanup_fn ()
8246 {
8247   static int counter = 0;
8248   int old_interface_unknown = interface_unknown;
8249   char name[32];
8250   tree parmtypes;
8251   tree fntype;
8252   tree fndecl;
8253
8254   push_to_top_level ();
8255
8256   /* No need to mangle this.  */
8257   push_lang_context (lang_name_c);
8258
8259   interface_unknown = 1;
8260
8261   /* Build the parameter-types.  */
8262   parmtypes = void_list_node;
8263   /* Functions passed to __cxa_atexit take an additional parameter.
8264      We'll just ignore it.  After we implement the new calling
8265      convention for destructors, we can eliminate the use of
8266      additional cleanup functions entirely in the -fnew-abi case.  */
8267   if (flag_use_cxa_atexit)
8268     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8269   /* Build the function type itself.  */
8270   fntype = build_function_type (void_type_node, parmtypes);
8271   /* Build the name of the function.  */
8272   sprintf (name, "__tcf_%d", counter++);
8273   /* Build the function declaration.  */
8274   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8275   /* It's a function with internal linkage, generated by the
8276      compiler.  */
8277   TREE_PUBLIC (fndecl) = 0;
8278   DECL_ARTIFICIAL (fndecl) = 1;
8279   /* Make the function `inline' so that it is only emitted if it is
8280      actually needed.  It is unlikely that it will be inlined, since
8281      it is only called via a function pointer, but we avoid unncessary
8282      emissions this way.  */
8283   DECL_INLINE (fndecl) = 1;
8284   /* Build the parameter.  */
8285   if (flag_use_cxa_atexit)
8286     {
8287       tree parmdecl;
8288
8289       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8290       DECL_CONTEXT (parmdecl) = fndecl;
8291       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8292       TREE_USED (parmdecl) = 1;
8293       DECL_ARGUMENTS (fndecl) = parmdecl;
8294     }
8295
8296   pushdecl (fndecl);
8297   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8298   do_pushlevel ();
8299
8300   interface_unknown = old_interface_unknown;
8301
8302   pop_lang_context ();
8303
8304   return current_function_decl;
8305 }
8306
8307 /* Finish the cleanup function begun by start_cleanup_fn.  */
8308
8309 static void
8310 end_cleanup_fn ()
8311 {
8312   do_poplevel ();
8313
8314   expand_body (finish_function (0));
8315
8316   pop_from_top_level ();
8317 }
8318
8319 /* Generate code to handle the destruction of DECL, an object with
8320    static storage duration.  */
8321
8322 void
8323 register_dtor_fn (decl)
8324      tree decl;
8325 {
8326   tree cleanup;
8327   tree compound_stmt;
8328   tree args;
8329   tree fcall;
8330
8331   int saved_flag_access_control;
8332
8333   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8334     return;
8335
8336   /* Call build_cleanup before we enter the anonymous function so that
8337      any access checks will be done relative to the current scope,
8338      rather than the scope of the anonymous function.  */
8339   build_cleanup (decl);
8340
8341   /* Now start the function.  */
8342   cleanup = start_cleanup_fn ();
8343
8344   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8345      to the original function, rather than the anonymous one.  That
8346      will make the back-end think that nested functions are in use,
8347      which causes confusion.  */
8348   saved_flag_access_control = flag_access_control;
8349   flag_access_control = 0;
8350   fcall = build_cleanup (decl);
8351   flag_access_control = saved_flag_access_control;
8352
8353   /* Create the body of the anonymous function.  */
8354   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8355   finish_expr_stmt (fcall);
8356   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8357   end_cleanup_fn ();
8358
8359   /* Call atexit with the cleanup function.  */
8360   mark_addressable (cleanup);
8361   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8362   if (flag_use_cxa_atexit)
8363     {
8364       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8365       args = tree_cons (NULL_TREE, null_pointer_node, args);
8366       args = tree_cons (NULL_TREE, cleanup, args);
8367     }
8368   else
8369     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8370   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8371 }
8372
8373 void
8374 expand_static_init (decl, init)
8375      tree decl;
8376      tree init;
8377 {
8378   tree oldstatic = value_member (decl, static_aggregates);
8379
8380   if (oldstatic)
8381     {
8382       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8383         cp_error ("multiple initializations given for `%D'", decl);
8384     }
8385   else if (! toplevel_bindings_p ())
8386     {
8387       /* Emit code to perform this initialization but once.  */
8388       tree if_stmt;
8389       tree then_clause;
8390       tree assignment;
8391       tree guard;
8392       tree guard_init;
8393
8394       /* Emit code to perform this initialization but once.  This code
8395          looks like:
8396
8397            static int guard = 0;
8398            if (!guard) {
8399              // Do initialization.
8400              guard = 1;
8401              // Register variable for destruction at end of program.
8402            }
8403
8404          Note that the `temp' variable is only set to 1 *after* the
8405          initialization is complete.  This ensures that an exception,
8406          thrown during the construction, will cause the variable to
8407          reinitialized when we pass through this code again, as per:
8408
8409            [stmt.dcl]
8410
8411            If the initialization exits by throwing an exception, the
8412            initialization is not complete, so it will be tried again
8413            the next time control enters the declaration.
8414
8415          In theory, this process should be thread-safe, too; multiple
8416          threads should not be able to initialize the variable more
8417          than once.  We don't yet attempt to ensure thread-safety.  */
8418
8419       /* Create the guard variable.  */
8420       guard = get_guard (decl);
8421
8422       /* Begin the conditional initialization.  */
8423       if_stmt = begin_if_stmt ();
8424       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8425       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8426
8427       /* Do the initialization itself.  */
8428       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8429           || (init && TREE_CODE (init) == TREE_LIST))
8430         assignment = build_aggr_init (decl, init, 0);
8431       else if (init)
8432         /* The initialization we're doing here is just a bitwise
8433            copy.  */
8434         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8435       else
8436         assignment = NULL_TREE;
8437
8438       /* Once the assignment is complete, set TEMP to 1.  Since the
8439          construction of the static object is complete at this point,
8440          we want to make sure TEMP is set to 1 even if a temporary
8441          constructed during the initialization throws an exception
8442          when it is destroyed.  So, we combine the initialization and
8443          the assignment to TEMP into a single expression, ensuring
8444          that when we call finish_expr_stmt the cleanups will not be
8445          run until after TEMP is set to 1.  */
8446       guard_init = set_guard (guard);
8447       if (assignment)
8448         {
8449           assignment = tree_cons (NULL_TREE, assignment,
8450                                   build_tree_list (NULL_TREE,
8451                                                    guard_init));
8452           assignment = build_compound_expr (assignment);
8453         }
8454       else
8455         assignment = guard_init;
8456       finish_expr_stmt (assignment);
8457
8458       /* Use atexit to register a function for destroying this static
8459          variable.  */
8460       register_dtor_fn (decl);
8461
8462       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8463       finish_then_clause (if_stmt);
8464       finish_if_stmt ();
8465     }
8466   else
8467     static_aggregates = tree_cons (init, decl, static_aggregates);
8468 }
8469
8470 /* Finish the declaration of a catch-parameter.  */
8471
8472 tree
8473 start_handler_parms (declspecs, declarator)
8474      tree declspecs;
8475      tree declarator;
8476 {
8477   tree decl;
8478   if (declspecs)
8479     {
8480       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8481                              1, NULL);
8482       if (decl == NULL_TREE)
8483         error ("invalid catch parameter");
8484     }
8485   else
8486     decl = NULL_TREE;
8487
8488   return decl;
8489 }
8490
8491 \f
8492 /* Make TYPE a complete type based on INITIAL_VALUE.
8493    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8494    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8495
8496 int
8497 complete_array_type (type, initial_value, do_default)
8498      tree type, initial_value;
8499      int do_default;
8500 {
8501   register tree maxindex = NULL_TREE;
8502   int value = 0;
8503
8504   if (initial_value)
8505     {
8506       /* An array of character type can be initialized from a
8507          brace-enclosed string constant.  */
8508       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8509           && TREE_CODE (initial_value) == CONSTRUCTOR
8510           && CONSTRUCTOR_ELTS (initial_value)
8511           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8512               == STRING_CST)
8513           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8514         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8515
8516       /* Note MAXINDEX is really the maximum index, one less than the
8517          size.  */
8518       if (TREE_CODE (initial_value) == STRING_CST)
8519         {
8520           int eltsize
8521             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8522           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8523                                    / eltsize) - 1, 0);
8524         }
8525       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8526         {
8527           tree elts = CONSTRUCTOR_ELTS (initial_value);
8528
8529           maxindex = ssize_int (-1);
8530           for (; elts; elts = TREE_CHAIN (elts))
8531             {
8532               if (TREE_PURPOSE (elts))
8533                 maxindex = TREE_PURPOSE (elts);
8534               else
8535                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8536             }
8537           maxindex = copy_node (maxindex);
8538         }
8539       else
8540         {
8541           /* Make an error message unless that happened already.  */
8542           if (initial_value != error_mark_node)
8543             value = 1;
8544           else
8545             initial_value = NULL_TREE;
8546
8547           /* Prevent further error messages.  */
8548           maxindex = build_int_2 (0, 0);
8549         }
8550     }
8551
8552   if (!maxindex)
8553     {
8554       if (do_default)
8555         maxindex = build_int_2 (0, 0);
8556       value = 2;
8557     }
8558
8559   if (maxindex)
8560     {
8561       tree itype;
8562       tree domain;
8563
8564       domain = build_index_type (maxindex);
8565       TYPE_DOMAIN (type) = domain;
8566
8567       if (! TREE_TYPE (maxindex))
8568         TREE_TYPE (maxindex) = domain;
8569       if (initial_value)
8570         itype = TREE_TYPE (initial_value);
8571       else
8572         itype = NULL;
8573       if (itype && !TYPE_DOMAIN (itype))
8574         TYPE_DOMAIN (itype) = domain;
8575       /* The type of the main variant should never be used for arrays
8576          of different sizes.  It should only ever be completed with the
8577          size of the array.  */
8578       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8579         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8580     }
8581
8582   /* Lay out the type now that we can get the real answer.  */
8583
8584   layout_type (type);
8585
8586   return value;
8587 }
8588 \f
8589 /* Return zero if something is declared to be a member of type
8590    CTYPE when in the context of CUR_TYPE.  STRING is the error
8591    message to print in that case.  Otherwise, quietly return 1.  */
8592
8593 static int
8594 member_function_or_else (ctype, cur_type, flags)
8595      tree ctype, cur_type;
8596      enum overload_flags flags;
8597 {
8598   if (ctype && ctype != cur_type)
8599     {
8600       if (flags == DTOR_FLAG)
8601         cp_error ("destructor for alien class `%T' cannot be a member",
8602                   ctype);
8603       else
8604         cp_error ("constructor for alien class `%T' cannot be a member",
8605                   ctype);
8606       return 0;
8607     }
8608   return 1;
8609 }
8610 \f
8611 /* Subroutine of `grokdeclarator'.  */
8612
8613 /* Generate errors possibly applicable for a given set of specifiers.
8614    This is for ARM $7.1.2.  */
8615
8616 static void
8617 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8618      tree object;
8619      const char *type;
8620      int virtualp, quals, friendp, raises, inlinep;
8621 {
8622   if (virtualp)
8623     cp_error ("`%D' declared as a `virtual' %s", object, type);
8624   if (inlinep)
8625     cp_error ("`%D' declared as an `inline' %s", object, type);
8626   if (quals)
8627     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8628               object, type);
8629   if (friendp)
8630     cp_error_at ("`%D' declared as a friend", object);
8631   if (raises && !TYPE_PTRFN_P (TREE_TYPE (object))
8632       && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))
8633     cp_error_at ("`%D' declared with an exception specification", object);
8634 }
8635
8636 /* CTYPE is class type, or null if non-class.
8637    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8638    or METHOD_TYPE.
8639    DECLARATOR is the function's name.
8640    VIRTUALP is truthvalue of whether the function is virtual or not.
8641    FLAGS are to be passed through to `grokclassfn'.
8642    QUALS are qualifiers indicating whether the function is `const'
8643    or `volatile'.
8644    RAISES is a list of exceptions that this function can raise.
8645    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8646    not look, and -1 if we should not call `grokclassfn' at all.
8647
8648    Returns `NULL_TREE' if something goes wrong, after issuing
8649    applicable error messages.  */
8650
8651 static tree
8652 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8653             raises, check, friendp, publicp, inlinep, funcdef_flag,
8654             template_count, in_namespace)
8655      tree ctype, type;
8656      tree declarator;
8657      tree orig_declarator;
8658      int virtualp;
8659      enum overload_flags flags;
8660      tree quals, raises;
8661      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8662      tree in_namespace;
8663 {
8664   tree decl;
8665   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8666   int has_default_arg = 0;
8667   tree t;
8668
8669   if (raises)
8670     {
8671       type = build_exception_variant (type, raises);
8672     }
8673
8674   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8675   /* Propagate volatile out from type to decl. */
8676   if (TYPE_VOLATILE (type))
8677     TREE_THIS_VOLATILE (decl) = 1;
8678
8679   /* If this decl has namespace scope, set that up.  */
8680   if (in_namespace)
8681     set_decl_namespace (decl, in_namespace, friendp);
8682   else if (!ctype)
8683     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8684
8685   /* `main' and builtins have implicit 'C' linkage.  */
8686   if ((MAIN_NAME_P (declarator)
8687        || (IDENTIFIER_LENGTH (declarator) > 10
8688            && IDENTIFIER_POINTER (declarator)[0] == '_'
8689            && IDENTIFIER_POINTER (declarator)[1] == '_'
8690            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8691       && current_lang_name == lang_name_cplusplus
8692       && ctype == NULL_TREE
8693       /* NULL_TREE means global namespace.  */
8694       && DECL_CONTEXT (decl) == NULL_TREE)
8695     SET_DECL_LANGUAGE (decl, lang_c);
8696
8697   /* Should probably propagate const out from type to decl I bet (mrs).  */
8698   if (staticp)
8699     {
8700       DECL_STATIC_FUNCTION_P (decl) = 1;
8701       DECL_CONTEXT (decl) = ctype;
8702     }
8703
8704   if (ctype)
8705     DECL_CONTEXT (decl) = ctype;
8706
8707   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8708     {
8709       if (processing_template_decl)
8710         error ("cannot declare `::main' to be a template");
8711       if (inlinep)
8712         error ("cannot declare `::main' to be inline");
8713       if (!publicp)
8714         error ("cannot declare `::main' to be static");
8715       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8716                         integer_type_node))
8717         error ("`main' must return `int'");
8718       inlinep = 0;
8719       publicp = 1;
8720     }
8721
8722   /* Members of anonymous types and local classes have no linkage; make
8723      them internal.  */
8724   /* FIXME what if it gets a name from typedef?  */
8725   if (ctype && (TYPE_ANONYMOUS_P (ctype)
8726                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8727     publicp = 0;
8728
8729   if (publicp)
8730     {
8731       /* [basic.link]: A name with no linkage (notably, the name of a class
8732          or enumeration declared in a local scope) shall not be used to
8733          declare an entity with linkage.
8734
8735          Only check this for public decls for now.  */
8736       t = no_linkage_check (TREE_TYPE (decl));
8737       if (t)
8738         {
8739           if (TYPE_ANONYMOUS_P (t))
8740             {
8741               if (DECL_EXTERN_C_P (decl))
8742                 /* Allow this; it's pretty common in C.  */;
8743               else
8744                 {
8745                   cp_pedwarn ("non-local function `%#D' uses anonymous type",
8746                               decl);
8747                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
8748                     cp_pedwarn_at ("\
8749 `%#D' does not refer to the unqualified type, so it is not used for linkage",
8750                                 TYPE_NAME (t));
8751                 }
8752             }
8753           else
8754             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8755                         decl, t);
8756         }
8757     }
8758
8759   TREE_PUBLIC (decl) = publicp;
8760   if (! publicp)
8761     {
8762       DECL_INTERFACE_KNOWN (decl) = 1;
8763       DECL_NOT_REALLY_EXTERN (decl) = 1;
8764     }
8765
8766   /* If the declaration was declared inline, mark it as such.  */
8767   if (inlinep)
8768     DECL_DECLARED_INLINE_P (decl) = 1;
8769   /* We inline functions that are explicitly declared inline, or, when
8770      the user explicitly asks us to, all functions.  */
8771   if (DECL_DECLARED_INLINE_P (decl) || flag_inline_trees == 2)
8772     DECL_INLINE (decl) = 1;
8773
8774   DECL_EXTERNAL (decl) = 1;
8775   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8776     {
8777       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8778                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8779       quals = NULL_TREE;
8780     }
8781
8782   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8783     grok_op_properties (decl, virtualp, check < 0);
8784
8785   if (ctype && decl_function_context (decl))
8786     DECL_NO_STATIC_CHAIN (decl) = 1;
8787
8788   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8789     if (TREE_PURPOSE (t)
8790         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8791       {
8792         has_default_arg = 1;
8793         break;
8794       }
8795
8796   if (friendp
8797       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8798     {
8799       if (funcdef_flag)
8800         cp_error
8801           ("defining explicit specialization `%D' in friend declaration",
8802            orig_declarator);
8803       else
8804         {
8805           tree fns = TREE_OPERAND (orig_declarator, 0);
8806           tree args = TREE_OPERAND (orig_declarator, 1);
8807
8808           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8809             {
8810               /* Something like `template <class T> friend void f<T>()'.  */
8811               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8812                         orig_declarator);
8813               return NULL_TREE;
8814             }
8815
8816
8817           /* A friend declaration of the form friend void f<>().  Record
8818              the information in the TEMPLATE_ID_EXPR.  */
8819           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8820
8821           if (TREE_CODE (fns) == COMPONENT_REF)
8822             {
8823               /* Due to bison parser ickiness, we will have already looked
8824                  up an operator_name or PFUNCNAME within the current class
8825                  (see template_id in parse.y). If the current class contains
8826                  such a name, we'll get a COMPONENT_REF here. Undo that. */
8827
8828               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
8829                                   == current_class_type, 20001120);
8830               fns = TREE_OPERAND (fns, 1);
8831             }
8832           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
8833                               || TREE_CODE (fns) == LOOKUP_EXPR
8834                               || TREE_CODE (fns) == OVERLOAD, 20001120);
8835           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
8836
8837           if (has_default_arg)
8838             {
8839               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8840                         decl);
8841               return NULL_TREE;
8842             }
8843
8844           if (inlinep)
8845             {
8846               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8847                         decl);
8848               return NULL_TREE;
8849             }
8850         }
8851     }
8852
8853   if (has_default_arg)
8854     add_defarg_fn (decl);
8855
8856   if (funcdef_flag)
8857     /* Make the init_value nonzero so pushdecl knows this is not
8858        tentative.  error_mark_node is replaced later with the BLOCK.  */
8859     DECL_INITIAL (decl) = error_mark_node;
8860
8861   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8862     TREE_NOTHROW (decl) = 1;
8863
8864   /* Caller will do the rest of this.  */
8865   if (check < 0)
8866     return decl;
8867
8868   if (flags == NO_SPECIAL && ctype && constructor_name (ctype) == declarator)
8869     DECL_CONSTRUCTOR_P (decl) = 1;
8870
8871   /* Function gets the ugly name, field gets the nice one.  This call
8872      may change the type of the function (because of default
8873      parameters)!  */
8874   if (ctype != NULL_TREE)
8875     grokclassfn (ctype, decl, flags, quals);
8876
8877   decl = check_explicit_specialization (orig_declarator, decl,
8878                                         template_count,
8879                                         2 * (funcdef_flag != 0) +
8880                                         4 * (friendp != 0));
8881   if (decl == error_mark_node)
8882     return NULL_TREE;
8883
8884   if (ctype != NULL_TREE
8885       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8886       && check)
8887     {
8888       tree old_decl;
8889
8890       old_decl = check_classfn (ctype, decl);
8891
8892       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
8893         /* Because grokfndecl is always supposed to return a
8894            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8895            here.  We depend on our callers to figure out that its
8896            really a template that's being returned.  */
8897         old_decl = DECL_TEMPLATE_RESULT (old_decl);
8898
8899       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
8900           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8901         {
8902           /* Remove the `this' parm added by grokclassfn.
8903              XXX Isn't this done in start_function, too?  */
8904           revert_static_member_fn (decl);
8905           last_function_parms = TREE_CHAIN (last_function_parms);
8906         }
8907       if (old_decl && DECL_ARTIFICIAL (old_decl))
8908         cp_error ("definition of implicitly-declared `%D'", old_decl);
8909
8910       if (old_decl)
8911         {
8912           /* Since we've smashed OLD_DECL to its
8913              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
8914           if (TREE_CODE (decl) == TEMPLATE_DECL)
8915             decl = DECL_TEMPLATE_RESULT (decl);
8916
8917           /* Attempt to merge the declarations.  This can fail, in
8918              the case of some illegal specialization declarations.  */
8919           if (!duplicate_decls (decl, old_decl))
8920             cp_error ("no `%#D' member function declared in class `%T'",
8921                       decl, ctype);
8922           return old_decl;
8923         }
8924     }
8925
8926   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
8927     return NULL_TREE;
8928
8929   if (ctype == NULL_TREE || check)
8930     return decl;
8931
8932   if (virtualp)
8933     DECL_VIRTUAL_P (decl) = 1;
8934
8935   return decl;
8936 }
8937
8938 static tree
8939 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
8940      tree type;
8941      tree declarator;
8942      RID_BIT_TYPE *specbits_in;
8943      int initialized;
8944      int constp;
8945      tree in_namespace;
8946 {
8947   tree decl;
8948   RID_BIT_TYPE specbits;
8949
8950   specbits = *specbits_in;
8951
8952   if (TREE_CODE (type) == OFFSET_TYPE)
8953     {
8954       /* If you declare a static member so that it
8955          can be initialized, the code will reach here.  */
8956       tree basetype = TYPE_OFFSET_BASETYPE (type);
8957       type = TREE_TYPE (type);
8958       decl = build_lang_decl (VAR_DECL, declarator, type);
8959       DECL_CONTEXT (decl) = basetype;
8960     }
8961   else
8962     {
8963       tree context;
8964
8965       if (in_namespace)
8966         context = in_namespace;
8967       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
8968         context = current_namespace;
8969       else
8970         context = NULL_TREE;
8971
8972       /* For namespace-scope variables, declared in a template, we
8973          need the full lang_decl.  The same is true for
8974          namespace-scope variables that do not have C++ language
8975          linkage.  */
8976       if (context
8977           && (processing_template_decl
8978               || current_lang_name != lang_name_cplusplus))
8979         decl = build_lang_decl (VAR_DECL, declarator, type);
8980       else
8981         decl = build_decl (VAR_DECL, declarator, type);
8982
8983       if (context)
8984         set_decl_namespace (decl, context, 0);
8985
8986       context = DECL_CONTEXT (decl);
8987       if (declarator && context && current_lang_name != lang_name_c)
8988         /* We can't mangle lazily here because we don't have any
8989            way to recover whether or not a variable was `extern
8990            "C"' later.  */
8991         mangle_decl (decl);
8992     }
8993
8994   if (in_namespace)
8995     set_decl_namespace (decl, in_namespace, 0);
8996
8997   if (RIDBIT_SETP (RID_EXTERN, specbits))
8998     {
8999       DECL_THIS_EXTERN (decl) = 1;
9000       DECL_EXTERNAL (decl) = !initialized;
9001     }
9002
9003   /* In class context, static means one per class,
9004      public access, and static storage.  */
9005   if (DECL_CLASS_SCOPE_P (decl))
9006     {
9007       TREE_PUBLIC (decl) = 1;
9008       TREE_STATIC (decl) = 1;
9009       DECL_EXTERNAL (decl) = 0;
9010     }
9011   /* At top level, either `static' or no s.c. makes a definition
9012      (perhaps tentative), and absence of `static' makes it public.  */
9013   else if (toplevel_bindings_p ())
9014     {
9015       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9016                             && (DECL_THIS_EXTERN (decl) || ! constp));
9017       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9018     }
9019   /* Not at top level, only `static' makes a static definition.  */
9020   else
9021     {
9022       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9023       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9024     }
9025
9026   if (TREE_PUBLIC (decl))
9027     {
9028       /* [basic.link]: A name with no linkage (notably, the name of a class
9029          or enumeration declared in a local scope) shall not be used to
9030          declare an entity with linkage.
9031
9032          Only check this for public decls for now.  */
9033       tree t = no_linkage_check (TREE_TYPE (decl));
9034       if (t)
9035         {
9036           if (TYPE_ANONYMOUS_P (t))
9037             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9038           else
9039             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9040                         decl, t);
9041         }
9042     }
9043
9044   return decl;
9045 }
9046
9047 /* Create and return a canonical pointer to member function type, for
9048    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9049
9050 tree
9051 build_ptrmemfunc_type (type)
9052      tree type;
9053 {
9054   tree fields[4];
9055   tree t;
9056   tree unqualified_variant = NULL_TREE;
9057
9058   if (type == error_mark_node)
9059     return type;
9060
9061   /* If a canonical type already exists for this type, use it.  We use
9062      this method instead of type_hash_canon, because it only does a
9063      simple equality check on the list of field members.  */
9064
9065   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9066     return t;
9067
9068   /* Make sure that we always have the unqualified pointer-to-member
9069      type first.  */
9070   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9071     unqualified_variant
9072       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9073
9074   t = make_aggr_type (RECORD_TYPE);
9075   /* Let the front-end know this is a pointer to member function...  */
9076   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9077   /* ... and not really an aggregate.  */
9078   SET_IS_AGGR_TYPE (t, 0);
9079
9080   fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9081   fields[1] = build_decl (FIELD_DECL, delta_identifier,
9082                           delta_type_node);
9083   finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9084
9085   /* Zap out the name so that the back-end will give us the debugging
9086      information for this anonymous RECORD_TYPE.  */
9087   TYPE_NAME (t) = NULL_TREE;
9088
9089   /* If this is not the unqualified form of this pointer-to-member
9090      type, set the TYPE_MAIN_VARIANT for this type to be the
9091      unqualified type.  Since they are actually RECORD_TYPEs that are
9092      not variants of each other, we must do this manually.  */
9093   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9094     {
9095       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9096       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9097       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9098       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9099     }
9100
9101   /* Cache this pointer-to-member type so that we can find it again
9102      later.  */
9103   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9104
9105   /* Seems to be wanted.  */
9106   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9107
9108   return t;
9109 }
9110
9111 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9112    Check to see that the definition is valid.  Issue appropriate error
9113    messages.  Return 1 if the definition is particularly bad, or 0
9114    otherwise.  */
9115
9116 int
9117 check_static_variable_definition (decl, type)
9118      tree decl;
9119      tree type;
9120 {
9121   /* Motion 10 at San Diego: If a static const integral data member is
9122      initialized with an integral constant expression, the initializer
9123      may appear either in the declaration (within the class), or in
9124      the definition, but not both.  If it appears in the class, the
9125      member is a member constant.  The file-scope definition is always
9126      required.  */
9127   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9128     {
9129       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9130                 type);
9131       /* If we just return the declaration, crashes will sometimes
9132          occur.  We therefore return void_type_node, as if this was a
9133          friend declaration, to cause callers to completely ignore
9134          this declaration.  */
9135       return 1;
9136     }
9137   else if (!CP_TYPE_CONST_P (type))
9138     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9139               decl);
9140   else if (pedantic && !INTEGRAL_TYPE_P (type))
9141     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9142
9143   return 0;
9144 }
9145
9146 /* Given the SIZE (i.e., number of elements) in an array, compute an
9147    appropriate index type for the array.  If non-NULL, NAME is the
9148    name of the thing being declared.  */
9149
9150 tree
9151 compute_array_index_type (name, size)
9152      tree name;
9153      tree size;
9154 {
9155   tree itype;
9156
9157   /* If this involves a template parameter, it will be a constant at
9158      instantiation time, but we don't know what the value is yet.
9159      Even if no template parameters are involved, we may an expression
9160      that is not a constant; we don't even simplify `1 + 2' when
9161      processing a template.  */
9162   if (processing_template_decl)
9163     {
9164       /* Resolve a qualified reference to an enumerator or static
9165          const data member of ours.  */
9166       if (TREE_CODE (size) == SCOPE_REF
9167           && TREE_OPERAND (size, 0) == current_class_type)
9168         {
9169           tree t = lookup_field (current_class_type,
9170                                  TREE_OPERAND (size, 1), 0, 0);
9171           if (t)
9172             size = t;
9173         }
9174
9175       return build_index_type (build_min (MINUS_EXPR, sizetype,
9176                                           size, integer_one_node));
9177     }
9178
9179   /* The size might be the result of a cast. */
9180   STRIP_TYPE_NOPS (size);
9181
9182   /* It might be a const variable or enumeration constant.  */
9183   size = decl_constant_value (size);
9184
9185   /* The array bound must be an integer type.  */
9186   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9187       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9188       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9189     {
9190       if (name)
9191         cp_error ("size of array `%D' has non-integer type", name);
9192       else
9193         cp_error ("size of array has non-integer type");
9194       size = integer_one_node;
9195     }
9196
9197   /* Normally, the array-bound will be a constant.  */
9198   if (TREE_CODE (size) == INTEGER_CST)
9199     {
9200       /* Check to see if the array bound overflowed.  Make that an
9201          error, no matter how generous we're being.  */
9202       int old_flag_pedantic_errors = flag_pedantic_errors;
9203       int old_pedantic = pedantic;
9204       pedantic = flag_pedantic_errors = 1;
9205       constant_expression_warning (size);
9206       pedantic = old_pedantic;
9207       flag_pedantic_errors = old_flag_pedantic_errors;
9208
9209       /* An array must have a positive number of elements.  */
9210       if (INT_CST_LT (size, integer_zero_node))
9211         {
9212           if (name)
9213             cp_error ("size of array `%D' is negative", name);
9214           else
9215             cp_error ("size of array is negative");
9216           size = integer_one_node;
9217         }
9218       /* Except that an extension we allow zero-sized arrays.  We
9219          always allow them in system headers because glibc uses
9220          them.  */
9221       else if (integer_zerop (size) && pedantic && !in_system_header)
9222         {
9223           if (name)
9224             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9225           else
9226             cp_pedwarn ("ISO C++ forbids zero-size array");
9227         }
9228     }
9229   else if (TREE_CONSTANT (size))
9230     {
9231       /* `(int) &fn' is not a valid array bound.  */
9232       if (name)
9233         cp_error ("size of array `%D' is not an integral constant-expression",
9234                   name);
9235       else
9236         cp_error ("size of array is not an integral constant-expression");
9237     }
9238
9239   /* Compute the index of the largest element in the array.  It is
9240      one less than the number of elements in the array.  */
9241   itype
9242     = fold (cp_build_binary_op (MINUS_EXPR,
9243                                 cp_convert (ssizetype, size),
9244                                 cp_convert (ssizetype,
9245                                             integer_one_node)));
9246
9247   /* Check for variable-sized arrays.  We allow such things as an
9248      extension, even though they are not allowed in ANSI/ISO C++.  */
9249   if (!TREE_CONSTANT (itype))
9250     {
9251       if (pedantic)
9252         {
9253           if (name)
9254             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9255                         name);
9256           else
9257             cp_pedwarn ("ISO C++ forbids variable-size array");
9258         }
9259
9260       /* Create a variable-sized array index type.  */
9261       itype = variable_size (itype);
9262     }
9263   /* Make sure that there was no overflow when creating to a signed
9264      index type.  (For example, on a 32-bit machine, an array with
9265      size 2^32 - 1 is too big.)  */
9266   else if (TREE_OVERFLOW (itype))
9267     {
9268       error ("overflow in array dimension");
9269       TREE_OVERFLOW (itype) = 0;
9270     }
9271
9272   /* Create and return the appropriate index type.  */
9273   return build_index_type (itype);
9274 }
9275
9276 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9277    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9278    with this type.  */
9279
9280 static tree
9281 create_array_type_for_decl (name, type, size)
9282      tree name;
9283      tree type;
9284      tree size;
9285 {
9286   tree itype = NULL_TREE;
9287   const char* error_msg;
9288
9289   /* If things have already gone awry, bail now.  */
9290   if (type == error_mark_node || size == error_mark_node)
9291     return error_mark_node;
9292
9293   /* Assume that everything will go OK.  */
9294   error_msg = NULL;
9295
9296   /* There are some types which cannot be array elements.  */
9297   switch (TREE_CODE (type))
9298     {
9299     case VOID_TYPE:
9300       error_msg = "array of void";
9301       break;
9302
9303     case FUNCTION_TYPE:
9304       error_msg = "array of functions";
9305       break;
9306
9307     case REFERENCE_TYPE:
9308       error_msg = "array of references";
9309       break;
9310
9311     case OFFSET_TYPE:
9312       error_msg = "array of data members";
9313       break;
9314
9315     case METHOD_TYPE:
9316       error_msg = "array of function members";
9317       break;
9318
9319     default:
9320       break;
9321     }
9322
9323   /* If something went wrong, issue an error-message and return.  */
9324   if (error_msg)
9325     {
9326       if (name)
9327         cp_error ("declaration of `%D' as %s", name, error_msg);
9328       else
9329         cp_error ("creating %s", error_msg);
9330
9331       return error_mark_node;
9332     }
9333
9334   /* [dcl.array]
9335
9336      The constant expressions that specify the bounds of the arrays
9337      can be omitted only for the first member of the sequence.  */
9338   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9339     {
9340       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9341                 name);
9342
9343       return error_mark_node;
9344     }
9345
9346   /* Figure out the index type for the array.  */
9347   if (size)
9348     itype = compute_array_index_type (name, size);
9349
9350   return build_cplus_array_type (type, itype);
9351 }
9352
9353 /* Check that it's OK to declare a function with the indicated TYPE.
9354    SFK indicates the kind of special function (if any) that this
9355    function is.  OPTYPE is the type given in a conversion operator
9356    declaration.  Returns the actual return type of the function; that
9357    may be different than TYPE if an error occurs, or for certain
9358    special functions.  */
9359
9360 static tree
9361 check_special_function_return_type (sfk, type, optype)
9362      special_function_kind sfk;
9363      tree type;
9364      tree optype;
9365 {
9366   switch (sfk)
9367     {
9368     case sfk_constructor:
9369       if (type)
9370         cp_error ("return type specification for constructor invalid");
9371
9372       type = void_type_node;
9373       break;
9374
9375     case sfk_destructor:
9376       if (type)
9377         cp_error ("return type specification for destructor invalid");
9378       type = void_type_node;
9379       break;
9380
9381     case sfk_conversion:
9382       if (type && !same_type_p (type, optype))
9383         cp_error ("operator `%T' declared to return `%T'", optype, type);
9384       else if (type)
9385         cp_pedwarn ("return type specified for `operator %T'",  optype);
9386       type = optype;
9387       break;
9388
9389     default:
9390       my_friendly_abort (20000408);
9391       break;
9392     }
9393
9394   return type;
9395 }
9396
9397 /* Given declspecs and a declarator,
9398    determine the name and type of the object declared
9399    and construct a ..._DECL node for it.
9400    (In one case we can return a ..._TYPE node instead.
9401     For invalid input we sometimes return 0.)
9402
9403    DECLSPECS is a chain of tree_list nodes whose value fields
9404     are the storage classes and type specifiers.
9405
9406    DECL_CONTEXT says which syntactic context this declaration is in:
9407      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9408      FUNCDEF for a function definition.  Like NORMAL but a few different
9409       error messages in each case.  Return value may be zero meaning
9410       this definition is too screwy to try to parse.
9411      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9412       handle member functions (which have FIELD context).
9413       Return value may be zero meaning this definition is too screwy to
9414       try to parse.
9415      PARM for a parameter declaration (either within a function prototype
9416       or before a function body).  Make a PARM_DECL, or return void_type_node.
9417      CATCHPARM for a parameter declaration before a catch clause.
9418      TYPENAME if for a typename (in a cast or sizeof).
9419       Don't make a DECL node; just return the ..._TYPE node.
9420      FIELD for a struct or union field; make a FIELD_DECL.
9421      BITFIELD for a field with specified width.
9422    INITIALIZED is 1 if the decl has an initializer.
9423
9424    ATTRLIST is a pointer to the list of attributes, which may be NULL
9425    if there are none; *ATTRLIST may be modified if attributes from inside
9426    the declarator should be applied to the declaration.
9427
9428    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9429    It may also be so in the PARM case, for a prototype where the
9430    argument type is specified but not the name.
9431
9432    This function is where the complicated C meanings of `static'
9433    and `extern' are interpreted.
9434
9435    For C++, if there is any monkey business to do, the function which
9436    calls this one must do it, i.e., prepending instance variables,
9437    renaming overloaded function names, etc.
9438
9439    Note that for this C++, it is an error to define a method within a class
9440    which does not belong to that class.
9441
9442    Except in the case where SCOPE_REFs are implicitly known (such as
9443    methods within a class being redundantly qualified),
9444    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9445    (class_name::decl_name).  The caller must also deal with this.
9446
9447    If a constructor or destructor is seen, and the context is FIELD,
9448    then the type gains the attribute TREE_HAS_x.  If such a declaration
9449    is erroneous, NULL_TREE is returned.
9450
9451    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9452    function, these are the qualifiers to give to the `this' pointer. We
9453    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9454
9455    May return void_type_node if the declarator turned out to be a friend.
9456    See grokfield for details.  */
9457
9458 tree
9459 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9460      tree declspecs;
9461      tree declarator;
9462      enum decl_context decl_context;
9463      int initialized;
9464      tree *attrlist;
9465 {
9466   RID_BIT_TYPE specbits;
9467   int nclasses = 0;
9468   tree spec;
9469   tree type = NULL_TREE;
9470   int longlong = 0;
9471   int constp;
9472   int restrictp;
9473   int volatilep;
9474   int type_quals;
9475   int virtualp, explicitp, friendp, inlinep, staticp;
9476   int explicit_int = 0;
9477   int explicit_char = 0;
9478   int defaulted_int = 0;
9479   tree typedef_decl = NULL_TREE;
9480   const char *name;
9481   tree typedef_type = NULL_TREE;
9482   int funcdef_flag = 0;
9483   enum tree_code innermost_code = ERROR_MARK;
9484   int bitfield = 0;
9485 #if 0
9486   /* See the code below that used this.  */
9487   tree decl_attr = NULL_TREE;
9488 #endif
9489   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9490      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9491   tree init = NULL_TREE;
9492
9493   /* Keep track of what sort of function is being processed
9494      so that we can warn about default return values, or explicit
9495      return values which do not match prescribed defaults.  */
9496   special_function_kind sfk = sfk_none;
9497
9498   tree dname = NULL_TREE;
9499   tree ctype = current_class_type;
9500   tree ctor_return_type = NULL_TREE;
9501   enum overload_flags flags = NO_SPECIAL;
9502   tree quals = NULL_TREE;
9503   tree raises = NULL_TREE;
9504   int template_count = 0;
9505   tree in_namespace = NULL_TREE;
9506   tree returned_attrs = NULL_TREE;
9507
9508   RIDBIT_RESET_ALL (specbits);
9509   if (decl_context == FUNCDEF)
9510     funcdef_flag = 1, decl_context = NORMAL;
9511   else if (decl_context == MEMFUNCDEF)
9512     funcdef_flag = -1, decl_context = FIELD;
9513   else if (decl_context == BITFIELD)
9514     bitfield = 1, decl_context = FIELD;
9515
9516   /* Look inside a declarator for the name being declared
9517      and get it as a string, for an error message.  */
9518   {
9519     tree *next = &declarator;
9520     register tree decl;
9521     name = NULL;
9522
9523     while (next && *next)
9524       {
9525         decl = *next;
9526         switch (TREE_CODE (decl))
9527           {
9528           case TREE_LIST:
9529             /* For attributes.  */
9530             next = &TREE_VALUE (decl);
9531             break;
9532
9533           case COND_EXPR:
9534             ctype = NULL_TREE;
9535             next = &TREE_OPERAND (decl, 0);
9536             break;
9537
9538           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9539             {
9540               tree name = TREE_OPERAND (decl, 0);
9541               tree rename = NULL_TREE;
9542
9543               my_friendly_assert (flags == NO_SPECIAL, 152);
9544               flags = DTOR_FLAG;
9545               sfk = sfk_destructor;
9546               if (TREE_CODE (name) == TYPE_DECL)
9547                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9548               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9549               if (ctype == NULL_TREE)
9550                 {
9551                   if (current_class_type == NULL_TREE)
9552                     {
9553                       error ("destructors must be member functions");
9554                       flags = NO_SPECIAL;
9555                     }
9556                   else
9557                     {
9558                       tree t = constructor_name (current_class_name);
9559                       if (t != name)
9560                         rename = t;
9561                     }
9562                 }
9563               else
9564                 {
9565                   tree t = constructor_name (ctype);
9566                   if (t != name)
9567                     rename = t;
9568                 }
9569
9570               if (rename)
9571                 {
9572                   cp_error ("destructor `%T' must match class name `%T'",
9573                             name, rename);
9574                   TREE_OPERAND (decl, 0) = rename;
9575                 }
9576               next = &name;
9577             }
9578             break;
9579
9580           case ADDR_EXPR:       /* C++ reference declaration */
9581             /* Fall through. */
9582           case ARRAY_REF:
9583           case INDIRECT_REF:
9584             ctype = NULL_TREE;
9585             innermost_code = TREE_CODE (decl);
9586             next = &TREE_OPERAND (decl, 0);
9587             break;
9588
9589           case CALL_EXPR:
9590             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9591               {
9592                 /* This is actually a variable declaration using
9593                    constructor syntax.  We need to call start_decl and
9594                    cp_finish_decl so we can get the variable
9595                    initialized...  */
9596
9597                 tree attributes;
9598
9599                 *next = TREE_OPERAND (decl, 0);
9600                 init = CALL_DECLARATOR_PARMS (decl);
9601
9602                 if (attrlist)
9603                   {
9604                     attributes = *attrlist;
9605                   }
9606                 else
9607                   {
9608                     attributes = NULL_TREE;
9609                   }
9610
9611                 decl = start_decl (declarator, declspecs, 1,
9612                                    attributes, NULL_TREE);
9613                 decl_type_access_control (decl);
9614                 if (decl)
9615                   {
9616                     /* Look for __unused__ attribute */
9617                     if (TREE_USED (TREE_TYPE (decl)))
9618                       TREE_USED (decl) = 1;
9619                     finish_decl (decl, init, NULL_TREE);
9620                   }
9621                 else
9622                   cp_error ("invalid declarator");
9623                 return 0;
9624               }
9625             innermost_code = TREE_CODE (decl);
9626             if (decl_context == FIELD && ctype == NULL_TREE)
9627               ctype = current_class_type;
9628             if (ctype
9629                 && TREE_OPERAND (decl, 0)
9630                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9631                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9632                          == constructor_name_full (ctype))
9633                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9634                             == constructor_name (ctype)))))
9635               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9636             next = &TREE_OPERAND (decl, 0);
9637             decl = *next;
9638             if (ctype != NULL_TREE
9639                 && decl != NULL_TREE && flags != DTOR_FLAG
9640                 && decl == constructor_name (ctype))
9641               {
9642                 sfk = sfk_constructor;
9643                 ctor_return_type = ctype;
9644               }
9645             ctype = NULL_TREE;
9646             break;
9647
9648           case TEMPLATE_ID_EXPR:
9649               {
9650                 tree fns = TREE_OPERAND (decl, 0);
9651
9652                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9653                   fns = TREE_OPERAND (fns, 0);
9654
9655                 dname = fns;
9656                 if (TREE_CODE (dname) == COMPONENT_REF)
9657                   dname = TREE_OPERAND (dname, 1);
9658                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9659                   {
9660                     my_friendly_assert (is_overloaded_fn (dname),
9661                                         19990331);
9662                     dname = DECL_NAME (get_first_fn (dname));
9663                   }
9664               }
9665           /* Fall through. */
9666
9667           case IDENTIFIER_NODE:
9668             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9669               dname = decl;
9670
9671             next = 0;
9672
9673             if (C_IS_RESERVED_WORD (dname))
9674               {
9675                 cp_error ("declarator-id missing; using reserved word `%D'",
9676                           dname);
9677                 name = IDENTIFIER_POINTER (dname);
9678               }
9679             else if (!IDENTIFIER_TYPENAME_P (dname))
9680               name = IDENTIFIER_POINTER (dname);
9681             else
9682               {
9683                 my_friendly_assert (flags == NO_SPECIAL, 154);
9684                 flags = TYPENAME_FLAG;
9685                 ctor_return_type = TREE_TYPE (dname);
9686                 sfk = sfk_conversion;
9687                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9688                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9689                         == TYPE_DECL))
9690                   name = IDENTIFIER_POINTER (dname);
9691                 else
9692                   name = "<invalid operator>";
9693               }
9694             break;
9695
9696             /* C++ extension */
9697           case SCOPE_REF:
9698             {
9699               /* Perform error checking, and decide on a ctype.  */
9700               tree cname = TREE_OPERAND (decl, 0);
9701               if (cname == NULL_TREE)
9702                 ctype = NULL_TREE;
9703               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9704                 {
9705                   ctype = NULL_TREE;
9706                   in_namespace = TREE_OPERAND (decl, 0);
9707                   TREE_OPERAND (decl, 0) = NULL_TREE;
9708                 }
9709               else if (! is_aggr_type (cname, 1))
9710                 TREE_OPERAND (decl, 0) = NULL_TREE;
9711               /* Must test TREE_OPERAND (decl, 1), in case user gives
9712                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9713               else if (TREE_OPERAND (decl, 1)
9714                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9715                 ctype = cname;
9716               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9717                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9718                 {
9719                   cp_error ("`%T::%D' is not a valid declarator", cname,
9720                             TREE_OPERAND (decl, 1));
9721                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9722                             cname, TREE_OPERAND (decl, 1));
9723                   return void_type_node;
9724                 }
9725               else if (ctype == NULL_TREE)
9726                 ctype = cname;
9727               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9728                 TREE_OPERAND (decl, 0) = ctype;
9729               else
9730                 {
9731                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9732                     {
9733                       cp_error ("type `%T' is not derived from type `%T'",
9734                                 cname, ctype);
9735                       TREE_OPERAND (decl, 0) = NULL_TREE;
9736                     }
9737                   else
9738                     ctype = cname;
9739                 }
9740
9741               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9742                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9743                        == constructor_name_full (ctype))
9744                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9745                           == constructor_name (ctype))))
9746                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9747               next = &TREE_OPERAND (decl, 1);
9748               decl = *next;
9749               if (ctype)
9750                 {
9751                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9752                       && constructor_name (ctype) == decl)
9753                     {
9754                       sfk = sfk_constructor;
9755                       ctor_return_type = ctype;
9756                     }
9757                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9758                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9759                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9760                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9761                     {
9762                       sfk = sfk_destructor;
9763                       ctor_return_type = ctype;
9764                       flags = DTOR_FLAG;
9765                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9766                       next = &TREE_OPERAND (decl, 0);
9767                     }
9768                 }
9769             }
9770             break;
9771
9772           case ERROR_MARK:
9773             next = 0;
9774             break;
9775
9776           case TYPE_DECL:
9777             /* Parse error puts this typespec where
9778                a declarator should go.  */
9779             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9780             if (TREE_TYPE (decl) == current_class_type)
9781               cp_error ("  perhaps you want `%T' for a constructor",
9782                         current_class_name);
9783             dname = DECL_NAME (decl);
9784             name = IDENTIFIER_POINTER (dname);
9785
9786             /* Avoid giving two errors for this.  */
9787             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9788
9789             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9790             *next = dname;
9791             next = 0;
9792             break;
9793
9794           default:
9795             cp_compiler_error ("`%D' as declarator", decl);
9796             return 0; /* We used to do a 155 abort here.  */
9797           }
9798       }
9799   }
9800
9801   /* A function definition's declarator must have the form of
9802      a function declarator.  */
9803
9804   if (funcdef_flag && innermost_code != CALL_EXPR)
9805     return 0;
9806
9807   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9808       && innermost_code != CALL_EXPR
9809       && ! (ctype && declspecs == NULL_TREE))
9810     {
9811       cp_error ("declaration of `%D' as non-function", dname);
9812       return void_type_node;
9813     }
9814
9815   /* Anything declared one level down from the top level
9816      must be one of the parameters of a function
9817      (because the body is at least two levels down).  */
9818
9819   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9820      by not allowing C++ class definitions to specify their parameters
9821      with xdecls (must be spec.d in the parmlist).
9822
9823      Since we now wait to push a class scope until we are sure that
9824      we are in a legitimate method context, we must set oldcname
9825      explicitly (since current_class_name is not yet alive).
9826
9827      We also want to avoid calling this a PARM if it is in a namespace.  */
9828
9829   if (decl_context == NORMAL && !toplevel_bindings_p ())
9830     {
9831       struct binding_level *b = current_binding_level;
9832       current_binding_level = b->level_chain;
9833       if (current_binding_level != 0 && toplevel_bindings_p ())
9834         decl_context = PARM;
9835       current_binding_level = b;
9836     }
9837
9838   if (name == NULL)
9839     name = decl_context == PARM ? "parameter" : "type name";
9840
9841   /* Look through the decl specs and record which ones appear.
9842      Some typespecs are defined as built-in typenames.
9843      Others, the ones that are modifiers of other types,
9844      are represented by bits in SPECBITS: set the bits for
9845      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9846
9847      If there is a typedef name or a type, store the type in TYPE.
9848      This includes builtin typedefs such as `int'.
9849
9850      Set EXPLICIT_INT if the type is `int' or `char' and did not
9851      come from a user typedef.
9852
9853      Set LONGLONG if `long' is mentioned twice.
9854
9855      For C++, constructors and destructors have their own fast treatment.  */
9856
9857   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9858     {
9859       register int i;
9860       register tree id;
9861
9862       /* Certain parse errors slip through.  For example,
9863          `int class;' is not caught by the parser. Try
9864          weakly to recover here.  */
9865       if (TREE_CODE (spec) != TREE_LIST)
9866         return 0;
9867
9868       id = TREE_VALUE (spec);
9869
9870       if (TREE_CODE (id) == IDENTIFIER_NODE)
9871         {
9872           if (id == ridpointers[(int) RID_INT]
9873               || id == ridpointers[(int) RID_CHAR]
9874               || id == ridpointers[(int) RID_BOOL]
9875               || id == ridpointers[(int) RID_WCHAR])
9876             {
9877               if (type)
9878                 {
9879                   if (id == ridpointers[(int) RID_BOOL])
9880                     error ("`bool' is now a keyword");
9881                   else
9882                     cp_error ("extraneous `%T' ignored", id);
9883                 }
9884               else
9885                 {
9886                   if (id == ridpointers[(int) RID_INT])
9887                     explicit_int = 1;
9888                   else if (id == ridpointers[(int) RID_CHAR])
9889                     explicit_char = 1;
9890                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9891                 }
9892               goto found;
9893             }
9894           /* C++ aggregate types.  */
9895           if (IDENTIFIER_HAS_TYPE_VALUE (id))
9896             {
9897               if (type)
9898                 cp_error ("multiple declarations `%T' and `%T'", type, id);
9899               else
9900                 type = IDENTIFIER_TYPE_VALUE (id);
9901               goto found;
9902             }
9903
9904           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
9905             {
9906               if (ridpointers[i] == id)
9907                 {
9908                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
9909                     {
9910                       if (pedantic && ! in_system_header && warn_long_long)
9911                         pedwarn ("ISO C++ does not support `long long'");
9912                       if (longlong)
9913                         error ("`long long long' is too long for GCC");
9914                       else
9915                         longlong = 1;
9916                     }
9917                   else if (RIDBIT_SETP (i, specbits))
9918                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
9919                   RIDBIT_SET (i, specbits);
9920                   goto found;
9921                 }
9922             }
9923         }
9924       /* C++ aggregate types.  */
9925       else if (TREE_CODE (id) == TYPE_DECL)
9926         {
9927           if (type)
9928             cp_error ("multiple declarations `%T' and `%T'", type,
9929                       TREE_TYPE (id));
9930           else
9931             {
9932               type = TREE_TYPE (id);
9933               TREE_VALUE (spec) = type;
9934             }
9935           goto found;
9936         }
9937       if (type)
9938         error ("two or more data types in declaration of `%s'", name);
9939       else if (TREE_CODE (id) == IDENTIFIER_NODE)
9940         {
9941           register tree t = lookup_name (id, 1);
9942           if (!t || TREE_CODE (t) != TYPE_DECL)
9943             error ("`%s' fails to be a typedef or built in type",
9944                    IDENTIFIER_POINTER (id));
9945           else
9946             {
9947               type = TREE_TYPE (t);
9948 #if 0
9949               /* See the code below that used this.  */
9950               decl_attr = DECL_ATTRIBUTES (id);
9951 #endif
9952               typedef_decl = t;
9953             }
9954         }
9955       else if (id != error_mark_node)
9956         /* Can't change CLASS nodes into RECORD nodes here!  */
9957         type = id;
9958
9959     found: ;
9960     }
9961
9962   typedef_type = type;
9963
9964   /* No type at all: default to `int', and set DEFAULTED_INT
9965      because it was not a user-defined typedef.  */
9966
9967   if (type == NULL_TREE
9968       && (RIDBIT_SETP (RID_SIGNED, specbits)
9969           || RIDBIT_SETP (RID_UNSIGNED, specbits)
9970           || RIDBIT_SETP (RID_LONG, specbits)
9971           || RIDBIT_SETP (RID_SHORT, specbits)))
9972     {
9973       /* These imply 'int'.  */
9974       type = integer_type_node;
9975       defaulted_int = 1;
9976     }
9977
9978   if (sfk != sfk_none)
9979     type = check_special_function_return_type (sfk, type,
9980                                                ctor_return_type);
9981   else if (type == NULL_TREE)
9982     {
9983       int is_main;
9984
9985       explicit_int = -1;
9986
9987       /* We handle `main' specially here, because 'main () { }' is so
9988          common.  With no options, it is allowed.  With -Wreturn-type,
9989          it is a warning.  It is only an error with -pedantic-errors.  */
9990       is_main = (funcdef_flag
9991                  && MAIN_NAME_P (dname)
9992                  && ctype == NULL_TREE
9993                  && in_namespace == NULL_TREE
9994                  && current_namespace == global_namespace);
9995
9996       if (in_system_header || flag_ms_extensions)
9997         /* Allow it, sigh.  */;
9998       else if (pedantic || ! is_main)
9999         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10000                     name);
10001       else if (warn_return_type)
10002         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10003                     name);
10004
10005       type = integer_type_node;
10006     }
10007
10008   ctype = NULL_TREE;
10009
10010   /* Now process the modifiers that were specified
10011      and check for invalid combinations.  */
10012
10013   /* Long double is a special combination.  */
10014
10015   if (RIDBIT_SETP (RID_LONG, specbits)
10016       && TYPE_MAIN_VARIANT (type) == double_type_node)
10017     {
10018       RIDBIT_RESET (RID_LONG, specbits);
10019       type = build_qualified_type (long_double_type_node,
10020                                    CP_TYPE_QUALS (type));
10021     }
10022
10023   /* Check all other uses of type modifiers.  */
10024
10025   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10026       || RIDBIT_SETP (RID_SIGNED, specbits)
10027       || RIDBIT_SETP (RID_LONG, specbits)
10028       || RIDBIT_SETP (RID_SHORT, specbits))
10029     {
10030       int ok = 0;
10031
10032       if (TREE_CODE (type) == REAL_TYPE)
10033         error ("short, signed or unsigned invalid for `%s'", name);
10034       else if (TREE_CODE (type) != INTEGER_TYPE)
10035         error ("long, short, signed or unsigned invalid for `%s'", name);
10036       else if (RIDBIT_SETP (RID_LONG, specbits)
10037                && RIDBIT_SETP (RID_SHORT, specbits))
10038         error ("long and short specified together for `%s'", name);
10039       else if ((RIDBIT_SETP (RID_LONG, specbits)
10040                 || RIDBIT_SETP (RID_SHORT, specbits))
10041                && explicit_char)
10042         error ("long or short specified with char for `%s'", name);
10043       else if ((RIDBIT_SETP (RID_LONG, specbits)
10044                 || RIDBIT_SETP (RID_SHORT, specbits))
10045                && TREE_CODE (type) == REAL_TYPE)
10046         error ("long or short specified with floating type for `%s'", name);
10047       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10048                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10049         error ("signed and unsigned given together for `%s'", name);
10050       else
10051         {
10052           ok = 1;
10053           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10054             {
10055               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10056                        name);
10057               if (flag_pedantic_errors)
10058                 ok = 0;
10059             }
10060         }
10061
10062       /* Discard the type modifiers if they are invalid.  */
10063       if (! ok)
10064         {
10065           RIDBIT_RESET (RID_UNSIGNED, specbits);
10066           RIDBIT_RESET (RID_SIGNED, specbits);
10067           RIDBIT_RESET (RID_LONG, specbits);
10068           RIDBIT_RESET (RID_SHORT, specbits);
10069           longlong = 0;
10070         }
10071     }
10072
10073   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10074       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10075     {
10076       error ("complex invalid for `%s'", name);
10077       RIDBIT_RESET (RID_COMPLEX, specbits);
10078     }
10079
10080   /* Decide whether an integer type is signed or not.
10081      Optionally treat bitfields as signed by default.  */
10082   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10083       /* [class.bit]
10084
10085          It is implementation-defined whether a plain (neither
10086          explicitly signed or unsigned) char, short, int, or long
10087          bit-field is signed or unsigned.
10088
10089          Naturally, we extend this to long long as well.  Note that
10090          this does not include wchar_t.  */
10091       || (bitfield && !flag_signed_bitfields
10092           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10093           /* A typedef for plain `int' without `signed' can be
10094              controlled just like plain `int', but a typedef for
10095              `signed int' cannot be so controlled.  */
10096           && !(typedef_decl
10097                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10098           && (TREE_CODE (type) == INTEGER_TYPE
10099               || TREE_CODE (type) == CHAR_TYPE)
10100           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10101     {
10102       if (longlong)
10103         type = long_long_unsigned_type_node;
10104       else if (RIDBIT_SETP (RID_LONG, specbits))
10105         type = long_unsigned_type_node;
10106       else if (RIDBIT_SETP (RID_SHORT, specbits))
10107         type = short_unsigned_type_node;
10108       else if (type == char_type_node)
10109         type = unsigned_char_type_node;
10110       else if (typedef_decl)
10111         type = unsigned_type (type);
10112       else
10113         type = unsigned_type_node;
10114     }
10115   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10116            && type == char_type_node)
10117     type = signed_char_type_node;
10118   else if (longlong)
10119     type = long_long_integer_type_node;
10120   else if (RIDBIT_SETP (RID_LONG, specbits))
10121     type = long_integer_type_node;
10122   else if (RIDBIT_SETP (RID_SHORT, specbits))
10123     type = short_integer_type_node;
10124
10125   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10126     {
10127       /* If we just have "complex", it is equivalent to
10128          "complex double", but if any modifiers at all are specified it is
10129          the complex form of TYPE.  E.g, "complex short" is
10130          "complex short int".  */
10131
10132       if (defaulted_int && ! longlong
10133           && ! (RIDBIT_SETP (RID_LONG, specbits)
10134                 || RIDBIT_SETP (RID_SHORT, specbits)
10135                 || RIDBIT_SETP (RID_SIGNED, specbits)
10136                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10137         type = complex_double_type_node;
10138       else if (type == integer_type_node)
10139         type = complex_integer_type_node;
10140       else if (type == float_type_node)
10141         type = complex_float_type_node;
10142       else if (type == double_type_node)
10143         type = complex_double_type_node;
10144       else if (type == long_double_type_node)
10145         type = complex_long_double_type_node;
10146       else
10147         type = build_complex_type (type);
10148     }
10149
10150   if (sfk == sfk_conversion
10151       && (RIDBIT_SETP (RID_CONST, specbits)
10152           || RIDBIT_SETP (RID_VOLATILE, specbits)
10153           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10154     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10155               ctor_return_type);
10156
10157   /* Set CONSTP if this declaration is `const', whether by
10158      explicit specification or via a typedef.
10159      Likewise for VOLATILEP.  */
10160
10161   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10162   restrictp =
10163     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10164   volatilep =
10165     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10166   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10167                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10168                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10169   type = cp_build_qualified_type (type, type_quals);
10170   staticp = 0;
10171   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10172   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10173   RIDBIT_RESET (RID_VIRTUAL, specbits);
10174   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10175   RIDBIT_RESET (RID_EXPLICIT, specbits);
10176
10177   if (RIDBIT_SETP (RID_STATIC, specbits))
10178     staticp = 1 + (decl_context == FIELD);
10179
10180   if (virtualp && staticp == 2)
10181     {
10182       cp_error ("member `%D' cannot be declared both virtual and static",
10183                 dname);
10184       staticp = 0;
10185     }
10186   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10187   RIDBIT_RESET (RID_FRIEND, specbits);
10188
10189   /* Warn if two storage classes are given. Default to `auto'.  */
10190
10191   if (RIDBIT_ANY_SET (specbits))
10192     {
10193       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10194       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10195       if (decl_context == PARM && nclasses > 0)
10196         error ("storage class specifiers invalid in parameter declarations");
10197       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10198         {
10199           if (decl_context == PARM)
10200             error ("typedef declaration invalid in parameter declaration");
10201           nclasses++;
10202         }
10203       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10204       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10205     }
10206
10207   /* Give error if `virtual' is used outside of class declaration.  */
10208   if (virtualp
10209       && (current_class_name == NULL_TREE || decl_context != FIELD))
10210     {
10211       error ("virtual outside class declaration");
10212       virtualp = 0;
10213     }
10214
10215   /* Static anonymous unions are dealt with here.  */
10216   if (staticp && decl_context == TYPENAME
10217       && TREE_CODE (declspecs) == TREE_LIST
10218       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10219     decl_context = FIELD;
10220
10221   /* Warn about storage classes that are invalid for certain
10222      kinds of declarations (parameters, typenames, etc.).  */
10223
10224   if (nclasses > 1)
10225     error ("multiple storage classes in declaration of `%s'", name);
10226   else if (decl_context != NORMAL && nclasses > 0)
10227     {
10228       if ((decl_context == PARM || decl_context == CATCHPARM)
10229           && (RIDBIT_SETP (RID_REGISTER, specbits)
10230               || RIDBIT_SETP (RID_AUTO, specbits)))
10231         ;
10232       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10233         ;
10234       else if (decl_context == FIELD
10235                /* C++ allows static class elements  */
10236                && RIDBIT_SETP (RID_STATIC, specbits))
10237         /* C++ also allows inlines and signed and unsigned elements,
10238            but in those cases we don't come in here.  */
10239         ;
10240       else
10241         {
10242           if (decl_context == FIELD)
10243             {
10244               tree tmp = NULL_TREE;
10245               register int op = 0;
10246
10247               if (declarator)
10248                 {
10249                   /* Avoid trying to get an operand off an identifier node.  */
10250                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10251                     tmp = declarator;
10252                   else
10253                     tmp = TREE_OPERAND (declarator, 0);
10254                   op = IDENTIFIER_OPNAME_P (tmp);
10255                   if (IDENTIFIER_TYPENAME_P (tmp))
10256                     {
10257                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10258                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10259                               == TYPE_DECL))
10260                         name = IDENTIFIER_POINTER (tmp);
10261                       else
10262                         name = "<invalid operator>";
10263                     }
10264                 }
10265               error ("storage class specified for %s `%s'",
10266                      op ? "member operator" : "field",
10267                      name);
10268             }
10269           else
10270             {
10271               if (decl_context == PARM || decl_context == CATCHPARM)
10272                 error ("storage class specified for parameter `%s'", name);
10273               else
10274                 error ("storage class specified for typename");
10275             }
10276           RIDBIT_RESET (RID_REGISTER, specbits);
10277           RIDBIT_RESET (RID_AUTO, specbits);
10278           RIDBIT_RESET (RID_EXTERN, specbits);
10279         }
10280     }
10281   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10282     {
10283       if (toplevel_bindings_p ())
10284         {
10285           /* It's common practice (and completely valid) to have a const
10286              be initialized and declared extern.  */
10287           if (!(type_quals & TYPE_QUAL_CONST))
10288             warning ("`%s' initialized and declared `extern'", name);
10289         }
10290       else
10291         error ("`%s' has both `extern' and initializer", name);
10292     }
10293   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10294            && ! toplevel_bindings_p ())
10295     error ("nested function `%s' declared `extern'", name);
10296   else if (toplevel_bindings_p ())
10297     {
10298       if (RIDBIT_SETP (RID_AUTO, specbits))
10299         error ("top-level declaration of `%s' specifies `auto'", name);
10300     }
10301
10302   if (nclasses > 0 && friendp)
10303     error ("storage class specifiers invalid in friend function declarations");
10304
10305   /* Now figure out the structure of the declarator proper.
10306      Descend through it, creating more complex types, until we reach
10307      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10308
10309   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10310          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10311     {
10312       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10313          an INDIRECT_REF (for *...),
10314          a CALL_EXPR (for ...(...)),
10315          an identifier (for the name being declared)
10316          or a null pointer (for the place in an absolute declarator
10317          where the name was omitted).
10318          For the last two cases, we have just exited the loop.
10319
10320          For C++ it could also be
10321          a SCOPE_REF (for class :: ...).  In this case, we have converted
10322          sensible names to types, and those are the values we use to
10323          qualify the member name.
10324          an ADDR_EXPR (for &...),
10325          a BIT_NOT_EXPR (for destructors)
10326
10327          At this point, TYPE is the type of elements of an array,
10328          or for a function to return, or for a pointer to point to.
10329          After this sequence of ifs, TYPE is the type of the
10330          array or function or pointer, and DECLARATOR has had its
10331          outermost layer removed.  */
10332
10333       if (type == error_mark_node)
10334         {
10335           if (TREE_CODE (declarator) == SCOPE_REF)
10336             declarator = TREE_OPERAND (declarator, 1);
10337           else
10338             declarator = TREE_OPERAND (declarator, 0);
10339           continue;
10340         }
10341       if (quals != NULL_TREE
10342           && (declarator == NULL_TREE
10343               || TREE_CODE (declarator) != SCOPE_REF))
10344         {
10345           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10346             ctype = TYPE_METHOD_BASETYPE (type);
10347           if (ctype != NULL_TREE)
10348             {
10349               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10350               grok_method_quals (ctype, dummy, quals);
10351               type = TREE_TYPE (dummy);
10352               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10353               quals = NULL_TREE;
10354             }
10355         }
10356
10357       switch (TREE_CODE (declarator))
10358         {
10359         case TREE_LIST:
10360           {
10361             /* We encode a declarator with embedded attributes using
10362                a TREE_LIST.  */
10363             tree attrs = TREE_PURPOSE (declarator);
10364             tree inner_decl;
10365             int attr_flags;
10366
10367             declarator = TREE_VALUE (declarator);
10368             inner_decl = declarator;
10369             while (inner_decl != NULL_TREE
10370                    && TREE_CODE (inner_decl) == TREE_LIST)
10371               inner_decl = TREE_VALUE (inner_decl);
10372             attr_flags = 0;
10373             if (inner_decl == NULL_TREE
10374                 || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
10375               attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
10376             if (TREE_CODE (inner_decl) == CALL_EXPR)
10377               attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
10378             if (TREE_CODE (inner_decl) == ARRAY_REF)
10379               attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
10380             returned_attrs = decl_attributes (&type,
10381                                               chainon (returned_attrs, attrs),
10382                                               attr_flags);
10383           }
10384           break;
10385
10386         case ARRAY_REF:
10387           {
10388             register tree size;
10389
10390             size = TREE_OPERAND (declarator, 1);
10391
10392             /* VC++ spells a zero-sized array with [].  */
10393             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10394                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10395               size = integer_zero_node;
10396
10397             declarator = TREE_OPERAND (declarator, 0);
10398
10399             type = create_array_type_for_decl (dname, type, size);
10400
10401             /* VLAs never work as fields. */
10402             if (decl_context == FIELD && !processing_template_decl
10403                 && TREE_CODE (type) == ARRAY_TYPE
10404                 && TYPE_DOMAIN (type) != NULL_TREE
10405                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10406               {
10407                 cp_error ("size of member `%D' is not constant", dname);
10408                 /* Proceed with arbitrary constant size, so that offset
10409                    computations don't get confused. */
10410                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10411                                                    integer_one_node);
10412               }
10413
10414             ctype = NULL_TREE;
10415           }
10416           break;
10417
10418         case CALL_EXPR:
10419           {
10420             tree arg_types;
10421             int funcdecl_p;
10422             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10423             tree inner_decl = TREE_OPERAND (declarator, 0);
10424
10425             /* Declaring a function type.
10426                Make sure we have a valid type for the function to return.  */
10427
10428             /* We now know that the TYPE_QUALS don't apply to the
10429                decl, but to its return type.  */
10430             type_quals = TYPE_UNQUALIFIED;
10431
10432             /* Warn about some types functions can't return.  */
10433
10434             if (TREE_CODE (type) == FUNCTION_TYPE)
10435               {
10436                 error ("`%s' declared as function returning a function", name);
10437                 type = integer_type_node;
10438               }
10439             if (TREE_CODE (type) == ARRAY_TYPE)
10440               {
10441                 error ("`%s' declared as function returning an array", name);
10442                 type = integer_type_node;
10443               }
10444
10445             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10446               inner_decl = TREE_OPERAND (inner_decl, 1);
10447
10448             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10449               inner_decl = dname;
10450
10451             /* Pick up type qualifiers which should be applied to `this'.  */
10452             quals = CALL_DECLARATOR_QUALS (declarator);
10453
10454             /* Pick up the exception specifications.  */
10455             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10456
10457             /* Say it's a definition only for the CALL_EXPR
10458                closest to the identifier.  */
10459             funcdecl_p
10460               = inner_decl
10461               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10462                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10463                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10464
10465             if (ctype == NULL_TREE
10466                 && decl_context == FIELD
10467                 && funcdecl_p
10468                 && (friendp == 0 || dname == current_class_name))
10469               ctype = current_class_type;
10470
10471             if (ctype && sfk == sfk_conversion)
10472               TYPE_HAS_CONVERSION (ctype) = 1;
10473             if (ctype && constructor_name (ctype) == dname)
10474               {
10475                 /* We are within a class's scope. If our declarator name
10476                    is the same as the class name, and we are defining
10477                    a function, then it is a constructor/destructor, and
10478                    therefore returns a void type.  */
10479
10480                 if (flags == DTOR_FLAG)
10481                   {
10482                     /* ISO C++ 12.4/2.  A destructor may not be
10483                        declared const or volatile.  A destructor may
10484                        not be static.  */
10485                     if (staticp == 2)
10486                       error ("destructor cannot be static member function");
10487                     if (quals)
10488                       {
10489                         cp_error ("destructors may not be `%s'",
10490                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10491                         quals = NULL_TREE;
10492                       }
10493                     if (decl_context == FIELD)
10494                       {
10495                         if (! member_function_or_else (ctype,
10496                                                        current_class_type,
10497                                                        flags))
10498                           return void_type_node;
10499                       }
10500                   }
10501                 else            /* It's a constructor.  */
10502                   {
10503                     if (explicitp == 1)
10504                       explicitp = 2;
10505                     /* ISO C++ 12.1.  A constructor may not be
10506                        declared const or volatile.  A constructor may
10507                        not be virtual.  A constructor may not be
10508                        static.  */
10509                     if (staticp == 2)
10510                       error ("constructor cannot be static member function");
10511                     if (virtualp)
10512                       {
10513                         pedwarn ("constructors cannot be declared virtual");
10514                         virtualp = 0;
10515                       }
10516                     if (quals)
10517                       {
10518                         cp_error ("constructors may not be `%s'",
10519                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10520                         quals = NULL_TREE;
10521                       }
10522                     {
10523                       RID_BIT_TYPE tmp_bits;
10524                       memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
10525                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10526                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10527                       if (RIDBIT_ANY_SET (tmp_bits))
10528                         error ("return value type specifier for constructor ignored");
10529                     }
10530                     if (decl_context == FIELD)
10531                       {
10532                         if (! member_function_or_else (ctype,
10533                                                        current_class_type,
10534                                                        flags))
10535                           return void_type_node;
10536                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10537                         if (sfk != sfk_constructor)
10538                           return NULL_TREE;
10539                       }
10540                   }
10541                 if (decl_context == FIELD)
10542                   staticp = 0;
10543               }
10544             else if (friendp)
10545               {
10546                 if (initialized)
10547                   error ("can't initialize friend function `%s'", name);
10548                 if (virtualp)
10549                   {
10550                     /* Cannot be both friend and virtual.  */
10551                     error ("virtual functions cannot be friends");
10552                     RIDBIT_RESET (RID_FRIEND, specbits);
10553                     friendp = 0;
10554                   }
10555                 if (decl_context == NORMAL)
10556                   error ("friend declaration not in class definition");
10557                 if (current_function_decl && funcdef_flag)
10558                   cp_error ("can't define friend function `%s' in a local class definition",
10559                             name);
10560               }
10561
10562             /* Construct the function type and go to the next
10563                inner layer of declarator.  */
10564
10565             declarator = TREE_OPERAND (declarator, 0);
10566
10567             /* FIXME: This is where default args should be fully
10568                processed.  */
10569
10570             arg_types = grokparms (inner_parms);
10571
10572             if (declarator && flags == DTOR_FLAG)
10573               {
10574                 /* A destructor declared in the body of a class will
10575                    be represented as a BIT_NOT_EXPR.  But, we just
10576                    want the underlying IDENTIFIER.  */
10577                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10578                   declarator = TREE_OPERAND (declarator, 0);
10579
10580                 if (arg_types != void_list_node)
10581                   {
10582                     cp_error ("destructors may not have parameters");
10583                     arg_types = void_list_node;
10584                     last_function_parms = NULL_TREE;
10585                   }
10586               }
10587
10588             /* ANSI says that `const int foo ();'
10589                does not make the function foo const.  */
10590             type = build_function_type (type, arg_types);
10591
10592             {
10593               tree t;
10594               for (t = arg_types; t; t = TREE_CHAIN (t))
10595                 if (TREE_PURPOSE (t)
10596                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10597                   {
10598                     add_defarg_fn (type);
10599                     break;
10600                   }
10601             }
10602           }
10603           break;
10604
10605         case ADDR_EXPR:
10606         case INDIRECT_REF:
10607           /* Filter out pointers-to-references and references-to-references.
10608              We can get these if a TYPE_DECL is used.  */
10609
10610           if (TREE_CODE (type) == REFERENCE_TYPE)
10611             {
10612               error ("cannot declare %s to references",
10613                      TREE_CODE (declarator) == ADDR_EXPR
10614                      ? "references" : "pointers");
10615               declarator = TREE_OPERAND (declarator, 0);
10616               continue;
10617             }
10618
10619           if (TREE_CODE (type) == OFFSET_TYPE
10620               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10621                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10622             {
10623               cp_error ("cannot declare pointer to `%#T' member",
10624                         TREE_TYPE (type));
10625               type = TREE_TYPE (type);
10626             }
10627
10628           /* Merge any constancy or volatility into the target type
10629              for the pointer.  */
10630
10631           /* We now know that the TYPE_QUALS don't apply to the decl,
10632              but to the target of the pointer.  */
10633           type_quals = TYPE_UNQUALIFIED;
10634
10635           if (TREE_CODE (declarator) == ADDR_EXPR)
10636             {
10637               if (TREE_CODE (type) == VOID_TYPE)
10638                 error ("invalid type: `void &'");
10639               else
10640                 type = build_reference_type (type);
10641             }
10642           else if (TREE_CODE (type) == METHOD_TYPE)
10643             type = build_ptrmemfunc_type (build_pointer_type (type));
10644           else
10645             type = build_pointer_type (type);
10646
10647           /* Process a list of type modifier keywords (such as
10648              const or volatile) that were given inside the `*' or `&'.  */
10649
10650           if (TREE_TYPE (declarator))
10651             {
10652               register tree typemodlist;
10653               int erred = 0;
10654
10655               constp = 0;
10656               volatilep = 0;
10657               restrictp = 0;
10658               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10659                    typemodlist = TREE_CHAIN (typemodlist))
10660                 {
10661                   tree qualifier = TREE_VALUE (typemodlist);
10662
10663                   if (qualifier == ridpointers[(int) RID_CONST])
10664                     constp++;
10665                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10666                     volatilep++;
10667                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10668                     restrictp++;
10669                   else if (!erred)
10670                     {
10671                       erred = 1;
10672                       error ("invalid type modifier within pointer declarator");
10673                     }
10674                 }
10675               if (constp > 1)
10676                 pedwarn ("duplicate `const'");
10677               if (volatilep > 1)
10678                 pedwarn ("duplicate `volatile'");
10679               if (restrictp > 1)
10680                 pedwarn ("duplicate `restrict'");
10681
10682               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10683                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10684                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10685               if (TREE_CODE (declarator) == ADDR_EXPR
10686                   && (constp || volatilep))
10687                 {
10688                   if (constp)
10689                     pedwarn ("discarding `const' applied to a reference");
10690                   if (volatilep)
10691                     pedwarn ("discarding `volatile' applied to a reference");
10692                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10693                 }
10694               type = cp_build_qualified_type (type, type_quals);
10695             }
10696           declarator = TREE_OPERAND (declarator, 0);
10697           ctype = NULL_TREE;
10698           break;
10699
10700         case SCOPE_REF:
10701           {
10702             /* We have converted type names to NULL_TREE if the
10703                name was bogus, or to a _TYPE node, if not.
10704
10705                The variable CTYPE holds the type we will ultimately
10706                resolve to.  The code here just needs to build
10707                up appropriate member types.  */
10708             tree sname = TREE_OPERAND (declarator, 1);
10709             tree t;
10710
10711             /* Destructors can have their visibilities changed as well.  */
10712             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10713               sname = TREE_OPERAND (sname, 0);
10714
10715             if (TREE_COMPLEXITY (declarator) == 0)
10716               /* This needs to be here, in case we are called
10717                  multiple times.  */ ;
10718             else if (TREE_COMPLEXITY (declarator) == -1)
10719               /* Namespace member. */
10720               pop_decl_namespace ();
10721             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10722               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10723             else if (! IS_AGGR_TYPE_CODE
10724                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10725               ;
10726             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10727               {
10728                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10729                    that refer to ctype.  They couldn't be resolved earlier
10730                    because we hadn't pushed into the class yet.
10731                    Example: resolve 'B<T>::type' in
10732                    'B<typename B<T>::type> B<T>::f () { }'.  */
10733                 if (current_template_parms
10734                     && uses_template_parms (type)
10735                     && uses_template_parms (current_class_type))
10736                   {
10737                     tree args = current_template_args ();
10738                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10739                   }
10740
10741                 /* This pop_nested_class corresponds to the
10742                    push_nested_class used to push into class scope for
10743                    parsing the argument list of a function decl, in
10744                    qualified_id.  */
10745                 pop_nested_class ();
10746                 TREE_COMPLEXITY (declarator) = current_class_depth;
10747               }
10748             else
10749               my_friendly_abort (16);
10750
10751             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10752               {
10753                 /* We had a reference to a global decl, or
10754                    perhaps we were given a non-aggregate typedef,
10755                    in which case we cleared this out, and should just
10756                    keep going as though it wasn't there.  */
10757                 declarator = sname;
10758                 continue;
10759               }
10760             ctype = TREE_OPERAND (declarator, 0);
10761
10762             t = ctype;
10763             while (t != NULL_TREE && CLASS_TYPE_P (t))
10764               {
10765                 /* You're supposed to have one `template <...>'
10766                    for every template class, but you don't need one
10767                    for a full specialization.  For example:
10768
10769                      template <class T> struct S{};
10770                      template <> struct S<int> { void f(); };
10771                      void S<int>::f () {}
10772
10773                    is correct; there shouldn't be a `template <>' for
10774                    the definition of `S<int>::f'.  */
10775                 if (CLASSTYPE_TEMPLATE_INFO (t)
10776                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10777                         || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
10778                     && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
10779                   template_count += 1;
10780
10781                 t = TYPE_MAIN_DECL (t);
10782                 t = DECL_CONTEXT (t);
10783               }
10784
10785             if (sname == NULL_TREE)
10786               goto done_scoping;
10787
10788             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10789               {
10790                 /* This is the `standard' use of the scoping operator:
10791                    basetype :: member .  */
10792
10793                 if (ctype == current_class_type)
10794                   {
10795                     /* class A {
10796                          void A::f ();
10797                        };
10798
10799                        Is this ill-formed?  */
10800
10801                     if (pedantic)
10802                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10803                                   ctype, name);
10804                   }
10805                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10806                   {
10807                     if (current_class_type == NULL_TREE || friendp)
10808                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10809                                                       TYPE_ARG_TYPES (type));
10810                     else
10811                       {
10812                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10813                                   ctype, name, current_class_type);
10814                         return void_type_node;
10815                       }
10816                   }
10817                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10818                          || COMPLETE_TYPE_P (complete_type (ctype)))
10819                   {
10820                     /* Have to move this code elsewhere in this function.
10821                        this code is used for i.e., typedef int A::M; M *pm;
10822
10823                        It is?  How? jason 10/2/94 */
10824
10825                     if (current_class_type)
10826                       {
10827                         cp_error ("cannot declare member `%T::%s' within `%T'",
10828                                   ctype, name, current_class_type);
10829                         return void_type_node;
10830                       }
10831                     type = build_offset_type (ctype, type);
10832                   }
10833                 else
10834                   {
10835                     incomplete_type_error (NULL_TREE, ctype);
10836                     return error_mark_node;
10837                   }
10838
10839                 declarator = sname;
10840               }
10841             else if (TREE_CODE (sname) == SCOPE_REF)
10842               my_friendly_abort (17);
10843             else
10844               {
10845               done_scoping:
10846                 declarator = TREE_OPERAND (declarator, 1);
10847                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10848                   /* In this case, we will deal with it later.  */
10849                   ;
10850                 else
10851                   {
10852                     if (TREE_CODE (type) == FUNCTION_TYPE)
10853                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10854                                                       TYPE_ARG_TYPES (type));
10855                     else
10856                       type = build_offset_type (ctype, type);
10857                   }
10858               }
10859           }
10860           break;
10861
10862         case BIT_NOT_EXPR:
10863           declarator = TREE_OPERAND (declarator, 0);
10864           break;
10865
10866         case RECORD_TYPE:
10867         case UNION_TYPE:
10868         case ENUMERAL_TYPE:
10869           declarator = NULL_TREE;
10870           break;
10871
10872         case ERROR_MARK:
10873           declarator = NULL_TREE;
10874           break;
10875
10876         default:
10877           my_friendly_abort (158);
10878         }
10879     }
10880
10881   if (returned_attrs)
10882     {
10883       if (attrlist)
10884         *attrlist = chainon (returned_attrs, *attrlist);
10885       else
10886         attrlist = &returned_attrs;
10887     }
10888
10889   /* Now TYPE has the actual type.  */
10890
10891   /* Did array size calculations overflow?  */
10892
10893   if (TREE_CODE (type) == ARRAY_TYPE
10894       && COMPLETE_TYPE_P (type)
10895       && TREE_OVERFLOW (TYPE_SIZE (type)))
10896     {
10897       error ("size of array `%s' is too large", name);
10898       /* If we proceed with the array type as it is, we'll eventully
10899          crash in tree_low_cst().  */
10900       type = error_mark_node;
10901     }
10902
10903   if (explicitp == 1 || (explicitp && friendp))
10904     {
10905       /* [dcl.fct.spec] The explicit specifier shall only be used in
10906          declarations of constructors within a class definition.  */
10907       error ("only declarations of constructors can be `explicit'");
10908       explicitp = 0;
10909     }
10910
10911   if (RIDBIT_SETP (RID_MUTABLE, specbits))
10912     {
10913       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
10914         {
10915           error ("non-member `%s' cannot be declared `mutable'", name);
10916           RIDBIT_RESET (RID_MUTABLE, specbits);
10917         }
10918       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
10919         {
10920           error ("non-object member `%s' cannot be declared `mutable'", name);
10921           RIDBIT_RESET (RID_MUTABLE, specbits);
10922         }
10923       else if (TREE_CODE (type) == FUNCTION_TYPE
10924                || TREE_CODE (type) == METHOD_TYPE)
10925         {
10926           error ("function `%s' cannot be declared `mutable'", name);
10927           RIDBIT_RESET (RID_MUTABLE, specbits);
10928         }
10929       else if (staticp)
10930         {
10931           error ("static `%s' cannot be declared `mutable'", name);
10932           RIDBIT_RESET (RID_MUTABLE, specbits);
10933         }
10934       else if (type_quals & TYPE_QUAL_CONST)
10935         {
10936           error ("const `%s' cannot be declared `mutable'", name);
10937           RIDBIT_RESET (RID_MUTABLE, specbits);
10938         }
10939     }
10940
10941   if (declarator == NULL_TREE
10942       || TREE_CODE (declarator) == IDENTIFIER_NODE
10943       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
10944           && (TREE_CODE (type) == FUNCTION_TYPE
10945               || TREE_CODE (type) == METHOD_TYPE)))
10946     /* OK */;
10947   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10948     {
10949       cp_error ("template-id `%D' used as a declarator", declarator);
10950       declarator = dname;
10951     }
10952   else
10953     /* Unexpected declarator format.  */
10954     my_friendly_abort (990210);
10955
10956   /* If this is declaring a typedef name, return a TYPE_DECL.  */
10957
10958   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
10959     {
10960       tree decl;
10961
10962       /* Note that the grammar rejects storage classes
10963          in typenames, fields or parameters.  */
10964       if (current_lang_name == lang_name_java)
10965         TYPE_FOR_JAVA (type) = 1;
10966
10967       if (decl_context == FIELD)
10968         {
10969           if (declarator == constructor_name (current_class_type))
10970             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
10971                         declarator);
10972           decl = build_lang_decl (TYPE_DECL, declarator, type);
10973         }
10974       else
10975         {
10976           decl = build_decl (TYPE_DECL, declarator, type);
10977           if (!current_function_decl)
10978             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
10979         }
10980
10981       /* If the user declares "typedef struct {...} foo" then the
10982          struct will have an anonymous name.  Fill that name in now.
10983          Nothing can refer to it, so nothing needs know about the name
10984          change.  */
10985       if (type != error_mark_node
10986           && declarator
10987           && TYPE_NAME (type)
10988           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10989           && TYPE_ANONYMOUS_P (type)
10990           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
10991         {
10992           tree oldname = TYPE_NAME (type);
10993           tree t;
10994
10995           /* Replace the anonymous name with the real name everywhere.  */
10996           lookup_tag_reverse (type, declarator);
10997           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10998             if (TYPE_NAME (t) == oldname)
10999               TYPE_NAME (t) = decl;
11000
11001           if (TYPE_LANG_SPECIFIC (type))
11002             TYPE_WAS_ANONYMOUS (type) = 1;
11003
11004           /* If this is a typedef within a template class, the nested
11005              type is a (non-primary) template.  The name for the
11006              template needs updating as well.  */
11007           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11008             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11009               = TYPE_IDENTIFIER (type);
11010
11011           /* FIXME remangle member functions; member functions of a
11012              type with external linkage have external linkage.  */
11013         }
11014
11015       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11016         {
11017           cp_error_at ("typedef name may not be class-qualified", decl);
11018           return NULL_TREE;
11019         }
11020       else if (quals)
11021         {
11022           if (ctype == NULL_TREE)
11023             {
11024               if (TREE_CODE (type) != METHOD_TYPE)
11025                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11026               else
11027                 ctype = TYPE_METHOD_BASETYPE (type);
11028             }
11029           if (ctype != NULL_TREE)
11030             grok_method_quals (ctype, decl, quals);
11031         }
11032
11033       if (RIDBIT_SETP (RID_SIGNED, specbits)
11034           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11035         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11036
11037       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11038                       inlinep, friendp, raises != NULL_TREE);
11039
11040       if (initialized)
11041         error ("typedef declaration includes an initializer");
11042
11043       return decl;
11044     }
11045
11046   /* Detect the case of an array type of unspecified size
11047      which came, as such, direct from a typedef name.
11048      We must copy the type, so that each identifier gets
11049      a distinct type, so that each identifier's size can be
11050      controlled separately by its own initializer.  */
11051
11052   if (type != 0 && typedef_type != 0
11053       && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0
11054       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
11055     {
11056       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11057     }
11058
11059   /* Detect where we're using a typedef of function type to declare a
11060      function. last_function_parms will not be set, so we must create
11061      it now.  */
11062
11063   if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
11064     {
11065       tree decls = NULL_TREE;
11066       tree args;
11067
11068       for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
11069         {
11070           tree decl = build_decl (PARM_DECL, NULL_TREE, TREE_VALUE (args));
11071
11072           TREE_CHAIN (decl) = decls;
11073           decls = decl;
11074         }
11075
11076       last_function_parms = nreverse (decls);
11077     }
11078
11079   /* If this is a type name (such as, in a cast or sizeof),
11080      compute the type and return it now.  */
11081
11082   if (decl_context == TYPENAME)
11083     {
11084       /* Note that the grammar rejects storage classes
11085          in typenames, fields or parameters.  */
11086       if (type_quals != TYPE_UNQUALIFIED)
11087         type_quals = TYPE_UNQUALIFIED;
11088
11089       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11090       if (friendp)
11091         {
11092           if (type_quals != TYPE_UNQUALIFIED)
11093             {
11094               cp_error ("type qualifiers specified for friend class declaration");
11095               type_quals = TYPE_UNQUALIFIED;
11096             }
11097           if (inlinep)
11098             {
11099               cp_error ("`inline' specified for friend class declaration");
11100               inlinep = 0;
11101             }
11102
11103           /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11104              But don't allow implicit typenames except with a class-key.  */
11105           if (!current_aggr && (TREE_CODE (type) != TYPENAME_TYPE
11106                                 || IMPLICIT_TYPENAME_P (type)))
11107             {
11108               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11109                 cp_pedwarn ("template parameters cannot be friends");
11110               else if (TREE_CODE (type) == TYPENAME_TYPE)
11111                 cp_pedwarn ("\
11112 friend declaration requires class-key, i.e. `friend class %T::%T'",
11113                             constructor_name (current_class_type),
11114                             TYPE_IDENTIFIER (type));
11115               else
11116                 cp_pedwarn ("\
11117 friend declaration requires class-key, i.e. `friend %#T'",
11118                             type);
11119             }
11120
11121           /* Only try to do this stuff if we didn't already give up.  */
11122           if (type != integer_type_node)
11123             {
11124               /* DR 209. The friendly class does not need to be accessible
11125                  in the scope of the class granting friendship. */
11126               skip_type_access_control ();
11127
11128               /* A friendly class?  */
11129               if (current_class_type)
11130                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11131               else
11132                 cp_error ("trying to make class `%T' a friend of global scope",
11133                           type);
11134
11135               type = void_type_node;
11136             }
11137         }
11138       else if (quals)
11139         {
11140           if (ctype == NULL_TREE)
11141             {
11142               if (TREE_CODE (type) != METHOD_TYPE)
11143                 cp_error ("invalid qualifiers on non-member function type");
11144               else
11145                 ctype = TYPE_METHOD_BASETYPE (type);
11146             }
11147           if (ctype)
11148             {
11149               tree dummy = build_decl (TYPE_DECL, declarator, type);
11150               grok_method_quals (ctype, dummy, quals);
11151               type = TREE_TYPE (dummy);
11152             }
11153         }
11154
11155       return type;
11156     }
11157   else if (declarator == NULL_TREE && decl_context != PARM
11158            && decl_context != CATCHPARM
11159            && TREE_CODE (type) != UNION_TYPE
11160            && ! bitfield)
11161     {
11162       cp_error ("abstract declarator `%T' used as declaration", type);
11163       declarator = make_anon_name ();
11164     }
11165
11166   /* `void' at top level (not within pointer)
11167      is allowed only in typedefs or type names.
11168      We don't complain about parms either, but that is because
11169      a better error message can be made later.  */
11170
11171   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11172     {
11173       if (! declarator)
11174         error ("unnamed variable or field declared void");
11175       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11176         {
11177           if (IDENTIFIER_OPNAME_P (declarator))
11178             my_friendly_abort (356);
11179           else
11180             error ("variable or field `%s' declared void", name);
11181         }
11182       else
11183         error ("variable or field declared void");
11184       type = integer_type_node;
11185     }
11186
11187   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11188      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11189
11190   if (decl_context == PARM || decl_context == CATCHPARM)
11191     {
11192       if (ctype || in_namespace)
11193         error ("cannot use `::' in parameter declaration");
11194
11195       /* A parameter declared as an array of T is really a pointer to T.
11196          One declared as a function is really a pointer to a function.
11197          One declared as a member is really a pointer to member.  */
11198
11199       if (TREE_CODE (type) == ARRAY_TYPE)
11200         {
11201           /* Transfer const-ness of array into that of type pointed to.  */
11202           type = build_pointer_type (TREE_TYPE (type));
11203           type_quals = TYPE_UNQUALIFIED;
11204         }
11205       else if (TREE_CODE (type) == FUNCTION_TYPE)
11206         type = build_pointer_type (type);
11207       else if (TREE_CODE (type) == OFFSET_TYPE)
11208         type = build_pointer_type (type);
11209     }
11210
11211   {
11212     register tree decl;
11213
11214     if (decl_context == PARM)
11215       {
11216         decl = build_decl (PARM_DECL, declarator, type);
11217
11218         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11219                         inlinep, friendp, raises != NULL_TREE);
11220
11221         /* Compute the type actually passed in the parmlist,
11222            for the case where there is no prototype.
11223            (For example, shorts and chars are passed as ints.)
11224            When there is a prototype, this is overridden later.  */
11225
11226         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11227       }
11228     else if (decl_context == FIELD)
11229       {
11230         if (type == error_mark_node)
11231           {
11232             /* Happens when declaring arrays of sizes which
11233                are error_mark_node, for example.  */
11234             decl = NULL_TREE;
11235           }
11236         else if (in_namespace && !friendp)
11237           {
11238             /* Something like struct S { int N::j; };  */
11239             cp_error ("invalid use of `::'");
11240             decl = NULL_TREE;
11241           }
11242         else if (TREE_CODE (type) == FUNCTION_TYPE)
11243           {
11244             int publicp = 0;
11245             tree function_context;
11246
11247             /* We catch the others as conflicts with the builtin
11248                typedefs.  */
11249             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11250               {
11251                 cp_error ("function `%D' cannot be declared friend",
11252                           declarator);
11253                 friendp = 0;
11254               }
11255
11256             if (friendp == 0)
11257               {
11258                 if (ctype == NULL_TREE)
11259                   ctype = current_class_type;
11260
11261                 if (ctype == NULL_TREE)
11262                   {
11263                     cp_error ("can't make `%D' into a method -- not in a class",
11264                               declarator);
11265                     return void_type_node;
11266                   }
11267
11268                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11269                    ARM 9.5 */
11270                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11271                   {
11272                     cp_error ("function `%D' declared virtual inside a union",
11273                               declarator);
11274                     return void_type_node;
11275                   }
11276
11277                 if (declarator == ansi_opname (NEW_EXPR)
11278                     || declarator == ansi_opname (VEC_NEW_EXPR)
11279                     || declarator == ansi_opname (DELETE_EXPR)
11280                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11281                   {
11282                     if (virtualp)
11283                       {
11284                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11285                                   declarator);
11286                         virtualp = 0;
11287                       }
11288                   }
11289                 else if (staticp < 2)
11290                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11291                                                   TYPE_ARG_TYPES (type));
11292               }
11293
11294             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11295             function_context = (ctype != NULL_TREE) ?
11296               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11297             publicp = (! friendp || ! staticp)
11298               && function_context == NULL_TREE;
11299             decl = grokfndecl (ctype, type,
11300                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11301                                ? declarator : dname,
11302                                declarator,
11303                                virtualp, flags, quals, raises,
11304                                friendp ? -1 : 0, friendp, publicp, inlinep,
11305                                funcdef_flag, template_count, in_namespace);
11306             if (decl == NULL_TREE)
11307               return decl;
11308 #if 0
11309             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11310             /* The decl and setting of decl_attr is also turned off.  */
11311             decl = build_decl_attribute_variant (decl, decl_attr);
11312 #endif
11313
11314             /* [class.conv.ctor]
11315
11316                A constructor declared without the function-specifier
11317                explicit that can be called with a single parameter
11318                specifies a conversion from the type of its first
11319                parameter to the type of its class.  Such a constructor
11320                is called a converting constructor.  */
11321             if (explicitp == 2)
11322               DECL_NONCONVERTING_P (decl) = 1;
11323             else if (DECL_CONSTRUCTOR_P (decl))
11324               {
11325                 /* The constructor can be called with exactly one
11326                    parameter if there is at least one parameter, and
11327                    any subsequent parameters have default arguments.
11328                    Ignore any compiler-added parms.  */
11329                 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
11330
11331                 if (arg_types == void_list_node
11332                     || (arg_types
11333                         && TREE_CHAIN (arg_types)
11334                         && TREE_CHAIN (arg_types) != void_list_node
11335                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11336                   DECL_NONCONVERTING_P (decl) = 1;
11337               }
11338           }
11339         else if (TREE_CODE (type) == METHOD_TYPE)
11340           {
11341             /* We only get here for friend declarations of
11342                members of other classes.  */
11343             /* All method decls are public, so tell grokfndecl to set
11344                TREE_PUBLIC, also.  */
11345             decl = grokfndecl (ctype, type, declarator, declarator,
11346                                virtualp, flags, quals, raises,
11347                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11348                                template_count, in_namespace);
11349             if (decl == NULL_TREE)
11350               return NULL_TREE;
11351           }
11352         else if (!staticp && ! processing_template_decl
11353                  && !COMPLETE_TYPE_P (complete_type (type))
11354                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11355           {
11356             if (declarator)
11357               cp_error ("field `%D' has incomplete type", declarator);
11358             else
11359               cp_error ("name `%T' has incomplete type", type);
11360
11361             /* If we're instantiating a template, tell them which
11362                instantiation made the field's type be incomplete.  */
11363             if (current_class_type
11364                 && TYPE_NAME (current_class_type)
11365                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11366                 && declspecs && TREE_VALUE (declspecs)
11367                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11368               cp_error ("  in instantiation of template `%T'",
11369                         current_class_type);
11370
11371             type = error_mark_node;
11372             decl = NULL_TREE;
11373           }
11374         else
11375           {
11376             if (friendp)
11377               {
11378                 error ("`%s' is neither function nor member function; cannot be declared friend",
11379                        IDENTIFIER_POINTER (declarator));
11380                 friendp = 0;
11381               }
11382             decl = NULL_TREE;
11383           }
11384
11385         if (friendp)
11386           {
11387             /* Friends are treated specially.  */
11388             tree t = NULL_TREE;
11389
11390             /* DR 209. The friend does not need to be accessible at this
11391                point. */
11392             skip_type_access_control ();
11393
11394             if (ctype == current_class_type)
11395               warning ("member functions are implicitly friends of their class");
11396
11397             if (decl && DECL_NAME (decl))
11398               {
11399                 if (template_class_depth (current_class_type) == 0)
11400                   {
11401                     decl = check_explicit_specialization
11402                             (declarator, decl,
11403                              template_count, 2 * (funcdef_flag != 0) + 4);
11404                     if (decl == error_mark_node)
11405                       return error_mark_node;
11406                   }
11407
11408                 t = do_friend (ctype, declarator, decl,
11409                                last_function_parms, *attrlist, flags, quals,
11410                                funcdef_flag);
11411               }
11412             if (t && funcdef_flag)
11413               return t;
11414             return void_type_node;
11415           }
11416
11417         /* Structure field.  It may not be a function, except for C++ */
11418
11419         if (decl == NULL_TREE)
11420           {
11421             if (initialized)
11422               {
11423                 if (!staticp)
11424                   {
11425                     /* An attempt is being made to initialize a non-static
11426                        member.  But, from [class.mem]:
11427
11428                        4 A member-declarator can contain a
11429                        constant-initializer only if it declares a static
11430                        member (_class.static_) of integral or enumeration
11431                        type, see _class.static.data_.
11432
11433                        This used to be relatively common practice, but
11434                        the rest of the compiler does not correctly
11435                        handle the initialization unless the member is
11436                        static so we make it static below.  */
11437                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11438                                 declarator);
11439                     cp_pedwarn ("making `%D' static", declarator);
11440                     staticp = 1;
11441                   }
11442
11443                 if (uses_template_parms (type))
11444                   /* We'll check at instantiation time.  */
11445                   ;
11446                 else if (check_static_variable_definition (declarator,
11447                                                            type))
11448                   /* If we just return the declaration, crashes
11449                      will sometimes occur.  We therefore return
11450                      void_type_node, as if this was a friend
11451                      declaration, to cause callers to completely
11452                      ignore this declaration.  */
11453                   return void_type_node;
11454               }
11455
11456             /* 9.2p13 [class.mem] */
11457             if (declarator == constructor_name (current_class_type)
11458                 /* The standard does not allow non-static data members
11459                    here either, but we agreed at the 10/99 meeting
11460                    to change that in TC 1 so that they are allowed in
11461                    classes with no user-defined constructors.  */
11462                 && staticp)
11463               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11464                           declarator);
11465
11466             if (staticp)
11467               {
11468                 /* C++ allows static class members.  All other work
11469                    for this is done by grokfield.  */
11470                 decl = build_lang_decl (VAR_DECL, declarator, type);
11471                 TREE_STATIC (decl) = 1;
11472                 /* In class context, 'static' means public access.  */
11473                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11474               }
11475             else
11476               {
11477                 decl = build_decl (FIELD_DECL, declarator, type);
11478                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11479                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11480                   {
11481                     DECL_MUTABLE_P (decl) = 1;
11482                     RIDBIT_RESET (RID_MUTABLE, specbits);
11483                   }
11484               }
11485
11486             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11487                             inlinep, friendp, raises != NULL_TREE);
11488           }
11489       }
11490     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11491       {
11492         tree original_name;
11493         int publicp = 0;
11494
11495         if (! declarator)
11496           return NULL_TREE;
11497
11498         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11499           original_name = dname;
11500         else
11501           original_name = declarator;
11502
11503         if (RIDBIT_SETP (RID_AUTO, specbits))
11504           error ("storage class `auto' invalid for function `%s'", name);
11505         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11506           error ("storage class `register' invalid for function `%s'", name);
11507
11508         /* Function declaration not at top level.
11509            Storage classes other than `extern' are not allowed
11510            and `extern' makes no difference.  */
11511         if (! toplevel_bindings_p ()
11512             && (RIDBIT_SETP (RID_STATIC, specbits)
11513                 || RIDBIT_SETP (RID_INLINE, specbits))
11514             && pedantic)
11515           {
11516             if (RIDBIT_SETP (RID_STATIC, specbits))
11517               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11518             else
11519               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11520           }
11521
11522         if (ctype == NULL_TREE)
11523           {
11524             if (virtualp)
11525               {
11526                 error ("virtual non-class function `%s'", name);
11527                 virtualp = 0;
11528               }
11529           }
11530         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11531           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11532                                           TYPE_ARG_TYPES (type));
11533
11534         /* Record presence of `static'.  */
11535         publicp = (ctype != NULL_TREE
11536                    || RIDBIT_SETP (RID_EXTERN, specbits)
11537                    || !RIDBIT_SETP (RID_STATIC, specbits));
11538
11539         decl = grokfndecl (ctype, type, original_name, declarator,
11540                            virtualp, flags, quals, raises,
11541                            1, friendp,
11542                            publicp, inlinep, funcdef_flag,
11543                            template_count, in_namespace);
11544         if (decl == NULL_TREE)
11545           return NULL_TREE;
11546
11547         if (staticp == 1)
11548           {
11549             int illegal_static = 0;
11550
11551             /* Don't allow a static member function in a class, and forbid
11552                declaring main to be static.  */
11553             if (TREE_CODE (type) == METHOD_TYPE)
11554               {
11555                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11556                 illegal_static = 1;
11557               }
11558             else if (current_function_decl)
11559               {
11560                 /* FIXME need arm citation */
11561                 error ("cannot declare static function inside another function");
11562                 illegal_static = 1;
11563               }
11564
11565             if (illegal_static)
11566               {
11567                 staticp = 0;
11568                 RIDBIT_RESET (RID_STATIC, specbits);
11569               }
11570           }
11571       }
11572     else
11573       {
11574         /* It's a variable.  */
11575
11576         /* An uninitialized decl with `extern' is a reference.  */
11577         decl = grokvardecl (type, declarator, &specbits,
11578                             initialized,
11579                             (type_quals & TYPE_QUAL_CONST) != 0,
11580                             in_namespace);
11581         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11582                         inlinep, friendp, raises != NULL_TREE);
11583
11584         if (ctype)
11585           {
11586             DECL_CONTEXT (decl) = ctype;
11587             if (staticp == 1)
11588               {
11589                 cp_pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
11590                 staticp = 0;
11591                 RIDBIT_RESET (RID_STATIC, specbits);
11592               }
11593             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11594               {
11595                 cp_error ("static member `%D' declared `register'", decl);
11596                 RIDBIT_RESET (RID_REGISTER, specbits);
11597               }
11598             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11599               {
11600                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11601                             decl);
11602                 RIDBIT_RESET (RID_EXTERN, specbits);
11603               }
11604           }
11605       }
11606
11607     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11608
11609     /* Record `register' declaration for warnings on &
11610        and in case doing stupid register allocation.  */
11611
11612     if (RIDBIT_SETP (RID_REGISTER, specbits))
11613       DECL_REGISTER (decl) = 1;
11614
11615     if (RIDBIT_SETP (RID_EXTERN, specbits))
11616       DECL_THIS_EXTERN (decl) = 1;
11617
11618     if (RIDBIT_SETP (RID_STATIC, specbits))
11619       DECL_THIS_STATIC (decl) = 1;
11620
11621     /* Record constancy and volatility.  There's no need to do this
11622        when processing a template; we'll do this for the instantiated
11623        declaration based on the type of DECL.  */
11624     if (!processing_template_decl)
11625       c_apply_type_quals_to_decl (type_quals, decl);
11626
11627     return decl;
11628   }
11629 }
11630 \f
11631 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11632    An empty exprlist is a parmlist.  An exprlist which
11633    contains only identifiers at the global level
11634    is a parmlist.  Otherwise, it is an exprlist.  */
11635
11636 int
11637 parmlist_is_exprlist (exprs)
11638      tree exprs;
11639 {
11640   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11641     return 0;
11642
11643   if (toplevel_bindings_p ())
11644     {
11645       /* At the global level, if these are all identifiers,
11646          then it is a parmlist.  */
11647       while (exprs)
11648         {
11649           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11650             return 1;
11651           exprs = TREE_CHAIN (exprs);
11652         }
11653       return 0;
11654     }
11655   return 1;
11656 }
11657
11658 /* Subroutine of start_function.  Ensure that each of the parameter
11659    types (as listed in PARMS) is complete, as is required for a
11660    function definition.  */
11661
11662 static void
11663 require_complete_types_for_parms (parms)
11664      tree parms;
11665 {
11666   for (; parms; parms = TREE_CHAIN (parms))
11667     {
11668       if (VOID_TYPE_P (TREE_TYPE (parms)))
11669         /* grokparms will have already issued an error */
11670         TREE_TYPE (parms) = error_mark_node;
11671       else if (complete_type_or_else (TREE_TYPE (parms), parms))
11672         layout_decl (parms, 0);
11673       else
11674         TREE_TYPE (parms) = error_mark_node;
11675     }
11676 }
11677
11678 /* Returns non-zero if T is a local variable.  */
11679
11680 int
11681 local_variable_p (t)
11682      tree t;
11683 {
11684   if ((TREE_CODE (t) == VAR_DECL
11685        /* A VAR_DECL with a context that is a _TYPE is a static data
11686           member.  */
11687        && !TYPE_P (CP_DECL_CONTEXT (t))
11688        /* Any other non-local variable must be at namespace scope.  */
11689        && !DECL_NAMESPACE_SCOPE_P (t))
11690       || (TREE_CODE (t) == PARM_DECL))
11691     return 1;
11692
11693   return 0;
11694 }
11695
11696 /* Returns non-zero if T is an automatic local variable or a label.
11697    (These are the declarations that need to be remapped when the code
11698    containing them is duplicated.)  */
11699
11700 int
11701 nonstatic_local_decl_p (t)
11702      tree t;
11703 {
11704   return ((local_variable_p (t) && !TREE_STATIC (t))
11705           || TREE_CODE (t) == LABEL_DECL
11706           || TREE_CODE (t) == RESULT_DECL);
11707 }
11708
11709 /* Like local_variable_p, but suitable for use as a tree-walking
11710    function.  */
11711
11712 static tree
11713 local_variable_p_walkfn (tp, walk_subtrees, data)
11714      tree *tp;
11715      int *walk_subtrees ATTRIBUTE_UNUSED;
11716      void *data ATTRIBUTE_UNUSED;
11717 {
11718   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11719           ? *tp : NULL_TREE);
11720 }
11721
11722 /* Check that ARG, which is a default-argument expression for a
11723    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11724    something goes wrong.  DECL may also be a _TYPE node, rather than a
11725    DECL, if there is no DECL available.  */
11726
11727 tree
11728 check_default_argument (decl, arg)
11729      tree decl;
11730      tree arg;
11731 {
11732   tree var;
11733   tree decl_type;
11734
11735   if (TREE_CODE (arg) == DEFAULT_ARG)
11736     /* We get a DEFAULT_ARG when looking at an in-class declaration
11737        with a default argument.  Ignore the argument for now; we'll
11738        deal with it after the class is complete.  */
11739     return arg;
11740
11741   if (processing_template_decl || uses_template_parms (arg))
11742     /* We don't do anything checking until instantiation-time.  Note
11743        that there may be uninstantiated arguments even for an
11744        instantiated function, since default arguments are not
11745        instantiated until they are needed.  */
11746     return arg;
11747
11748   if (TYPE_P (decl))
11749     {
11750       decl_type = decl;
11751       decl = NULL_TREE;
11752     }
11753   else
11754     decl_type = TREE_TYPE (decl);
11755
11756   if (arg == error_mark_node
11757       || decl == error_mark_node
11758       || TREE_TYPE (arg) == error_mark_node
11759       || decl_type == error_mark_node)
11760     /* Something already went wrong.  There's no need to check
11761        further.  */
11762     return error_mark_node;
11763
11764   /* [dcl.fct.default]
11765
11766      A default argument expression is implicitly converted to the
11767      parameter type.  */
11768   if (!TREE_TYPE (arg)
11769       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11770     {
11771       if (decl)
11772         cp_error ("default argument for `%#D' has type `%T'",
11773                   decl, TREE_TYPE (arg));
11774       else
11775         cp_error ("default argument for parameter of type `%T' has type `%T'",
11776                   decl_type, TREE_TYPE (arg));
11777
11778       return error_mark_node;
11779     }
11780
11781   /* [dcl.fct.default]
11782
11783      Local variables shall not be used in default argument
11784      expressions.
11785
11786      The keyword `this' shall not be used in a default argument of a
11787      member function.  */
11788   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
11789                                       NULL);
11790   if (var)
11791     {
11792       cp_error ("default argument `%E' uses local variable `%D'",
11793                 arg, var);
11794       return error_mark_node;
11795     }
11796
11797   /* All is well.  */
11798   return arg;
11799 }
11800
11801 /* Decode the list of parameter types for a function type.
11802    Given the list of things declared inside the parens,
11803    return a list of types.
11804
11805    We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
11806    flag. If unset, we append void_list_node. A parmlist declared
11807    as `(void)' is accepted as the empty parmlist.
11808
11809    Also set last_function_parms to the chain of PARM_DECLs.  */
11810
11811 static tree
11812 grokparms (first_parm)
11813      tree first_parm;
11814 {
11815   tree result = NULL_TREE;
11816   tree decls = NULL_TREE;
11817   int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
11818   tree parm, chain;
11819   int any_error = 0;
11820
11821   my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
11822
11823   for (parm = first_parm; parm != NULL_TREE; parm = chain)
11824     {
11825       tree type = NULL_TREE;
11826       register tree decl = TREE_VALUE (parm);
11827       tree init = TREE_PURPOSE (parm);
11828
11829       chain = TREE_CHAIN (parm);
11830       /* @@ weak defense against parse errors.  */
11831       if (TREE_CODE (decl) != VOID_TYPE
11832           && TREE_CODE (decl) != TREE_LIST)
11833         {
11834           /* Give various messages as the need arises.  */
11835           if (TREE_CODE (decl) == STRING_CST)
11836             cp_error ("invalid string constant `%E'", decl);
11837           else if (TREE_CODE (decl) == INTEGER_CST)
11838             error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11839           continue;
11840         }
11841
11842       if (parm == void_list_node)
11843         break;
11844
11845       decl = grokdeclarator (TREE_VALUE (decl), TREE_PURPOSE (decl),
11846                      PARM, init != NULL_TREE, NULL);
11847       if (! decl || TREE_TYPE (decl) == error_mark_node)
11848         continue;
11849
11850       type = TREE_TYPE (decl);
11851       if (VOID_TYPE_P (type))
11852         {
11853           if (same_type_p (type, void_type_node)
11854               && !DECL_NAME (decl) && !result && !chain && !ellipsis)
11855             /* this is a parmlist of `(void)', which is ok.  */
11856             break;
11857           incomplete_type_error (decl, type);
11858           /* It's not a good idea to actually create parameters of
11859              type `void'; other parts of the compiler assume that a
11860              void type terminates the parameter list.  */
11861           type = error_mark_node;
11862           TREE_TYPE (decl) = error_mark_node;
11863         }
11864
11865       if (type != error_mark_node)
11866         {
11867           /* Top-level qualifiers on the parameters are
11868              ignored for function types.  */
11869           type = TYPE_MAIN_VARIANT (type);
11870           if (TREE_CODE (type) == METHOD_TYPE)
11871             {
11872               cp_error ("parameter `%D' invalidly declared method type", decl);
11873               type = build_pointer_type (type);
11874               TREE_TYPE (decl) = type;
11875             }
11876           else if (TREE_CODE (type) == OFFSET_TYPE)
11877             {
11878               cp_error ("parameter `%D' invalidly declared offset type", decl);
11879               type = build_pointer_type (type);
11880               TREE_TYPE (decl) = type;
11881             }
11882           else if (abstract_virtuals_error (decl, type))
11883             any_error = 1;  /* Seems like a good idea. */
11884           else if (POINTER_TYPE_P (type))
11885             {
11886               /* [dcl.fct]/6, parameter types cannot contain pointers
11887                  (references) to arrays of unknown bound.  */
11888               tree t = TREE_TYPE (type);
11889               int ptr = TYPE_PTR_P (type);
11890
11891               while (1)
11892                 {
11893                   if (TYPE_PTR_P (t))
11894                     ptr = 1;
11895                   else if (TREE_CODE (t) != ARRAY_TYPE)
11896                     break;
11897                   else if (!TYPE_DOMAIN (t))
11898                     break;
11899                   t = TREE_TYPE (t);
11900                 }
11901               if (TREE_CODE (t) == ARRAY_TYPE)
11902                 cp_error ("parameter `%D' includes %s to array of unknown bound `%T'",
11903                           decl, ptr ? "pointer" : "reference", t);
11904             }
11905
11906           DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11907           if (PROMOTE_PROTOTYPES
11908               && INTEGRAL_TYPE_P (type)
11909               && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11910             DECL_ARG_TYPE (decl) = integer_type_node;
11911           if (!any_error && init)
11912             init = check_default_argument (decl, init);
11913           else
11914             init = NULL_TREE;
11915         }
11916
11917       TREE_CHAIN (decl) = decls;
11918       decls = decl;
11919       result = tree_cons (init, type, result);
11920     }
11921   decls = nreverse (decls);
11922   result = nreverse (result);
11923   if (!ellipsis)
11924     result = chainon (result, void_list_node);
11925   last_function_parms = decls;
11926
11927   return result;
11928 }
11929
11930 \f
11931 /* D is a constructor or overloaded `operator='.  Returns non-zero if
11932    D's arguments allow it to be a copy constructor, or copy assignment
11933    operator.  */
11934
11935 int
11936 copy_args_p (d)
11937      tree d;
11938 {
11939   tree t;
11940
11941   if (!DECL_FUNCTION_MEMBER_P (d))
11942     return 0;
11943
11944   t = FUNCTION_FIRST_USER_PARMTYPE (d);
11945   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
11946       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
11947           == DECL_CONTEXT (d))
11948       && (TREE_CHAIN (t) == NULL_TREE
11949           || TREE_CHAIN (t) == void_list_node
11950           || TREE_PURPOSE (TREE_CHAIN (t))))
11951     return 1;
11952   return 0;
11953 }
11954
11955 /* These memoizing functions keep track of special properties which
11956    a class may have.  `grok_ctor_properties' notices whether a class
11957    has a constructor of the form X(X&), and also complains
11958    if the class has a constructor of the form X(X).
11959    `grok_op_properties' takes notice of the various forms of
11960    operator= which are defined, as well as what sorts of type conversion
11961    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
11962
11963 int
11964 grok_ctor_properties (ctype, decl)
11965      tree ctype, decl;
11966 {
11967   tree parmtypes = FUNCTION_FIRST_USER_PARMTYPE (decl);
11968   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
11969
11970   /* [class.copy]
11971
11972      A non-template constructor for class X is a copy constructor if
11973      its first parameter is of type X&, const X&, volatile X& or const
11974      volatile X&, and either there are no other parameters or else all
11975      other parameters have default arguments.  */
11976   if (TREE_CODE (parmtype) == REFERENCE_TYPE
11977       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
11978       && sufficient_parms_p (TREE_CHAIN (parmtypes))
11979       && !(DECL_TEMPLATE_INSTANTIATION (decl)
11980            && is_member_template (DECL_TI_TEMPLATE (decl))))
11981     {
11982       TYPE_HAS_INIT_REF (ctype) = 1;
11983       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
11984         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
11985     }
11986   /* [class.copy]
11987
11988      A declaration of a constructor for a class X is ill-formed if its
11989      first parameter is of type (optionally cv-qualified) X and either
11990      there are no other parameters or else all other parameters have
11991      default arguments.
11992
11993      We *don't* complain about member template instantiations that
11994      have this form, though; they can occur as we try to decide what
11995      constructor to use during overload resolution.  Since overload
11996      resolution will never prefer such a constructor to the
11997      non-template copy constructor (which is either explicitly or
11998      implicitly defined), there's no need to worry about their
11999      existence.  Theoretically, they should never even be
12000      instantiated, but that's hard to forestall.  */
12001   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12002            && sufficient_parms_p (TREE_CHAIN (parmtypes))
12003            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12004                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12005     {
12006       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12007                 ctype, ctype);
12008       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12009       return 0;
12010     }
12011   else if (TREE_CODE (parmtype) == VOID_TYPE
12012            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12013     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12014
12015   return 1;
12016 }
12017
12018 /* An operator with this code is unary, but can also be binary.  */
12019
12020 static int
12021 ambi_op_p (code)
12022      enum tree_code code;
12023 {
12024   return (code == INDIRECT_REF
12025           || code == ADDR_EXPR
12026           || code == CONVERT_EXPR
12027           || code == NEGATE_EXPR
12028           || code == PREINCREMENT_EXPR
12029           || code == PREDECREMENT_EXPR);
12030 }
12031
12032 /* An operator with this name can only be unary.  */
12033
12034 static int
12035 unary_op_p (code)
12036      enum tree_code code;
12037 {
12038   return (code == TRUTH_NOT_EXPR
12039           || code == BIT_NOT_EXPR
12040           || code == COMPONENT_REF
12041           || code == TYPE_EXPR);
12042 }
12043
12044 /* Do a little sanity-checking on how they declared their operator.  */
12045
12046 void
12047 grok_op_properties (decl, virtualp, friendp)
12048      tree decl;
12049      int virtualp, friendp;
12050 {
12051   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12052   tree argtype;
12053   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12054   tree name = DECL_NAME (decl);
12055   enum tree_code operator_code;
12056   int arity;
12057
12058   /* Count the number of arguments.  */
12059   for (argtype = argtypes, arity = 0;
12060        argtype && argtype != void_list_node;
12061        argtype = TREE_CHAIN (argtype))
12062     ++arity;
12063
12064   if (current_class_type == NULL_TREE)
12065     friendp = 1;
12066
12067   if (DECL_CONV_FN_P (decl))
12068     operator_code = TYPE_EXPR;
12069   else
12070     do
12071       {
12072 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)       \
12073         if (ansi_opname (CODE) == name)                         \
12074           {                                                     \
12075             operator_code = CODE;                               \
12076             break;                                              \
12077           }                                                     \
12078         else if (ansi_assopname (CODE) == name)                 \
12079           {                                                     \
12080             operator_code = CODE;                               \
12081             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;              \
12082             break;                                              \
12083           }
12084
12085 #include "operators.def"
12086 #undef DEF_OPERATOR
12087
12088         my_friendly_abort (20000527);
12089       }
12090     while (0);
12091   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12092   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12093
12094   if (! friendp)
12095     {
12096       switch (operator_code)
12097         {
12098         case CALL_EXPR:
12099           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12100           break;
12101
12102         case ARRAY_REF:
12103           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12104           break;
12105
12106         case COMPONENT_REF:
12107         case MEMBER_REF:
12108           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12109           break;
12110
12111         case NEW_EXPR:
12112           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12113           break;
12114
12115         case DELETE_EXPR:
12116           TYPE_GETS_DELETE (current_class_type) |= 1;
12117           break;
12118
12119         case VEC_NEW_EXPR:
12120           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12121           break;
12122
12123         case VEC_DELETE_EXPR:
12124           TYPE_GETS_DELETE (current_class_type) |= 2;
12125           break;
12126
12127         default:
12128           break;
12129         }
12130     }
12131
12132   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12133     {
12134       /* When the compiler encounters the definition of A::operator new, it
12135          doesn't look at the class declaration to find out if it's static.  */
12136       if (methodp)
12137         revert_static_member_fn (decl);
12138
12139       TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12140     }
12141   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12142     {
12143       if (methodp)
12144         revert_static_member_fn (decl);
12145
12146       TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12147     }
12148   else
12149     {
12150       /* An operator function must either be a non-static member function
12151          or have at least one parameter of a class, a reference to a class,
12152          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12153       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12154         {
12155           if (operator_code == TYPE_EXPR
12156               || operator_code == CALL_EXPR
12157               || operator_code == COMPONENT_REF
12158               || operator_code == ARRAY_REF
12159               || operator_code == NOP_EXPR)
12160             cp_error ("`%D' must be a nonstatic member function", decl);
12161           else
12162             {
12163               tree p = argtypes;
12164
12165               if (DECL_STATIC_FUNCTION_P (decl))
12166                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12167
12168               if (p)
12169                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12170                   {
12171                     tree arg = TREE_VALUE (p);
12172                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12173                       arg = TREE_TYPE (arg);
12174
12175                     /* This lets bad template code slip through.  */
12176                     if (IS_AGGR_TYPE (arg)
12177                         || TREE_CODE (arg) == ENUMERAL_TYPE
12178                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12179                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12180                       goto foundaggr;
12181                   }
12182               cp_error
12183                 ("`%D' must have an argument of class or enumerated type",
12184                  decl);
12185             foundaggr:
12186               ;
12187             }
12188         }
12189
12190       if (operator_code == CALL_EXPR)
12191         return;                 /* No restrictions on args. */
12192
12193       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12194         {
12195           tree t = TREE_TYPE (name);
12196           if (! friendp)
12197             {
12198               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12199               const char *what = 0;
12200
12201               if (ref)
12202                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12203
12204               if (TREE_CODE (t) == VOID_TYPE)
12205                 what = "void";
12206               else if (t == current_class_type)
12207                 what = "the same type";
12208               /* Don't force t to be complete here.  */
12209               else if (IS_AGGR_TYPE (t)
12210                        && COMPLETE_TYPE_P (t)
12211                        && DERIVED_FROM_P (t, current_class_type))
12212                 what = "a base class";
12213
12214               if (what)
12215                 warning ("conversion to %s%s will never use a type conversion operator",
12216                          ref ? "a reference to " : "", what);
12217             }
12218         }
12219
12220       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12221           && operator_code == NOP_EXPR)
12222         {
12223           tree parmtype;
12224
12225           if (arity != 2 && methodp)
12226             {
12227               cp_error ("`%D' must take exactly one argument", decl);
12228               return;
12229             }
12230           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12231
12232           /* [class.copy]
12233
12234              A user-declared copy assignment operator X::operator= is
12235              a non-static non-template member function of class X with
12236              exactly one parameter of type X, X&, const X&, volatile
12237              X& or const volatile X&.  */
12238           if (copy_assignment_arg_p (parmtype, virtualp)
12239               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12240                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12241               && ! friendp)
12242             {
12243               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12244               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12245                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12246                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12247             }
12248         }
12249       else if (operator_code == COND_EXPR)
12250         {
12251           /* 13.4.0.3 */
12252           cp_error ("ISO C++ prohibits overloading operator ?:");
12253         }
12254       else if (ambi_op_p (operator_code))
12255         {
12256           if (arity == 1)
12257             /* We pick the one-argument operator codes by default, so
12258                we don't have to change anything.  */
12259             ;
12260           else if (arity == 2)
12261             {
12262               /* If we thought this was a unary operator, we now know
12263                  it to be a binary operator.  */
12264               switch (operator_code)
12265                 {
12266                 case INDIRECT_REF:
12267                   operator_code = MULT_EXPR;
12268                   break;
12269
12270                 case ADDR_EXPR:
12271                   operator_code = BIT_AND_EXPR;
12272                   break;
12273
12274                 case CONVERT_EXPR:
12275                   operator_code = PLUS_EXPR;
12276                   break;
12277
12278                 case NEGATE_EXPR:
12279                   operator_code = MINUS_EXPR;
12280                   break;
12281
12282                 case PREINCREMENT_EXPR:
12283                   operator_code = POSTINCREMENT_EXPR;
12284                   break;
12285
12286                 case PREDECREMENT_EXPR:
12287                   operator_code = POSTDECREMENT_EXPR;
12288                   break;
12289
12290                 default:
12291                   my_friendly_abort (20000527);
12292                 }
12293
12294               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12295
12296               if ((operator_code == POSTINCREMENT_EXPR
12297                    || operator_code == POSTDECREMENT_EXPR)
12298                   && ! processing_template_decl
12299                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12300                 {
12301                   if (methodp)
12302                     cp_error ("postfix `%D' must take `int' as its argument",
12303                               decl);
12304                   else
12305                     cp_error
12306                       ("postfix `%D' must take `int' as its second argument",
12307                        decl);
12308                 }
12309             }
12310           else
12311             {
12312               if (methodp)
12313                 cp_error ("`%D' must take either zero or one argument", decl);
12314               else
12315                 cp_error ("`%D' must take either one or two arguments", decl);
12316             }
12317
12318           /* More Effective C++ rule 6.  */
12319           if (warn_ecpp
12320               && (operator_code == POSTINCREMENT_EXPR
12321                   || operator_code == POSTDECREMENT_EXPR
12322                   || operator_code == PREINCREMENT_EXPR
12323                   || operator_code == PREDECREMENT_EXPR))
12324             {
12325               tree arg = TREE_VALUE (argtypes);
12326               tree ret = TREE_TYPE (TREE_TYPE (decl));
12327               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12328                 arg = TREE_TYPE (arg);
12329               arg = TYPE_MAIN_VARIANT (arg);
12330               if (operator_code == PREINCREMENT_EXPR
12331                   || operator_code == PREDECREMENT_EXPR)
12332                 {
12333                   if (TREE_CODE (ret) != REFERENCE_TYPE
12334                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12335                                        arg))
12336                     cp_warning ("prefix `%D' should return `%T'", decl,
12337                                 build_reference_type (arg));
12338                 }
12339               else
12340                 {
12341                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12342                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12343                 }
12344             }
12345         }
12346       else if (unary_op_p (operator_code))
12347         {
12348           if (arity != 1)
12349             {
12350               if (methodp)
12351                 cp_error ("`%D' must take `void'", decl);
12352               else
12353                 cp_error ("`%D' must take exactly one argument", decl);
12354             }
12355         }
12356       else /* if (binary_op_p (operator_code)) */
12357         {
12358           if (arity != 2)
12359             {
12360               if (methodp)
12361                 cp_error ("`%D' must take exactly one argument", decl);
12362               else
12363                 cp_error ("`%D' must take exactly two arguments", decl);
12364             }
12365
12366           /* More Effective C++ rule 7.  */
12367           if (warn_ecpp
12368               && (operator_code == TRUTH_ANDIF_EXPR
12369                   || operator_code == TRUTH_ORIF_EXPR
12370                   || operator_code == COMPOUND_EXPR))
12371             cp_warning ("user-defined `%D' always evaluates both arguments",
12372                         decl);
12373         }
12374
12375       /* Effective C++ rule 23.  */
12376       if (warn_ecpp
12377           && arity == 2
12378           && (operator_code == PLUS_EXPR
12379               || operator_code == MINUS_EXPR
12380               || operator_code == TRUNC_DIV_EXPR
12381               || operator_code == MULT_EXPR)
12382           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12383         cp_warning ("`%D' should return by value", decl);
12384
12385       /* 13.4.0.8 */
12386       for (; argtypes && argtypes != void_list_node;
12387           argtypes = TREE_CHAIN (argtypes))
12388         if (TREE_PURPOSE (argtypes))
12389           {
12390             TREE_PURPOSE (argtypes) = NULL_TREE;
12391             if (operator_code == POSTINCREMENT_EXPR
12392                 || operator_code == POSTDECREMENT_EXPR)
12393               {
12394                 if (pedantic)
12395                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12396               }
12397             else
12398               cp_error ("`%D' cannot have default arguments", decl);
12399           }
12400
12401     }
12402 }
12403 \f
12404 static const char *
12405 tag_name (code)
12406      enum tag_types code;
12407 {
12408   switch (code)
12409     {
12410     case record_type:
12411       return "struct";
12412     case class_type:
12413       return "class";
12414     case union_type:
12415       return "union ";
12416     case enum_type:
12417       return "enum";
12418     default:
12419       my_friendly_abort (981122);
12420     }
12421 }
12422
12423 /* Get the struct, enum or union (CODE says which) with tag NAME.
12424    Define the tag as a forward-reference if it is not defined.
12425
12426    C++: If a class derivation is given, process it here, and report
12427    an error if multiple derivation declarations are not identical.
12428
12429    If this is a definition, come in through xref_tag and only look in
12430    the current frame for the name (since C++ allows new names in any
12431    scope.)  */
12432
12433 tree
12434 xref_tag (code_type_node, name, globalize)
12435      tree code_type_node;
12436      tree name;
12437      int globalize;
12438 {
12439   enum tag_types tag_code;
12440   enum tree_code code;
12441   register tree ref, t;
12442   struct binding_level *b = current_binding_level;
12443   int got_type = 0;
12444   tree attributes = NULL_TREE;
12445   tree context = NULL_TREE;
12446
12447   /* If we are called from the parser, code_type_node will sometimes be a
12448      TREE_LIST.  This indicates that the user wrote
12449      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12450      use them later.  */
12451   if (TREE_CODE (code_type_node) == TREE_LIST)
12452     {
12453       attributes = TREE_PURPOSE (code_type_node);
12454       code_type_node = TREE_VALUE (code_type_node);
12455     }
12456
12457   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12458   switch (tag_code)
12459     {
12460     case record_type:
12461     case class_type:
12462       code = RECORD_TYPE;
12463       break;
12464     case union_type:
12465       code = UNION_TYPE;
12466       break;
12467     case enum_type:
12468       code = ENUMERAL_TYPE;
12469       break;
12470     default:
12471       my_friendly_abort (18);
12472     }
12473
12474   /* If a cross reference is requested, look up the type
12475      already defined for this tag and return it.  */
12476   if (TYPE_P (name))
12477     {
12478       t = name;
12479       name = TYPE_IDENTIFIER (t);
12480       got_type = 1;
12481     }
12482   else
12483     t = IDENTIFIER_TYPE_VALUE (name);
12484
12485   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12486   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12487     {
12488       static int explained;
12489       tree shadowed;
12490
12491       cp_warning ("`%s %T' declares a new type at namespace scope",
12492                   tag_name (tag_code), name);
12493       if (!explained++)
12494         cp_warning ("  names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'",
12495                     tag_name (tag_code),
12496                     constructor_name (current_class_type),
12497                     TYPE_IDENTIFIER (t));
12498
12499       /* We need to remove the class scope binding for the
12500          TYPENAME_TYPE as otherwise poplevel_class gets confused. */
12501       for (shadowed = b->class_shadowed;
12502            shadowed;
12503            shadowed = TREE_CHAIN (shadowed))
12504         if (TREE_TYPE (shadowed) == TYPE_NAME (t))
12505           {
12506             TREE_PURPOSE (shadowed) = NULL_TREE;
12507             break;
12508           }
12509     }
12510
12511   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12512       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12513     t = NULL_TREE;
12514
12515   if (! globalize)
12516     {
12517       /* If we know we are defining this tag, only look it up in
12518          this scope and don't try to find it as a type.  */
12519       ref = lookup_tag (code, name, b, 1);
12520     }
12521   else
12522     {
12523       if (t)
12524         {
12525           /* [dcl.type.elab] If the identifier resolves to a
12526              typedef-name or a template type-parameter, the
12527              elaborated-type-specifier is ill-formed.  */
12528           if (t != TYPE_MAIN_VARIANT (t)
12529               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12530             cp_pedwarn ("using typedef-name `%D' after `%s'",
12531                         TYPE_NAME (t), tag_name (tag_code));
12532           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12533             cp_error ("using template type parameter `%T' after `%s'",
12534                       t, tag_name (tag_code));
12535
12536           ref = t;
12537         }
12538       else
12539         ref = lookup_tag (code, name, b, 0);
12540
12541       if (! ref)
12542         {
12543           /* Try finding it as a type declaration.  If that wins,
12544              use it.  */
12545           ref = lookup_name (name, 1);
12546
12547           if (ref != NULL_TREE
12548               && processing_template_decl
12549               && DECL_CLASS_TEMPLATE_P (ref)
12550               && template_class_depth (current_class_type) == 0)
12551             /* Since GLOBALIZE is true, we're declaring a global
12552                template, so we want this type.  */
12553             ref = DECL_TEMPLATE_RESULT (ref);
12554
12555           if (ref && TREE_CODE (ref) == TYPE_DECL
12556               && TREE_CODE (TREE_TYPE (ref)) == code)
12557             ref = TREE_TYPE (ref);
12558           else
12559             ref = NULL_TREE;
12560         }
12561
12562       if (ref && current_class_type
12563           && template_class_depth (current_class_type)
12564           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12565         {
12566           /* Since GLOBALIZE is non-zero, we are not looking at a
12567              definition of this tag.  Since, in addition, we are currently
12568              processing a (member) template declaration of a template
12569              class, we must be very careful; consider:
12570
12571                template <class X>
12572                struct S1
12573
12574                template <class U>
12575                struct S2
12576                { template <class V>
12577                friend struct S1; };
12578
12579              Here, the S2::S1 declaration should not be confused with the
12580              outer declaration.  In particular, the inner version should
12581              have a template parameter of level 2, not level 1.  This
12582              would be particularly important if the member declaration
12583              were instead:
12584
12585                template <class V = U> friend struct S1;
12586
12587              say, when we should tsubst into `U' when instantiating
12588              S2.  On the other hand, when presented with:
12589
12590                  template <class T>
12591                  struct S1 {
12592                    template <class U>
12593                    struct S2 {};
12594                    template <class U>
12595                    friend struct S2;
12596                  };
12597
12598               we must find the inner binding eventually.  We
12599               accomplish this by making sure that the new type we
12600               create to represent this declaration has the right
12601               TYPE_CONTEXT.  */
12602           context = TYPE_CONTEXT (ref);
12603           ref = NULL_TREE;
12604         }
12605     }
12606
12607   if (! ref)
12608     {
12609       /* If no such tag is yet defined, create a forward-reference node
12610          and record it as the "definition".
12611          When a real declaration of this type is found,
12612          the forward-reference will be altered into a real type.  */
12613       if (code == ENUMERAL_TYPE)
12614         {
12615           cp_error ("use of enum `%#D' without previous declaration", name);
12616
12617           ref = make_node (ENUMERAL_TYPE);
12618
12619           /* Give the type a default layout like unsigned int
12620              to avoid crashing if it does not get defined.  */
12621           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12622           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12623           TYPE_USER_ALIGN (ref) = 0;
12624           TREE_UNSIGNED (ref) = 1;
12625           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12626           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12627           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12628
12629           /* Enable us to recognize when a type is created in class context.
12630              To do nested classes correctly, this should probably be cleared
12631              out when we leave this classes scope.  Currently this in only
12632              done in `start_enum'.  */
12633
12634           pushtag (name, ref, globalize);
12635         }
12636       else
12637         {
12638           struct binding_level *old_b = class_binding_level;
12639
12640           ref = make_aggr_type (code);
12641           TYPE_CONTEXT (ref) = context;
12642
12643 #ifdef NONNESTED_CLASSES
12644           /* Class types don't nest the way enums do.  */
12645           class_binding_level = (struct binding_level *)0;
12646 #endif
12647           pushtag (name, ref, globalize);
12648           class_binding_level = old_b;
12649         }
12650     }
12651   else
12652     {
12653       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12654         redeclare_class_template (ref, current_template_parms);
12655     }
12656
12657   /* Until the type is defined, tentatively accept whatever
12658      structure tag the user hands us.  */
12659   if (!COMPLETE_TYPE_P (ref)
12660       && ref != current_class_type
12661       /* Have to check this, in case we have contradictory tag info.  */
12662       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12663     {
12664       if (tag_code == class_type)
12665         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12666       else if (tag_code == record_type)
12667         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12668     }
12669
12670   TREE_TYPE (ref) = attributes;
12671
12672   return ref;
12673 }
12674
12675 tree
12676 xref_tag_from_type (old, id, globalize)
12677      tree old, id;
12678      int globalize;
12679 {
12680   tree code_type_node;
12681
12682   if (TREE_CODE (old) == RECORD_TYPE)
12683     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12684                       ? class_type_node : record_type_node);
12685   else
12686     code_type_node = union_type_node;
12687
12688   if (id == NULL_TREE)
12689     id = TYPE_IDENTIFIER (old);
12690
12691   return xref_tag (code_type_node, id, globalize);
12692 }
12693
12694 /* REF is a type (named NAME), for which we have just seen some
12695    baseclasses.  BINFO is a list of those baseclasses; the
12696    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12697    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12698    struct, or union.  */
12699
12700 void
12701 xref_basetypes (code_type_node, name, ref, binfo)
12702      tree code_type_node;
12703      tree name, ref;
12704      tree binfo;
12705 {
12706   /* In the declaration `A : X, Y, ... Z' we mark all the types
12707      (A, X, Y, ..., Z) so we can check for duplicates.  */
12708   tree binfos;
12709   tree base;
12710
12711   int i, len;
12712   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12713
12714   if (tag_code == union_type)
12715     {
12716       cp_error ("derived union `%T' invalid", ref);
12717       return;
12718     }
12719
12720   len = list_length (binfo);
12721
12722   /* First, make sure that any templates in base-classes are
12723      instantiated.  This ensures that if we call ourselves recursively
12724      we do not get confused about which classes are marked and which
12725      are not.  */
12726   for (base = binfo; base; base = TREE_CHAIN (base))
12727     complete_type (TREE_VALUE (base));
12728
12729   SET_CLASSTYPE_MARKED (ref);
12730   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12731
12732   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12733     {
12734       /* The base of a derived struct is public by default.  */
12735       int via_public
12736         = (TREE_PURPOSE (binfo) == access_public_node
12737            || TREE_PURPOSE (binfo) == access_public_virtual_node
12738            || (tag_code != class_type
12739                && (TREE_PURPOSE (binfo) == access_default_node
12740                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12741       int via_protected
12742         = (TREE_PURPOSE (binfo) == access_protected_node
12743            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12744       int via_virtual
12745         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12746            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12747            || TREE_PURPOSE (binfo) == access_public_virtual_node
12748            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12749       tree basetype = TREE_VALUE (binfo);
12750       tree base_binfo;
12751
12752       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12753         basetype = TREE_TYPE (basetype);
12754       if (!basetype
12755           || (TREE_CODE (basetype) != RECORD_TYPE
12756               && TREE_CODE (basetype) != TYPENAME_TYPE
12757               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12758               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
12759         {
12760           cp_error ("base type `%T' fails to be a struct or class type",
12761                     TREE_VALUE (binfo));
12762           continue;
12763         }
12764
12765       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12766
12767       /* This code replaces similar code in layout_basetypes.
12768          We put the complete_type first for implicit `typename'.  */
12769       if (!COMPLETE_TYPE_P (basetype)
12770           && ! (current_template_parms && uses_template_parms (basetype)))
12771         {
12772           cp_error ("base class `%T' has incomplete type", basetype);
12773           continue;
12774         }
12775       else
12776         {
12777           if (CLASSTYPE_MARKED (basetype))
12778             {
12779               if (basetype == ref)
12780                 cp_error ("recursive type `%T' undefined", basetype);
12781               else
12782                 cp_error ("duplicate base type `%T' invalid", basetype);
12783               continue;
12784             }
12785
12786           if (TYPE_FOR_JAVA (basetype)
12787               && (current_lang_depth () == 0))
12788             TYPE_FOR_JAVA (ref) = 1;
12789
12790           /* Note that the BINFO records which describe individual
12791              inheritances are *not* shared in the lattice!  They
12792              cannot be shared because a given baseclass may be
12793              inherited with different `accessibility' by different
12794              derived classes.  (Each BINFO record describing an
12795              individual inheritance contains flags which say what
12796              the `accessibility' of that particular inheritance is.)  */
12797
12798           base_binfo
12799             = make_binfo (size_zero_node, basetype,
12800                           CLASS_TYPE_P (basetype)
12801                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12802                           CLASS_TYPE_P (basetype)
12803                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12804
12805           TREE_VEC_ELT (binfos, i) = base_binfo;
12806           TREE_VIA_PUBLIC (base_binfo) = via_public;
12807           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12808           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12809           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12810
12811           /* We need to unshare the binfos now so that lookups during class
12812              definition work.  */
12813           unshare_base_binfos (base_binfo);
12814
12815           SET_CLASSTYPE_MARKED (basetype);
12816
12817           /* We are free to modify these bits because they are meaningless
12818              at top level, and BASETYPE is a top-level type.  */
12819           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12820             {
12821               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12822               /* Converting to a virtual base class requires looking
12823                  up the offset of the virtual base.  */
12824               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12825             }
12826
12827           if (CLASS_TYPE_P (basetype))
12828             {
12829               TYPE_HAS_NEW_OPERATOR (ref)
12830                 |= TYPE_HAS_NEW_OPERATOR (basetype);
12831               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12832                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12833               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12834               /* If the base-class uses multiple inheritance, so do we.  */
12835               TYPE_USES_MULTIPLE_INHERITANCE (ref)
12836                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12837               /* Likewise, if converting to a base of the base may require
12838                  code, then we may need to generate code to convert to a
12839                  base as well.  */
12840               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12841                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12842             }
12843
12844           i += 1;
12845         }
12846     }
12847   if (i)
12848     TREE_VEC_LENGTH (binfos) = i;
12849   else
12850     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12851
12852   if (i > 1)
12853     {
12854       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12855       /* If there is more than one non-empty they cannot be at the same
12856          address.  */
12857       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12858     }
12859
12860   /* Unmark all the types.  */
12861   while (--i >= 0)
12862     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12863   CLEAR_CLASSTYPE_MARKED (ref);
12864
12865   /* Now that we know all the base-classes, set up the list of virtual
12866      bases.  */
12867   get_vbase_types (ref);
12868 }
12869
12870 \f
12871 /* Begin compiling the definition of an enumeration type.
12872    NAME is its name (or null if anonymous).
12873    Returns the type object, as yet incomplete.
12874    Also records info about it so that build_enumerator
12875    may be used to declare the individual values as they are read.  */
12876
12877 tree
12878 start_enum (name)
12879      tree name;
12880 {
12881   register tree enumtype = NULL_TREE;
12882   struct binding_level *b = current_binding_level;
12883
12884   /* If this is the real definition for a previous forward reference,
12885      fill in the contents in the same object that used to be the
12886      forward reference.  */
12887
12888   if (name != NULL_TREE)
12889     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12890
12891   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12892     {
12893       cp_error ("multiple definition of `%#T'", enumtype);
12894       cp_error_at ("previous definition here", enumtype);
12895       /* Clear out TYPE_VALUES, and start again.  */
12896       TYPE_VALUES (enumtype) = NULL_TREE;
12897     }
12898   else
12899     {
12900       enumtype = make_node (ENUMERAL_TYPE);
12901       pushtag (name, enumtype, 0);
12902     }
12903
12904   if (current_class_type)
12905     TREE_ADDRESSABLE (b->tags) = 1;
12906
12907   GNU_xref_decl (current_function_decl, enumtype);
12908   return enumtype;
12909 }
12910
12911 /* After processing and defining all the values of an enumeration type,
12912    install their decls in the enumeration type and finish it off.
12913    ENUMTYPE is the type object and VALUES a list of name-value pairs.  */
12914
12915 void
12916 finish_enum (enumtype)
12917      tree enumtype;
12918 {
12919   tree pair;
12920   tree minnode;
12921   tree maxnode;
12922   tree t;
12923   bool unsignedp;
12924   int lowprec;
12925   int highprec;
12926   int precision;
12927
12928   /* We built up the VALUES in reverse order.  */
12929   TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
12930
12931   /* [dcl.enum]
12932
12933      Following the closing brace of an enum-specifier, each
12934      enumerator has the type of its enumeration.  Prior to the
12935      closing brace, the type of each enumerator is the type of
12936      its initializing value.  */
12937   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
12938     TREE_TYPE (TREE_VALUE (pair)) = enumtype;
12939
12940   /* For a enum defined in a template, all further processing is
12941      postponed until the template is instantiated.  */
12942   if (processing_template_decl)
12943     {
12944       tree scope = current_scope ();
12945       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12946         add_stmt (build_min (TAG_DEFN, enumtype));
12947
12948
12949       return;
12950     }
12951
12952   /* Figure out what the minimum and maximum values of the enumerators
12953      are.  */
12954   if (TYPE_VALUES (enumtype))
12955     {
12956       minnode = maxnode = NULL_TREE;
12957
12958       for (pair = TYPE_VALUES (enumtype);
12959            pair;
12960            pair = TREE_CHAIN (pair))
12961         {
12962           tree value;
12963
12964           value = DECL_INITIAL (TREE_VALUE (pair));
12965
12966           if (!minnode)
12967             minnode = maxnode = value;
12968           else if (tree_int_cst_lt (maxnode, value))
12969             maxnode = value;
12970           else if (tree_int_cst_lt (value, minnode))
12971             minnode = value;
12972         }
12973     }
12974   else
12975     minnode = maxnode = integer_zero_node;
12976
12977   /* Compute the number of bits require to represent all values of the
12978      enumeration.  We must do this before the type of MINNODE and
12979      MAXNODE are transformed, since min_precision relies on the
12980      TREE_TYPE of the value it is passed.  */
12981   unsignedp = tree_int_cst_sgn (minnode) >= 0;
12982   lowprec = min_precision (minnode, unsignedp);
12983   highprec = min_precision (maxnode, unsignedp);
12984   precision = MAX (lowprec, highprec);
12985
12986   /* Set the TREE_TYPE for the values as well.  That's so that when we
12987      call decl_constant_value we get an entity of the right type (but
12988      with the constant value).  In addition, transform the TYPE_VALUES
12989      list to contain the values, rather than the CONST_DECLs for them.  */
12990   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
12991     {
12992       tree value = DECL_INITIAL (TREE_VALUE (pair));
12993
12994       TREE_TYPE (value) = enumtype;
12995       TREE_VALUE (pair) = value;
12996     }
12997
12998   /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
12999   TYPE_SIZE (enumtype) = NULL_TREE;
13000   TYPE_PRECISION (enumtype) = precision;
13001   if (unsignedp)
13002     fixup_unsigned_type (enumtype);
13003   else
13004     fixup_signed_type (enumtype);
13005
13006   if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13007     /* Use the width of the narrowest normal C type which is wide
13008        enough.  */
13009     TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13010                                                 (precision, 1));
13011   else
13012     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13013
13014   TYPE_SIZE (enumtype) = NULL_TREE;
13015   layout_type (enumtype);
13016
13017   /* Fix up all variant types of this enum type.  */
13018   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13019     {
13020       TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13021       TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
13022       TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
13023       TYPE_SIZE (t) = TYPE_SIZE (enumtype);
13024       TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
13025       TYPE_MODE (t) = TYPE_MODE (enumtype);
13026       TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
13027       TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
13028       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
13029       TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype);
13030     }
13031
13032   /* Finish debugging output for this type.  */
13033   rest_of_type_compilation (enumtype, namespace_bindings_p ());
13034 }
13035
13036 /* Build and install a CONST_DECL for an enumeration constant of the
13037    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13038    Assignment of sequential values by default is handled here.  */
13039
13040 void
13041 build_enumerator (name, value, enumtype)
13042      tree name;
13043      tree value;
13044      tree enumtype;
13045 {
13046   tree decl;
13047   tree context;
13048   tree type;
13049   tree values;
13050
13051   /* Remove no-op casts from the value.  */
13052   if (value)
13053     STRIP_TYPE_NOPS (value);
13054
13055   if (! processing_template_decl)
13056     {
13057       /* Validate and default VALUE.  */
13058       if (value != NULL_TREE)
13059         {
13060           value = decl_constant_value (value);
13061
13062           if (TREE_CODE (value) == INTEGER_CST)
13063             {
13064               value = default_conversion (value);
13065               constant_expression_warning (value);
13066             }
13067           else
13068             {
13069               cp_error ("enumerator value for `%D' not integer constant", name);
13070               value = NULL_TREE;
13071             }
13072         }
13073
13074       /* Default based on previous value.  */
13075       if (value == NULL_TREE && ! processing_template_decl)
13076         {
13077           tree prev_value;
13078
13079           if (TYPE_VALUES (enumtype))
13080             {
13081               /* The next value is the previous value ... */
13082               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13083               /* ... plus one.  */
13084               value = cp_build_binary_op (PLUS_EXPR,
13085                                           prev_value,
13086                                           integer_one_node);
13087
13088               if (tree_int_cst_lt (value, prev_value))
13089                 cp_error ("overflow in enumeration values at `%D'", name);
13090             }
13091           else
13092             value = integer_zero_node;
13093         }
13094
13095       /* Remove no-op casts from the value.  */
13096       if (value)
13097         STRIP_TYPE_NOPS (value);
13098 #if 0
13099       /* To fix MAX_VAL enum consts. (bkoz)  */
13100       TREE_TYPE (value) = integer_type_node;
13101 #endif
13102     }
13103
13104   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13105      Even in other cases, we will later (in finish_enum) be setting
13106      the type of VALUE.  But, we don't need to make a copy if this
13107      VALUE is one of the enumeration constants for this same
13108      enumeration type.  */
13109   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13110     if (TREE_VALUE (values) == value)
13111       break;
13112   /* If we didn't break out of the loop, then we do need a copy.  */
13113   if (!values && value)
13114     value = copy_node (value);
13115
13116   /* C++ associates enums with global, function, or class declarations.  */
13117   context = current_scope ();
13118
13119   /* Build the actual enumeration constant.  Note that the enumeration
13120     constants have the type of their initializers until the
13121     enumeration is complete:
13122
13123       [ dcl.enum ]
13124
13125       Following the closing brace of an enum-specifier, each enumer-
13126       ator has the type of its enumeration.  Prior to the closing
13127       brace, the type of each enumerator is the type of its
13128       initializing value.
13129
13130     In finish_enum we will reset the type.  Of course, if we're
13131     processing a template, there may be no value.   */
13132   type = value ? TREE_TYPE (value) : NULL_TREE;
13133
13134   if (context && context == current_class_type)
13135     /* This enum declaration is local to the class.  We need the full
13136        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13137     decl = build_lang_decl (CONST_DECL, name, type);
13138   else
13139     /* It's a global enum, or it's local to a function.  (Note local to
13140       a function could mean local to a class method.  */
13141     decl = build_decl (CONST_DECL, name, type);
13142
13143   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13144   DECL_INITIAL (decl) = value;
13145   TREE_READONLY (decl) = 1;
13146
13147   if (context && context == current_class_type)
13148     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13149       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13150       things like `S::i' later.)  */
13151     finish_member_declaration (decl);
13152   else
13153     {
13154       pushdecl (decl);
13155       GNU_xref_decl (current_function_decl, decl);
13156     }
13157
13158   /* Add this enumeration constant to the list for this type.  */
13159   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13160 }
13161
13162 \f
13163 /* We're defining DECL.  Make sure that it's type is OK.  */
13164
13165 static void
13166 check_function_type (decl, current_function_parms)
13167      tree decl;
13168      tree current_function_parms;
13169 {
13170   tree fntype = TREE_TYPE (decl);
13171   tree return_type = complete_type (TREE_TYPE (fntype));
13172
13173   /* In a function definition, arg types must be complete.  */
13174   require_complete_types_for_parms (current_function_parms);
13175
13176   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13177     {
13178       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13179
13180       /* Make it return void instead, but don't change the
13181          type of the DECL_RESULT, in case we have a named return value.  */
13182       if (TREE_CODE (fntype) == METHOD_TYPE)
13183         {
13184           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13185           TREE_TYPE (decl)
13186             = build_cplus_method_type (ctype,
13187                                        void_type_node,
13188                                        FUNCTION_ARG_CHAIN (decl));
13189         }
13190       else
13191         TREE_TYPE (decl)
13192           = build_function_type (void_type_node,
13193                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13194       TREE_TYPE (decl)
13195         = build_exception_variant (fntype,
13196                                    TYPE_RAISES_EXCEPTIONS (fntype));
13197     }
13198   else
13199     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13200 }
13201
13202 /* Create the FUNCTION_DECL for a function definition.
13203    DECLSPECS and DECLARATOR are the parts of the declaration;
13204    they describe the function's name and the type it returns,
13205    but twisted together in a fashion that parallels the syntax of C.
13206
13207    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13208    DECLARATOR is really the DECL for the function we are about to
13209    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13210    indicating that the function is an inline defined in-class.
13211
13212    This function creates a binding context for the function body
13213    as well as setting up the FUNCTION_DECL in current_function_decl.
13214
13215    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13216    (it defines a datum instead), we return 0, which tells
13217    yyparse to report a parse error.
13218
13219    For C++, we must first check whether that datum makes any sense.
13220    For example, "class A local_a(1,2);" means that variable local_a
13221    is an aggregate of type A, which should have a constructor
13222    applied to it with the argument list [1, 2].  */
13223
13224 int
13225 start_function (declspecs, declarator, attrs, flags)
13226      tree declspecs, declarator, attrs;
13227      int flags;
13228 {
13229   tree decl1;
13230   tree ctype = NULL_TREE;
13231   tree fntype;
13232   tree restype;
13233   extern int have_extern_spec;
13234   extern int used_extern_spec;
13235   int doing_friend = 0;
13236   struct binding_level *bl;
13237   tree current_function_parms;
13238
13239   /* Sanity check.  */
13240   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13241   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13242
13243   /* This should only be done once on the top most decl.  */
13244   if (have_extern_spec && !used_extern_spec)
13245     {
13246       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13247       used_extern_spec = 1;
13248     }
13249
13250   if (flags & SF_PRE_PARSED)
13251     {
13252       decl1 = declarator;
13253
13254       fntype = TREE_TYPE (decl1);
13255       if (TREE_CODE (fntype) == METHOD_TYPE)
13256         ctype = TYPE_METHOD_BASETYPE (fntype);
13257
13258       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13259          the (lexical) scope of the class in which it is defined.  */
13260       if (!ctype && DECL_FRIEND_P (decl1))
13261         {
13262           ctype = DECL_FRIEND_CONTEXT (decl1);
13263
13264           /* CTYPE could be null here if we're dealing with a template;
13265              for example, `inline friend float foo()' inside a template
13266              will have no CTYPE set.  */
13267           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13268             ctype = NULL_TREE;
13269           else
13270             doing_friend = 1;
13271         }
13272
13273       last_function_parms = DECL_ARGUMENTS (decl1);
13274     }
13275   else
13276     {
13277       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL);
13278       /* If the declarator is not suitable for a function definition,
13279          cause a syntax error.  */
13280       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13281
13282       fntype = TREE_TYPE (decl1);
13283
13284       restype = TREE_TYPE (fntype);
13285       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13286         {
13287           cp_error ("semicolon missing after declaration of `%#T'", restype);
13288           shadow_tag (build_tree_list (NULL_TREE, restype));
13289           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13290           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13291             fntype = build_function_type (integer_type_node,
13292                                           TYPE_ARG_TYPES (fntype));
13293           else
13294             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13295                                               integer_type_node,
13296                                               TYPE_ARG_TYPES (fntype));
13297           TREE_TYPE (decl1) = fntype;
13298         }
13299
13300       if (TREE_CODE (fntype) == METHOD_TYPE)
13301         ctype = TYPE_METHOD_BASETYPE (fntype);
13302       else if (DECL_MAIN_P (decl1))
13303         {
13304           /* If this doesn't return integer_type, complain.  */
13305           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13306             {
13307               if (pedantic || warn_return_type)
13308                 pedwarn ("return type for `main' changed to `int'");
13309               TREE_TYPE (decl1) = fntype = default_function_type;
13310             }
13311         }
13312     }
13313
13314   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13315     /* This is a constructor, we must ensure that any default args
13316        introduced by this definition are propagated to the clones
13317        now. The clones are used directly in overload resolution.  */
13318     adjust_clone_args (decl1);
13319
13320   /* Sometimes we don't notice that a function is a static member, and
13321      build a METHOD_TYPE for it.  Fix that up now.  */
13322   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13323       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13324     {
13325       revert_static_member_fn (decl1);
13326       last_function_parms = TREE_CHAIN (last_function_parms);
13327       ctype = NULL_TREE;
13328     }
13329
13330   /* Warn if function was previously implicitly declared
13331      (but not if we warned then).  */
13332   if (! warn_implicit
13333       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13334     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13335
13336   /* Set up current_class_type, and enter the scope of the class, if
13337      appropriate.  */
13338   if (ctype)
13339     push_nested_class (ctype, 1);
13340   else if (DECL_STATIC_FUNCTION_P (decl1))
13341     push_nested_class (DECL_CONTEXT (decl1), 2);
13342
13343   /* Now that we have entered the scope of the class, we must restore
13344      the bindings for any template parameters surrounding DECL1, if it
13345      is an inline member template.  (Order is important; consider the
13346      case where a template parameter has the same name as a field of
13347      the class.)  It is not until after this point that
13348      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13349   if (flags & SF_INCLASS_INLINE)
13350     maybe_begin_member_template_processing (decl1);
13351
13352   /* Effective C++ rule 15.  */
13353   if (warn_ecpp
13354       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13355       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13356     cp_warning ("`operator=' should return a reference to `*this'");
13357
13358   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13359      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13360   if (!DECL_INITIAL (decl1))
13361     DECL_INITIAL (decl1) = error_mark_node;
13362
13363   /* This function exists in static storage.
13364      (This does not mean `static' in the C sense!)  */
13365   TREE_STATIC (decl1) = 1;
13366
13367   /* We must call push_template_decl after current_class_type is set
13368      up.  (If we are processing inline definitions after exiting a
13369      class scope, current_class_type will be NULL_TREE until set above
13370      by push_nested_class.)  */
13371   if (processing_template_decl)
13372     decl1 = push_template_decl (decl1);
13373
13374   /* We are now in the scope of the function being defined.  */
13375   current_function_decl = decl1;
13376
13377   /* Save the parm names or decls from this function's declarator
13378      where store_parm_decls will find them.  */
13379   current_function_parms = last_function_parms;
13380
13381   /* Make sure the parameter and return types are reasonable.  When
13382      you declare a function, these types can be incomplete, but they
13383      must be complete when you define the function.  */
13384   if (! processing_template_decl)
13385     check_function_type (decl1, current_function_parms);
13386
13387   /* Build the return declaration for the function.  */
13388   restype = TREE_TYPE (fntype);
13389   if (!processing_template_decl)
13390     {
13391       if (!DECL_RESULT (decl1))
13392         {
13393           DECL_RESULT (decl1)
13394             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13395           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13396                                       DECL_RESULT (decl1));
13397         }
13398     }
13399   else
13400     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13401     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13402
13403   /* Initialize RTL machinery.  We cannot do this until
13404      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13405      even when processing a template; this is how we get
13406      CFUN set up, and our per-function variables initialized.
13407      FIXME factor out the non-RTL stuff.  */
13408   bl = current_binding_level;
13409   init_function_start (decl1, input_filename, lineno);
13410   current_binding_level = bl;
13411
13412   /* Even though we're inside a function body, we still don't want to
13413      call expand_expr to calculate the size of a variable-sized array.
13414      We haven't necessarily assigned RTL to all variables yet, so it's
13415      not safe to try to expand expressions involving them.  */
13416   immediate_size_expand = 0;
13417   cfun->x_dont_save_pending_sizes_p = 1;
13418
13419   /* Start the statement-tree, start the tree now.  */
13420   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13421
13422   /* Let the user know we're compiling this function.  */
13423   announce_function (decl1);
13424
13425   /* Record the decl so that the function name is defined.
13426      If we already have a decl for this name, and it is a FUNCTION_DECL,
13427      use the old decl.  */
13428   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13429     {
13430       /* A specialization is not used to guide overload resolution.  */
13431       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13432           && ! DECL_FUNCTION_MEMBER_P (decl1))
13433         decl1 = pushdecl (decl1);
13434       else
13435         {
13436           /* We need to set the DECL_CONTEXT. */
13437           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13438             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13439           /* And make sure we have enough default args.  */
13440           check_default_args (decl1);
13441         }
13442       fntype = TREE_TYPE (decl1);
13443     }
13444
13445   /* Reset these in case the call to pushdecl changed them.  */
13446   current_function_decl = decl1;
13447   cfun->decl = decl1;
13448
13449   /* If we are (erroneously) defining a function that we have already
13450      defined before, wipe out what we knew before.  */
13451   if (!DECL_PENDING_INLINE_P (decl1)
13452       && DECL_SAVED_FUNCTION_DATA (decl1))
13453     {
13454       free (DECL_SAVED_FUNCTION_DATA (decl1));
13455       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13456     }
13457
13458   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13459     {
13460       /* We know that this was set up by `grokclassfn'.  We do not
13461          wait until `store_parm_decls', since evil parse errors may
13462          never get us to that point.  Here we keep the consistency
13463          between `current_class_type' and `current_class_ptr'.  */
13464       tree t = DECL_ARGUMENTS (decl1);
13465
13466       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13467                           162);
13468       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13469                           19990811);
13470
13471       cp_function_chain->x_current_class_ref
13472         = build_indirect_ref (t, NULL);
13473       cp_function_chain->x_current_class_ptr = t;
13474
13475       /* Constructors and destructors need to know whether they're "in
13476          charge" of initializing virtual base classes.  */
13477       t = TREE_CHAIN (t);
13478       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13479         {
13480           current_in_charge_parm = t;
13481           t = TREE_CHAIN (t);
13482         }
13483       if (DECL_HAS_VTT_PARM_P (decl1))
13484         {
13485           if (DECL_NAME (t) != vtt_parm_identifier)
13486             abort ();
13487           current_vtt_parm = t;
13488         }
13489     }
13490
13491   if (DECL_INTERFACE_KNOWN (decl1))
13492     {
13493       tree ctx = decl_function_context (decl1);
13494
13495       if (DECL_NOT_REALLY_EXTERN (decl1))
13496         DECL_EXTERNAL (decl1) = 0;
13497
13498       if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
13499           && TREE_PUBLIC (ctx))
13500         /* This is a function in a local class in an extern inline
13501            function.  */
13502         comdat_linkage (decl1);
13503     }
13504   /* If this function belongs to an interface, it is public.
13505      If it belongs to someone else's interface, it is also external.
13506      This only affects inlines and template instantiations.  */
13507   else if (interface_unknown == 0
13508            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13509                || flag_alt_external_templates))
13510     {
13511       if (DECL_DECLARED_INLINE_P (decl1)
13512           || DECL_TEMPLATE_INSTANTIATION (decl1)
13513           || processing_template_decl)
13514         {
13515           DECL_EXTERNAL (decl1)
13516             = (interface_only
13517                || (DECL_DECLARED_INLINE_P (decl1)
13518                    && ! flag_implement_inlines
13519                    && !DECL_VINDEX (decl1)));
13520
13521           /* For WIN32 we also want to put these in linkonce sections.  */
13522           maybe_make_one_only (decl1);
13523         }
13524       else
13525         DECL_EXTERNAL (decl1) = 0;
13526       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13527       DECL_INTERFACE_KNOWN (decl1) = 1;
13528     }
13529   else if (interface_unknown && interface_only
13530            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13531                || flag_alt_external_templates))
13532     {
13533       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13534          interface, we will have interface_only set but not
13535          interface_known.  In that case, we don't want to use the normal
13536          heuristics because someone will supply a #pragma implementation
13537          elsewhere, and deducing it here would produce a conflict.  */
13538       comdat_linkage (decl1);
13539       DECL_EXTERNAL (decl1) = 0;
13540       DECL_INTERFACE_KNOWN (decl1) = 1;
13541       DECL_DEFER_OUTPUT (decl1) = 1;
13542     }
13543   else
13544     {
13545       /* This is a definition, not a reference.
13546          So clear DECL_EXTERNAL.  */
13547       DECL_EXTERNAL (decl1) = 0;
13548
13549       if ((DECL_DECLARED_INLINE_P (decl1)
13550            || DECL_TEMPLATE_INSTANTIATION (decl1))
13551           && ! DECL_INTERFACE_KNOWN (decl1)
13552           /* Don't try to defer nested functions for now.  */
13553           && ! decl_function_context (decl1))
13554         DECL_DEFER_OUTPUT (decl1) = 1;
13555       else
13556         DECL_INTERFACE_KNOWN (decl1) = 1;
13557     }
13558
13559   pushlevel (0);
13560   current_binding_level->parm_flag = 1;
13561
13562   cplus_decl_attributes (&decl1, attrs, 0);
13563
13564   /* Promote the value to int before returning it.  */
13565   if (c_promoting_integer_type_p (restype))
13566     restype = type_promotes_to (restype);
13567
13568   if (DECL_RESULT (decl1) == NULL_TREE)
13569     {
13570       DECL_RESULT (decl1)
13571         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13572       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13573       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13574     }
13575
13576   ++function_depth;
13577
13578   if (DECL_DESTRUCTOR_P (decl1))
13579     {
13580       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13581       DECL_CONTEXT (dtor_label) = current_function_decl;
13582     }
13583
13584   start_fname_decls ();
13585
13586   store_parm_decls (current_function_parms);
13587
13588   return 1;
13589 }
13590 \f
13591 /* Store the parameter declarations into the current function declaration.
13592    This is called after parsing the parameter declarations, before
13593    digesting the body of the function.
13594
13595    Also install to binding contour return value identifier, if any.  */
13596
13597 static void
13598 store_parm_decls (current_function_parms)
13599      tree current_function_parms;
13600 {
13601   register tree fndecl = current_function_decl;
13602   register tree parm;
13603   int parms_have_cleanups = 0;
13604   tree cleanups = NULL_TREE;
13605
13606   /* This is a chain of any other decls that came in among the parm
13607      declarations.  If a parm is declared with  enum {foo, bar} x;
13608      then CONST_DECLs for foo and bar are put here.  */
13609   tree nonparms = NULL_TREE;
13610
13611   if (current_function_parms)
13612     {
13613       /* This case is when the function was defined with an ANSI prototype.
13614          The parms already have decls, so we need not do anything here
13615          except record them as in effect
13616          and complain if any redundant old-style parm decls were written.  */
13617
13618       tree specparms = current_function_parms;
13619       tree next;
13620
13621       /* Must clear this because it might contain TYPE_DECLs declared
13622              at class level.  */
13623       storedecls (NULL_TREE);
13624
13625       /* If we're doing semantic analysis, then we'll call pushdecl
13626              for each of these.  We must do them in reverse order so that
13627              they end in the correct forward order.  */
13628       specparms = nreverse (specparms);
13629
13630       for (parm = specparms; parm; parm = next)
13631         {
13632           next = TREE_CHAIN (parm);
13633           if (TREE_CODE (parm) == PARM_DECL)
13634             {
13635               tree cleanup;
13636
13637               if (DECL_NAME (parm) == NULL_TREE
13638                   || TREE_CODE (parm) != VOID_TYPE)
13639                 pushdecl (parm);
13640               else
13641                 cp_error ("parameter `%D' declared void", parm);
13642
13643               cleanup = (processing_template_decl
13644                          ? NULL_TREE
13645                          : maybe_build_cleanup (parm));
13646
13647               if (cleanup)
13648                 cleanups = tree_cons (parm, cleanup, cleanups);
13649             }
13650           else
13651             {
13652               /* If we find an enum constant or a type tag,
13653                  put it aside for the moment.  */
13654               TREE_CHAIN (parm) = NULL_TREE;
13655               nonparms = chainon (nonparms, parm);
13656             }
13657         }
13658
13659       /* Get the decls in their original chain order and record in the
13660          function.  This is all and only the PARM_DECLs that were
13661          pushed into scope by the loop above.  */
13662       DECL_ARGUMENTS (fndecl) = getdecls ();
13663       storetags (gettags ());
13664     }
13665   else
13666     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13667
13668   /* Now store the final chain of decls for the arguments
13669      as the decl-chain of the current lexical scope.
13670      Put the enumerators in as well, at the front so that
13671      DECL_ARGUMENTS is not modified.  */
13672   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13673
13674   /* Now that we have initialized the parms, we can start their
13675      cleanups.  We cannot do this before, since expand_decl_cleanup
13676      should not be called before the parm can be used.  */
13677   while (cleanups)
13678     {
13679       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13680                            TREE_VALUE (cleanups));
13681       cleanups = TREE_CHAIN (cleanups);
13682     }
13683
13684   /* Create a binding contour which can be used to catch
13685      cleanup-generated temporaries.  */
13686   if (parms_have_cleanups)
13687     pushlevel (0);
13688
13689   /* Do the starting of the exception specifications, if we have any.  */
13690   if (flag_exceptions && !processing_template_decl
13691       && flag_enforce_eh_specs
13692       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13693     current_eh_spec_block = begin_eh_spec_block ();
13694 }
13695
13696 \f
13697 /* We have finished doing semantic analysis on DECL, but have not yet
13698    generated RTL for its body.  Save away our current state, so that
13699    when we want to generate RTL later we know what to do.  */
13700
13701 static void
13702 save_function_data (decl)
13703      tree decl;
13704 {
13705   struct cp_language_function *f;
13706
13707   /* Save the language-specific per-function data so that we can
13708      get it back when we really expand this function.  */
13709   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13710                       19990908);
13711
13712   /* Make a copy.  */
13713   f = ((struct cp_language_function *)
13714        xmalloc (sizeof (struct cp_language_function)));
13715   memcpy (f, cp_function_chain, sizeof (struct cp_language_function));
13716   DECL_SAVED_FUNCTION_DATA (decl) = f;
13717
13718   /* Clear out the bits we don't need.  */
13719   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
13720   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
13721   f->x_named_label_uses = NULL;
13722   f->bindings = NULL;
13723   f->x_local_names = NULL;
13724
13725   /* When we get back here again, we will be expanding.  */
13726   f->x_expanding_p = 1;
13727
13728   /* If we've already decided that we cannot inline this function, we
13729      must remember that fact when we actually go to expand the
13730      function.  */
13731   if (current_function_cannot_inline)
13732     {
13733       f->cannot_inline = current_function_cannot_inline;
13734       DECL_INLINE (decl) = 0;
13735     }
13736 }
13737
13738 /* At the end of every constructor we generate to code to return
13739    `this'.  Do that now.  */
13740
13741 static void
13742 finish_constructor_body ()
13743 {
13744   /* Any return from a constructor will end up here.  */
13745   if (ctor_label)
13746     add_stmt (build_stmt (LABEL_STMT, ctor_label));
13747
13748   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13749      generate the return, rather than a goto to CTOR_LABEL.  */
13750   ctor_label = NULL_TREE;
13751   /* In check_return_expr we translate an empty return from a
13752      constructor to a return of `this'.  */
13753   finish_return_stmt (NULL_TREE);
13754   /* Mark the end of the constructor.  */
13755   add_stmt (build_stmt (CTOR_STMT));
13756 }
13757
13758 /* At the end of every destructor we generate code to restore virtual
13759    function tables to the values desired by base classes and to call
13760    to base class destructors.  Do that now.  */
13761
13762 static void
13763 finish_destructor_body ()
13764 {
13765   tree compound_stmt;
13766   tree exprstmt;
13767
13768   /* Create a block to contain all the extra code.  */
13769   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13770
13771   /* Any return from a destructor will end up here.  */
13772   add_stmt (build_stmt (LABEL_STMT, dtor_label));
13773
13774   /* Generate the code to call destructor on base class.  If this
13775      destructor belongs to a class with virtual functions, then set
13776      the virtual function table pointer to represent the type of our
13777      base class.  */
13778
13779   /* This side-effect makes call to `build_delete' generate the code
13780      we have to have at the end of this destructor.  `build_delete'
13781      will set the flag again.  */
13782   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13783
13784   exprstmt = build_delete (current_class_type,
13785                            current_class_ref,
13786                            sfk_base_destructor,
13787                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13788                            0);
13789
13790   if (exprstmt != error_mark_node
13791       && (TREE_CODE (exprstmt) != NOP_EXPR
13792           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13793           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13794     {
13795       if (exprstmt != void_zero_node)
13796         /* Don't call `expand_expr_stmt' if we're not going to do
13797            anything, since -Wall will give a diagnostic.  */
13798         finish_expr_stmt (exprstmt);
13799
13800       /* Run destructors for all virtual baseclasses.  */
13801       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13802         {
13803           tree vbases;
13804           tree if_stmt;
13805
13806           if_stmt = begin_if_stmt ();
13807           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13808                                       current_in_charge_parm,
13809                                       integer_two_node),
13810                                if_stmt);
13811
13812           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
13813           /* The CLASSTYPE_VBASECLASSES list is in initialization
13814              order, so we have to march through it in reverse order.  */
13815           for (vbases = nreverse (copy_list (vbases));
13816                vbases;
13817                vbases = TREE_CHAIN (vbases))
13818             {
13819               tree vbase = TREE_VALUE (vbases);
13820               tree base_type = BINFO_TYPE (vbase);
13821
13822               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (base_type))
13823                 {
13824                   tree base_ptr_type = build_pointer_type (base_type);
13825                   tree expr = current_class_ptr;
13826
13827                   /* Convert to the basetype here, as we know the layout is
13828                      fixed. What is more, if we let build_method_call do it,
13829                      it will use the vtable, which may have been clobbered
13830                      by the deletion of our primary base.  */
13831
13832                   expr = build1 (NOP_EXPR, base_ptr_type, expr);
13833                   expr = build (PLUS_EXPR, base_ptr_type, expr,
13834                                 BINFO_OFFSET (vbase));
13835                   expr = build_indirect_ref (expr, NULL);
13836                   expr = build_method_call (expr, base_dtor_identifier,
13837                                             NULL_TREE, vbase,
13838                                             LOOKUP_NORMAL);
13839                   finish_expr_stmt (expr);
13840                 }
13841             }
13842
13843           finish_then_clause (if_stmt);
13844           finish_if_stmt ();
13845         }
13846     }
13847
13848   /* In a virtual destructor, we must call delete.  */
13849   if (DECL_VIRTUAL_P (current_function_decl))
13850     {
13851       tree if_stmt;
13852       tree virtual_size = c_sizeof (current_class_type);
13853
13854       /* [class.dtor]
13855
13856          At the point of definition of a virtual destructor (including
13857          an implicit definition), non-placement operator delete shall
13858          be looked up in the scope of the destructor's class and if
13859          found shall be accessible and unambiguous.  */
13860       exprstmt = build_op_delete_call
13861         (DELETE_EXPR, current_class_ptr, virtual_size,
13862          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13863
13864       if_stmt = begin_if_stmt ();
13865       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13866                                   current_in_charge_parm,
13867                                   integer_one_node),
13868                            if_stmt);
13869       finish_expr_stmt (exprstmt);
13870       finish_then_clause (if_stmt);
13871       finish_if_stmt ();
13872     }
13873
13874   /* Close the block we started above.  */
13875   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13876 }
13877
13878 /* Finish up a function declaration and compile that function
13879    all the way to assembler language output.  The free the storage
13880    for the function definition.
13881
13882    FLAGS is a bitwise or of the following values:
13883      1 - CALL_POPLEVEL
13884        An extra call to poplevel (and expand_end_bindings) must be
13885        made to take care of the binding contour for the base
13886        initializers.  This is only relevant for constructors.
13887      2 - INCLASS_INLINE
13888        We just finished processing the body of an in-class inline
13889        function definition.  (This processing will have taken place
13890        after the class definition is complete.)  */
13891
13892 tree
13893 finish_function (flags)
13894      int flags;
13895 {
13896   register tree fndecl = current_function_decl;
13897   tree fntype, ctype = NULL_TREE;
13898   int call_poplevel = (flags & 1) != 0;
13899   int inclass_inline = (flags & 2) != 0;
13900   int nested;
13901
13902   /* When we get some parse errors, we can end up without a
13903      current_function_decl, so cope.  */
13904   if (fndecl == NULL_TREE)
13905     return error_mark_node;
13906
13907   nested = function_depth > 1;
13908   fntype = TREE_TYPE (fndecl);
13909
13910   /*  TREE_READONLY (fndecl) = 1;
13911       This caused &foo to be of type ptr-to-const-function
13912       which then got a warning when stored in a ptr-to-function variable.  */
13913
13914   my_friendly_assert (building_stmt_tree (), 20000911);
13915
13916   finish_fname_decls ();
13917
13918   /* For a cloned function, we've already got all the code we need;
13919      there's no need to add any extra bits.  */
13920   if (!DECL_CLONED_FUNCTION_P (fndecl))
13921     {
13922       if (DECL_CONSTRUCTOR_P (fndecl))
13923         {
13924           finish_constructor_body ();
13925           if (call_poplevel)
13926             do_poplevel ();
13927         }
13928       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
13929         finish_destructor_body ();
13930       else if (DECL_MAIN_P (fndecl))
13931         {
13932           /* Make it so that `main' always returns 0 by default.  */
13933 #ifdef VMS
13934           finish_return_stmt (integer_one_node);
13935 #else
13936           finish_return_stmt (integer_zero_node);
13937 #endif
13938         }
13939
13940       /* Finish dealing with exception specifiers.  */
13941       if (flag_exceptions && !processing_template_decl
13942           && flag_enforce_eh_specs
13943           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13944         finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
13945                               (TREE_TYPE (current_function_decl)),
13946                               current_eh_spec_block);
13947     }
13948
13949   /* If we're saving up tree structure, tie off the function now.  */
13950   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
13951
13952   /* This must come after expand_function_end because cleanups might
13953      have declarations (from inline functions) that need to go into
13954      this function's blocks.  */
13955   if (current_binding_level->parm_flag != 1)
13956     my_friendly_abort (122);
13957   poplevel (1, 0, 1);
13958
13959   /* Set up the named return value optimization, if we can.  Here, we
13960      eliminate the copy from the nrv into the RESULT_DECL and any cleanup
13961      for the nrv.  genrtl_start_function and declare_return_variable
13962      handle making the nrv and RESULT_DECL share space.  */
13963   if (current_function_return_value)
13964     {
13965       tree r = current_function_return_value;
13966       /* This is only worth doing for fns that return in memory--and
13967          simpler, since we don't have to worry about promoted modes.  */
13968       if (r != error_mark_node
13969           && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl))))
13970         {
13971           DECL_ALIGN (r) = DECL_ALIGN (DECL_RESULT (fndecl));
13972           walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl),
13973                                         nullify_returns_r, r);
13974         }
13975       else
13976         /* Clear it so genrtl_start_function and declare_return_variable
13977            know we're not optimizing.  */
13978         current_function_return_value = NULL_TREE;
13979     }
13980
13981   /* Remember that we were in class scope.  */
13982   if (current_class_name)
13983     ctype = current_class_type;
13984
13985   /* Must mark the RESULT_DECL as being in this function.  */
13986   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
13987
13988   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13989      to the FUNCTION_DECL node itself.  */
13990   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
13991
13992   /* Save away current state, if appropriate.  */
13993   if (!processing_template_decl)
13994     save_function_data (fndecl);
13995
13996   /* If this function calls `setjmp' it cannot be inlined.  When
13997      `longjmp' is called it is not guaranteed to restore the value of
13998      local variables that have been modified since the call to
13999      `setjmp'.  So, if were to inline this function into some caller
14000      `c', then when we `longjmp', we might not restore all variables
14001      in `c'.  (It might seem, at first blush, that there's no way for
14002      this function to modify local variables in `c', but their
14003      addresses may have been stored somewhere accessible to this
14004      function.)  */
14005   if (!processing_template_decl && calls_setjmp_p (fndecl))
14006     DECL_UNINLINABLE (fndecl) = 1;
14007
14008   /* Clear out memory we no longer need.  */
14009   free_after_parsing (cfun);
14010   /* Since we never call rest_of_compilation, we never clear
14011      CFUN.  Do so explicitly.  */
14012   free_after_compilation (cfun);
14013   cfun = NULL;
14014
14015   /* If this is a in-class inline definition, we may have to pop the
14016      bindings for the template parameters that we added in
14017      maybe_begin_member_template_processing when start_function was
14018      called.  */
14019   if (inclass_inline)
14020     maybe_end_member_template_processing ();
14021
14022   /* Leave the scope of the class.  */
14023   if (ctype)
14024     pop_nested_class ();
14025
14026   --function_depth;
14027
14028   /* Clean up.  */
14029   if (! nested)
14030     /* Let the error reporting routines know that we're outside a
14031        function.  For a nested function, this value is used in
14032        pop_cp_function_context and then reset via pop_function_context.  */
14033     current_function_decl = NULL_TREE;
14034
14035   return fndecl;
14036 }
14037 \f
14038 /* Create the FUNCTION_DECL for a function definition.
14039    DECLSPECS and DECLARATOR are the parts of the declaration;
14040    they describe the return type and the name of the function,
14041    but twisted together in a fashion that parallels the syntax of C.
14042
14043    This function creates a binding context for the function body
14044    as well as setting up the FUNCTION_DECL in current_function_decl.
14045
14046    Returns a FUNCTION_DECL on success.
14047
14048    If the DECLARATOR is not suitable for a function (it defines a datum
14049    instead), we return 0, which tells yyparse to report a parse error.
14050
14051    May return void_type_node indicating that this method is actually
14052    a friend.  See grokfield for more details.
14053
14054    Came here with a `.pushlevel' .
14055
14056    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14057    CHANGES TO CODE IN `grokfield'.  */
14058
14059 tree
14060 start_method (declspecs, declarator, attrlist)
14061      tree declarator, declspecs, attrlist;
14062 {
14063   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14064                                 &attrlist);
14065
14066   /* Something too ugly to handle.  */
14067   if (fndecl == NULL_TREE)
14068     return NULL_TREE;
14069
14070   /* Pass friends other than inline friend functions back.  */
14071   if (fndecl == void_type_node)
14072     return fndecl;
14073
14074   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14075     /* Not a function, tell parser to report parse error.  */
14076     return NULL_TREE;
14077
14078   if (DECL_IN_AGGR_P (fndecl))
14079     {
14080       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14081         {
14082           if (DECL_CONTEXT (fndecl)
14083               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14084             cp_error ("`%D' is already defined in class `%T'", fndecl,
14085                       DECL_CONTEXT (fndecl));
14086         }
14087       return void_type_node;
14088     }
14089
14090   check_template_shadow (fndecl);
14091
14092   DECL_DECLARED_INLINE_P (fndecl) = 1;
14093
14094   if (flag_default_inline)
14095     DECL_INLINE (fndecl) = 1;
14096
14097   /* We process method specializations in finish_struct_1.  */
14098   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14099     fndecl = push_template_decl (fndecl);
14100
14101   if (! DECL_FRIEND_P (fndecl))
14102     {
14103       if (TREE_CHAIN (fndecl))
14104         {
14105           fndecl = copy_node (fndecl);
14106           TREE_CHAIN (fndecl) = NULL_TREE;
14107         }
14108
14109       if (DECL_CONSTRUCTOR_P (fndecl))
14110         {
14111           if (! grok_ctor_properties (current_class_type, fndecl))
14112             return void_type_node;
14113         }
14114       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14115         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14116     }
14117
14118   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14119
14120   /* Make a place for the parms */
14121   pushlevel (0);
14122   current_binding_level->parm_flag = 1;
14123
14124   DECL_IN_AGGR_P (fndecl) = 1;
14125   return fndecl;
14126 }
14127
14128 /* Go through the motions of finishing a function definition.
14129    We don't compile this method until after the whole class has
14130    been processed.
14131
14132    FINISH_METHOD must return something that looks as though it
14133    came from GROKFIELD (since we are defining a method, after all).
14134
14135    This is called after parsing the body of the function definition.
14136    STMTS is the chain of statements that makes up the function body.
14137
14138    DECL is the ..._DECL that `start_method' provided.  */
14139
14140 tree
14141 finish_method (decl)
14142      tree decl;
14143 {
14144   register tree fndecl = decl;
14145   tree old_initial;
14146
14147   register tree link;
14148
14149   if (decl == void_type_node)
14150     return decl;
14151
14152   old_initial = DECL_INITIAL (fndecl);
14153
14154   /* Undo the level for the parms (from start_method).
14155      This is like poplevel, but it causes nothing to be
14156      saved.  Saving information here confuses symbol-table
14157      output routines.  Besides, this information will
14158      be correctly output when this method is actually
14159      compiled.  */
14160
14161   /* Clear out the meanings of the local variables of this level;
14162      also record in each decl which block it belongs to.  */
14163
14164   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14165     {
14166       if (DECL_NAME (link) != NULL_TREE)
14167         pop_binding (DECL_NAME (link), link);
14168       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14169       DECL_CONTEXT (link) = NULL_TREE;
14170     }
14171
14172   GNU_xref_end_scope ((size_t) current_binding_level,
14173                       (size_t) current_binding_level->level_chain,
14174                       current_binding_level->parm_flag,
14175                       current_binding_level->keep);
14176
14177   poplevel (0, 0, 0);
14178
14179   DECL_INITIAL (fndecl) = old_initial;
14180
14181   /* We used to check if the context of FNDECL was different from
14182      current_class_type as another way to get inside here.  This didn't work
14183      for String.cc in libg++.  */
14184   if (DECL_FRIEND_P (fndecl))
14185     {
14186       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14187         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14188       decl = void_type_node;
14189     }
14190
14191   return decl;
14192 }
14193 \f
14194 /* Called when a new struct TYPE is defined.
14195    If this structure or union completes the type of any previous
14196    variable declaration, lay it out and output its rtl.  */
14197
14198 void
14199 hack_incomplete_structures (type)
14200      tree type;
14201 {
14202   tree *list;
14203   struct binding_level *level;
14204
14205   if (!type) /* Don't do this for class templates.  */
14206     return;
14207
14208   if (namespace_bindings_p ())
14209     {
14210       level = 0;
14211       list = &namespace_scope_incomplete;
14212     }
14213   else
14214     {
14215       level = innermost_nonclass_level ();
14216       list = &level->incomplete;
14217     }
14218
14219   while (1)
14220     {
14221       while (*list)
14222         {
14223           tree decl = TREE_VALUE (*list);
14224           if ((decl && TREE_TYPE (decl) == type)
14225               || (TREE_TYPE (decl)
14226                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14227                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14228             {
14229               int toplevel = toplevel_bindings_p ();
14230               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14231                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14232                 layout_type (TREE_TYPE (decl));
14233               layout_decl (decl, 0);
14234               rest_of_decl_compilation (decl, NULL, toplevel, 0);
14235               if (! toplevel)
14236                 {
14237                   tree cleanup;
14238                   expand_decl (decl);
14239                   cleanup = maybe_build_cleanup (decl);
14240                   expand_decl_init (decl);
14241                   if (! expand_decl_cleanup (decl, cleanup))
14242                     cp_error ("parser lost in parsing declaration of `%D'",
14243                               decl);
14244                 }
14245               *list = TREE_CHAIN (*list);
14246             }
14247           else
14248             list = &TREE_CHAIN (*list);
14249         }
14250
14251       /* Keep looking through artificial binding levels generated
14252          for local variables.  */
14253       if (level && level->keep == 2)
14254         {
14255           level = level->level_chain;
14256           list = &level->incomplete;
14257         }
14258       else
14259         break;
14260     }
14261 }
14262
14263 /* If DECL is of a type which needs a cleanup, build that cleanup
14264    here.  */
14265
14266 tree
14267 maybe_build_cleanup (decl)
14268      tree decl;
14269 {
14270   tree type = TREE_TYPE (decl);
14271
14272   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14273     {
14274       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14275       tree rval;
14276
14277       if (TREE_CODE (type) == ARRAY_TYPE)
14278         rval = decl;
14279       else
14280         {
14281           mark_addressable (decl);
14282           rval = build_unary_op (ADDR_EXPR, decl, 0);
14283         }
14284
14285       /* Optimize for space over speed here.  */
14286       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14287           || flag_expensive_optimizations)
14288         flags |= LOOKUP_NONVIRTUAL;
14289
14290       rval = build_delete (TREE_TYPE (rval), rval,
14291                            sfk_complete_destructor, flags, 0);
14292
14293       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14294           && ! TYPE_HAS_DESTRUCTOR (type))
14295         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14296                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14297
14298       return rval;
14299     }
14300   return 0;
14301 }
14302 \f
14303 /* When a stmt has been parsed, this function is called.  */
14304
14305 void
14306 finish_stmt ()
14307 {
14308   /* Always assume this statement was not an expression statement.  If
14309      it actually was an expression statement, its our callers
14310      responsibility to fix this up.  */
14311   last_expr_type = NULL_TREE;
14312 }
14313
14314 /* DECL was originally constructed as a non-static member function,
14315    but turned out to be static.  Update it accordingly.  */
14316
14317 void
14318 revert_static_member_fn (decl)
14319      tree decl;
14320 {
14321   tree tmp;
14322   tree function = TREE_TYPE (decl);
14323   tree args = TYPE_ARG_TYPES (function);
14324
14325   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14326       != TYPE_UNQUALIFIED)
14327     cp_error ("static member function `%#D' declared with type qualifiers",
14328               decl);
14329
14330   args = TREE_CHAIN (args);
14331   tmp = build_function_type (TREE_TYPE (function), args);
14332   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14333   tmp = build_exception_variant (tmp,
14334                                  TYPE_RAISES_EXCEPTIONS (function));
14335   TREE_TYPE (decl) = tmp;
14336   if (DECL_ARGUMENTS (decl))
14337     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14338   DECL_STATIC_FUNCTION_P (decl) = 1;
14339 }
14340
14341 /* Initialize the variables used during compilation of a C++
14342    function.  */
14343
14344 static void
14345 push_cp_function_context (f)
14346      struct function *f;
14347 {
14348   struct cp_language_function *p
14349     = ((struct cp_language_function *)
14350        xcalloc (1, sizeof (struct cp_language_function)));
14351   f->language = (struct language_function *) p;
14352
14353   /* It takes an explicit call to expand_body to generate RTL for a
14354      function.  */
14355   expanding_p = 0;
14356
14357   /* Whenever we start a new function, we destroy temporaries in the
14358      usual way.  */
14359   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14360 }
14361
14362 /* Free the language-specific parts of F, now that we've finished
14363    compiling the function.  */
14364
14365 static void
14366 pop_cp_function_context (f)
14367      struct function *f;
14368 {
14369   if (f->language)
14370     {
14371       struct cp_language_function *cp =
14372         (struct cp_language_function *) f->language;
14373       if (cp->x_local_names)
14374         VARRAY_FREE (cp->x_local_names);
14375       free (f->language);
14376     }
14377   f->language = 0;
14378 }
14379
14380 /* Mark P for GC.  */
14381
14382 static void
14383 mark_lang_function (p)
14384      struct cp_language_function *p;
14385 {
14386   if (!p)
14387     return;
14388
14389   mark_c_language_function (&p->base);
14390
14391   ggc_mark_tree (p->x_ctor_label);
14392   ggc_mark_tree (p->x_dtor_label);
14393   ggc_mark_tree (p->x_current_class_ptr);
14394   ggc_mark_tree (p->x_current_class_ref);
14395   ggc_mark_tree (p->x_eh_spec_block);
14396   ggc_mark_tree_varray (p->x_local_names);
14397
14398   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14399   mark_binding_level (&p->bindings);
14400 }
14401
14402 /* Mark the language-specific data in F for GC.  */
14403
14404 static void
14405 mark_cp_function_context (f)
14406      struct function *f;
14407 {
14408   mark_lang_function ((struct cp_language_function *) f->language);
14409 }
14410
14411 void
14412 lang_mark_tree (t)
14413      tree t;
14414 {
14415   enum tree_code code = TREE_CODE (t);
14416   if (code == IDENTIFIER_NODE)
14417     {
14418       struct lang_identifier *li = (struct lang_identifier *) t;
14419       struct lang_id2 *li2 = li->x;
14420       ggc_mark_tree (li->namespace_bindings);
14421       ggc_mark_tree (li->bindings);
14422       ggc_mark_tree (li->class_value);
14423       ggc_mark_tree (li->class_template_info);
14424
14425       if (li2)
14426         {
14427           ggc_mark_tree (li2->label_value);
14428           ggc_mark_tree (li2->implicit_decl);
14429           ggc_mark_tree (li2->error_locus);
14430         }
14431     }
14432   else if (code == CPLUS_BINDING)
14433     {
14434       if (BINDING_HAS_LEVEL_P (t))
14435         mark_binding_level (&BINDING_LEVEL (t));
14436       else
14437         ggc_mark_tree (BINDING_SCOPE (t));
14438       ggc_mark_tree (BINDING_VALUE (t));
14439     }
14440   else if (code == OVERLOAD)
14441     ggc_mark_tree (OVL_FUNCTION (t));
14442   else if (code == TEMPLATE_PARM_INDEX)
14443     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14444   else if (TREE_CODE_CLASS (code) == 'd')
14445     {
14446       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14447
14448       if (ld)
14449         {
14450           ggc_mark (ld);
14451           c_mark_lang_decl (&ld->decl_flags.base);
14452           if (!DECL_GLOBAL_CTOR_P (t)
14453               && !DECL_GLOBAL_DTOR_P (t)
14454               && !DECL_THUNK_P (t)
14455               && !DECL_DISCRIMINATOR_P (t))
14456             ggc_mark_tree (ld->decl_flags.u2.access);
14457           else if (DECL_THUNK_P (t))
14458             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14459           if (TREE_CODE (t) != NAMESPACE_DECL)
14460             ggc_mark_tree (ld->decl_flags.u.template_info);
14461           else
14462             mark_binding_level (&NAMESPACE_LEVEL (t));
14463           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14464             {
14465               ggc_mark_tree (ld->befriending_classes);
14466               ggc_mark_tree (ld->context);
14467               ggc_mark_tree (ld->cloned_function);
14468               ggc_mark_tree (ld->inlined_fns);
14469               if (TREE_CODE (t) == TYPE_DECL)
14470                 ggc_mark_tree (ld->u.sorted_fields);
14471               else if (TREE_CODE (t) == FUNCTION_DECL
14472                        && !DECL_PENDING_INLINE_P (t))
14473                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14474             }
14475         }
14476     }
14477   else if (TREE_CODE_CLASS (code) == 't')
14478     {
14479       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14480
14481       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14482                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14483         {
14484           ggc_mark (lt);
14485           ggc_mark_tree (lt->primary_base);
14486           ggc_mark_tree (lt->vfields);
14487           ggc_mark_tree (lt->vbases);
14488           ggc_mark_tree (lt->tags);
14489           ggc_mark_tree (lt->size);
14490           ggc_mark_tree (lt->pure_virtuals);
14491           ggc_mark_tree (lt->friend_classes);
14492           ggc_mark_tree (lt->rtti);
14493           ggc_mark_tree (lt->methods);
14494           ggc_mark_tree (lt->template_info);
14495           ggc_mark_tree (lt->befriending_classes);
14496         }
14497       else if (lt)
14498         /* In the case of pointer-to-member function types, the
14499            TYPE_LANG_SPECIFIC is really just a tree.  */
14500         ggc_mark_tree ((tree) lt);
14501     }
14502 }
14503
14504 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14505    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
14506
14507 tree
14508 identifier_global_value (t)
14509      tree t;
14510 {
14511   return IDENTIFIER_GLOBAL_VALUE (t);
14512 }
14513
14514 /* Build the void_list_node (void_type_node having been created).  */
14515 tree
14516 build_void_list_node ()
14517 {
14518   tree t = build_tree_list (NULL_TREE, void_type_node);
14519   TREE_PARMLIST (t) = 1;
14520   return t;
14521 }
14522
14523 static int
14524 cp_missing_noreturn_ok_p (decl)
14525      tree decl;
14526 {
14527   /* A missing noreturn is ok for the `main' function.  */
14528   return DECL_MAIN_P (decl);
14529 }