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
  47 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  48
  49 #ifndef BOOL_TYPE_SIZE
  50 /* In the new ABI, `bool' has size and alignment `1', on all
  51    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 #if 0
 166    Old rtti stuff.
 167         tree __baselist_desc_type_node;
 168         tree __i_desc_type_node, __m_desc_type_node;
 169         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 170 #endif
 171         tree __t_desc_type_node;
 172 #if 0
 173         tree __tp_desc_type_node;
 174 #endif
 175         tree ti_desc_type_node;
 176         tree bltn_desc_type_node, ptr_desc_type_node;
 177         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 178         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 179         tree ptm_desc_type_node;
 180         tree base_desc_type_node;
 181 #if 0
 182    Not needed yet?  May be needed one day?
 183         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 184         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 185         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 186 #endif
 187
 188         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 189         tree unknown_type_node;
 190
 191    Array type `vtable_entry_type[]'
 192
 193         tree vtbl_type_node;
 194         tree vtbl_ptr_type_node;
 195
 196    Namespaces,
 197
 198         tree std_node;
 199         tree abi_node;
 200
 201    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 202    one that the user will declare, but sufficient to be called
 203    by routines that want to abort the program.
 204
 205         tree abort_fndecl;
 206
 207    The FUNCTION_DECL for the default `::operator delete'.
 208
 209         tree global_delete_fndecl;
 210
 211    Used by RTTI
 212         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 213         tree tinfo_var_id;
 214
 215 */
 216
 217 tree cp_global_trees[CPTI_MAX];
 218
 219 /* Indicates that there is a type value in some namespace, although
 220    that is not necessarily in scope at the moment.  */
 221
 222 static tree global_type_node;
 223
 224 /* If non-zero, this is the number of times we have entered the `std'
 225    namespace when we are treating that namespace as an alias for the
 226    global namespace.  */
 227 static int in_fake_std;
 228
 229 /* Expect only namespace names now. */
 230 static int only_namespace_names;
 231
 232 /* Used only for jumps to as-yet undefined labels, since jumps to
 233    defined labels can have their validity checked immediately.  */
 234
 235 struct named_label_use_list
 236 {
 237   struct binding_level *binding_level;
 238   tree names_in_scope;
 239   tree label_decl;
 240   const char *filename_o_goto;
 241   int lineno_o_goto;
 242   struct named_label_use_list *next;
 243 };
 244
 245 #define named_label_uses cp_function_chain->x_named_label_uses
 246
 247 #define local_names cp_function_chain->x_local_names
 248
 249 /* A list of objects which have constructors or destructors
 250    which reside in the global scope.  The decl is stored in
 251    the TREE_VALUE slot and the initializer is stored
 252    in the TREE_PURPOSE slot.  */
 253 tree static_aggregates;
 254
 255 /* -- end of C++ */
 256
 257 /* A node for the integer constants 2, and 3.  */
 258
 259 tree integer_two_node, integer_three_node;
 260
 261 /* Parsing a function declarator leaves here a chain of structure
 262    and enum types declared in the parmlist.  */
 263
 264 static tree last_function_parm_tags;
 265
 266 /* Similar, for last_function_parm_tags.  */
 267 tree last_function_parms;
 268 static tree current_function_parm_tags;
 269
 270 /* A list of all LABEL_DECLs in the function that have names.  Here so
 271    we can clear out their names' definitions at the end of the
 272    function, and so we can check the validity of jumps to these labels.  */
 273
 274 struct named_label_list
 275 {
 276   struct binding_level *binding_level;
 277   tree names_in_scope;
 278   tree old_value;
 279   tree label_decl;
 280   tree bad_decls;
 281   struct named_label_list *next;
 282   unsigned int in_try_scope : 1;
 283   unsigned int in_catch_scope : 1;
 284 };
 285
 286 #define named_labels cp_function_chain->x_named_labels
 287
 288 /* Set to 0 at beginning of a function definition, and whenever
 289    a label (case or named) is defined.  Set to value of expression
 290    returned from function when that value can be transformed into
 291    a named return value.  */
 292
 293 tree current_function_return_value;
 294
 295 /* Nonzero means use the ISO C94 dialect of C.  */
 296
 297 int flag_isoc94;
 298
 299 /* Nonzero means use the ISO C99 dialect of C.  */
 300
 301 int flag_isoc99;
 302
 303 /* Nonzero means we are a hosted implementation for code shared with C.  */
 304
 305 int flag_hosted = 1;
 306
 307 /* Nonzero means add default format_arg attributes for functions not
 308    in ISO C.  */
 309
 310 int flag_noniso_default_format_attributes = 1;
 311
 312 /* Nonzero if we want to conserve space in the .o files.  We do this
 313    by putting uninitialized data and runtime initialized data into
 314    .common instead of .data at the expense of not flagging multiple
 315    definitions.  */
 316 extern int flag_conserve_space;
 317 \f
 318 /* C and C++ flags are in decl2.c.  */
 319
 320 /* Flag used when debugging spew.c */
 321
 322 extern int spew_debug;
 323
 324 /* A expression of value 0 with the same precision as a sizetype
 325    node, but signed.  */
 326 tree signed_size_zero_node;
 327
 328 /* The name of the anonymous namespace, throughout this translation
 329    unit.  */
 330 tree anonymous_namespace_name;
 331
 332 /* The number of function bodies which we are currently processing.
 333    (Zero if we are at namespace scope, one inside the body of a
 334    function, two inside the body of a function in a local class, etc.)  */
 335 int function_depth;
 336 \f
 337 /* For each binding contour we allocate a binding_level structure
 338    which records the names defined in that contour.
 339    Contours include:
 340     0) the global one
 341     1) one for each function definition,
 342        where internal declarations of the parameters appear.
 343     2) one for each compound statement,
 344        to record its declarations.
 345
 346    The current meaning of a name can be found by searching the levels
 347    from the current one out to the global one.
 348
 349    Off to the side, may be the class_binding_level.  This exists only
 350    to catch class-local declarations.  It is otherwise nonexistent.
 351
 352    Also there may be binding levels that catch cleanups that must be
 353    run when exceptions occur.  Thus, to see whether a name is bound in
 354    the current scope, it is not enough to look in the
 355    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 356    instead.  */
 357
 358 /* Note that the information in the `names' component of the global contour
 359    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 360
 361 struct binding_level
 362   {
 363     /* A chain of _DECL nodes for all variables, constants, functions,
 364        and typedef types.  These are in the reverse of the order
 365        supplied.  There may be OVERLOADs on this list, too, but they
 366        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 367     tree names;
 368
 369     /* A list of structure, union and enum definitions, for looking up
 370        tag names.
 371        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 372        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 373        or ENUMERAL_TYPE node.
 374
 375        C++: the TREE_VALUE nodes can be simple types for
 376        component_bindings.  */
 377     tree tags;
 378
 379     /* A list of USING_DECL nodes. */
 380     tree usings;
 381
 382     /* A list of used namespaces. PURPOSE is the namespace,
 383        VALUE the common ancestor with this binding_level's namespace. */
 384     tree using_directives;
 385
 386     /* If this binding level is the binding level for a class, then
 387        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 388        is the name of an entity bound in the class.  The TREE_TYPE is
 389        the DECL bound by this name in the class.  */
 390     tree class_shadowed;
 391
 392     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 393        is used for all binding levels. In addition the TREE_VALUE is the
 394        IDENTIFIER_TYPE_VALUE before we entered the class.  */
 395     tree type_shadowed;
 396
 397     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 398        label in this scope.  The TREE_PURPOSE is the previous value of
 399        the IDENTIFIER_LABEL VALUE.  */
 400     tree shadowed_labels;
 401
 402     /* For each level (except not the global one),
 403        a chain of BLOCK nodes for all the levels
 404        that were entered and exited one level down.  */
 405     tree blocks;
 406
 407     /* The _TYPE node for this level, if parm_flag == 2.  */
 408     tree this_class;
 409
 410     /* The binding level which this one is contained in (inherits from).  */
 411     struct binding_level *level_chain;
 412
 413     /* List of decls in `names' that have incomplete
 414        structure or union types.  */
 415     tree incomplete;
 416
 417     /* List of VAR_DECLS saved from a previous for statement.
 418        These would be dead in ISO-conforming code, but might
 419        be referenced in ARM-era code.  These are stored in a
 420        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 421     tree dead_vars_from_for;
 422
 423     /* 1 for the level that holds the parameters of a function.
 424        2 for the level that holds a class declaration.  */
 425     unsigned parm_flag : 2;
 426
 427     /* 1 means make a BLOCK for this level regardless of all else.
 428        2 for temporary binding contours created by the compiler.  */
 429     unsigned keep : 2;
 430
 431     /* Nonzero if this level "doesn't exist" for tags.  */
 432     unsigned tag_transparent : 1;
 433
 434     /* Nonzero if this level can safely have additional
 435        cleanup-needing variables added to it.  */
 436     unsigned more_cleanups_ok : 1;
 437     unsigned have_cleanups : 1;
 438
 439     /* Nonzero if this scope is for storing the decls for template
 440        parameters and generic decls; these decls will be discarded and
 441        replaced with a TEMPLATE_DECL.  */
 442     unsigned template_parms_p : 1;
 443
 444     /* Nonzero if this scope corresponds to the `<>' in a
 445        `template <>' clause.  Whenever this flag is set,
 446        TEMPLATE_PARMS_P will be set as well.  */
 447     unsigned template_spec_p : 1;
 448
 449     /* This is set for a namespace binding level.  */
 450     unsigned namespace_p : 1;
 451
 452     /* True if this level is that of a for-statement where we need to
 453        worry about ambiguous (ARM or ISO) scope rules.  */
 454     unsigned is_for_scope : 1;
 455
 456     /* True if this level corresponds to a TRY block.  Currently this
 457        information is only available while building the tree structure.  */
 458     unsigned is_try_scope : 1;
 459
 460     /* True if this level corresponds to a CATCH block.  Currently this
 461        information is only available while building the tree structure.  */
 462     unsigned is_catch_scope : 1;
 463
 464     /* Three bits left for this word.  */
 465
 466 #if defined(DEBUG_CP_BINDING_LEVELS)
 467     /* Binding depth at which this level began.  */
 468     unsigned binding_depth;
 469 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 470   };
 471
 472 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 473
 474 /* The binding level currently in effect.  */
 475
 476 #define current_binding_level                   \
 477   (cfun && cp_function_chain->bindings          \
 478    ? cp_function_chain->bindings                \
 479    : scope_chain->bindings)
 480
 481 /* The binding level of the current class, if any.  */
 482
 483 #define class_binding_level scope_chain->class_bindings
 484
 485 /* A chain of binding_level structures awaiting reuse.  */
 486
 487 static struct binding_level *free_binding_level;
 488
 489 /* The outermost binding level, for names of file scope.
 490    This is created when the compiler is started and exists
 491    through the entire run.  */
 492
 493 static struct binding_level *global_binding_level;
 494
 495 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 496
 497 static int keep_next_level_flag;
 498
 499 #if defined(DEBUG_CP_BINDING_LEVELS)
 500 static int binding_depth = 0;
 501 static int is_class_level = 0;
 502
 503 static void
 504 indent ()
 505 {
 506   register unsigned i;
 507
 508   for (i = 0; i < binding_depth*2; i++)
 509     putc (' ', stderr);
 510 }
 511 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 512
 513 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 514
 515 static void
 516 push_binding_level (newlevel, tag_transparent, keep)
 517      struct binding_level *newlevel;
 518      int tag_transparent, keep;
 519 {
 520   /* Add this level to the front of the chain (stack) of levels that
 521      are active.  */
 522   memset ((char*) newlevel, 0, sizeof (struct binding_level));
 523   newlevel->level_chain = current_binding_level;
 524   current_binding_level = newlevel;
 525   newlevel->tag_transparent = tag_transparent;
 526   newlevel->more_cleanups_ok = 1;
 527
 528   newlevel->keep = keep;
 529 #if defined(DEBUG_CP_BINDING_LEVELS)
 530   newlevel->binding_depth = binding_depth;
 531   indent ();
 532   fprintf (stderr, "push %s level 0x%08x line %d\n",
 533            (is_class_level) ? "class" : "block", newlevel, lineno);
 534   is_class_level = 0;
 535   binding_depth++;
 536 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 537 }
 538
 539 /* Find the innermost enclosing class scope, and reset
 540    CLASS_BINDING_LEVEL appropriately.  */
 541
 542 static void
 543 find_class_binding_level ()
 544 {
 545   struct binding_level *level = current_binding_level;
 546
 547   while (level && level->parm_flag != 2)
 548     level = level->level_chain;
 549   if (level && level->parm_flag == 2)
 550     class_binding_level = level;
 551   else
 552     class_binding_level = 0;
 553 }
 554
 555 static void
 556 pop_binding_level ()
 557 {
 558   if (global_binding_level)
 559     {
 560       /* Cannot pop a level, if there are none left to pop.  */
 561       if (current_binding_level == global_binding_level)
 562         my_friendly_abort (123);
 563     }
 564   /* Pop the current level, and free the structure for reuse.  */
 565 #if defined(DEBUG_CP_BINDING_LEVELS)
 566   binding_depth--;
 567   indent ();
 568   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 569           (is_class_level) ? "class" : "block",
 570           current_binding_level, lineno);
 571   if (is_class_level != (current_binding_level == class_binding_level))
 572     {
 573       indent ();
 574       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 575     }
 576   is_class_level = 0;
 577 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 578   {
 579     register struct binding_level *level = current_binding_level;
 580     current_binding_level = current_binding_level->level_chain;
 581     level->level_chain = free_binding_level;
 582 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 583     if (level->binding_depth != binding_depth)
 584       abort ();
 585 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 586     free_binding_level = level;
 587     find_class_binding_level ();
 588   }
 589 }
 590
 591 static void
 592 suspend_binding_level ()
 593 {
 594   if (class_binding_level)
 595     current_binding_level = class_binding_level;
 596
 597   if (global_binding_level)
 598     {
 599       /* Cannot suspend a level, if there are none left to suspend.  */
 600       if (current_binding_level == global_binding_level)
 601         my_friendly_abort (123);
 602     }
 603   /* Suspend the current level.  */
 604 #if defined(DEBUG_CP_BINDING_LEVELS)
 605   binding_depth--;
 606   indent ();
 607   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 608           (is_class_level) ? "class" : "block",
 609           current_binding_level, lineno);
 610   if (is_class_level != (current_binding_level == class_binding_level))
 611     {
 612       indent ();
 613       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 614     }
 615   is_class_level = 0;
 616 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 617   current_binding_level = current_binding_level->level_chain;
 618   find_class_binding_level ();
 619 }
 620
 621 static void
 622 resume_binding_level (b)
 623      struct binding_level *b;
 624 {
 625   /* Resuming binding levels is meant only for namespaces,
 626      and those cannot nest into classes. */
 627   my_friendly_assert(!class_binding_level, 386);
 628   /* Also, resuming a non-directly nested namespace is a no-no.  */
 629   my_friendly_assert(b->level_chain == current_binding_level, 386);
 630   current_binding_level = b;
 631 #if defined(DEBUG_CP_BINDING_LEVELS)
 632   b->binding_depth = binding_depth;
 633   indent ();
 634   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 635            (is_class_level) ? "class" : "block", b, lineno);
 636   is_class_level = 0;
 637   binding_depth++;
 638 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 639 }
 640 \f
 641 /* Create a new `struct binding_level'.  */
 642
 643 static
 644 struct binding_level *
 645 make_binding_level ()
 646 {
 647   /* NOSTRICT */
 648   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 649 }
 650
 651 /* Nonzero if we are currently in the global binding level.  */
 652
 653 int
 654 global_bindings_p ()
 655 {
 656   return current_binding_level == global_binding_level;
 657 }
 658
 659 /* Return the innermost binding level that is not for a class scope.  */
 660
 661 static struct binding_level *
 662 innermost_nonclass_level ()
 663 {
 664   struct binding_level *b;
 665
 666   b = current_binding_level;
 667   while (b->parm_flag == 2)
 668     b = b->level_chain;
 669
 670   return b;
 671 }
 672
 673 /* Nonzero if we are currently in a toplevel binding level.  This
 674    means either the global binding level or a namespace in a toplevel
 675    binding level.  Since there are no non-toplevel namespace levels,
 676    this really means any namespace or template parameter level.  We
 677    also include a class whose context is toplevel.  */
 678
 679 int
 680 toplevel_bindings_p ()
 681 {
 682   struct binding_level *b = innermost_nonclass_level ();
 683
 684   return b->namespace_p || b->template_parms_p;
 685 }
 686
 687 /* Nonzero if this is a namespace scope, or if we are defining a class
 688    which is itself at namespace scope, or whose enclosing class is
 689    such a class, etc.  */
 690
 691 int
 692 namespace_bindings_p ()
 693 {
 694   struct binding_level *b = innermost_nonclass_level ();
 695
 696   return b->namespace_p;
 697 }
 698
 699 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 700    unconditionally.  Otherwise, use the normal logic to decide whether
 701    or not to create a BLOCK.  */
 702
 703 void
 704 keep_next_level (keep)
 705      int keep;
 706 {
 707   keep_next_level_flag = keep;
 708 }
 709
 710 /* Nonzero if the current level needs to have a BLOCK made.  */
 711
 712 int
 713 kept_level_p ()
 714 {
 715   return (current_binding_level->blocks != NULL_TREE
 716           || current_binding_level->keep
 717           || current_binding_level->names != NULL_TREE
 718           || (current_binding_level->tags != NULL_TREE
 719               && !current_binding_level->tag_transparent));
 720 }
 721
 722 static void
 723 declare_namespace_level ()
 724 {
 725   current_binding_level->namespace_p = 1;
 726 }
 727
 728 /* Returns non-zero if this scope was created to store template
 729    parameters.  */
 730
 731 int
 732 template_parm_scope_p ()
 733 {
 734   return current_binding_level->template_parms_p;
 735 }
 736
 737 /* Returns the kind of template specialization we are currently
 738    processing, given that it's declaration contained N_CLASS_SCOPES
 739    explicit scope qualifications.  */
 740
 741 tmpl_spec_kind
 742 current_tmpl_spec_kind (n_class_scopes)
 743      int n_class_scopes;
 744 {
 745   int n_template_parm_scopes = 0;
 746   int seen_specialization_p = 0;
 747   int innermost_specialization_p = 0;
 748   struct binding_level *b;
 749
 750   /* Scan through the template parameter scopes.  */
 751   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 752     {
 753       /* If we see a specialization scope inside a parameter scope,
 754          then something is wrong.  That corresponds to a declaration
 755          like:
 756
 757             template <class T> template <> ...
 758
 759          which is always illegal since [temp.expl.spec] forbids the
 760          specialization of a class member template if the enclosing
 761          class templates are not explicitly specialized as well.  */
 762       if (b->template_spec_p)
 763         {
 764           if (n_template_parm_scopes == 0)
 765             innermost_specialization_p = 1;
 766           else
 767             seen_specialization_p = 1;
 768         }
 769       else if (seen_specialization_p == 1)
 770         return tsk_invalid_member_spec;
 771
 772       ++n_template_parm_scopes;
 773     }
 774
 775   /* Handle explicit instantiations.  */
 776   if (processing_explicit_instantiation)
 777     {
 778       if (n_template_parm_scopes != 0)
 779         /* We've seen a template parameter list during an explicit
 780            instantiation.  For example:
 781
 782              template <class T> template void f(int);
 783
 784            This is erroneous.  */
 785         return tsk_invalid_expl_inst;
 786       else
 787         return tsk_expl_inst;
 788     }
 789
 790   if (n_template_parm_scopes < n_class_scopes)
 791     /* We've not seen enough template headers to match all the
 792        specialized classes present.  For example:
 793
 794          template <class T> void R<T>::S<T>::f(int);
 795
 796        This is illegal; there needs to be one set of template
 797        parameters for each class.  */
 798     return tsk_insufficient_parms;
 799   else if (n_template_parm_scopes == n_class_scopes)
 800     /* We're processing a non-template declaration (even though it may
 801        be a member of a template class.)  For example:
 802
 803          template <class T> void S<T>::f(int);
 804
 805        The `class T' maches the `S<T>', leaving no template headers
 806        corresponding to the `f'.  */
 807     return tsk_none;
 808   else if (n_template_parm_scopes > n_class_scopes + 1)
 809     /* We've got too many template headers.  For example:
 810
 811          template <> template <class T> void f (T);
 812
 813        There need to be more enclosing classes.  */
 814     return tsk_excessive_parms;
 815   else
 816     /* This must be a template.  It's of the form:
 817
 818          template <class T> template <class U> void S<T>::f(U);
 819
 820        This is a specialization if the innermost level was a
 821        specialization; otherwise it's just a definition of the
 822        template.  */
 823     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 824 }
 825
 826 void
 827 set_class_shadows (shadows)
 828      tree shadows;
 829 {
 830   class_binding_level->class_shadowed = shadows;
 831 }
 832
 833 /* Enter a new binding level.
 834    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 835    not for that of tags.  */
 836
 837 void
 838 pushlevel (tag_transparent)
 839      int tag_transparent;
 840 {
 841   struct binding_level *newlevel;
 842
 843   if (cfun && !doing_semantic_analysis_p ())
 844     return;
 845
 846   /* Reuse or create a struct for this binding level.  */
 847 #if defined(DEBUG_CP_BINDING_LEVELS)
 848   if (0)
 849 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 850   if (free_binding_level)
 851 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 852     {
 853       newlevel = free_binding_level;
 854       free_binding_level = free_binding_level->level_chain;
 855     }
 856   else
 857     newlevel = make_binding_level ();
 858
 859   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 860   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 861   keep_next_level_flag = 0;
 862 }
 863
 864 /* We're defining an object of type TYPE.  If it needs a cleanup, but
 865    we're not allowed to add any more objects with cleanups to the current
 866    scope, create a new binding level.  */
 867
 868 void
 869 maybe_push_cleanup_level (type)
 870      tree type;
 871 {
 872   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
 873       && current_binding_level->more_cleanups_ok == 0)
 874     {
 875       keep_next_level (2);
 876       pushlevel (1);
 877       clear_last_expr ();
 878       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
 879     }
 880 }
 881
 882 /* Enter a new scope.  The KIND indicates what kind of scope is being
 883    created.  */
 884
 885 void
 886 begin_scope (sk)
 887      scope_kind sk;
 888 {
 889   pushlevel (0);
 890
 891   switch (sk)
 892     {
 893     case sk_template_spec:
 894       current_binding_level->template_spec_p = 1;
 895       /* Fall through.  */
 896
 897     case sk_template_parms:
 898       current_binding_level->template_parms_p = 1;
 899       break;
 900
 901     default:
 902       my_friendly_abort (20000309);
 903     }
 904 }
 905
 906 /* Exit the current scope.  */
 907
 908 void
 909 finish_scope ()
 910 {
 911   poplevel (0, 0, 0);
 912 }
 913
 914 void
 915 note_level_for_for ()
 916 {
 917   current_binding_level->is_for_scope = 1;
 918 }
 919
 920 /* Record that the current binding level represents a try block.  */
 921
 922 void
 923 note_level_for_try ()
 924 {
 925   current_binding_level->is_try_scope = 1;
 926 }
 927
 928 /* Record that the current binding level represents a catch block.  */
 929
 930 void
 931 note_level_for_catch ()
 932 {
 933   current_binding_level->is_catch_scope = 1;
 934 }
 935
 936 /* For a binding between a name and an entity at a block scope,
 937    this is the `struct binding_level' for the block.  */
 938 #define BINDING_LEVEL(NODE) \
 939    (((struct tree_binding*)NODE)->scope.level)
 940
 941 /* A free list of CPLUS_BINDING nodes, connected by their
 942    TREE_CHAINs.  */
 943
 944 static tree free_bindings;
 945
 946 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 947    level at which this declaration is being bound.  */
 948
 949 static void
 950 push_binding (id, decl, level)
 951      tree id;
 952      tree decl;
 953      struct binding_level* level;
 954 {
 955   tree binding;
 956
 957   if (free_bindings)
 958     {
 959       binding = free_bindings;
 960       free_bindings = TREE_CHAIN (binding);
 961     }
 962   else
 963     binding = make_node (CPLUS_BINDING);
 964
 965   /* Now, fill in the binding information.  */
 966   BINDING_VALUE (binding) = decl;
 967   BINDING_TYPE (binding) = NULL_TREE;
 968   BINDING_LEVEL (binding) = level;
 969   INHERITED_VALUE_BINDING_P (binding) = 0;
 970   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 971   BINDING_HAS_LEVEL_P (binding) = 1;
 972
 973   /* And put it on the front of the list of bindings for ID.  */
 974   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 975   IDENTIFIER_BINDING (id) = binding;
 976 }
 977
 978 /* ID is already bound in the current scope.  But, DECL is an
 979    additional binding for ID in the same scope.  This is the `struct
 980    stat' hack whereby a non-typedef class-name or enum-name can be
 981    bound at the same level as some other kind of entity.  It's the
 982    responsibility of the caller to check that inserting this name is
 983    legal here.  Returns nonzero if the new binding was successful.  */
 984 static int
 985 add_binding (id, decl)
 986      tree id;
 987      tree decl;
 988 {
 989   tree binding = IDENTIFIER_BINDING (id);
 990   int ok = 1;
 991
 992   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 993     /* The new name is the type name.  */
 994     BINDING_TYPE (binding) = decl;
 995   else if (!BINDING_VALUE (binding))
 996     /* This situation arises when push_class_level_binding moves an
 997        inherited type-binding out of the way to make room for a new
 998        value binding.  */
 999     BINDING_VALUE (binding) = decl;
1000   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1001            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
1002     {
1003       /* The old binding was a type name.  It was placed in
1004          BINDING_VALUE because it was thought, at the point it was
1005          declared, to be the only entity with such a name.  Move the
1006          type name into the type slot; it is now hidden by the new
1007          binding.  */
1008       BINDING_TYPE (binding) = BINDING_VALUE (binding);
1009       BINDING_VALUE (binding) = decl;
1010       INHERITED_VALUE_BINDING_P (binding) = 0;
1011     }
1012   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1013            && TREE_CODE (decl) == TYPE_DECL
1014            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1015            && same_type_p (TREE_TYPE (decl),
1016                            TREE_TYPE (BINDING_VALUE (binding))))
1017     /* We have two typedef-names, both naming the same type to have
1018        the same name.  This is OK because of:
1019
1020          [dcl.typedef]
1021
1022          In a given scope, a typedef specifier can be used to redefine
1023          the name of any type declared in that scope to refer to the
1024          type to which it already refers.  */
1025     ok = 0;
1026   /* There can be two block-scope declarations of the same variable,
1027      so long as they are `extern' declarations.  */
1028   else if (TREE_CODE (decl) == VAR_DECL
1029            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1030            && DECL_EXTERNAL (decl)
1031            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1032     {
1033       duplicate_decls (decl, BINDING_VALUE (binding));
1034       ok = 0;
1035     }
1036   else
1037     {
1038       cp_error ("declaration of `%#D'", decl);
1039       cp_error_at ("conflicts with previous declaration `%#D'",
1040                    BINDING_VALUE (binding));
1041       ok = 0;
1042     }
1043
1044   return ok;
1045 }
1046
1047 /* Add DECL to the list of things declared in B.  */
1048
1049 static void
1050 add_decl_to_level (decl, b)
1051      tree decl;
1052      struct binding_level *b;
1053 {
1054   /* We build up the list in reverse order, and reverse it later if
1055      necessary.  */
1056   TREE_CHAIN (decl) = b->names;
1057   b->names = decl;
1058 }
1059
1060 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1061    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1062    doesn't really belong to this binding level, that it got here
1063    through a using-declaration.  */
1064
1065 void
1066 push_local_binding (id, decl, flags)
1067      tree id;
1068      tree decl;
1069      int flags;
1070 {
1071   struct binding_level *b;
1072
1073   /* Skip over any local classes.  This makes sense if we call
1074      push_local_binding with a friend decl of a local class.  */
1075   b = current_binding_level;
1076   while (b->parm_flag == 2)
1077     b = b->level_chain;
1078
1079   if (lookup_name_current_level (id))
1080     {
1081       /* Supplement the existing binding.  */
1082       if (!add_binding (id, decl))
1083         /* It didn't work.  Something else must be bound at this
1084            level.  Do not add DECL to the list of things to pop
1085            later.  */
1086         return;
1087     }
1088   else
1089     /* Create a new binding.  */
1090     push_binding (id, decl, b);
1091
1092   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1093     /* We must put the OVERLOAD into a TREE_LIST since the
1094        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1095        decls that got here through a using-declaration.  */
1096     decl = build_tree_list (NULL_TREE, decl);
1097
1098   /* And put DECL on the list of things declared by the current
1099      binding level.  */
1100   add_decl_to_level (decl, b);
1101 }
1102
1103 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1104    binding was successful.  */
1105
1106 int
1107 push_class_binding (id, decl)
1108      tree id;
1109      tree decl;
1110 {
1111   int result = 1;
1112   tree binding = IDENTIFIER_BINDING (id);
1113   tree context;
1114
1115   /* Note that we declared this value so that we can issue an error if
1116      this an illegal redeclaration of a name already used for some
1117      other purpose.  */
1118   note_name_declared_in_class (id, decl);
1119
1120   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1121     /* Supplement the existing binding.  */
1122     result = add_binding (id, decl);
1123   else
1124     /* Create a new binding.  */
1125     push_binding (id, decl, class_binding_level);
1126
1127   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1128      class-level declaration.  Note that we do not use DECL here
1129      because of the possibility of the `struct stat' hack; if DECL is
1130      a class-name or enum-name we might prefer a field-name, or some
1131      such.  */
1132   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1133
1134   /* If this is a binding from a base class, mark it as such.  */
1135   binding = IDENTIFIER_BINDING (id);
1136   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1137     {
1138       /* Any implicit typename must be from a base-class.  The
1139          context for an implicit typename declaration is always
1140          the derived class in which the lookup was done, so the checks
1141          based on the context of DECL below will not trigger.  */
1142       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1143         INHERITED_VALUE_BINDING_P (binding) = 1;
1144       else
1145         {
1146           if (TREE_CODE (decl) == OVERLOAD)
1147             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1148           else
1149             {
1150               my_friendly_assert (DECL_P (decl), 0);
1151               context = context_for_name_lookup (decl);
1152             }
1153
1154           if (is_properly_derived_from (current_class_type, context))
1155             INHERITED_VALUE_BINDING_P (binding) = 1;
1156           else
1157             INHERITED_VALUE_BINDING_P (binding) = 0;
1158         }
1159     }
1160   else if (BINDING_VALUE (binding) == decl)
1161     /* We only encounter a TREE_LIST when push_class_decls detects an
1162        ambiguity.  Such an ambiguity can be overridden by a definition
1163        in this class.  */
1164     INHERITED_VALUE_BINDING_P (binding) = 1;
1165
1166   return result;
1167 }
1168
1169 /* Remove the binding for DECL which should be the innermost binding
1170    for ID.  */
1171
1172 static void
1173 pop_binding (id, decl)
1174      tree id;
1175      tree decl;
1176 {
1177   tree binding;
1178
1179   if (id == NULL_TREE)
1180     /* It's easiest to write the loops that call this function without
1181        checking whether or not the entities involved have names.  We
1182        get here for such an entity.  */
1183     return;
1184
1185   /* Get the innermost binding for ID.  */
1186   binding = IDENTIFIER_BINDING (id);
1187
1188   /* The name should be bound.  */
1189   my_friendly_assert (binding != NULL_TREE, 0);
1190
1191   /* The DECL will be either the ordinary binding or the type
1192      binding for this identifier.  Remove that binding.  */
1193   if (BINDING_VALUE (binding) == decl)
1194     BINDING_VALUE (binding) = NULL_TREE;
1195   else if (BINDING_TYPE (binding) == decl)
1196     BINDING_TYPE (binding) = NULL_TREE;
1197   else
1198     my_friendly_abort (0);
1199
1200   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1201     {
1202       /* We're completely done with the innermost binding for this
1203          identifier.  Unhook it from the list of bindings.  */
1204       IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1205
1206       /* Add it to the free list.  */
1207       TREE_CHAIN (binding) = free_bindings;
1208       free_bindings = binding;
1209
1210       /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
1211          it.  */
1212       BINDING_LEVEL (binding) = NULL;
1213     }
1214 }
1215
1216 /* When a label goes out of scope, check to see if that label was used
1217    in a valid manner, and issue any appropriate warnings or errors.  */
1218
1219 static void
1220 pop_label (label, old_value)
1221      tree label;
1222      tree old_value;
1223 {
1224   if (!processing_template_decl && doing_semantic_analysis_p ())
1225     {
1226       if (DECL_INITIAL (label) == NULL_TREE)
1227         {
1228           cp_error_at ("label `%D' used but not defined", label);
1229           /* Avoid crashing later.  */
1230           define_label (input_filename, 1, DECL_NAME (label));
1231         }
1232       else if (warn_unused_label && !TREE_USED (label))
1233         cp_warning_at ("label `%D' defined but not used", label);
1234     }
1235
1236   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1237 }
1238
1239 /* At the end of a function, all labels declared within the function
1240    go out of scope.  BLOCK is the top-level block for the
1241    function.  */
1242
1243 static void
1244 pop_labels (block)
1245      tree block;
1246 {
1247   struct named_label_list *link;
1248
1249   /* Clear out the definitions of all label names, since their scopes
1250      end here.  */
1251   for (link = named_labels; link; link = link->next)
1252     {
1253       pop_label (link->label_decl, link->old_value);
1254       /* Put the labels into the "variables" of the top-level block,
1255          so debugger can see them.  */
1256       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1257       BLOCK_VARS (block) = link->label_decl;
1258     }
1259
1260   named_labels = NULL;
1261 }
1262
1263 /* Exit a binding level.
1264    Pop the level off, and restore the state of the identifier-decl mappings
1265    that were in effect when this level was entered.
1266
1267    If KEEP == 1, this level had explicit declarations, so
1268    and create a "block" (a BLOCK node) for the level
1269    to record its declarations and subblocks for symbol table output.
1270
1271    If FUNCTIONBODY is nonzero, this level is the body of a function,
1272    so create a block as if KEEP were set and also clear out all
1273    label names.
1274
1275    If REVERSE is nonzero, reverse the order of decls before putting
1276    them into the BLOCK.  */
1277
1278 tree
1279 poplevel (keep, reverse, functionbody)
1280      int keep;
1281      int reverse;
1282      int functionbody;
1283 {
1284   register tree link;
1285   /* The chain of decls was accumulated in reverse order.
1286      Put it into forward order, just for cleanliness.  */
1287   tree decls;
1288   int tmp = functionbody;
1289   int real_functionbody;
1290   tree tags;
1291   tree subblocks;
1292   tree block = NULL_TREE;
1293   tree decl;
1294   int leaving_for_scope;
1295
1296   if (cfun && !doing_semantic_analysis_p ())
1297     return NULL_TREE;
1298
1299   my_friendly_assert (current_binding_level->parm_flag != 2,
1300                       19990916);
1301
1302   real_functionbody = (current_binding_level->keep == 2
1303                        ? ((functionbody = 0), tmp) : functionbody);
1304   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1305   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1306
1307   my_friendly_assert (!current_binding_level->class_shadowed,
1308                       19990414);
1309
1310   /* We used to use KEEP == 2 to indicate that the new block should go
1311      at the beginning of the list of blocks at this binding level,
1312      rather than the end.  This hack is no longer used.  */
1313   my_friendly_assert (keep == 0 || keep == 1, 0);
1314
1315   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1316                       (HOST_WIDE_INT) current_binding_level->level_chain,
1317                       current_binding_level->parm_flag,
1318                       current_binding_level->keep);
1319
1320   if (current_binding_level->keep == 1)
1321     keep = 1;
1322
1323   /* Any uses of undefined labels, and any defined labels, now operate
1324      under constraints of next binding contour.  */
1325   if (cfun && !functionbody)
1326     {
1327       struct binding_level *level_chain;
1328       level_chain = current_binding_level->level_chain;
1329       if (level_chain)
1330         {
1331           struct named_label_use_list *uses;
1332           struct named_label_list *labels;
1333           for (labels = named_labels; labels; labels = labels->next)
1334             if (labels->binding_level == current_binding_level)
1335               {
1336                 tree decl;
1337                 if (current_binding_level->is_try_scope)
1338                   labels->in_try_scope = 1;
1339                 if (current_binding_level->is_catch_scope)
1340                   labels->in_catch_scope = 1;
1341                 for (decl = labels->names_in_scope; decl;
1342                      decl = TREE_CHAIN (decl))
1343                   if (decl_jump_unsafe (decl))
1344                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1345                                                    labels->bad_decls);
1346                 labels->binding_level = level_chain;
1347                 labels->names_in_scope = level_chain->names;
1348               }
1349
1350           for (uses = named_label_uses; uses; uses = uses->next)
1351             if (uses->binding_level == current_binding_level)
1352               {
1353                 uses->binding_level = level_chain;
1354                 uses->names_in_scope = level_chain->names;
1355               }
1356         }
1357     }
1358
1359   /* Get the decls in the order they were written.
1360      Usually current_binding_level->names is in reverse order.
1361      But parameter decls were previously put in forward order.  */
1362
1363   if (reverse)
1364     current_binding_level->names
1365       = decls = nreverse (current_binding_level->names);
1366   else
1367     decls = current_binding_level->names;
1368
1369   /* Output any nested inline functions within this block
1370      if they weren't already output.  */
1371   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1372     if (TREE_CODE (decl) == FUNCTION_DECL
1373         && ! TREE_ASM_WRITTEN (decl)
1374         && DECL_INITIAL (decl) != NULL_TREE
1375         && TREE_ADDRESSABLE (decl)
1376         && decl_function_context (decl) == current_function_decl)
1377       {
1378         /* If this decl was copied from a file-scope decl
1379            on account of a block-scope extern decl,
1380            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1381         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1382           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1383         else
1384           {
1385             push_function_context ();
1386             output_inline_function (decl);
1387             pop_function_context ();
1388           }
1389       }
1390
1391   /* When not in function-at-a-time mode, expand_end_bindings will
1392      warn about unused variables.  But, in function-at-a-time mode
1393      expand_end_bindings is not passed the list of variables in the
1394      current scope, and therefore no warning is emitted.  So, we
1395      explicitly warn here.  */
1396   if (!processing_template_decl)
1397     warn_about_unused_variables (getdecls ());
1398
1399   /* If there were any declarations or structure tags in that level,
1400      or if this level is a function body,
1401      create a BLOCK to record them for the life of this function.  */
1402   block = NULL_TREE;
1403   if (keep == 1 || functionbody)
1404     block = make_node (BLOCK);
1405   if (block != NULL_TREE)
1406     {
1407       BLOCK_VARS (block) = decls;
1408       BLOCK_SUBBLOCKS (block) = subblocks;
1409     }
1410
1411   /* In each subblock, record that this is its superior.  */
1412   if (keep >= 0)
1413     for (link = subblocks; link; link = TREE_CHAIN (link))
1414       BLOCK_SUPERCONTEXT (link) = block;
1415
1416   /* We still support the old for-scope rules, whereby the variables
1417      in a for-init statement were in scope after the for-statement
1418      ended.  We only use the new rules in flag_new_for_scope is
1419      nonzero.  */
1420   leaving_for_scope
1421     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1422
1423   /* Remove declarations for all the DECLs in this level.  */
1424   for (link = decls; link; link = TREE_CHAIN (link))
1425     {
1426       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1427           && DECL_NAME (link))
1428         {
1429           tree outer_binding
1430             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1431           tree ns_binding;
1432
1433           if (!outer_binding)
1434             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1435           else
1436             ns_binding = NULL_TREE;
1437
1438           if (outer_binding
1439               && (BINDING_LEVEL (outer_binding)
1440                   == current_binding_level->level_chain))
1441             /* We have something like:
1442
1443                  int i;
1444                  for (int i; ;);
1445
1446                and we are leaving the `for' scope.  There's no reason to
1447                keep the binding of the inner `i' in this case.  */
1448             pop_binding (DECL_NAME (link), link);
1449           else if ((outer_binding
1450                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1451                         == TYPE_DECL))
1452                    || (ns_binding
1453                        && TREE_CODE (ns_binding) == TYPE_DECL))
1454             /* Here, we have something like:
1455
1456                  typedef int I;
1457
1458                  void f () {
1459                    for (int I; ;);
1460                  }
1461
1462                We must pop the for-scope binding so we know what's a
1463                type and what isn't.  */
1464             pop_binding (DECL_NAME (link), link);
1465           else
1466             {
1467               /* Mark this VAR_DECL as dead so that we can tell we left it
1468                  there only for backward compatibility.  */
1469               DECL_DEAD_FOR_LOCAL (link) = 1;
1470
1471               /* Keep track of what should of have happenned when we
1472                  popped the binding.  */
1473               if (outer_binding && BINDING_VALUE (outer_binding))
1474                 DECL_SHADOWED_FOR_VAR (link)
1475                   = BINDING_VALUE (outer_binding);
1476
1477               /* Add it to the list of dead variables in the next
1478                  outermost binding to that we can remove these when we
1479                  leave that binding.  */
1480               current_binding_level->level_chain->dead_vars_from_for
1481                 = tree_cons (NULL_TREE, link,
1482                              current_binding_level->level_chain->
1483                              dead_vars_from_for);
1484
1485               /* Although we don't pop the CPLUS_BINDING, we do clear
1486                  its BINDING_LEVEL since the level is going away now.  */
1487               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1488                 = 0;
1489             }
1490         }
1491       else
1492         {
1493           /* Remove the binding.  */
1494           decl = link;
1495           if (TREE_CODE (decl) == TREE_LIST)
1496             decl = TREE_VALUE (decl);
1497           if (DECL_P (decl))
1498             pop_binding (DECL_NAME (decl), decl);
1499           else if (TREE_CODE (decl) == OVERLOAD)
1500             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1501           else
1502             my_friendly_abort (0);
1503         }
1504     }
1505
1506   /* Remove declarations for any `for' variables from inner scopes
1507      that we kept around.  */
1508   for (link = current_binding_level->dead_vars_from_for;
1509        link; link = TREE_CHAIN (link))
1510     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1511
1512   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1513   for (link = current_binding_level->type_shadowed;
1514        link; link = TREE_CHAIN (link))
1515     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1516
1517   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1518   for (link = current_binding_level->shadowed_labels;
1519        link;
1520        link = TREE_CHAIN (link))
1521     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1522
1523   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1524      list if a `using' declaration put them there.  The debugging
1525      back-ends won't understand OVERLOAD, so we remove them here.
1526      Because the BLOCK_VARS are (temporarily) shared with
1527      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1528      popped all the bindings.  */
1529   if (block)
1530     {
1531       tree* d;
1532
1533       for (d = &BLOCK_VARS (block); *d; )
1534         {
1535           if (TREE_CODE (*d) == TREE_LIST)
1536             *d = TREE_CHAIN (*d);
1537           else
1538             d = &TREE_CHAIN (*d);
1539         }
1540     }
1541
1542   /* If the level being exited is the top level of a function,
1543      check over all the labels.  */
1544   if (functionbody)
1545     {
1546       /* Since this is the top level block of a function, the vars are
1547          the function's parameters.  Don't leave them in the BLOCK
1548          because they are found in the FUNCTION_DECL instead.  */
1549       BLOCK_VARS (block) = 0;
1550       pop_labels (block);
1551     }
1552
1553   tmp = current_binding_level->keep;
1554
1555   pop_binding_level ();
1556   if (functionbody)
1557     DECL_INITIAL (current_function_decl) = block;
1558   else if (block)
1559     current_binding_level->blocks
1560       = chainon (current_binding_level->blocks, block);
1561
1562   /* If we did not make a block for the level just exited,
1563      any blocks made for inner levels
1564      (since they cannot be recorded as subblocks in that level)
1565      must be carried forward so they will later become subblocks
1566      of something else.  */
1567   else if (subblocks)
1568     current_binding_level->blocks
1569       = chainon (current_binding_level->blocks, subblocks);
1570
1571   /* Each and every BLOCK node created here in `poplevel' is important
1572      (e.g. for proper debugging information) so if we created one
1573      earlier, mark it as "used".  */
1574   if (block)
1575     TREE_USED (block) = 1;
1576
1577   /* Take care of compiler's internal binding structures.  */
1578   if (tmp == 2)
1579     {
1580       tree scope_stmts;
1581
1582       scope_stmts
1583         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1584       if (block)
1585         {
1586           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1587           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1588         }
1589
1590       block = poplevel (keep, reverse, functionbody);
1591     }
1592
1593   return block;
1594 }
1595
1596 /* Delete the node BLOCK from the current binding level.
1597    This is used for the block inside a stmt expr ({...})
1598    so that the block can be reinserted where appropriate.  */
1599
1600 void
1601 delete_block (block)
1602      tree block;
1603 {
1604   tree t;
1605   if (current_binding_level->blocks == block)
1606     current_binding_level->blocks = TREE_CHAIN (block);
1607   for (t = current_binding_level->blocks; t;)
1608     {
1609       if (TREE_CHAIN (t) == block)
1610         TREE_CHAIN (t) = TREE_CHAIN (block);
1611       else
1612         t = TREE_CHAIN (t);
1613     }
1614   TREE_CHAIN (block) = NULL_TREE;
1615   /* Clear TREE_USED which is always set by poplevel.
1616      The flag is set again if insert_block is called.  */
1617   TREE_USED (block) = 0;
1618 }
1619
1620 /* Insert BLOCK at the end of the list of subblocks of the
1621    current binding level.  This is used when a BIND_EXPR is expanded,
1622    to handle the BLOCK node inside the BIND_EXPR.  */
1623
1624 void
1625 insert_block (block)
1626      tree block;
1627 {
1628   TREE_USED (block) = 1;
1629   current_binding_level->blocks
1630     = chainon (current_binding_level->blocks, block);
1631 }
1632
1633 /* Set the BLOCK node for the innermost scope
1634    (the one we are currently in).  */
1635
1636 void
1637 set_block (block)
1638     tree block ATTRIBUTE_UNUSED;
1639 {
1640   /* The RTL expansion machinery requires us to provide this callback,
1641      but it is not applicable in function-at-a-time mode.  */
1642   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1643 }
1644
1645 /* Do a pushlevel for class declarations.  */
1646
1647 void
1648 pushlevel_class ()
1649 {
1650   register struct binding_level *newlevel;
1651
1652   /* Reuse or create a struct for this binding level.  */
1653 #if defined(DEBUG_CP_BINDING_LEVELS)
1654   if (0)
1655 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1656   if (free_binding_level)
1657 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1658     {
1659       newlevel = free_binding_level;
1660       free_binding_level = free_binding_level->level_chain;
1661     }
1662   else
1663     newlevel = make_binding_level ();
1664
1665 #if defined(DEBUG_CP_BINDING_LEVELS)
1666   is_class_level = 1;
1667 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1668
1669   push_binding_level (newlevel, 0, 0);
1670
1671   class_binding_level = current_binding_level;
1672   class_binding_level->parm_flag = 2;
1673   class_binding_level->this_class = current_class_type;
1674 }
1675
1676 /* ...and a poplevel for class declarations.  */
1677
1678 void
1679 poplevel_class ()
1680 {
1681   register struct binding_level *level = class_binding_level;
1682   tree shadowed;
1683
1684   my_friendly_assert (level != 0, 354);
1685
1686   /* If we're leaving a toplevel class, don't bother to do the setting
1687      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1688      shouldn't even be used when current_class_type isn't set, and second,
1689      if we don't touch it here, we're able to use the cache effect if the
1690      next time we're entering a class scope, it is the same class.  */
1691   if (current_class_depth != 1)
1692     {
1693       struct binding_level* b;
1694
1695       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1696       for (shadowed = level->class_shadowed;
1697            shadowed;
1698            shadowed = TREE_CHAIN (shadowed))
1699         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1700
1701       /* Find the next enclosing class, and recreate
1702          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1703       b = level->level_chain;
1704       while (b && b->parm_flag != 2)
1705         b = b->level_chain;
1706
1707       if (b)
1708         for (shadowed = b->class_shadowed;
1709              shadowed;
1710              shadowed = TREE_CHAIN (shadowed))
1711           {
1712             tree t;
1713
1714             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1715             while (t && BINDING_LEVEL (t) != b)
1716               t = TREE_CHAIN (t);
1717
1718             if (t)
1719               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1720                 = BINDING_VALUE (t);
1721           }
1722     }
1723   else
1724     /* Remember to save what IDENTIFIER's were bound in this scope so we
1725        can recover from cache misses.  */
1726     {
1727       previous_class_type = current_class_type;
1728       previous_class_values = class_binding_level->class_shadowed;
1729     }
1730   for (shadowed = level->type_shadowed;
1731        shadowed;
1732        shadowed = TREE_CHAIN (shadowed))
1733     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1734
1735   /* Remove the bindings for all of the class-level declarations.  */
1736   for (shadowed = level->class_shadowed;
1737        shadowed;
1738        shadowed = TREE_CHAIN (shadowed))
1739     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1740
1741   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1742                       (HOST_WIDE_INT) class_binding_level->level_chain,
1743                       class_binding_level->parm_flag,
1744                       class_binding_level->keep);
1745
1746   /* Now, pop out of the binding level which we created up in the
1747      `pushlevel_class' routine.  */
1748 #if defined(DEBUG_CP_BINDING_LEVELS)
1749   is_class_level = 1;
1750 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1751
1752   pop_binding_level ();
1753 }
1754
1755 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1756    for any names in enclosing classes.  */
1757
1758 void
1759 clear_identifier_class_values ()
1760 {
1761   tree t;
1762
1763   if (!class_binding_level)
1764     return;
1765
1766   for (t = class_binding_level->class_shadowed;
1767        t;
1768        t = TREE_CHAIN (t))
1769     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1770 }
1771
1772 /* Returns non-zero if T is a virtual function table.  */
1773
1774 int
1775 vtable_decl_p (t, data)
1776      tree t;
1777      void *data ATTRIBUTE_UNUSED;
1778 {
1779   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1780 }
1781
1782 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1783    functions.  */
1784
1785 int
1786 vtype_decl_p (t, data)
1787      tree t;
1788      void *data ATTRIBUTE_UNUSED;
1789 {
1790   return (TREE_CODE (t) == TYPE_DECL
1791           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1792           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1793 }
1794
1795 /* Return the declarations that are members of the namespace NS.  */
1796
1797 tree
1798 cp_namespace_decls (ns)
1799      tree ns;
1800 {
1801   return NAMESPACE_LEVEL (ns)->names;
1802 }
1803
1804 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1805    itself, calling F for each.  The DATA is passed to F as well.  */
1806
1807 static int
1808 walk_namespaces_r (namespace, f, data)
1809      tree namespace;
1810      walk_namespaces_fn f;
1811      void *data;
1812 {
1813   tree current;
1814   int result = 0;
1815
1816   result |= (*f) (namespace, data);
1817
1818   for (current = cp_namespace_decls (namespace);
1819        current;
1820        current = TREE_CHAIN (current))
1821     {
1822       if (TREE_CODE (current) != NAMESPACE_DECL
1823           || DECL_NAMESPACE_ALIAS (current))
1824         continue;
1825       if (!DECL_LANG_SPECIFIC (current))
1826         {
1827           /* Hmm. std. */
1828           my_friendly_assert (current == fake_std_node, 393);
1829           continue;
1830         }
1831
1832       /* We found a namespace.  */
1833       result |= walk_namespaces_r (current, f, data);
1834     }
1835
1836   return result;
1837 }
1838
1839 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1840    F as well.  */
1841
1842 int
1843 walk_namespaces (f, data)
1844      walk_namespaces_fn f;
1845      void *data;
1846 {
1847   return walk_namespaces_r (global_namespace, f, data);
1848 }
1849
1850 struct walk_globals_data {
1851   walk_globals_pred p;
1852   walk_globals_fn f;
1853   void *data;
1854 };
1855
1856 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1857    for which P returns non-zero, call F with its address.  If any call
1858    to F returns a non-zero value, return a non-zero value.  */
1859
1860 static int
1861 walk_globals_r (namespace, data)
1862      tree namespace;
1863      void *data;
1864 {
1865   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1866   walk_globals_pred p = wgd->p;
1867   walk_globals_fn f = wgd->f;
1868   void *d = wgd->data;
1869   tree *t;
1870   int result = 0;
1871
1872   t = &NAMESPACE_LEVEL (namespace)->names;
1873
1874   while (*t)
1875     {
1876       tree glbl = *t;
1877
1878       if ((*p) (glbl, d))
1879         result |= (*f) (t, d);
1880
1881       /* If F changed *T, then *T still points at the next item to
1882          examine.  */
1883       if (*t == glbl)
1884         t = &TREE_CHAIN (*t);
1885     }
1886
1887   return result;
1888 }
1889
1890 /* Walk the global declarations.  Whenever one is found for which P
1891    returns non-zero, call F with its address.  If any call to F
1892    returns a non-zero value, return a non-zero value.  */
1893
1894 int
1895 walk_globals (p, f, data)
1896      walk_globals_pred p;
1897      walk_globals_fn f;
1898      void *data;
1899 {
1900   struct walk_globals_data wgd;
1901   wgd.p = p;
1902   wgd.f = f;
1903   wgd.data = data;
1904
1905   return walk_namespaces (walk_globals_r, &wgd);
1906 }
1907
1908 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1909    DATA is non-NULL, this is the last time we will call
1910    wrapup_global_declarations for this NAMESPACE.  */
1911
1912 int
1913 wrapup_globals_for_namespace (namespace, data)
1914      tree namespace;
1915      void *data;
1916 {
1917   tree globals = cp_namespace_decls (namespace);
1918   int len = list_length (globals);
1919   tree *vec = (tree *) alloca (sizeof (tree) * len);
1920   int i;
1921   int result;
1922   tree decl;
1923   int last_time = (data != 0);
1924
1925   if (last_time && namespace == global_namespace)
1926     /* Let compile_file handle the global namespace.  */
1927     return 0;
1928
1929   /* Process the decls in reverse order--earliest first.
1930      Put them into VEC from back to front, then take out from front.  */
1931   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1932     vec[len - i - 1] = decl;
1933
1934   if (last_time)
1935     {
1936       check_global_declarations (vec, len);
1937       return 0;
1938     }
1939
1940   /* Temporarily mark vtables as external.  That prevents
1941      wrapup_global_declarations from writing them out; we must process
1942      them ourselves in finish_vtable_vardecl.  */
1943   for (i = 0; i < len; ++i)
1944     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1945       {
1946         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1947         DECL_EXTERNAL (vec[i]) = 1;
1948       }
1949
1950   /* Write out any globals that need to be output.  */
1951   result = wrapup_global_declarations (vec, len);
1952
1953   /* Undo the hack to DECL_EXTERNAL above.  */
1954   for (i = 0; i < len; ++i)
1955     if (vtable_decl_p (vec[i], /*data=*/0)
1956         && DECL_NOT_REALLY_EXTERN (vec[i]))
1957       {
1958         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1959         DECL_EXTERNAL (vec[i]) = 0;
1960       }
1961
1962   return result;
1963 }
1964
1965 \f
1966 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1967
1968 static void
1969 mark_binding_level (arg)
1970      void *arg;
1971 {
1972   struct binding_level *lvl = *(struct binding_level **)arg;
1973
1974   for (; lvl; lvl = lvl->level_chain)
1975     {
1976       ggc_mark_tree (lvl->names);
1977       ggc_mark_tree (lvl->tags);
1978       ggc_mark_tree (lvl->usings);
1979       ggc_mark_tree (lvl->using_directives);
1980       ggc_mark_tree (lvl->class_shadowed);
1981       ggc_mark_tree (lvl->type_shadowed);
1982       ggc_mark_tree (lvl->shadowed_labels);
1983       ggc_mark_tree (lvl->blocks);
1984       ggc_mark_tree (lvl->this_class);
1985       ggc_mark_tree (lvl->incomplete);
1986       ggc_mark_tree (lvl->dead_vars_from_for);
1987     }
1988 }
1989
1990 static void
1991 mark_named_label_lists (labs, uses)
1992      void *labs;
1993      void *uses;
1994 {
1995   struct named_label_list *l = *(struct named_label_list **)labs;
1996   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
1997
1998   for (; l; l = l->next)
1999     {
2000       ggc_mark (l);
2001       mark_binding_level (l->binding_level);
2002       ggc_mark_tree (l->old_value);
2003       ggc_mark_tree (l->label_decl);
2004       ggc_mark_tree (l->bad_decls);
2005     }
2006
2007   for (; u; u = u->next)
2008     ggc_mark (u);
2009 }
2010 \f
2011 /* For debugging.  */
2012 static int no_print_functions = 0;
2013 static int no_print_builtins = 0;
2014
2015 void
2016 print_binding_level (lvl)
2017      struct binding_level *lvl;
2018 {
2019   tree t;
2020   int i = 0, len;
2021   fprintf (stderr, " blocks=");
2022   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2023   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2024            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2025   if (lvl->tag_transparent)
2026     fprintf (stderr, " tag-transparent");
2027   if (lvl->more_cleanups_ok)
2028     fprintf (stderr, " more-cleanups-ok");
2029   if (lvl->have_cleanups)
2030     fprintf (stderr, " have-cleanups");
2031   fprintf (stderr, "\n");
2032   if (lvl->names)
2033     {
2034       fprintf (stderr, " names:\t");
2035       /* We can probably fit 3 names to a line?  */
2036       for (t = lvl->names; t; t = TREE_CHAIN (t))
2037         {
2038           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2039             continue;
2040           if (no_print_builtins
2041               && (TREE_CODE (t) == TYPE_DECL)
2042               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2043             continue;
2044
2045           /* Function decls tend to have longer names.  */
2046           if (TREE_CODE (t) == FUNCTION_DECL)
2047             len = 3;
2048           else
2049             len = 2;
2050           i += len;
2051           if (i > 6)
2052             {
2053               fprintf (stderr, "\n\t");
2054               i = len;
2055             }
2056           print_node_brief (stderr, "", t, 0);
2057           if (t == error_mark_node)
2058             break;
2059         }
2060       if (i)
2061         fprintf (stderr, "\n");
2062     }
2063   if (lvl->tags)
2064     {
2065       fprintf (stderr, " tags:\t");
2066       i = 0;
2067       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2068         {
2069           if (TREE_PURPOSE (t) == NULL_TREE)
2070             len = 3;
2071           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2072             len = 2;
2073           else
2074             len = 4;
2075           i += len;
2076           if (i > 5)
2077             {
2078               fprintf (stderr, "\n\t");
2079               i = len;
2080             }
2081           if (TREE_PURPOSE (t) == NULL_TREE)
2082             {
2083               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2084               fprintf (stderr, ">");
2085             }
2086           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2087             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2088           else
2089             {
2090               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2091               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2092               fprintf (stderr, ">");
2093             }
2094         }
2095       if (i)
2096         fprintf (stderr, "\n");
2097     }
2098   if (lvl->class_shadowed)
2099     {
2100       fprintf (stderr, " class-shadowed:");
2101       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2102         {
2103           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2104         }
2105       fprintf (stderr, "\n");
2106     }
2107   if (lvl->type_shadowed)
2108     {
2109       fprintf (stderr, " type-shadowed:");
2110       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2111         {
2112           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2113         }
2114       fprintf (stderr, "\n");
2115     }
2116 }
2117
2118 void
2119 print_other_binding_stack (stack)
2120      struct binding_level *stack;
2121 {
2122   struct binding_level *level;
2123   for (level = stack; level != global_binding_level; level = level->level_chain)
2124     {
2125       fprintf (stderr, "binding level ");
2126       fprintf (stderr, HOST_PTR_PRINTF, level);
2127       fprintf (stderr, "\n");
2128       print_binding_level (level);
2129     }
2130 }
2131
2132 void
2133 print_binding_stack ()
2134 {
2135   struct binding_level *b;
2136   fprintf (stderr, "current_binding_level=");
2137   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2138   fprintf (stderr, "\nclass_binding_level=");
2139   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2140   fprintf (stderr, "\nglobal_binding_level=");
2141   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2142   fprintf (stderr, "\n");
2143   if (class_binding_level)
2144     {
2145       for (b = class_binding_level; b; b = b->level_chain)
2146         if (b == current_binding_level)
2147           break;
2148       if (b)
2149         b = class_binding_level;
2150       else
2151         b = current_binding_level;
2152     }
2153   else
2154     b = current_binding_level;
2155   print_other_binding_stack (b);
2156   fprintf (stderr, "global:\n");
2157   print_binding_level (global_binding_level);
2158 }
2159
2160 /* Namespace binding access routines: The namespace_bindings field of
2161    the identifier is polymorphic, with three possible values:
2162    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2163    indicating the BINDING_VALUE of global_namespace. */
2164
2165 /* Check whether the a binding for the name to scope is known.
2166    Assumes that the bindings of the name are already a list
2167    of bindings. Returns the binding found, or NULL_TREE. */
2168
2169 static tree
2170 find_binding (name, scope)
2171      tree name;
2172      tree scope;
2173 {
2174   tree iter, prev = NULL_TREE;
2175
2176   scope = ORIGINAL_NAMESPACE (scope);
2177
2178   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2179        iter = TREE_CHAIN (iter))
2180     {
2181       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2182       if (BINDING_SCOPE (iter) == scope)
2183         {
2184           /* Move binding found to the front of the list, so
2185              subsequent lookups will find it faster. */
2186           if (prev)
2187             {
2188               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2189               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2190               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2191             }
2192           return iter;
2193         }
2194       prev = iter;
2195     }
2196   return NULL_TREE;
2197 }
2198
2199 /* Always returns a binding for name in scope. If the
2200    namespace_bindings is not a list, convert it to one first.
2201    If no binding is found, make a new one. */
2202
2203 tree
2204 binding_for_name (name, scope)
2205      tree name;
2206      tree scope;
2207 {
2208   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2209   tree result;
2210
2211   scope = ORIGINAL_NAMESPACE (scope);
2212
2213   if (b && TREE_CODE (b) != CPLUS_BINDING)
2214     {
2215       /* Get rid of optimization for global scope. */
2216       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2217       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2218       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2219     }
2220   if (b && (result = find_binding (name, scope)))
2221     return result;
2222   /* Not found, make a new one. */
2223   result = make_node (CPLUS_BINDING);
2224   TREE_CHAIN (result) = b;
2225   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2226   BINDING_SCOPE (result) = scope;
2227   BINDING_TYPE (result) = NULL_TREE;
2228   BINDING_VALUE (result) = NULL_TREE;
2229   return result;
2230 }
2231
2232 /* Return the binding value for name in scope, considering that
2233    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2234
2235 tree
2236 namespace_binding (name, scope)
2237      tree name;
2238      tree scope;
2239 {
2240   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2241   if (b == NULL_TREE)
2242     return NULL_TREE;
2243   if (scope == NULL_TREE)
2244     scope = global_namespace;
2245   if (TREE_CODE (b) != CPLUS_BINDING)
2246     return (scope == global_namespace) ? b : NULL_TREE;
2247   name = find_binding (name,scope);
2248   if (name == NULL_TREE)
2249     return name;
2250   return BINDING_VALUE (name);
2251 }
2252
2253 /* Set the binding value for name in scope. If modifying the binding
2254    of global_namespace is attempted, try to optimize it. */
2255
2256 void
2257 set_namespace_binding (name, scope, val)
2258      tree name;
2259      tree scope;
2260      tree val;
2261 {
2262   tree b;
2263
2264   if (scope == NULL_TREE)
2265     scope = global_namespace;
2266
2267   if (scope == global_namespace)
2268     {
2269       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2270       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2271         {
2272           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2273           return;
2274         }
2275     }
2276   b = binding_for_name (name, scope);
2277   BINDING_VALUE (b) = val;
2278 }
2279
2280 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2281    select a name that is unique to this compilation unit.  */
2282
2283 void
2284 push_namespace (name)
2285      tree name;
2286 {
2287   tree d = NULL_TREE;
2288   int need_new = 1;
2289   int implicit_use = 0;
2290   int global = 0;
2291   if (!global_namespace)
2292     {
2293       /* This must be ::. */
2294       my_friendly_assert (name == get_identifier ("::"), 377);
2295       global = 1;
2296     }
2297   else if (!name)
2298     {
2299       /* The name of anonymous namespace is unique for the translation
2300          unit.  */
2301       if (!anonymous_namespace_name)
2302         anonymous_namespace_name = get_file_function_name ('N');
2303       name = anonymous_namespace_name;
2304       d = IDENTIFIER_NAMESPACE_VALUE (name);
2305       if (d)
2306         /* Reopening anonymous namespace.  */
2307         need_new = 0;
2308       implicit_use = 1;
2309     }
2310   else if (current_namespace == global_namespace
2311            && !flag_honor_std
2312            && name == std_identifier)
2313     {
2314       in_fake_std++;
2315       return;
2316     }
2317   else
2318     {
2319       /* Check whether this is an extended namespace definition. */
2320       d = IDENTIFIER_NAMESPACE_VALUE (name);
2321       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2322         {
2323           need_new = 0;
2324           if (DECL_NAMESPACE_ALIAS (d))
2325             {
2326               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2327                         d, DECL_NAMESPACE_ALIAS (d));
2328               d = DECL_NAMESPACE_ALIAS (d);
2329             }
2330         }
2331     }
2332
2333   if (need_new)
2334     {
2335       /* Make a new namespace, binding the name to it. */
2336       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2337       /* The global namespace is not pushed, and the global binding
2338          level is set elsewhere.  */
2339       if (!global)
2340         {
2341           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2342           d = pushdecl (d);
2343           pushlevel (0);
2344           declare_namespace_level ();
2345           NAMESPACE_LEVEL (d) = current_binding_level;
2346         }
2347     }
2348   else
2349     resume_binding_level (NAMESPACE_LEVEL (d));
2350
2351   if (implicit_use)
2352     do_using_directive (d);
2353   /* Enter the name space. */
2354   current_namespace = d;
2355 }
2356
2357 /* Pop from the scope of the current namespace.  */
2358
2359 void
2360 pop_namespace ()
2361 {
2362   if (current_namespace == global_namespace)
2363     {
2364       my_friendly_assert (in_fake_std > 0, 980421);
2365       in_fake_std--;
2366       return;
2367     }
2368   current_namespace = CP_DECL_CONTEXT (current_namespace);
2369   /* The binding level is not popped, as it might be re-opened later.  */
2370   suspend_binding_level ();
2371 }
2372
2373 /* Push into the scope of the namespace NS, even if it is deeply
2374    nested within another namespace.  */
2375
2376 void
2377 push_nested_namespace (ns)
2378      tree ns;
2379 {
2380   if (ns == global_namespace)
2381     push_to_top_level ();
2382   else
2383     {
2384       push_nested_namespace (CP_DECL_CONTEXT (ns));
2385       push_namespace (DECL_NAME (ns));
2386     }
2387 }
2388
2389 /* Pop back from the scope of the namespace NS, which was previously
2390    entered with push_nested_namespace.  */
2391
2392 void
2393 pop_nested_namespace (ns)
2394      tree ns;
2395 {
2396   while (ns != global_namespace)
2397     {
2398       pop_namespace ();
2399       ns = CP_DECL_CONTEXT (ns);
2400     }
2401
2402   pop_from_top_level ();
2403 }
2404
2405 \f
2406 /* Subroutines for reverting temporarily to top-level for instantiation
2407    of templates and such.  We actually need to clear out the class- and
2408    local-value slots of all identifiers, so that only the global values
2409    are at all visible.  Simply setting current_binding_level to the global
2410    scope isn't enough, because more binding levels may be pushed.  */
2411 struct saved_scope *scope_chain;
2412
2413 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2414
2415 static void
2416 mark_saved_scope (arg)
2417      void *arg;
2418 {
2419   struct saved_scope *t = *(struct saved_scope **)arg;
2420   while (t)
2421     {
2422       mark_binding_level (&t->class_bindings);
2423       ggc_mark_tree (t->old_bindings);
2424       ggc_mark_tree (t->old_namespace);
2425       ggc_mark_tree (t->decl_ns_list);
2426       ggc_mark_tree (t->class_name);
2427       ggc_mark_tree (t->class_type);
2428       ggc_mark_tree (t->access_specifier);
2429       ggc_mark_tree (t->function_decl);
2430       if (t->lang_base)
2431         ggc_mark_tree_varray (t->lang_base);
2432       ggc_mark_tree (t->lang_name);
2433       ggc_mark_tree (t->template_parms);
2434       ggc_mark_tree (t->x_previous_class_type);
2435       ggc_mark_tree (t->x_previous_class_values);
2436       ggc_mark_tree (t->x_saved_tree);
2437       ggc_mark_tree (t->incomplete);
2438       ggc_mark_tree (t->lookups);
2439
2440       mark_stmt_tree (&t->x_stmt_tree);
2441       mark_binding_level (&t->bindings);
2442       t = t->prev;
2443     }
2444 }
2445
2446 static tree
2447 store_bindings (names, old_bindings)
2448      tree names, old_bindings;
2449 {
2450   tree t;
2451   tree search_bindings = old_bindings;
2452
2453   for (t = names; t; t = TREE_CHAIN (t))
2454     {
2455       tree binding, t1, id;
2456
2457       if (TREE_CODE (t) == TREE_LIST)
2458         id = TREE_PURPOSE (t);
2459       else
2460         id = DECL_NAME (t);
2461
2462       if (!id
2463           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2464              we have no IDENTIFIER_BINDING if we have left the class
2465              scope, but cached the class-level declarations.  */
2466           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2467         continue;
2468
2469       for (t1 = search_bindings; t1; t1 = TREE_CHAIN (t1))
2470         if (TREE_VEC_ELT (t1, 0) == id)
2471           goto skip_it;
2472
2473       my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2474       binding = make_tree_vec (4);
2475       TREE_VEC_ELT (binding, 0) = id;
2476       TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2477       TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2478       TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2479       IDENTIFIER_BINDING (id) = NULL_TREE;
2480       IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2481       TREE_CHAIN (binding) = old_bindings;
2482       old_bindings = binding;
2483     skip_it:
2484       ;
2485     }
2486   return old_bindings;
2487 }
2488
2489 void
2490 maybe_push_to_top_level (pseudo)
2491      int pseudo;
2492 {
2493   struct saved_scope *s;
2494   struct binding_level *b;
2495   tree old_bindings;
2496   int need_pop;
2497
2498   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2499
2500   b = scope_chain ? current_binding_level : 0;
2501
2502   /* If we're in the middle of some function, save our state.  */
2503   if (cfun)
2504     {
2505       need_pop = 1;
2506       push_function_context_to (NULL_TREE);
2507     }
2508   else
2509     need_pop = 0;
2510
2511   old_bindings = NULL_TREE;
2512   if (scope_chain && previous_class_type)
2513     old_bindings = store_bindings (previous_class_values, old_bindings);
2514
2515   /* Have to include global_binding_level, because class-level decls
2516      aren't listed anywhere useful.  */
2517   for (; b; b = b->level_chain)
2518     {
2519       tree t;
2520
2521       /* Template IDs are inserted into the global level. If they were
2522          inserted into namespace level, finish_file wouldn't find them
2523          when doing pending instantiations. Therefore, don't stop at
2524          namespace level, but continue until :: .  */
2525       if (b == global_binding_level || (pseudo && b->template_parms_p))
2526         break;
2527
2528       old_bindings = store_bindings (b->names, old_bindings);
2529       /* We also need to check class_shadowed to save class-level type
2530          bindings, since pushclass doesn't fill in b->names.  */
2531       if (b->parm_flag == 2)
2532         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2533
2534       /* Unwind type-value slots back to top level.  */
2535       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2536         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2537     }
2538   s->prev = scope_chain;
2539   s->old_bindings = old_bindings;
2540   s->bindings = b;
2541   s->need_pop_function_context = need_pop;
2542   s->function_decl = current_function_decl;
2543
2544   scope_chain = s;
2545   current_function_decl = NULL_TREE;
2546   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2547   current_lang_name = lang_name_cplusplus;
2548   current_namespace = global_namespace;
2549 }
2550
2551 void
2552 push_to_top_level ()
2553 {
2554   maybe_push_to_top_level (0);
2555 }
2556
2557 void
2558 pop_from_top_level ()
2559 {
2560   struct saved_scope *s = scope_chain;
2561   tree t;
2562
2563   /* Clear out class-level bindings cache.  */
2564   if (previous_class_type)
2565     invalidate_class_lookup_cache ();
2566
2567   VARRAY_FREE (current_lang_base);
2568
2569   scope_chain = s->prev;
2570   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2571     {
2572       tree id = TREE_VEC_ELT (t, 0);
2573
2574       SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2575       IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2576       IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2577     }
2578
2579   /* If we were in the middle of compiling a function, restore our
2580      state.  */
2581   if (s->need_pop_function_context)
2582     pop_function_context_from (NULL_TREE);
2583   current_function_decl = s->function_decl;
2584
2585   free (s);
2586 }
2587 \f
2588 /* Push a definition of struct, union or enum tag "name".
2589    into binding_level "b".   "type" should be the type node,
2590    We assume that the tag "name" is not already defined.
2591
2592    Note that the definition may really be just a forward reference.
2593    In that case, the TYPE_SIZE will be a NULL_TREE.
2594
2595    C++ gratuitously puts all these tags in the name space.  */
2596
2597 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2598    record the shadowed value for this binding contour.  TYPE is
2599    the type that ID maps to.  */
2600
2601 static void
2602 set_identifier_type_value_with_scope (id, type, b)
2603      tree id;
2604      tree type;
2605      struct binding_level *b;
2606 {
2607   if (!b->namespace_p)
2608     {
2609       /* Shadow the marker, not the real thing, so that the marker
2610          gets restored later. */
2611       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2612       b->type_shadowed
2613         = tree_cons (id, old_type_value, b->type_shadowed);
2614     }
2615   else
2616     {
2617       tree binding = binding_for_name (id, current_namespace);
2618       BINDING_TYPE (binding) = type;
2619       /* Store marker instead of real type. */
2620       type = global_type_node;
2621     }
2622   SET_IDENTIFIER_TYPE_VALUE (id, type);
2623 }
2624
2625 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2626
2627 void
2628 set_identifier_type_value (id, type)
2629      tree id;
2630      tree type;
2631 {
2632   set_identifier_type_value_with_scope (id, type, current_binding_level);
2633 }
2634
2635 /* Return the type associated with id. */
2636
2637 tree
2638 identifier_type_value (id)
2639      tree id;
2640 {
2641   /* There is no type with that name, anywhere. */
2642   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2643     return NULL_TREE;
2644   /* This is not the type marker, but the real thing. */
2645   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2646     return REAL_IDENTIFIER_TYPE_VALUE (id);
2647   /* Have to search for it. It must be on the global level, now.
2648      Ask lookup_name not to return non-types. */
2649   id = lookup_name_real (id, 2, 1, 0);
2650   if (id)
2651     return TREE_TYPE (id);
2652   return NULL_TREE;
2653 }
2654
2655 /* Pop off extraneous binding levels left over due to syntax errors.
2656
2657    We don't pop past namespaces, as they might be valid.  */
2658
2659 void
2660 pop_everything ()
2661 {
2662 #ifdef DEBUG_CP_BINDING_LEVELS
2663   fprintf (stderr, "XXX entering pop_everything ()\n");
2664 #endif
2665   while (!toplevel_bindings_p ())
2666     {
2667       if (current_binding_level->parm_flag == 2)
2668         pop_nested_class ();
2669       else
2670         poplevel (0, 0, 0);
2671     }
2672 #ifdef DEBUG_CP_BINDING_LEVELS
2673   fprintf (stderr, "XXX leaving pop_everything ()\n");
2674 #endif
2675 }
2676
2677 /* The type TYPE is being declared.  If it is a class template, or a
2678    specialization of a class template, do any processing required and
2679    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2680    being declared a friend.  B is the binding level at which this TYPE
2681    should be bound.
2682
2683    Returns the TYPE_DECL for TYPE, which may have been altered by this
2684    processing.  */
2685
2686 static tree
2687 maybe_process_template_type_declaration (type, globalize, b)
2688      tree type;
2689      int globalize;
2690      struct binding_level* b;
2691 {
2692   tree decl = TYPE_NAME (type);
2693
2694   if (processing_template_parmlist)
2695     /* You can't declare a new template type in a template parameter
2696        list.  But, you can declare a non-template type:
2697
2698          template <class A*> struct S;
2699
2700        is a forward-declaration of `A'.  */
2701     ;
2702   else
2703     {
2704       maybe_check_template_type (type);
2705
2706       my_friendly_assert (IS_AGGR_TYPE (type)
2707                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2708
2709
2710       if (processing_template_decl)
2711         {
2712           /* This may change after the call to
2713              push_template_decl_real, but we want the original value.  */
2714           tree name = DECL_NAME (decl);
2715
2716           decl = push_template_decl_real (decl, globalize);
2717           /* If the current binding level is the binding level for the
2718              template parameters (see the comment in
2719              begin_template_parm_list) and the enclosing level is a class
2720              scope, and we're not looking at a friend, push the
2721              declaration of the member class into the class scope.  In the
2722              friend case, push_template_decl will already have put the
2723              friend into global scope, if appropriate.  */
2724           if (TREE_CODE (type) != ENUMERAL_TYPE
2725               && !globalize && b->template_parms_p
2726               && b->level_chain->parm_flag == 2)
2727             {
2728               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2729               /* Put this tag on the list of tags for the class, since
2730                  that won't happen below because B is not the class
2731                  binding level, but is instead the pseudo-global level.  */
2732               b->level_chain->tags =
2733                 tree_cons (name, type, b->level_chain->tags);
2734               if (!COMPLETE_TYPE_P (current_class_type))
2735                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2736             }
2737         }
2738     }
2739
2740   return decl;
2741 }
2742
2743 /* In C++, you don't have to write `struct S' to refer to `S'; you
2744    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2745    if the user had written `typedef struct S S'.  Create and return
2746    the TYPE_DECL for TYPE.  */
2747
2748 tree
2749 create_implicit_typedef (name, type)
2750      tree name;
2751      tree type;
2752 {
2753   tree decl;
2754
2755   decl = build_decl (TYPE_DECL, name, type);
2756   DECL_ARTIFICIAL (decl) = 1;
2757   /* There are other implicit type declarations, like the one *within*
2758      a class that allows you to write `S::S'.  We must distinguish
2759      amongst these.  */
2760   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2761   TYPE_NAME (type) = decl;
2762
2763   return decl;
2764 }
2765
2766 /* Remember a local name for name-mangling purposes.  */
2767
2768 static void
2769 push_local_name (decl)
2770      tree decl;
2771 {
2772   size_t i, nelts;
2773   tree t, name;
2774
2775   if (!local_names)
2776     VARRAY_TREE_INIT (local_names, 8, "local_names");
2777
2778   name = DECL_NAME (decl);
2779
2780   nelts = VARRAY_ACTIVE_SIZE (local_names);
2781   for (i = 0; i < nelts; i++)
2782     {
2783       t = VARRAY_TREE (local_names, i);
2784       if (DECL_NAME (t) == name)
2785         {
2786           if (!DECL_LANG_SPECIFIC (decl))
2787             retrofit_lang_decl (decl);
2788           if (DECL_LANG_SPECIFIC (t))
2789             DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
2790           else
2791             DECL_DISCRIMINATOR (decl) = 1;
2792
2793           VARRAY_TREE (local_names, i) = decl;
2794           return;
2795         }
2796     }
2797
2798   VARRAY_PUSH_TREE (local_names, decl);
2799 }
2800
2801 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2802    Normally put it into the inner-most non-tag-transparent scope,
2803    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2804    The latter is needed for implicit declarations.  */
2805
2806 void
2807 pushtag (name, type, globalize)
2808      tree name, type;
2809      int globalize;
2810 {
2811   register struct binding_level *b;
2812
2813   b = current_binding_level;
2814   while (b->tag_transparent
2815          || (globalize && b->parm_flag == 2))
2816     b = b->level_chain;
2817
2818   b->tags = tree_cons (name, type, b->tags);
2819
2820   if (name)
2821     {
2822       /* Do C++ gratuitous typedefing.  */
2823       if (IDENTIFIER_TYPE_VALUE (name) != type)
2824         {
2825           register tree d = NULL_TREE;
2826           int in_class = 0;
2827           tree context = TYPE_CONTEXT (type);
2828
2829           if (! context)
2830             {
2831               tree cs = current_scope ();
2832
2833               if (! globalize)
2834                 context = cs;
2835               else if (cs != NULL_TREE && TYPE_P (cs))
2836                 /* When declaring a friend class of a local class, we want
2837                    to inject the newly named class into the scope
2838                    containing the local class, not the namespace scope.  */
2839                 context = decl_function_context (get_type_decl (cs));
2840             }
2841           if (!context)
2842             context = current_namespace;
2843
2844           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2845               || b->parm_flag == 2)
2846             in_class = 1;
2847
2848           if (current_lang_name == lang_name_java)
2849             TYPE_FOR_JAVA (type) = 1;
2850
2851           d = create_implicit_typedef (name, type);
2852           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2853           if (! in_class)
2854             set_identifier_type_value_with_scope (name, type, b);
2855
2856           d = maybe_process_template_type_declaration (type,
2857                                                        globalize, b);
2858
2859           if (b->parm_flag == 2)
2860             {
2861               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2862                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2863                    class.  But if it's a member template class, we
2864                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2865                    is done later.  */
2866                 finish_member_declaration (d);
2867               else
2868                 pushdecl_class_level (d);
2869             }
2870           else
2871             d = pushdecl_with_scope (d, b);
2872
2873           /* FIXME what if it gets a name from typedef?  */
2874           if (ANON_AGGRNAME_P (name))
2875             DECL_IGNORED_P (d) = 1;
2876
2877           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2878
2879           /* If this is a local class, keep track of it.  We need this
2880              information for name-mangling, and so that it is possible to find
2881              all function definitions in a translation unit in a convenient
2882              way.  (It's otherwise tricky to find a member function definition
2883              it's only pointed to from within a local class.)  */
2884           if (TYPE_CONTEXT (type)
2885               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2886               && !processing_template_decl)
2887             VARRAY_PUSH_TREE (local_classes, type);
2888         }
2889       if (b->parm_flag == 2)
2890         {
2891           if (!COMPLETE_TYPE_P (current_class_type))
2892             CLASSTYPE_TAGS (current_class_type) = b->tags;
2893         }
2894     }
2895
2896   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2897     /* Use the canonical TYPE_DECL for this node.  */
2898     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2899   else
2900     {
2901       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2902          will be the tagged type we just added to the current
2903          binding level.  This fake NULL-named TYPE_DECL node helps
2904          dwarfout.c to know when it needs to output a
2905          representation of a tagged type, and it also gives us a
2906          convenient place to record the "scope start" address for
2907          the tagged type.  */
2908
2909       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2910       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2911     }
2912 }
2913
2914 /* Counter used to create anonymous type names.  */
2915
2916 static int anon_cnt = 0;
2917
2918 /* Return an IDENTIFIER which can be used as a name for
2919    anonymous structs and unions.  */
2920
2921 tree
2922 make_anon_name ()
2923 {
2924   char buf[32];
2925
2926   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2927   return get_identifier (buf);
2928 }
2929
2930 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2931    This keeps dbxout from getting confused.  */
2932
2933 void
2934 clear_anon_tags ()
2935 {
2936   register struct binding_level *b;
2937   register tree tags;
2938   static int last_cnt = 0;
2939
2940   /* Fast out if no new anon names were declared.  */
2941   if (last_cnt == anon_cnt)
2942     return;
2943
2944   b = current_binding_level;
2945   while (b->tag_transparent)
2946     b = b->level_chain;
2947   tags = b->tags;
2948   while (tags)
2949     {
2950       /* A NULL purpose means we have already processed all tags
2951          from here to the end of the list.  */
2952       if (TREE_PURPOSE (tags) == NULL_TREE)
2953         break;
2954       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2955         TREE_PURPOSE (tags) = NULL_TREE;
2956       tags = TREE_CHAIN (tags);
2957     }
2958   last_cnt = anon_cnt;
2959 }
2960 \f
2961 /* Subroutine of duplicate_decls: return truthvalue of whether
2962    or not types of these decls match.
2963
2964    For C++, we must compare the parameter list so that `int' can match
2965    `int&' in a parameter position, but `int&' is not confused with
2966    `const int&'.  */
2967
2968 int
2969 decls_match (newdecl, olddecl)
2970      tree newdecl, olddecl;
2971 {
2972   int types_match;
2973
2974   if (newdecl == olddecl)
2975     return 1;
2976
2977   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2978     /* If the two DECLs are not even the same kind of thing, we're not
2979        interested in their types.  */
2980     return 0;
2981
2982   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2983     {
2984       tree f1 = TREE_TYPE (newdecl);
2985       tree f2 = TREE_TYPE (olddecl);
2986       tree p1 = TYPE_ARG_TYPES (f1);
2987       tree p2 = TYPE_ARG_TYPES (f2);
2988
2989       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2990           && ! (DECL_EXTERN_C_P (newdecl)
2991                 && DECL_EXTERN_C_P (olddecl)))
2992         return 0;
2993
2994       if (TREE_CODE (f1) != TREE_CODE (f2))
2995         return 0;
2996
2997       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2998         {
2999           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
3000               && (DECL_BUILT_IN (olddecl)
3001 #ifndef NO_IMPLICIT_EXTERN_C
3002                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
3003                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
3004 #endif
3005               ))
3006             {
3007               types_match = self_promoting_args_p (p1);
3008               if (p1 == void_list_node)
3009                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3010             }
3011 #ifndef NO_IMPLICIT_EXTERN_C
3012           else if (p1 == NULL_TREE
3013                    && (DECL_EXTERN_C_P (olddecl)
3014                        && DECL_IN_SYSTEM_HEADER (olddecl)
3015                        && !DECL_CLASS_SCOPE_P (olddecl))
3016                    && (DECL_EXTERN_C_P (newdecl)
3017                        && DECL_IN_SYSTEM_HEADER (newdecl)
3018                        && !DECL_CLASS_SCOPE_P (newdecl)))
3019             {
3020               types_match = self_promoting_args_p (p2);
3021               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3022             }
3023 #endif
3024           else
3025             types_match = compparms (p1, p2);
3026         }
3027       else
3028         types_match = 0;
3029     }
3030   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3031     {
3032       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3033                                 DECL_TEMPLATE_PARMS (olddecl)))
3034         return 0;
3035
3036       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
3037           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
3038         return 0;
3039
3040       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3041         types_match = 1;
3042       else
3043         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3044                                    DECL_TEMPLATE_RESULT (newdecl));
3045     }
3046   else
3047     {
3048       if (TREE_TYPE (newdecl) == error_mark_node)
3049         types_match = TREE_TYPE (olddecl) == error_mark_node;
3050       else if (TREE_TYPE (olddecl) == NULL_TREE)
3051         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3052       else if (TREE_TYPE (newdecl) == NULL_TREE)
3053         types_match = 0;
3054       else
3055         types_match = comptypes (TREE_TYPE (newdecl),
3056                                  TREE_TYPE (olddecl),
3057                                  COMPARE_REDECLARATION);
3058     }
3059
3060   return types_match;
3061 }
3062
3063 /* If NEWDECL is `static' and an `extern' was seen previously,
3064    warn about it.  OLDDECL is the previous declaration.
3065
3066    Note that this does not apply to the C++ case of declaring
3067    a variable `extern const' and then later `const'.
3068
3069    Don't complain about built-in functions, since they are beyond
3070    the user's control.  */
3071
3072 static void
3073 warn_extern_redeclared_static (newdecl, olddecl)
3074      tree newdecl, olddecl;
3075 {
3076   static const char *explicit_extern_static_warning
3077     = "`%D' was declared `extern' and later `static'";
3078   static const char *implicit_extern_static_warning
3079     = "`%D' was declared implicitly `extern' and later `static'";
3080
3081   tree name;
3082
3083   if (TREE_CODE (newdecl) == TYPE_DECL
3084       || TREE_CODE (newdecl) == TEMPLATE_DECL
3085       || TREE_CODE (newdecl) == CONST_DECL)
3086     return;
3087
3088   /* Don't get confused by static member functions; that's a different
3089      use of `static'.  */
3090   if (TREE_CODE (newdecl) == FUNCTION_DECL
3091       && DECL_STATIC_FUNCTION_P (newdecl))
3092     return;
3093
3094   /* If the old declaration was `static', or the new one isn't, then
3095      then everything is OK.  */
3096   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3097     return;
3098
3099   /* It's OK to declare a builtin function as `static'.  */
3100   if (TREE_CODE (olddecl) == FUNCTION_DECL
3101       && DECL_ARTIFICIAL (olddecl))
3102     return;
3103
3104   name = DECL_ASSEMBLER_NAME (newdecl);
3105   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3106               ? implicit_extern_static_warning
3107               : explicit_extern_static_warning, newdecl);
3108   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3109 }
3110
3111 /* Handle when a new declaration NEWDECL has the same name as an old
3112    one OLDDECL in the same binding contour.  Prints an error message
3113    if appropriate.
3114
3115    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3116    Otherwise, return 0.  */
3117
3118 int
3119 duplicate_decls (newdecl, olddecl)
3120      tree newdecl, olddecl;
3121 {
3122   unsigned olddecl_uid = DECL_UID (olddecl);
3123   int olddecl_friend = 0, types_match = 0;
3124   int new_defines_function = 0;
3125
3126   if (newdecl == olddecl)
3127     return 1;
3128
3129   types_match = decls_match (newdecl, olddecl);
3130
3131   /* If either the type of the new decl or the type of the old decl is an
3132      error_mark_node, then that implies that we have already issued an
3133      error (earlier) for some bogus type specification, and in that case,
3134      it is rather pointless to harass the user with yet more error message
3135      about the same declaration, so just pretend the types match here.  */
3136   if (TREE_TYPE (newdecl) == error_mark_node
3137       || TREE_TYPE (olddecl) == error_mark_node)
3138     types_match = 1;
3139
3140   /* Check for redeclaration and other discrepancies. */
3141   if (TREE_CODE (olddecl) == FUNCTION_DECL
3142       && DECL_ARTIFICIAL (olddecl))
3143     {
3144       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3145         {
3146           /* If you declare a built-in or predefined function name as static,
3147              the old definition is overridden, but optionally warn this was a
3148              bad choice of name.  */
3149           if (! TREE_PUBLIC (newdecl))
3150             {
3151               if (warn_shadow)
3152                 cp_warning ("shadowing %s function `%#D'",
3153                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3154                             olddecl);
3155               /* Discard the old built-in function.  */
3156               return 0;
3157             }
3158           /* If the built-in is not ansi, then programs can override
3159              it even globally without an error.  */
3160           else if (! DECL_BUILT_IN (olddecl))
3161             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3162                         olddecl, newdecl);
3163           else
3164             {
3165               cp_error ("declaration of `%#D'", newdecl);
3166               cp_error ("conflicts with built-in declaration `%#D'",
3167                         olddecl);
3168             }
3169           return 0;
3170         }
3171       else if (!types_match)
3172         {
3173           if ((DECL_EXTERN_C_P (newdecl)
3174                && DECL_EXTERN_C_P (olddecl))
3175               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3176                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3177             {
3178               /* A near match; override the builtin.  */
3179
3180               if (TREE_PUBLIC (newdecl))
3181                 {
3182                   cp_warning ("new declaration `%#D'", newdecl);
3183                   cp_warning ("ambiguates built-in declaration `%#D'",
3184                               olddecl);
3185                 }
3186               else if (warn_shadow)
3187                 cp_warning ("shadowing %s function `%#D'",
3188                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3189                             olddecl);
3190             }
3191           else
3192             /* Discard the old built-in function.  */
3193             return 0;
3194         }
3195
3196       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3197         {
3198           /* If a builtin function is redeclared as `static', merge
3199              the declarations, but make the original one static.  */
3200           DECL_THIS_STATIC (olddecl) = 1;
3201           TREE_PUBLIC (olddecl) = 0;
3202
3203           /* Make the old declaration consistent with the new one so
3204              that all remnants of the builtin-ness of this function
3205              will be banished.  */
3206           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3207           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3208           COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3209           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3210                                        newdecl);
3211         }
3212     }
3213   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3214     {
3215       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3216            && TREE_CODE (newdecl) != TYPE_DECL
3217            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3218                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3219           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3220               && TREE_CODE (olddecl) != TYPE_DECL
3221               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3222                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3223                         == TYPE_DECL))))
3224         {
3225           /* We do nothing special here, because C++ does such nasty
3226              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3227              get shadowed, and know that if we need to find a TYPE_DECL
3228              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3229              slot of the identifier.  */
3230           return 0;
3231         }
3232
3233       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3234            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3235           || (TREE_CODE (olddecl) == FUNCTION_DECL
3236               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3237         return 0;
3238
3239       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3240       if (TREE_CODE (olddecl) == TREE_LIST)
3241         olddecl = TREE_VALUE (olddecl);
3242       cp_error_at ("previous declaration of `%#D'", olddecl);
3243
3244       /* New decl is completely inconsistent with the old one =>
3245          tell caller to replace the old one.  */
3246
3247       return 0;
3248     }
3249   else if (!types_match)
3250     {
3251       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3252         /* These are certainly not duplicate declarations; they're
3253            from different scopes.  */
3254         return 0;
3255
3256       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3257         {
3258           /* The name of a class template may not be declared to refer to
3259              any other template, class, function, object, namespace, value,
3260              or type in the same scope.  */
3261           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3262               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3263             {
3264               cp_error ("declaration of template `%#D'", newdecl);
3265               cp_error_at ("conflicts with previous declaration `%#D'",
3266                            olddecl);
3267             }
3268           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3269                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3270                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3271                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3272                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3273                                            DECL_TEMPLATE_PARMS (olddecl)))
3274             {
3275               cp_error ("new declaration `%#D'", newdecl);
3276               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3277             }
3278           return 0;
3279         }
3280       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3281         {
3282           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3283             {
3284               cp_error ("declaration of C function `%#D' conflicts with",
3285                         newdecl);
3286               cp_error_at ("previous declaration `%#D' here", olddecl);
3287             }
3288           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3289                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3290             {
3291               cp_error ("new declaration `%#D'", newdecl);
3292               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3293             }
3294           else
3295             return 0;
3296         }
3297
3298       /* Already complained about this, so don't do so again.  */
3299       else if (current_class_type == NULL_TREE
3300           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3301         {
3302           cp_error ("conflicting types for `%#D'", newdecl);
3303           cp_error_at ("previous declaration as `%#D'", olddecl);
3304         }
3305     }
3306   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3307             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3308                  && (!DECL_TEMPLATE_INFO (newdecl)
3309                      || (DECL_TI_TEMPLATE (newdecl)
3310                          != DECL_TI_TEMPLATE (olddecl))))
3311                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3312                     && (!DECL_TEMPLATE_INFO (olddecl)
3313                         || (DECL_TI_TEMPLATE (olddecl)
3314                             != DECL_TI_TEMPLATE (newdecl))))))
3315     /* It's OK to have a template specialization and a non-template
3316        with the same type, or to have specializations of two
3317        different templates with the same type.  Note that if one is a
3318        specialization, and the other is an instantiation of the same
3319        template, that we do not exit at this point.  That situation
3320        can occur if we instantiate a template class, and then
3321        specialize one of its methods.  This situation is legal, but
3322        the declarations must be merged in the usual way.  */
3323     return 0;
3324   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3325            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3326                 && !DECL_USE_TEMPLATE (newdecl))
3327                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3328                    && !DECL_USE_TEMPLATE (olddecl))))
3329     /* One of the declarations is a template instantiation, and the
3330        other is not a template at all.  That's OK.  */
3331     return 0;
3332   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3333            && DECL_NAMESPACE_ALIAS (newdecl)
3334            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3335     /* Redeclaration of namespace alias, ignore it. */
3336     return 1;
3337   else
3338     {
3339       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3340       if (errmsg)
3341         {
3342           cp_error (errmsg, newdecl);
3343           if (DECL_NAME (olddecl) != NULL_TREE)
3344             cp_error_at ((DECL_INITIAL (olddecl)
3345                           && namespace_bindings_p ())
3346                          ? "`%#D' previously defined here"
3347                          : "`%#D' previously declared here", olddecl);
3348         }
3349       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3350                && DECL_INITIAL (olddecl) != NULL_TREE
3351                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3352                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3353         {
3354           /* Prototype decl follows defn w/o prototype.  */
3355           cp_warning_at ("prototype for `%#D'", newdecl);
3356           cp_warning_at ("follows non-prototype definition here", olddecl);
3357         }
3358       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3359                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3360         {
3361           /* extern "C" int foo ();
3362              int foo () { bar (); }
3363              is OK.  */
3364           if (current_lang_depth () == 0)
3365             SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3366           else
3367             {
3368               cp_error_at ("previous declaration of `%#D' with %L linkage",
3369                            olddecl, DECL_LANGUAGE (olddecl));
3370               cp_error ("conflicts with new declaration with %L linkage",
3371                         DECL_LANGUAGE (newdecl));
3372             }
3373         }
3374
3375       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3376         ;
3377       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3378         {
3379           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3380           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3381           int i = 1;
3382
3383           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3384             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3385
3386           for (; t1 && t1 != void_list_node;
3387                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3388             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3389               {
3390                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3391                                            TREE_PURPOSE (t2)))
3392                   {
3393                     if (pedantic)
3394                       {
3395                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3396                                     i, newdecl);
3397                         cp_pedwarn_at ("after previous specification in `%#D'",
3398                                        olddecl);
3399                       }
3400                   }
3401                 else
3402                   {
3403                     cp_error ("default argument given for parameter %d of `%#D'",
3404                               i, newdecl);
3405                     cp_error_at ("after previous specification in `%#D'",
3406                                  olddecl);
3407                   }
3408               }
3409
3410           if (DECL_DECLARED_INLINE_P (newdecl)
3411               && ! DECL_DECLARED_INLINE_P (olddecl)
3412               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3413             {
3414               cp_warning ("`%#D' was used before it was declared inline",
3415                           newdecl);
3416               cp_warning_at ("previous non-inline declaration here",
3417                              olddecl);
3418             }
3419         }
3420     }
3421
3422   /* If new decl is `static' and an `extern' was seen previously,
3423      warn about it.  */
3424   warn_extern_redeclared_static (newdecl, olddecl);
3425
3426   /* We have committed to returning 1 at this point.  */
3427   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3428     {
3429       /* Now that functions must hold information normally held
3430          by field decls, there is extra work to do so that
3431          declaration information does not get destroyed during
3432          definition.  */
3433       if (DECL_VINDEX (olddecl))
3434         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3435       if (DECL_VIRTUAL_CONTEXT (olddecl))
3436         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3437       if (DECL_CONTEXT (olddecl))
3438         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3439       if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3440         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3441       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3442       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3443       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3444       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3445       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3446       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3447       if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
3448         SET_OVERLOADED_OPERATOR_CODE
3449           (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
3450       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3451
3452       /* Optionally warn about more than one declaration for the same
3453          name, but don't warn about a function declaration followed by a
3454          definition.  */
3455       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3456           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3457           /* Don't warn about extern decl followed by definition. */
3458           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3459           /* Don't warn about friends, let add_friend take care of it. */
3460           && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
3461         {
3462           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3463           cp_warning_at ("previous declaration of `%D'", olddecl);
3464         }
3465     }
3466
3467   /* Deal with C++: must preserve virtual function table size.  */
3468   if (TREE_CODE (olddecl) == TYPE_DECL)
3469     {
3470       register tree newtype = TREE_TYPE (newdecl);
3471       register tree oldtype = TREE_TYPE (olddecl);
3472
3473       if (newtype != error_mark_node && oldtype != error_mark_node
3474           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3475         {
3476           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3477           CLASSTYPE_FRIEND_CLASSES (newtype)
3478             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3479         }
3480
3481       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3482     }
3483
3484   /* Copy all the DECL_... slots specified in the new decl
3485      except for any that we copy here from the old type.  */
3486   DECL_MACHINE_ATTRIBUTES (newdecl)
3487     = merge_machine_decl_attributes (olddecl, newdecl);
3488
3489   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3490     {
3491       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3492       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3493         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3494                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3495
3496       return 1;
3497     }
3498
3499   if (types_match)
3500     {
3501       /* Automatically handles default parameters.  */
3502       tree oldtype = TREE_TYPE (olddecl);
3503       tree newtype;
3504
3505       /* Merge the data types specified in the two decls.  */
3506       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3507
3508       /* If common_type produces a non-typedef type, just use the old type.  */
3509       if (TREE_CODE (newdecl) == TYPE_DECL
3510           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3511         newtype = oldtype;
3512
3513       if (TREE_CODE (newdecl) == VAR_DECL)
3514         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3515       /* Do this after calling `common_type' so that default
3516          parameters don't confuse us.  */
3517       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3518           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3519               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3520         {
3521           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3522                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3523           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3524                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3525
3526           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3527               && DECL_SOURCE_LINE (olddecl) != 0
3528               && flag_exceptions
3529               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3530                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3531             {
3532               cp_error ("declaration of `%F' throws different exceptions",
3533                         newdecl);
3534               cp_error_at ("than previous declaration `%F'", olddecl);
3535             }
3536         }
3537       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3538
3539       /* Lay the type out, unless already done.  */
3540       if (! same_type_p (newtype, oldtype)
3541           && TREE_TYPE (newdecl) != error_mark_node
3542           && !(processing_template_decl && uses_template_parms (newdecl)))
3543         layout_type (TREE_TYPE (newdecl));
3544
3545       if ((TREE_CODE (newdecl) == VAR_DECL
3546            || TREE_CODE (newdecl) == PARM_DECL
3547            || TREE_CODE (newdecl) == RESULT_DECL
3548            || TREE_CODE (newdecl) == FIELD_DECL
3549            || TREE_CODE (newdecl) == TYPE_DECL)
3550           && !(processing_template_decl && uses_template_parms (newdecl)))
3551         layout_decl (newdecl, 0);
3552
3553       /* Merge the type qualifiers.  */
3554       if (TREE_READONLY (newdecl))
3555         TREE_READONLY (olddecl) = 1;
3556       if (TREE_THIS_VOLATILE (newdecl))
3557         TREE_THIS_VOLATILE (olddecl) = 1;
3558
3559       /* Merge the initialization information.  */
3560       if (DECL_INITIAL (newdecl) == NULL_TREE
3561           && DECL_INITIAL (olddecl) != NULL_TREE)
3562         {
3563           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3564           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3565           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3566           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3567               && DECL_LANG_SPECIFIC (newdecl)
3568               && DECL_LANG_SPECIFIC (olddecl))
3569             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3570         }
3571
3572       /* Merge the section attribute.
3573          We want to issue an error if the sections conflict but that must be
3574          done later in decl_attributes since we are called before attributes
3575          are assigned.  */
3576       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3577         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3578
3579       /* Keep the old rtl since we can safely use it.  */
3580       COPY_DECL_RTL (olddecl, newdecl);
3581
3582       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3583         {
3584           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3585             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3586           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3587             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3588           DECL_NO_LIMIT_STACK (newdecl)
3589             |= DECL_NO_LIMIT_STACK (olddecl);
3590         }
3591     }
3592   /* If cannot merge, then use the new type and qualifiers,
3593      and don't preserve the old rtl.  */
3594   else
3595     {
3596       /* Clean out any memory we had of the old declaration.  */
3597       tree oldstatic = value_member (olddecl, static_aggregates);
3598       if (oldstatic)
3599         TREE_VALUE (oldstatic) = error_mark_node;
3600
3601       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3602       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3603       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3604       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3605     }
3606
3607   /* Merge the storage class information.  */
3608   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3609   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3610   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3611   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3612   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3613   if (! DECL_EXTERNAL (olddecl))
3614     DECL_EXTERNAL (newdecl) = 0;
3615
3616   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3617     {
3618       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3619       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3620       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3621       DECL_TEMPLATE_INSTANTIATED (newdecl)
3622         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3623       /* Don't really know how much of the language-specific
3624          values we should copy from old to new.  */
3625       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3626       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3627       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3628       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3629       DECL_INITIALIZED_IN_CLASS_P (newdecl)
3630         |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
3631       olddecl_friend = DECL_FRIEND_P (olddecl);
3632
3633       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3634       if (TREE_CODE (newdecl) == FUNCTION_DECL
3635           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3636         DECL_BEFRIENDING_CLASSES (newdecl)
3637           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3638                      DECL_BEFRIENDING_CLASSES (olddecl));
3639     }
3640
3641   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3642     {
3643       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3644           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3645         {
3646           /* If newdecl is not a specialization, then it is not a
3647              template-related function at all.  And that means that we
3648              shoud have exited above, returning 0.  */
3649           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3650                               0);
3651
3652           if (TREE_USED (olddecl))
3653             /* From [temp.expl.spec]:
3654
3655                If a template, a member template or the member of a class
3656                template is explicitly specialized then that
3657                specialization shall be declared before the first use of
3658                that specialization that would cause an implicit
3659                instantiation to take place, in every translation unit in
3660                which such a use occurs.  */
3661             cp_error ("explicit specialization of %D after first use",
3662                       olddecl);
3663
3664           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3665         }
3666       DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
3667
3668       /* If either decl says `inline', this fn is inline, unless its
3669          definition was passed already.  */
3670       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3671         DECL_INLINE (olddecl) = 1;
3672       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3673
3674       /* Preserve abstractness on cloned [cd]tors.  */
3675       DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
3676
3677       if (! types_match)
3678         {
3679           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3680           COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
3681           SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3682         }
3683       if (! types_match || new_defines_function)
3684         {
3685           /* These need to be copied so that the names are available.
3686              Note that if the types do match, we'll preserve inline
3687              info and other bits, but if not, we won't.  */
3688           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3689           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3690         }
3691       if (new_defines_function)
3692         /* If defining a function declared with other language
3693            linkage, use the previously declared language linkage.  */
3694         SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3695       else if (types_match)
3696         {
3697           /* If redeclaring a builtin function, and not a definition,
3698              it stays built in.  */
3699           if (DECL_BUILT_IN (olddecl))
3700             {
3701               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3702               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3703               /* If we're keeping the built-in definition, keep the rtl,
3704                  regardless of declaration matches.  */
3705               SET_DECL_RTL (newdecl, DECL_RTL (olddecl));
3706             }
3707           else
3708             DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
3709
3710           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3711           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3712             /* Previously saved insns go together with
3713                the function's previous definition.  */
3714             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3715           /* Don't clear out the arguments if we're redefining a function.  */
3716           if (DECL_ARGUMENTS (olddecl))
3717             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3718         }
3719     }
3720   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3721     NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3722
3723   /* Now preserve various other info from the definition.  */
3724   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3725   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3726   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3727   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3728
3729   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3730     {
3731       int function_size;
3732
3733       function_size = sizeof (struct tree_decl);
3734
3735       memcpy ((char *) olddecl + sizeof (struct tree_common),
3736               (char *) newdecl + sizeof (struct tree_common),
3737               function_size - sizeof (struct tree_common));
3738
3739       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3740         {
3741           /* If newdecl is a template instantiation, it is possible that
3742              the following sequence of events has occurred:
3743
3744              o A friend function was declared in a class template.  The
3745              class template was instantiated.
3746
3747              o The instantiation of the friend declaration was
3748              recorded on the instantiation list, and is newdecl.
3749
3750              o Later, however, instantiate_class_template called pushdecl
3751              on the newdecl to perform name injection.  But, pushdecl in
3752              turn called duplicate_decls when it discovered that another
3753              declaration of a global function with the same name already
3754              existed.
3755
3756              o Here, in duplicate_decls, we decided to clobber newdecl.
3757
3758              If we're going to do that, we'd better make sure that
3759              olddecl, and not newdecl, is on the list of
3760              instantiations so that if we try to do the instantiation
3761              again we won't get the clobbered declaration.  */
3762
3763           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3764           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3765
3766           for (; decls; decls = TREE_CHAIN (decls))
3767             if (TREE_VALUE (decls) == newdecl)
3768               TREE_VALUE (decls) = olddecl;
3769         }
3770     }
3771   else
3772     {
3773       memcpy ((char *) olddecl + sizeof (struct tree_common),
3774               (char *) newdecl + sizeof (struct tree_common),
3775               sizeof (struct tree_decl) - sizeof (struct tree_common)
3776               + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3777     }
3778
3779   DECL_UID (olddecl) = olddecl_uid;
3780   if (olddecl_friend)
3781     DECL_FRIEND_P (olddecl) = 1;
3782
3783   /* NEWDECL contains the merged attribute lists.
3784      Update OLDDECL to be the same.  */
3785   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3786
3787   return 1;
3788 }
3789
3790 /* Record a decl-node X as belonging to the current lexical scope.
3791    Check for errors (such as an incompatible declaration for the same
3792    name already seen in the same scope).
3793
3794    Returns either X or an old decl for the same name.
3795    If an old decl is returned, it may have been smashed
3796    to agree with what X says.  */
3797
3798 tree
3799 pushdecl (x)
3800      tree x;
3801 {
3802   register tree t;
3803   register tree name;
3804   int need_new_binding;
3805
3806   /* We shouldn't be calling pushdecl when we're generating RTL for a
3807      function that we already did semantic analysis on previously.  */
3808   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3809                       19990913);
3810
3811   need_new_binding = 1;
3812
3813   if (DECL_TEMPLATE_PARM_P (x))
3814     /* Template parameters have no context; they are not X::T even
3815        when declared within a class or namespace.  */
3816     ;
3817   else
3818     {
3819       if (current_function_decl && x != current_function_decl
3820           /* A local declaration for a function doesn't constitute
3821              nesting.  */
3822           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3823           /* A local declaration for an `extern' variable is in the
3824              scope of the current namespace, not the current
3825              function.  */
3826           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3827           && !DECL_CONTEXT (x))
3828         DECL_CONTEXT (x) = current_function_decl;
3829
3830       /* If this is the declaration for a namespace-scope function,
3831          but the declaration itself is in a local scope, mark the
3832          declaration.  */
3833       if (TREE_CODE (x) == FUNCTION_DECL
3834           && DECL_NAMESPACE_SCOPE_P (x)
3835           && current_function_decl
3836           && x != current_function_decl)
3837         DECL_LOCAL_FUNCTION_P (x) = 1;
3838     }
3839
3840   name = DECL_NAME (x);
3841   if (name)
3842     {
3843       int different_binding_level = 0;
3844
3845       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3846         name = TREE_OPERAND (name, 0);
3847
3848       /* In case this decl was explicitly namespace-qualified, look it
3849          up in its namespace context.  */
3850       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3851           && namespace_bindings_p ())
3852         t = namespace_binding (name, DECL_CONTEXT (x));
3853       else
3854         t = lookup_name_current_level (name);
3855
3856       /* [basic.link] If there is a visible declaration of an entity
3857          with linkage having the same name and type, ignoring entities
3858          declared outside the innermost enclosing namespace scope, the
3859          block scope declaration declares that same entity and
3860          receives the linkage of the previous declaration.  */
3861       if (! t && current_function_decl && x != current_function_decl
3862           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3863           && DECL_EXTERNAL (x))
3864         {
3865           /* Look in block scope.  */
3866           t = IDENTIFIER_VALUE (name);
3867           /* Or in the innermost namespace.  */
3868           if (! t)
3869             t = namespace_binding (name, DECL_CONTEXT (x));
3870           /* Does it have linkage?  Note that if this isn't a DECL, it's an
3871              OVERLOAD, which is OK.  */
3872           if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3873             t = NULL_TREE;
3874           if (t)
3875             different_binding_level = 1;
3876         }
3877
3878       /* If we are declaring a function, and the result of name-lookup
3879          was an OVERLOAD, look for an overloaded instance that is
3880          actually the same as the function we are declaring.  (If
3881          there is one, we have to merge our declaration with the
3882          previous declaration.)  */
3883       if (t && TREE_CODE (t) == OVERLOAD)
3884         {
3885           tree match;
3886
3887           if (TREE_CODE (x) == FUNCTION_DECL)
3888             for (match = t; match; match = OVL_NEXT (match))
3889               {
3890                 if (decls_match (OVL_CURRENT (match), x))
3891                   break;
3892               }
3893           else
3894             /* Just choose one.  */
3895             match = t;
3896
3897           if (match)
3898             t = OVL_CURRENT (match);
3899           else
3900             t = NULL_TREE;
3901         }
3902
3903       if (t == error_mark_node)
3904         {
3905           /* error_mark_node is 0 for a while during initialization!  */
3906           t = NULL_TREE;
3907           cp_error_at ("`%#D' used prior to declaration", x);
3908         }
3909       else if (t != NULL_TREE)
3910         {
3911           if (different_binding_level)
3912             {
3913               if (decls_match (x, t))
3914                 /* The standard only says that the local extern
3915                    inherits linkage from the previous decl; in
3916                    particular, default args are not shared.  It would
3917                    be nice to propagate inlining info, though.  FIXME.  */
3918                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3919             }
3920           else if (TREE_CODE (t) == PARM_DECL)
3921             {
3922               if (DECL_CONTEXT (t) == NULL_TREE)
3923                 /* This is probaby caused by too many errors, but calling
3924                    abort will say that if errors have occurred.  */
3925                 abort ();
3926
3927               /* Check for duplicate params.  */
3928               if (duplicate_decls (x, t))
3929                 return t;
3930             }
3931           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3932                     || DECL_FUNCTION_TEMPLATE_P (x))
3933                    && is_overloaded_fn (t))
3934             /* Don't do anything just yet. */;
3935           else if (t == wchar_decl_node)
3936             {
3937               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3938                 cp_pedwarn ("redeclaration of `wchar_t' as `%T'",
3939                             TREE_TYPE (x));
3940
3941               /* Throw away the redeclaration.  */
3942               return t;
3943             }
3944           else if (TREE_CODE (t) != TREE_CODE (x))
3945             {
3946               if (duplicate_decls (x, t))
3947                 return t;
3948             }
3949           else if (duplicate_decls (x, t))
3950             {
3951               if (TREE_CODE (t) == TYPE_DECL)
3952                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3953               else if (TREE_CODE (t) == FUNCTION_DECL)
3954                 check_default_args (t);
3955
3956               return t;
3957             }
3958           else if (DECL_MAIN_P (x))
3959             {
3960               /* A redeclaration of main, but not a duplicate of the
3961                  previous one.
3962
3963                  [basic.start.main]
3964
3965                  This function shall not be overloaded.  */
3966               cp_error_at ("invalid redeclaration of `%D'", t);
3967               cp_error ("as `%D'", x);
3968               /* We don't try to push this declaration since that
3969                  causes a crash.  */
3970               return x;
3971             }
3972         }
3973
3974       check_template_shadow (x);
3975
3976       /* If this is a function conjured up by the backend, massage it
3977          so it looks friendly.  */
3978       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3979         {
3980           retrofit_lang_decl (x);
3981           SET_DECL_LANGUAGE (x, lang_c);
3982         }
3983
3984       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3985         {
3986           t = push_overloaded_decl (x, PUSH_LOCAL);
3987           if (t != x)
3988             return t;
3989           if (!namespace_bindings_p ())
3990             /* We do not need to create a binding for this name;
3991                push_overloaded_decl will have already done so if
3992                necessary.  */
3993             need_new_binding = 0;
3994         }
3995       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3996         {
3997           t = push_overloaded_decl (x, PUSH_GLOBAL);
3998           if (t == x)
3999             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
4000           return t;
4001         }
4002
4003       /* If declaring a type as a typedef, copy the type (unless we're
4004          at line 0), and install this TYPE_DECL as the new type's typedef
4005          name.  See the extensive comment in ../c-decl.c (pushdecl). */
4006       if (TREE_CODE (x) == TYPE_DECL)
4007         {
4008           tree type = TREE_TYPE (x);
4009           if (DECL_SOURCE_LINE (x) == 0)
4010             {
4011               if (TYPE_NAME (type) == 0)
4012                 TYPE_NAME (type) = x;
4013             }
4014           else if (type != error_mark_node && TYPE_NAME (type) != x
4015                    /* We don't want to copy the type when all we're
4016                       doing is making a TYPE_DECL for the purposes of
4017                       inlining.  */
4018                    && (!TYPE_NAME (type)
4019                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
4020             {
4021               DECL_ORIGINAL_TYPE (x) = type;
4022               type = build_type_copy (type);
4023               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4024               TYPE_NAME (type) = x;
4025               TREE_TYPE (x) = type;
4026             }
4027
4028           if (type != error_mark_node
4029               && TYPE_NAME (type)
4030               && TYPE_IDENTIFIER (type))
4031             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4032                                                   current_binding_level);
4033
4034         }
4035
4036       /* Multiple external decls of the same identifier ought to match.
4037
4038          We get warnings about inline functions where they are defined.
4039          We get warnings about other functions from push_overloaded_decl.
4040
4041          Avoid duplicate warnings where they are used.  */
4042       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4043         {
4044           tree decl;
4045
4046           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4047           if (decl && TREE_CODE (decl) == OVERLOAD)
4048             decl = OVL_FUNCTION (decl);
4049
4050           if (decl && decl != error_mark_node
4051               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4052               /* If different sort of thing, we already gave an error.  */
4053               && TREE_CODE (decl) == TREE_CODE (x)
4054               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4055             {
4056               cp_pedwarn ("type mismatch with previous external decl", x);
4057               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4058             }
4059         }
4060
4061       /* This name is new in its binding level.
4062          Install the new declaration and return it.  */
4063       if (namespace_bindings_p ())
4064         {
4065           /* Install a global value.  */
4066
4067           /* If the first global decl has external linkage,
4068              warn if we later see static one.  */
4069           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4070             TREE_PUBLIC (name) = 1;
4071
4072           /* Bind the name for the entity.  */
4073           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4074                 && t != NULL_TREE)
4075               && (TREE_CODE (x) == TYPE_DECL
4076                   || TREE_CODE (x) == VAR_DECL
4077                   || TREE_CODE (x) == NAMESPACE_DECL
4078                   || TREE_CODE (x) == CONST_DECL
4079                   || TREE_CODE (x) == TEMPLATE_DECL))
4080             SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
4081
4082           /* Don't forget if the function was used via an implicit decl.  */
4083           if (IDENTIFIER_IMPLICIT_DECL (name)
4084               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4085             TREE_USED (x) = 1;
4086
4087           /* Don't forget if its address was taken in that way.  */
4088           if (IDENTIFIER_IMPLICIT_DECL (name)
4089               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4090             TREE_ADDRESSABLE (x) = 1;
4091
4092           /* Warn about mismatches against previous implicit decl.  */
4093           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4094               /* If this real decl matches the implicit, don't complain.  */
4095               && ! (TREE_CODE (x) == FUNCTION_DECL
4096                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4097             cp_warning
4098               ("`%D' was previously implicitly declared to return `int'", x);
4099
4100           /* If new decl is `static' and an `extern' was seen previously,
4101              warn about it.  */
4102           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4103             warn_extern_redeclared_static (x, t);
4104         }
4105       else
4106         {
4107           /* Here to install a non-global value.  */
4108           tree oldlocal = IDENTIFIER_VALUE (name);
4109           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4110
4111           if (need_new_binding)
4112             {
4113               push_local_binding (name, x, 0);
4114               /* Because push_local_binding will hook X on to the
4115                  current_binding_level's name list, we don't want to
4116                  do that again below.  */
4117               need_new_binding = 0;
4118             }
4119
4120           /* If this is a TYPE_DECL, push it into the type value slot.  */
4121           if (TREE_CODE (x) == TYPE_DECL)
4122             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4123                                                   current_binding_level);
4124
4125           /* Clear out any TYPE_DECL shadowed by a namespace so that
4126              we won't think this is a type.  The C struct hack doesn't
4127              go through namespaces.  */
4128           if (TREE_CODE (x) == NAMESPACE_DECL)
4129             set_identifier_type_value_with_scope (name, NULL_TREE,
4130                                                   current_binding_level);
4131
4132           if (oldlocal)
4133             {
4134               tree d = oldlocal;
4135
4136               while (oldlocal
4137                      && TREE_CODE (oldlocal) == VAR_DECL
4138                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4139                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4140
4141               if (oldlocal == NULL_TREE)
4142                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4143             }
4144
4145           /* If this is an extern function declaration, see if we
4146              have a global definition or declaration for the function.  */
4147           if (oldlocal == NULL_TREE
4148               && DECL_EXTERNAL (x)
4149               && oldglobal != NULL_TREE
4150               && TREE_CODE (x) == FUNCTION_DECL
4151               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4152             {
4153               /* We have one.  Their types must agree.  */
4154               if (decls_match (x, oldglobal))
4155                 /* OK */;
4156               else
4157                 {
4158                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4159                   cp_warning_at ("global declaration `%#D'", oldglobal);
4160                 }
4161             }
4162           /* If we have a local external declaration,
4163              and no file-scope declaration has yet been seen,
4164              then if we later have a file-scope decl it must not be static.  */
4165           if (oldlocal == NULL_TREE
4166               && oldglobal == NULL_TREE
4167               && DECL_EXTERNAL (x)
4168               && TREE_PUBLIC (x))
4169             TREE_PUBLIC (name) = 1;
4170
4171           /* Warn if shadowing an argument at the top level of the body.  */
4172           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4173               /* Inline decls shadow nothing.  */
4174               && !DECL_FROM_INLINE (x)
4175               && TREE_CODE (oldlocal) == PARM_DECL
4176               /* Don't complain if it's from an enclosing function.  */
4177               && DECL_CONTEXT (oldlocal) == current_function_decl
4178               && TREE_CODE (x) != PARM_DECL)
4179             {
4180               /* Go to where the parms should be and see if we
4181                  find them there.  */
4182               struct binding_level *b = current_binding_level->level_chain;
4183
4184               if (cleanup_label)
4185                 b = b->level_chain;
4186
4187               /* ARM $8.3 */
4188               if (b->parm_flag == 1)
4189                 cp_error ("declaration of `%#D' shadows a parameter", name);
4190             }
4191
4192           /* Maybe warn if shadowing something else.  */
4193           if (warn_shadow && !DECL_EXTERNAL (x)
4194               /* Inline decls shadow nothing.  */
4195               && !DECL_FROM_INLINE (x)
4196               /* No shadow warnings for internally generated vars.  */
4197               && ! DECL_ARTIFICIAL (x)
4198               /* No shadow warnings for vars made for inlining.  */
4199               && ! DECL_FROM_INLINE (x))
4200             {
4201               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4202                 warning ("declaration of `%s' shadows a parameter",
4203                         IDENTIFIER_POINTER (name));
4204               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4205                        && current_class_ptr
4206                        && !TREE_STATIC (name))
4207                 warning ("declaration of `%s' shadows a member of `this'",
4208                         IDENTIFIER_POINTER (name));
4209               else if (oldlocal != NULL_TREE)
4210                 warning ("declaration of `%s' shadows previous local",
4211                         IDENTIFIER_POINTER (name));
4212               else if (oldglobal != NULL_TREE)
4213                 /* XXX shadow warnings in outer-more namespaces */
4214                 warning ("declaration of `%s' shadows global declaration",
4215                         IDENTIFIER_POINTER (name));
4216             }
4217         }
4218
4219       if (TREE_CODE (x) == FUNCTION_DECL)
4220         check_default_args (x);
4221
4222       /* Keep count of variables in this level with incomplete type.  */
4223       if (TREE_CODE (x) == VAR_DECL
4224           && TREE_TYPE (x) != error_mark_node
4225           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4226                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4227               /* RTTI TD entries are created while defining the type_info.  */
4228               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4229                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4230         {
4231           if (namespace_bindings_p ())
4232             namespace_scope_incomplete
4233               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4234           else
4235             current_binding_level->incomplete
4236               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4237         }
4238     }
4239
4240   if (need_new_binding)
4241     add_decl_to_level (x,
4242                        DECL_NAMESPACE_SCOPE_P (x)
4243                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4244                        : current_binding_level);
4245
4246   return x;
4247 }
4248
4249 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4250    caller to set DECL_CONTEXT properly.  */
4251
4252 static tree
4253 pushdecl_with_scope (x, level)
4254      tree x;
4255      struct binding_level *level;
4256 {
4257   register struct binding_level *b;
4258   tree function_decl = current_function_decl;
4259
4260   current_function_decl = NULL_TREE;
4261   if (level->parm_flag == 2)
4262     {
4263       b = class_binding_level;
4264       class_binding_level = level;
4265       pushdecl_class_level (x);
4266       class_binding_level = b;
4267     }
4268   else
4269     {
4270       b = current_binding_level;
4271       current_binding_level = level;
4272       x = pushdecl (x);
4273       current_binding_level = b;
4274     }
4275   current_function_decl = function_decl;
4276   return x;
4277 }
4278
4279 /* Like pushdecl, only it places X in the current namespace,
4280    if appropriate.  */
4281
4282 tree
4283 pushdecl_namespace_level (x)
4284      tree x;
4285 {
4286   register struct binding_level *b = current_binding_level;
4287   register tree t;
4288
4289   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4290
4291   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4292      what we want.  */
4293   if (TREE_CODE (x) == TYPE_DECL)
4294     {
4295       tree name = DECL_NAME (x);
4296       tree newval;
4297       tree *ptr = (tree *)0;
4298       for (; b != global_binding_level; b = b->level_chain)
4299         {
4300           tree shadowed = b->type_shadowed;
4301           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4302             if (TREE_PURPOSE (shadowed) == name)
4303               {
4304                 ptr = &TREE_VALUE (shadowed);
4305                 /* Can't break out of the loop here because sometimes
4306                    a binding level will have duplicate bindings for
4307                    PT names.  It's gross, but I haven't time to fix it.  */
4308               }
4309         }
4310       newval = TREE_TYPE (x);
4311       if (ptr == (tree *)0)
4312         {
4313           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4314              up here if this is changed to an assertion.  --KR  */
4315           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4316         }
4317       else
4318         {
4319           *ptr = newval;
4320         }
4321     }
4322   return t;
4323 }
4324
4325 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4326    if appropriate.  */
4327
4328 tree
4329 pushdecl_top_level (x)
4330      tree x;
4331 {
4332   push_to_top_level ();
4333   x = pushdecl_namespace_level (x);
4334   pop_from_top_level ();
4335   return x;
4336 }
4337
4338 /* Make the declaration of X appear in CLASS scope.  */
4339
4340 void
4341 pushdecl_class_level (x)
4342      tree x;
4343 {
4344   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4345      scope looks for the pre-mangled name.  */
4346   register tree name;
4347
4348   if (TREE_CODE (x) == OVERLOAD)
4349     x = OVL_CURRENT (x);
4350   name = DECL_NAME (x);
4351
4352   if (name)
4353     {
4354       push_class_level_binding (name, x);
4355       if (TREE_CODE (x) == TYPE_DECL)
4356         set_identifier_type_value (name, TREE_TYPE (x));
4357     }
4358   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4359     {
4360       tree f;
4361
4362       for (f = TYPE_FIELDS (TREE_TYPE (x));
4363            f;
4364            f = TREE_CHAIN (f))
4365         pushdecl_class_level (f);
4366     }
4367 }
4368
4369 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4370    DECL, or a modified version thereof.  */
4371
4372 tree
4373 maybe_push_decl (decl)
4374      tree decl;
4375 {
4376   tree type = TREE_TYPE (decl);
4377
4378   /* Add this decl to the current binding level, but not if it comes
4379      from another scope, e.g. a static member variable.  TEM may equal
4380      DECL or it may be a previous decl of the same name.  */
4381   if (decl == error_mark_node
4382       || (TREE_CODE (decl) != PARM_DECL
4383           && DECL_CONTEXT (decl) != NULL_TREE
4384           /* Definitions of namespace members outside their namespace are
4385              possible. */
4386           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4387       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4388       || TREE_CODE (type) == UNKNOWN_TYPE
4389       /* The declaration of a template specialization does not affect
4390          the functions available for overload resolution, so we do not
4391          call pushdecl.  */
4392       || (TREE_CODE (decl) == FUNCTION_DECL
4393           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4394     return decl;
4395   else
4396     return pushdecl (decl);
4397 }
4398
4399 /* Make the declaration(s) of X appear in CLASS scope
4400    under the name NAME.  */
4401
4402 void
4403 push_class_level_binding (name, x)
4404      tree name;
4405      tree x;
4406 {
4407   tree binding;
4408   /* The class_binding_level will be NULL if x is a template
4409      parameter name in a member template.  */
4410   if (!class_binding_level)
4411     return;
4412
4413   /* Make sure that this new member does not have the same name
4414      as a template parameter.  */
4415   if (TYPE_BEING_DEFINED (current_class_type))
4416     check_template_shadow (x);
4417
4418   /* If this declaration shadows a declaration from an enclosing
4419      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4420      we leave this class.  Record the shadowed declaration here.  */
4421   binding = IDENTIFIER_BINDING (name);
4422   if (binding
4423       && ((TREE_CODE (x) == OVERLOAD
4424            && BINDING_VALUE (binding)
4425            && is_overloaded_fn (BINDING_VALUE (binding)))
4426           || INHERITED_VALUE_BINDING_P (binding)))
4427     {
4428       tree shadow;
4429       tree old_decl;
4430
4431       /* If the old binding was from a base class, and was for a tag
4432          name, slide it over to make room for the new binding.  The
4433          old binding is still visible if explicitly qualified with a
4434          class-key.  */
4435       if (INHERITED_VALUE_BINDING_P (binding)
4436           && BINDING_VALUE (binding)
4437           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4438           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4439           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4440         {
4441           old_decl = BINDING_TYPE (binding);
4442           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4443           BINDING_VALUE (binding) = NULL_TREE;
4444           INHERITED_VALUE_BINDING_P (binding) = 0;
4445         }
4446       else
4447         old_decl = BINDING_VALUE (binding);
4448
4449       /* Find the previous binding of name on the class-shadowed
4450          list, and update it.  */
4451       for (shadow = class_binding_level->class_shadowed;
4452            shadow;
4453            shadow = TREE_CHAIN (shadow))
4454         if (TREE_PURPOSE (shadow) == name
4455             && TREE_TYPE (shadow) == old_decl)
4456           {
4457             BINDING_VALUE (binding) = x;
4458             INHERITED_VALUE_BINDING_P (binding) = 0;
4459             TREE_TYPE (shadow) = x;
4460             IDENTIFIER_CLASS_VALUE (name) = x;
4461             return;
4462           }
4463     }
4464
4465   /* If we didn't replace an existing binding, put the binding on the
4466      stack of bindings for the identifier, and update the shadowed list.  */
4467   if (push_class_binding (name, x))
4468     {
4469       class_binding_level->class_shadowed
4470         = tree_cons (name, NULL,
4471                      class_binding_level->class_shadowed);
4472       /* Record the value we are binding NAME to so that we can know
4473          what to pop later.  */
4474       TREE_TYPE (class_binding_level->class_shadowed) = x;
4475     }
4476 }
4477
4478 /* Insert another USING_DECL into the current binding level, returning
4479    this declaration. If this is a redeclaration, do nothing, and
4480    return NULL_TREE if this not in namespace scope (in namespace
4481    scope, a using decl might extend any previous bindings).  */
4482
4483 tree
4484 push_using_decl (scope, name)
4485      tree scope;
4486      tree name;
4487 {
4488   tree decl;
4489
4490   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4491   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4492   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4493     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4494       break;
4495   if (decl)
4496     return namespace_bindings_p () ? decl : NULL_TREE;
4497   decl = build_lang_decl (USING_DECL, name, void_type_node);
4498   DECL_INITIAL (decl) = scope;
4499   TREE_CHAIN (decl) = current_binding_level->usings;
4500   current_binding_level->usings = decl;
4501   return decl;
4502 }
4503
4504 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4505    changed (i.e. there was already a directive), or the fresh
4506    TREE_LIST otherwise.  */
4507
4508 tree
4509 push_using_directive (used)
4510      tree used;
4511 {
4512   tree ud = current_binding_level->using_directives;
4513   tree iter, ancestor;
4514
4515   /* Check if we already have this. */
4516   if (purpose_member (used, ud) != NULL_TREE)
4517     return NULL_TREE;
4518
4519   /* Recursively add all namespaces used. */
4520   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4521     push_using_directive (TREE_PURPOSE (iter));
4522
4523   ancestor = namespace_ancestor (current_decl_namespace (), used);
4524   ud = current_binding_level->using_directives;
4525   ud = tree_cons (used, ancestor, ud);
4526   current_binding_level->using_directives = ud;
4527   return ud;
4528 }
4529
4530 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4531    other definitions already in place.  We get around this by making
4532    the value of the identifier point to a list of all the things that
4533    want to be referenced by that name.  It is then up to the users of
4534    that name to decide what to do with that list.
4535
4536    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4537    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4538
4539    FLAGS is a bitwise-or of the following values:
4540      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4541                  namespace scope.
4542      PUSH_USING: DECL is being pushed as the result of a using
4543                  declaration.
4544
4545    The value returned may be a previous declaration if we guessed wrong
4546    about what language DECL should belong to (C or C++).  Otherwise,
4547    it's always DECL (and never something that's not a _DECL).  */
4548
4549 tree
4550 push_overloaded_decl (decl, flags)
4551      tree decl;
4552      int flags;
4553 {
4554   tree name = DECL_NAME (decl);
4555   tree old;
4556   tree new_binding;
4557   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4558
4559   if (doing_global)
4560     old = namespace_binding (name, DECL_CONTEXT (decl));
4561   else
4562     old = lookup_name_current_level (name);
4563
4564   if (old)
4565     {
4566       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4567         {
4568           tree t = TREE_TYPE (old);
4569           if (IS_AGGR_TYPE (t) && warn_shadow
4570               && (! DECL_IN_SYSTEM_HEADER (decl)
4571                   || ! DECL_IN_SYSTEM_HEADER (old)))
4572             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4573           old = NULL_TREE;
4574         }
4575       else if (is_overloaded_fn (old))
4576         {
4577           tree tmp;
4578
4579           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4580             {
4581               tree fn = OVL_CURRENT (tmp);
4582
4583               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4584                   && !(flags & PUSH_USING)
4585                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4586                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4587                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4588                           decl, fn);
4589
4590               if (duplicate_decls (decl, fn))
4591                 return fn;
4592             }
4593         }
4594       else if (old == error_mark_node)
4595         /* Ignore the undefined symbol marker.  */
4596         old = NULL_TREE;
4597       else
4598         {
4599           cp_error_at ("previous non-function declaration `%#D'", old);
4600           cp_error ("conflicts with function declaration `%#D'", decl);
4601           return decl;
4602         }
4603     }
4604
4605   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4606     {
4607       if (old && TREE_CODE (old) != OVERLOAD)
4608         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4609       else
4610         new_binding = ovl_cons (decl, old);
4611       if (flags & PUSH_USING)
4612         OVL_USED (new_binding) = 1;
4613     }
4614   else
4615     /* NAME is not ambiguous.  */
4616     new_binding = decl;
4617
4618   if (doing_global)
4619     set_namespace_binding (name, current_namespace, new_binding);
4620   else
4621     {
4622       /* We only create an OVERLOAD if there was a previous binding at
4623          this level, or if decl is a template. In the former case, we
4624          need to remove the old binding and replace it with the new
4625          binding.  We must also run through the NAMES on the binding
4626          level where the name was bound to update the chain.  */
4627
4628       if (TREE_CODE (new_binding) == OVERLOAD && old)
4629         {
4630           tree *d;
4631
4632           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4633                *d;
4634                d = &TREE_CHAIN (*d))
4635             if (*d == old
4636                 || (TREE_CODE (*d) == TREE_LIST
4637                     && TREE_VALUE (*d) == old))
4638               {
4639                 if (TREE_CODE (*d) == TREE_LIST)
4640                   /* Just replace the old binding with the new.  */
4641                   TREE_VALUE (*d) = new_binding;
4642                 else
4643                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4644                   *d = tree_cons (NULL_TREE, new_binding,
4645                                   TREE_CHAIN (*d));
4646
4647                 /* And update the CPLUS_BINDING node.  */
4648                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4649                   = new_binding;
4650                 return decl;
4651               }
4652
4653           /* We should always find a previous binding in this case.  */
4654           my_friendly_abort (0);
4655         }
4656
4657       /* Install the new binding.  */
4658       push_local_binding (name, new_binding, flags);
4659     }
4660
4661   return decl;
4662 }
4663 \f
4664 /* Generate an implicit declaration for identifier FUNCTIONID
4665    as a function of type int ().  Print a warning if appropriate.  */
4666
4667 tree
4668 implicitly_declare (functionid)
4669      tree functionid;
4670 {
4671   register tree decl;
4672
4673   /* We used to reuse an old implicit decl here,
4674      but this loses with inline functions because it can clobber
4675      the saved decl chains.  */
4676   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4677
4678   DECL_EXTERNAL (decl) = 1;
4679   TREE_PUBLIC (decl) = 1;
4680
4681   /* ISO standard says implicit declarations are in the innermost block.
4682      So we record the decl in the standard fashion.  */
4683   pushdecl (decl);
4684   rest_of_decl_compilation (decl, NULL, 0, 0);
4685
4686   if (warn_implicit
4687       /* Only one warning per identifier.  */
4688       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4689     {
4690       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4691     }
4692
4693   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4694
4695   return decl;
4696 }
4697
4698 /* Return zero if the declaration NEWDECL is valid
4699    when the declaration OLDDECL (assumed to be for the same name)
4700    has already been seen.
4701    Otherwise return an error message format string with a %s
4702    where the identifier should go.  */
4703
4704 static const char *
4705 redeclaration_error_message (newdecl, olddecl)
4706      tree newdecl, olddecl;
4707 {
4708   if (TREE_CODE (newdecl) == TYPE_DECL)
4709     {
4710       /* Because C++ can put things into name space for free,
4711          constructs like "typedef struct foo { ... } foo"
4712          would look like an erroneous redeclaration.  */
4713       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4714         return 0;
4715       else
4716         return "redefinition of `%#D'";
4717     }
4718   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4719     {
4720       /* If this is a pure function, its olddecl will actually be
4721          the original initialization to `0' (which we force to call
4722          abort()).  Don't complain about redefinition in this case.  */
4723       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4724         return 0;
4725
4726       /* If both functions come from different namespaces, this is not
4727          a redeclaration - this is a conflict with a used function. */
4728       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4729           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4730         return "`%D' conflicts with used function";
4731
4732       /* We'll complain about linkage mismatches in
4733          warn_extern_redeclared_static.  */
4734
4735       /* Defining the same name twice is no good.  */
4736       if (DECL_INITIAL (olddecl) != NULL_TREE
4737           && DECL_INITIAL (newdecl) != NULL_TREE)
4738         {
4739           if (DECL_NAME (olddecl) == NULL_TREE)
4740             return "`%#D' not declared in class";
4741           else
4742             return "redefinition of `%#D'";
4743         }
4744       return 0;
4745     }
4746   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4747     {
4748       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4749            && (DECL_TEMPLATE_RESULT (newdecl)
4750                != DECL_TEMPLATE_RESULT (olddecl))
4751            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4752            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4753           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4754               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4755               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4756         return "redefinition of `%#D'";
4757       return 0;
4758     }
4759   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4760     {
4761       /* Objects declared at top level:  */
4762       /* If at least one is a reference, it's ok.  */
4763       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4764         return 0;
4765       /* Reject two definitions.  */
4766       return "redefinition of `%#D'";
4767     }
4768   else
4769     {
4770       /* Objects declared with block scope:  */
4771       /* Reject two definitions, and reject a definition
4772          together with an external reference.  */
4773       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4774         return "redeclaration of `%#D'";
4775       return 0;
4776     }
4777 }
4778 \f
4779 /* Create a new label, named ID.  */
4780
4781 static tree
4782 make_label_decl (id, local_p)
4783      tree id;
4784      int local_p;
4785 {
4786   tree decl;
4787
4788   decl = build_decl (LABEL_DECL, id, void_type_node);
4789   if (expanding_p)
4790     /* Make sure every label has an rtx.  */
4791     label_rtx (decl);
4792
4793   DECL_CONTEXT (decl) = current_function_decl;
4794   DECL_MODE (decl) = VOIDmode;
4795   C_DECLARED_LABEL_FLAG (decl) = local_p;
4796
4797   /* Say where one reference is to the label, for the sake of the
4798      error if it is not defined.  */
4799   DECL_SOURCE_LINE (decl) = lineno;
4800   DECL_SOURCE_FILE (decl) = input_filename;
4801
4802   /* Record the fact that this identifier is bound to this label.  */
4803   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4804
4805   return decl;
4806 }
4807
4808 /* Record this label on the list of used labels so that we can check
4809    at the end of the function to see whether or not the label was
4810    actually defined, and so we can check when the label is defined whether
4811    this use is valid.  */
4812
4813 static void
4814 use_label (decl)
4815      tree decl;
4816 {
4817   if (named_label_uses == NULL
4818       || named_label_uses->names_in_scope != current_binding_level->names
4819       || named_label_uses->label_decl != decl)
4820     {
4821       struct named_label_use_list *new_ent;
4822       new_ent = ((struct named_label_use_list *)
4823                  ggc_alloc (sizeof (struct named_label_use_list)));
4824       new_ent->label_decl = decl;
4825       new_ent->names_in_scope = current_binding_level->names;
4826       new_ent->binding_level = current_binding_level;
4827       new_ent->lineno_o_goto = lineno;
4828       new_ent->filename_o_goto = input_filename;
4829       new_ent->next = named_label_uses;
4830       named_label_uses = new_ent;
4831     }
4832 }
4833
4834 /* Look for a label named ID in the current function.  If one cannot
4835    be found, create one.  (We keep track of used, but undefined,
4836    labels, and complain about them at the end of a function.)  */
4837
4838 tree
4839 lookup_label (id)
4840      tree id;
4841 {
4842   tree decl;
4843   struct named_label_list *ent;
4844
4845   /* You can't use labels at global scope.  */
4846   if (current_function_decl == NULL_TREE)
4847     {
4848       error ("label `%s' referenced outside of any function",
4849              IDENTIFIER_POINTER (id));
4850       return NULL_TREE;
4851     }
4852
4853   /* See if we've already got this label.  */
4854   decl = IDENTIFIER_LABEL_VALUE (id);
4855   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4856     return decl;
4857
4858   /* Record this label on the list of labels used in this function.
4859      We do this before calling make_label_decl so that we get the
4860      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4861   ent = ((struct named_label_list *)
4862          ggc_alloc_cleared (sizeof (struct named_label_list)));
4863   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4864   ent->next = named_labels;
4865   named_labels = ent;
4866
4867   /* We need a new label.  */
4868   decl = make_label_decl (id, /*local_p=*/0);
4869
4870   /* Now fill in the information we didn't have before.  */
4871   ent->label_decl = decl;
4872
4873   return decl;
4874 }
4875
4876 /* Declare a local label named ID.  */
4877
4878 tree
4879 declare_local_label (id)
4880      tree id;
4881 {
4882   tree decl;
4883
4884   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4885      this scope we can restore the old value of
4886      IDENTIFIER_TYPE_VALUE.  */
4887   current_binding_level->shadowed_labels
4888     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4889                  current_binding_level->shadowed_labels);
4890   /* Look for the label.  */
4891   decl = make_label_decl (id, /*local_p=*/1);
4892   /* Now fill in the information we didn't have before.  */
4893   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4894
4895   return decl;
4896 }
4897
4898 /* Returns nonzero if it is ill-formed to jump past the declaration of
4899    DECL.  Returns 2 if it's also a real problem.  */
4900
4901 static int
4902 decl_jump_unsafe (decl)
4903      tree decl;
4904 {
4905   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4906     return 0;
4907
4908   if (DECL_INITIAL (decl) == NULL_TREE
4909       && pod_type_p (TREE_TYPE (decl)))
4910     return 0;
4911
4912   /* This is really only important if we're crossing an initialization.
4913      The POD stuff is just pedantry; why should it matter if the class
4914      contains a field of pointer to member type?  */
4915   if (DECL_INITIAL (decl)
4916       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4917     return 2;
4918   return 1;
4919 }
4920
4921 /* Check that a single previously seen jump to a newly defined label
4922    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4923    the jump context; NAMES are the names in scope in LEVEL at the jump
4924    context; FILE and LINE are the source position of the jump or 0.  */
4925
4926 static void
4927 check_previous_goto_1 (decl, level, names, file, line)
4928      tree decl;
4929      struct binding_level *level;
4930      tree names;
4931      const char *file;
4932      int line;
4933 {
4934   int identified = 0;
4935   int saw_eh = 0;
4936   struct binding_level *b = current_binding_level;
4937   for (; b; b = b->level_chain)
4938     {
4939       tree new_decls = b->names;
4940       tree old_decls = (b == level ? names : NULL_TREE);
4941       for (; new_decls != old_decls;
4942            new_decls = TREE_CHAIN (new_decls))
4943         {
4944           int problem = decl_jump_unsafe (new_decls);
4945           if (! problem)
4946             continue;
4947
4948           if (! identified)
4949             {
4950               if (decl)
4951                 cp_pedwarn ("jump to label `%D'", decl);
4952               else
4953                 pedwarn ("jump to case label");
4954
4955               if (file)
4956                 pedwarn_with_file_and_line (file, line, "  from here");
4957               identified = 1;
4958             }
4959
4960           if (problem > 1)
4961             cp_error_at ("  crosses initialization of `%#D'",
4962                          new_decls);
4963           else
4964             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4965                            new_decls);
4966         }
4967
4968       if (b == level)
4969         break;
4970       if ((b->is_try_scope || b->is_catch_scope) && ! saw_eh)
4971         {
4972           if (! identified)
4973             {
4974               if (decl)
4975                 cp_pedwarn ("jump to label `%D'", decl);
4976               else
4977                 pedwarn ("jump to case label");
4978
4979               if (file)
4980                 pedwarn_with_file_and_line (file, line, "  from here");
4981               identified = 1;
4982             }
4983           if (b->is_try_scope)
4984             error ("  enters try block");
4985           else
4986             error ("  enters catch block");
4987           saw_eh = 1;
4988         }
4989     }
4990 }
4991
4992 static void
4993 check_previous_goto (use)
4994      struct named_label_use_list *use;
4995 {
4996   check_previous_goto_1 (use->label_decl, use->binding_level,
4997                          use->names_in_scope, use->filename_o_goto,
4998                          use->lineno_o_goto);
4999 }
5000
5001 static void
5002 check_switch_goto (level)
5003      struct binding_level *level;
5004 {
5005   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
5006 }
5007
5008 /* Check that any previously seen jumps to a newly defined label DECL
5009    are OK.  Called by define_label.  */
5010
5011 static void
5012 check_previous_gotos (decl)
5013      tree decl;
5014 {
5015   struct named_label_use_list **usep;
5016
5017   if (! TREE_USED (decl))
5018     return;
5019
5020   for (usep = &named_label_uses; *usep; )
5021     {
5022       struct named_label_use_list *use = *usep;
5023       if (use->label_decl == decl)
5024         {
5025           check_previous_goto (use);
5026           *usep = use->next;
5027         }
5028       else
5029         usep = &(use->next);
5030     }
5031 }
5032
5033 /* Check that a new jump to a label DECL is OK.  Called by
5034    finish_goto_stmt.  */
5035
5036 void
5037 check_goto (decl)
5038      tree decl;
5039 {
5040   int identified = 0;
5041   tree bad;
5042   struct named_label_list *lab;
5043
5044   /* We can't know where a computed goto is jumping.  So we assume
5045      that it's OK.  */
5046   if (! DECL_P (decl))
5047     return;
5048
5049   /* If the label hasn't been defined yet, defer checking.  */
5050   if (! DECL_INITIAL (decl))
5051     {
5052       use_label (decl);
5053       return;
5054     }
5055
5056   for (lab = named_labels; lab; lab = lab->next)
5057     if (decl == lab->label_decl)
5058       break;
5059
5060   /* If the label is not on named_labels it's a gcc local label, so
5061      it must be in an outer scope, so jumping to it is always OK.  */
5062   if (lab == 0)
5063     return;
5064
5065   if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
5066       && !identified)
5067     {
5068       cp_pedwarn_at ("jump to label `%D'", decl);
5069       pedwarn ("  from here");
5070       identified = 1;
5071     }
5072
5073   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5074     {
5075       tree b = TREE_VALUE (bad);
5076       int u = decl_jump_unsafe (b);
5077
5078       if (u > 1 && DECL_ARTIFICIAL (b))
5079         /* Can't skip init of __exception_info.  */
5080         cp_error_at ("  enters catch block", b);
5081       else if (u > 1)
5082         cp_error_at ("  skips initialization of `%#D'", b);
5083       else
5084         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5085     }
5086
5087   if (lab->in_try_scope)
5088     error ("  enters try block");
5089   else if (lab->in_catch_scope)
5090     error ("  enters catch block");
5091 }
5092
5093 /* Define a label, specifying the location in the source file.
5094    Return the LABEL_DECL node for the label, if the definition is valid.
5095    Otherwise return 0.  */
5096
5097 tree
5098 define_label (filename, line, name)
5099      const char *filename;
5100      int line;
5101      tree name;
5102 {
5103   tree decl = lookup_label (name);
5104   struct named_label_list *ent;
5105   register struct binding_level *p;
5106
5107   for (ent = named_labels; ent; ent = ent->next)
5108     if (ent->label_decl == decl)
5109       break;
5110
5111   /* After labels, make any new cleanups in the function go into their
5112      own new (temporary) binding contour.  */
5113   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5114     p->more_cleanups_ok = 0;
5115
5116   if (name == get_identifier ("wchar_t"))
5117     cp_pedwarn ("label named wchar_t");
5118
5119   if (DECL_INITIAL (decl) != NULL_TREE)
5120     {
5121       cp_error ("duplicate label `%D'", decl);
5122       return 0;
5123     }
5124   else
5125     {
5126       /* Mark label as having been defined.  */
5127       DECL_INITIAL (decl) = error_mark_node;
5128       /* Say where in the source.  */
5129       DECL_SOURCE_FILE (decl) = filename;
5130       DECL_SOURCE_LINE (decl) = line;
5131       if (ent)
5132         {
5133           ent->names_in_scope = current_binding_level->names;
5134           ent->binding_level = current_binding_level;
5135         }
5136       check_previous_gotos (decl);
5137       current_function_return_value = NULL_TREE;
5138       return decl;
5139     }
5140 }
5141
5142 struct cp_switch
5143 {
5144   struct binding_level *level;
5145   struct cp_switch *next;
5146   /* The SWITCH_STMT being built.  */
5147   tree switch_stmt;
5148   /* A splay-tree mapping the low element of a case range to the high
5149      element, or NULL_TREE if there is no high element.  Used to
5150      determine whether or not a new case label duplicates an old case
5151      label.  We need a tree, rather than simply a hash table, because
5152      of the GNU case range extension.  */
5153   splay_tree cases;
5154 };
5155
5156 /* A stack of the currently active switch statements.  The innermost
5157    switch statement is on the top of the stack.  There is no need to
5158    mark the stack for garbage collection because it is only active
5159    during the processing of the body of a function, and we never
5160    collect at that point.  */
5161
5162 static struct cp_switch *switch_stack;
5163
5164 /* Called right after a switch-statement condition is parsed.
5165    SWITCH_STMT is the switch statement being parsed.  */
5166
5167 void
5168 push_switch (switch_stmt)
5169      tree switch_stmt;
5170 {
5171   struct cp_switch *p
5172     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5173   p->level = current_binding_level;
5174   p->next = switch_stack;
5175   p->switch_stmt = switch_stmt;
5176   p->cases = splay_tree_new (case_compare, NULL, NULL);
5177   switch_stack = p;
5178 }
5179
5180 void
5181 pop_switch ()
5182 {
5183   struct cp_switch *cs;
5184
5185   cs = switch_stack;
5186   splay_tree_delete (cs->cases);
5187   switch_stack = switch_stack->next;
5188   free (cs);
5189 }
5190
5191 /* Note that we've seen a definition of a case label, and complain if this
5192    is a bad place for one.  */
5193
5194 tree
5195 finish_case_label (low_value, high_value)
5196      tree low_value;
5197      tree high_value;
5198 {
5199   tree cond, r;
5200   register struct binding_level *p;
5201
5202   if (! switch_stack)
5203     {
5204       if (high_value)
5205         error ("case label not within a switch statement");
5206       else if (low_value)
5207         cp_error ("case label `%E' not within a switch statement",
5208                   low_value);
5209       else
5210         error ("`default' label not within a switch statement");
5211       return NULL_TREE;
5212     }
5213
5214   if (processing_template_decl)
5215     {
5216       tree label;
5217
5218       /* For templates, just add the case label; we'll do semantic
5219          analysis at instantiation-time.  */
5220       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5221       return add_stmt (build_case_label (low_value, high_value, label));
5222     }
5223
5224   /* Find the condition on which this switch statement depends.  */
5225   cond = SWITCH_COND (switch_stack->switch_stmt);
5226   if (cond && TREE_CODE (cond) == TREE_LIST)
5227     cond = TREE_VALUE (cond);
5228
5229   r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5230   if (r == error_mark_node)
5231     r = NULL_TREE;
5232
5233   check_switch_goto (switch_stack->level);
5234
5235   /* After labels, make any new cleanups in the function go into their
5236      own new (temporary) binding contour.  */
5237   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5238     p->more_cleanups_ok = 0;
5239   current_function_return_value = NULL_TREE;
5240
5241   return r;
5242 }
5243 \f
5244 /* Return the list of declarations of the current level.
5245    Note that this list is in reverse order unless/until
5246    you nreverse it; and when you do nreverse it, you must
5247    store the result back using `storedecls' or you will lose.  */
5248
5249 tree
5250 getdecls ()
5251 {
5252   return current_binding_level->names;
5253 }
5254
5255 /* Return the list of type-tags (for structs, etc) of the current level.  */
5256
5257 tree
5258 gettags ()
5259 {
5260   return current_binding_level->tags;
5261 }
5262
5263 /* Store the list of declarations of the current level.
5264    This is done for the parameter declarations of a function being defined,
5265    after they are modified in the light of any missing parameters.  */
5266
5267 static void
5268 storedecls (decls)
5269      tree decls;
5270 {
5271   current_binding_level->names = decls;
5272 }
5273
5274 /* Similarly, store the list of tags of the current level.  */
5275
5276 void
5277 storetags (tags)
5278      tree tags;
5279 {
5280   current_binding_level->tags = tags;
5281 }
5282 \f
5283 /* Given NAME, an IDENTIFIER_NODE,
5284    return the structure (or union or enum) definition for that name.
5285    Searches binding levels from BINDING_LEVEL up to the global level.
5286    If THISLEVEL_ONLY is nonzero, searches only the specified context
5287    (but skips any tag-transparent contexts to find one that is
5288    meaningful for tags).
5289    FORM says which kind of type the caller wants;
5290    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5291    If the wrong kind of type is found, and it's not a template, an error is
5292    reported.  */
5293
5294 static tree
5295 lookup_tag (form, name, binding_level, thislevel_only)
5296      enum tree_code form;
5297      tree name;
5298      struct binding_level *binding_level;
5299      int thislevel_only;
5300 {
5301   register struct binding_level *level;
5302   /* Non-zero if, we should look past a template parameter level, even
5303      if THISLEVEL_ONLY.  */
5304   int allow_template_parms_p = 1;
5305
5306   for (level = binding_level; level; level = level->level_chain)
5307     {
5308       register tree tail;
5309       if (ANON_AGGRNAME_P (name))
5310         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5311           {
5312             /* There's no need for error checking here, because
5313                anon names are unique throughout the compilation.  */
5314             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5315               return TREE_VALUE (tail);
5316           }
5317       else if (level->namespace_p)
5318         /* Do namespace lookup. */
5319         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5320           {
5321             tree old = binding_for_name (name, tail);
5322
5323             /* If we just skipped past a template parameter level,
5324                even though THISLEVEL_ONLY, and we find a template
5325                class declaration, then we use the _TYPE node for the
5326                template.  See the example below.  */
5327             if (thislevel_only && !allow_template_parms_p
5328                 && old && BINDING_VALUE (old)
5329                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5330               old = TREE_TYPE (BINDING_VALUE (old));
5331             else
5332               old = BINDING_TYPE (old);
5333
5334             /* If it has an original type, it is a typedef, and we
5335                should not return it.  */
5336             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5337               old = NULL_TREE;
5338             if (old && TREE_CODE (old) != form
5339                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5340               {
5341                 cp_error ("`%#D' redeclared as %C", old, form);
5342                 return NULL_TREE;
5343               }
5344             if (old)
5345               return old;
5346             if (thislevel_only || tail == global_namespace)
5347               return NULL_TREE;
5348           }
5349       else
5350         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5351           {
5352             if (TREE_PURPOSE (tail) == name)
5353               {
5354                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5355                 /* Should tighten this up; it'll probably permit
5356                    UNION_TYPE and a struct template, for example.  */
5357                 if (code != form
5358                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5359                   {
5360                     /* Definition isn't the kind we were looking for.  */
5361                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5362                               form);
5363                     return NULL_TREE;
5364                   }
5365                 return TREE_VALUE (tail);
5366               }
5367           }
5368       if (thislevel_only && ! level->tag_transparent)
5369         {
5370           if (level->template_parms_p && allow_template_parms_p)
5371             {
5372               /* We must deal with cases like this:
5373
5374                    template <class T> struct S;
5375                    template <class T> struct S {};
5376
5377                  When looking up `S', for the second declaration, we
5378                  would like to find the first declaration.  But, we
5379                  are in the pseudo-global level created for the
5380                  template parameters, rather than the (surrounding)
5381                  namespace level.  Thus, we keep going one more level,
5382                  even though THISLEVEL_ONLY is non-zero.  */
5383               allow_template_parms_p = 0;
5384               continue;
5385             }
5386           else
5387             return NULL_TREE;
5388         }
5389     }
5390   return NULL_TREE;
5391 }
5392
5393 #if 0
5394 void
5395 set_current_level_tags_transparency (tags_transparent)
5396      int tags_transparent;
5397 {
5398   current_binding_level->tag_transparent = tags_transparent;
5399 }
5400 #endif
5401
5402 /* Given a type, find the tag that was defined for it and return the tag name.
5403    Otherwise return 0.  However, the value can never be 0
5404    in the cases in which this is used.
5405
5406    C++: If NAME is non-zero, this is the new name to install.  This is
5407    done when replacing anonymous tags with real tag names.  */
5408
5409 static tree
5410 lookup_tag_reverse (type, name)
5411      tree type;
5412      tree name;
5413 {
5414   register struct binding_level *level;
5415
5416   for (level = current_binding_level; level; level = level->level_chain)
5417     {
5418       register tree tail;
5419       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5420         {
5421           if (TREE_VALUE (tail) == type)
5422             {
5423               if (name)
5424                 TREE_PURPOSE (tail) = name;
5425               return TREE_PURPOSE (tail);
5426             }
5427         }
5428     }
5429   return NULL_TREE;
5430 }
5431 \f
5432 /* Look up NAME in the NAMESPACE.  */
5433
5434 tree
5435 lookup_namespace_name (namespace, name)
5436      tree namespace, name;
5437 {
5438   tree val;
5439   tree template_id = NULL_TREE;
5440
5441   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5442
5443   if (TREE_CODE (name) == NAMESPACE_DECL)
5444     /* This happens for A::B<int> when B is a namespace. */
5445     return name;
5446   else if (TREE_CODE (name) == TEMPLATE_DECL)
5447     {
5448       /* This happens for A::B where B is a template, and there are no
5449          template arguments.  */
5450       cp_error ("invalid use of `%D'", name);
5451       return error_mark_node;
5452     }
5453
5454   namespace = ORIGINAL_NAMESPACE (namespace);
5455
5456   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5457     {
5458       template_id = name;
5459       name = TREE_OPERAND (name, 0);
5460       if (TREE_CODE (name) == OVERLOAD)
5461         name = DECL_NAME (OVL_CURRENT (name));
5462       else if (DECL_P (name))
5463         name = DECL_NAME (name);
5464     }
5465
5466   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5467
5468   val = make_node (CPLUS_BINDING);
5469   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5470     return error_mark_node;
5471
5472   if (BINDING_VALUE (val))
5473     {
5474       val = BINDING_VALUE (val);
5475
5476       if (template_id)
5477         {
5478           if (DECL_CLASS_TEMPLATE_P (val))
5479             val = lookup_template_class (val,
5480                                          TREE_OPERAND (template_id, 1),
5481                                          /*in_decl=*/NULL_TREE,
5482                                          /*context=*/NULL_TREE,
5483                                          /*entering_scope=*/0,
5484                                          /*complain=*/1);
5485           else if (DECL_FUNCTION_TEMPLATE_P (val)
5486                    || TREE_CODE (val) == OVERLOAD)
5487             val = lookup_template_function (val,
5488                                             TREE_OPERAND (template_id, 1));
5489           else
5490             {
5491               cp_error ("`%D::%D' is not a template",
5492                         namespace, name);
5493               return error_mark_node;
5494             }
5495         }
5496
5497       /* If we have a single function from a using decl, pull it out.  */
5498       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5499         val = OVL_FUNCTION (val);
5500       return val;
5501     }
5502
5503   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5504   return error_mark_node;
5505 }
5506
5507 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5508
5509 static unsigned long
5510 typename_hash (k)
5511      hash_table_key k;
5512 {
5513   unsigned long hash;
5514   tree t;
5515
5516   t = (tree) k;
5517   hash = (((unsigned long) TYPE_CONTEXT (t))
5518           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5519
5520   return hash;
5521 }
5522
5523 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5524
5525 static bool
5526 typename_compare (k1, k2)
5527      hash_table_key k1;
5528      hash_table_key k2;
5529 {
5530   tree t1;
5531   tree t2;
5532   tree d1;
5533   tree d2;
5534
5535   t1 = (tree) k1;
5536   t2 = (tree) k2;
5537   d1 = TYPE_NAME (t1);
5538   d2 = TYPE_NAME (t2);
5539
5540   return (DECL_NAME (d1) == DECL_NAME (d2)
5541           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5542           && ((TREE_TYPE (t1) != NULL_TREE)
5543               == (TREE_TYPE (t2) != NULL_TREE))
5544           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5545           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5546 }
5547
5548 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5549    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5550    is non-NULL, this type is being created by the implicit typename
5551    extension, and BASE_TYPE is a type named `t' in some base class of
5552    `T' which depends on template parameters.
5553
5554    Returns the new TYPENAME_TYPE.  */
5555
5556 tree
5557 build_typename_type (context, name, fullname, base_type)
5558      tree context;
5559      tree name;
5560      tree fullname;
5561      tree base_type;
5562 {
5563   tree t;
5564   tree d;
5565   struct hash_entry *e;
5566
5567   static struct hash_table ht;
5568
5569   if (!ht.table)
5570     {
5571       static struct hash_table *h = &ht;
5572
5573       hash_table_init (&ht, &hash_newfunc, &typename_hash, &typename_compare);
5574       ggc_add_tree_hash_table_root (&h, 1);
5575     }
5576
5577   /* Build the TYPENAME_TYPE.  */
5578   t = make_aggr_type (TYPENAME_TYPE);
5579   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5580   TYPENAME_TYPE_FULLNAME (t) = fullname;
5581   TREE_TYPE (t) = base_type;
5582
5583   /* Build the corresponding TYPE_DECL.  */
5584   d = build_decl (TYPE_DECL, name, t);
5585   TYPE_NAME (TREE_TYPE (d)) = d;
5586   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5587   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5588   DECL_ARTIFICIAL (d) = 1;
5589
5590   /* See if we already have this type.  */
5591   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5592   if (e)
5593     t = (tree) e->key;
5594   else
5595     /* Insert the type into the table.  */
5596     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5597
5598   return t;
5599 }
5600
5601 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5602    unless an error occurs, in which case error_mark_node is returned.
5603    If COMPLAIN zero, don't complain about any errors that occur.  */
5604
5605 tree
5606 make_typename_type (context, name, complain)
5607      tree context, name;
5608      int complain;
5609 {
5610   tree fullname;
5611
5612   if (TYPE_P (name))
5613     {
5614       if (!(TYPE_LANG_SPECIFIC (name)
5615             && (CLASSTYPE_IS_TEMPLATE (name)
5616                 || CLASSTYPE_USE_TEMPLATE (name))))
5617         name = TYPE_IDENTIFIER (name);
5618       else
5619         /* Create a TEMPLATE_ID_EXPR for the type.  */
5620         name = build_nt (TEMPLATE_ID_EXPR,
5621                          CLASSTYPE_TI_TEMPLATE (name),
5622                          CLASSTYPE_TI_ARGS (name));
5623     }
5624   else if (TREE_CODE (name) == TYPE_DECL)
5625     name = DECL_NAME (name);
5626
5627   fullname = name;
5628
5629   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5630     {
5631       name = TREE_OPERAND (name, 0);
5632       if (TREE_CODE (name) == TEMPLATE_DECL)
5633         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5634     }
5635   if (TREE_CODE (name) != IDENTIFIER_NODE)
5636     my_friendly_abort (2000);
5637
5638   if (TREE_CODE (context) == NAMESPACE_DECL)
5639     {
5640       /* We can get here from typename_sub0 in the explicit_template_type
5641          expansion.  Just fail.  */
5642       if (complain)
5643         cp_error ("no class template named `%#T' in `%#T'",
5644                   name, context);
5645       return error_mark_node;
5646     }
5647
5648   if (! uses_template_parms (context)
5649       || currently_open_class (context))
5650     {
5651       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5652         {
5653           tree tmpl = NULL_TREE;
5654           if (IS_AGGR_TYPE (context))
5655             tmpl = lookup_field (context, name, 0, 0);
5656           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5657             {
5658               if (complain)
5659                 cp_error ("no class template named `%#T' in `%#T'",
5660                           name, context);
5661               return error_mark_node;
5662             }
5663
5664           return lookup_template_class (tmpl,
5665                                         TREE_OPERAND (fullname, 1),
5666                                         NULL_TREE, context,
5667                                         /*entering_scope=*/0,
5668                                         /*complain=*/1);
5669         }
5670       else
5671         {
5672           tree t;
5673
5674           if (!IS_AGGR_TYPE (context))
5675             {
5676               if (complain)
5677                 cp_error ("no type named `%#T' in `%#T'", name, context);
5678               return error_mark_node;
5679             }
5680
5681           t = lookup_field (context, name, 0, 1);
5682           if (t)
5683             return TREE_TYPE (t);
5684         }
5685     }
5686
5687   /* If the CONTEXT is not a template type, then either the field is
5688      there now or its never going to be.  */
5689   if (!uses_template_parms (context))
5690     {
5691       if (complain)
5692         cp_error ("no type named `%#T' in `%#T'", name, context);
5693       return error_mark_node;
5694     }
5695
5696
5697   return build_typename_type (context, name, fullname,  NULL_TREE);
5698 }
5699
5700 /* Select the right _DECL from multiple choices. */
5701
5702 static tree
5703 select_decl (binding, flags)
5704      tree binding;
5705      int flags;
5706 {
5707   tree val;
5708   val = BINDING_VALUE (binding);
5709
5710   /* When we implicitly declare some builtin entity, we mark it
5711      DECL_ANTICIPATED, so that we know to ignore it until it is
5712      really declared.  */
5713   if (val && DECL_P (val)
5714       && DECL_LANG_SPECIFIC (val)
5715       && DECL_ANTICIPATED (val))
5716     return NULL_TREE;
5717
5718   if (LOOKUP_NAMESPACES_ONLY (flags))
5719     {
5720       /* We are not interested in types. */
5721       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5722         return val;
5723       return NULL_TREE;
5724     }
5725
5726   /* If we could have a type and
5727      we have nothing or we need a type and have none.  */
5728   if (BINDING_TYPE (binding)
5729       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5730                    && TREE_CODE (val) != TYPE_DECL)))
5731     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5732   /* Don't return non-types if we really prefer types. */
5733   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5734            && (TREE_CODE (val) != TEMPLATE_DECL
5735                || !DECL_CLASS_TEMPLATE_P (val)))
5736     val = NULL_TREE;
5737
5738   return val;
5739 }
5740
5741 /* Unscoped lookup of a global: iterate over current namespaces,
5742    considering using-directives.  If SPACESP is non-NULL, store a list
5743    of the namespaces we've considered in it.  */
5744
5745 tree
5746 unqualified_namespace_lookup (name, flags, spacesp)
5747      tree name;
5748      int flags;
5749      tree *spacesp;
5750 {
5751   tree b = make_node (CPLUS_BINDING);
5752   tree initial = current_decl_namespace ();
5753   tree scope = initial;
5754   tree siter;
5755   struct binding_level *level;
5756   tree val = NULL_TREE;
5757
5758   if (spacesp)
5759     *spacesp = NULL_TREE;
5760
5761   for (; !val; scope = CP_DECL_CONTEXT (scope))
5762     {
5763       if (spacesp)
5764         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5765       val = binding_for_name (name, scope);
5766
5767       /* Initialize binding for this context. */
5768       BINDING_VALUE (b) = BINDING_VALUE (val);
5769       BINDING_TYPE (b) = BINDING_TYPE (val);
5770
5771       /* Add all _DECLs seen through local using-directives. */
5772       for (level = current_binding_level;
5773            !level->namespace_p;
5774            level = level->level_chain)
5775         if (!lookup_using_namespace (name, b, level->using_directives,
5776                                      scope, flags, spacesp))
5777           /* Give up because of error. */
5778           return error_mark_node;
5779
5780       /* Add all _DECLs seen through global using-directives. */
5781       /* XXX local and global using lists should work equally. */
5782       siter = initial;
5783       while (1)
5784         {
5785           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5786                                        scope, flags, spacesp))
5787             /* Give up because of error. */
5788             return error_mark_node;
5789           if (siter == scope) break;
5790           siter = CP_DECL_CONTEXT (siter);
5791         }
5792
5793       val = select_decl (b, flags);
5794       if (scope == global_namespace)
5795         break;
5796     }
5797   return val;
5798 }
5799
5800 /* Combine prefer_type and namespaces_only into flags.  */
5801
5802 static int
5803 lookup_flags (prefer_type, namespaces_only)
5804   int prefer_type, namespaces_only;
5805 {
5806   if (namespaces_only)
5807     return LOOKUP_PREFER_NAMESPACES;
5808   if (prefer_type > 1)
5809     return LOOKUP_PREFER_TYPES;
5810   if (prefer_type > 0)
5811     return LOOKUP_PREFER_BOTH;
5812   return 0;
5813 }
5814
5815 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5816    ignore it or not.  Subroutine of lookup_name_real.  */
5817
5818 static tree
5819 qualify_lookup (val, flags)
5820      tree val;
5821      int flags;
5822 {
5823   if (val == NULL_TREE)
5824     return val;
5825   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5826     return val;
5827   if ((flags & LOOKUP_PREFER_TYPES)
5828       && (TREE_CODE (val) == TYPE_DECL
5829           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5830               && DECL_CLASS_TEMPLATE_P (val))))
5831     return val;
5832   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5833     return NULL_TREE;
5834   return val;
5835 }
5836
5837 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5838    that.  */
5839
5840 static void
5841 warn_about_implicit_typename_lookup (typename, binding)
5842      tree typename;
5843      tree binding;
5844 {
5845   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5846   tree name = DECL_NAME (typename);
5847
5848   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5849          && CLASSTYPE_TEMPLATE_INFO (subtype)
5850          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5851       && ! (TREE_CODE (binding) == TYPE_DECL
5852             && same_type_p (TREE_TYPE (binding), subtype)))
5853     {
5854       cp_warning ("lookup of `%D' finds `%#D'",
5855                   name, binding);
5856       cp_warning ("  instead of `%D' from dependent base class",
5857                   typename);
5858       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5859                   constructor_name (current_class_type), name);
5860     }
5861 }
5862
5863 /* Look up NAME in the current binding level and its superiors in the
5864    namespace of variables, functions and typedefs.  Return a ..._DECL
5865    node of some kind representing its definition if there is only one
5866    such declaration, or return a TREE_LIST with all the overloaded
5867    definitions if there are many, or return 0 if it is undefined.
5868
5869    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5870    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5871    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5872    Otherwise we prefer non-TYPE_DECLs.
5873
5874    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5875    using IDENTIFIER_CLASS_VALUE.  */
5876
5877 static tree
5878 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5879      tree name;
5880      int prefer_type, nonclass, namespaces_only;
5881 {
5882   tree t;
5883   tree val = NULL_TREE;
5884   int yylex = 0;
5885   tree from_obj = NULL_TREE;
5886   int flags;
5887   int val_is_implicit_typename = 0;
5888
5889   /* Hack: copy flag set by parser, if set. */
5890   if (only_namespace_names)
5891     namespaces_only = 1;
5892
5893   if (prefer_type == -2)
5894     {
5895       extern int looking_for_typename;
5896       tree type = NULL_TREE;
5897
5898       yylex = 1;
5899       prefer_type = looking_for_typename;
5900
5901       flags = lookup_flags (prefer_type, namespaces_only);
5902       /* If the next thing is '<', class templates are types. */
5903       if (looking_for_template)
5904         flags |= LOOKUP_TEMPLATES_EXPECTED;
5905
5906       /* std:: becomes :: for now.  */
5907       if (got_scope && got_scope == fake_std_node)
5908         got_scope = void_type_node;
5909
5910       if (got_scope)
5911         type = got_scope;
5912       else if (got_object != error_mark_node)
5913         type = got_object;
5914
5915       if (type)
5916         {
5917           if (type == error_mark_node)
5918             return error_mark_node;
5919           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5920             type = TREE_TYPE (type);
5921
5922           if (TYPE_P (type))
5923             type = complete_type (type);
5924
5925           if (TREE_CODE (type) == VOID_TYPE)
5926             type = global_namespace;
5927           if (TREE_CODE (type) == NAMESPACE_DECL)
5928             {
5929               val = make_node (CPLUS_BINDING);
5930               flags |= LOOKUP_COMPLAIN;
5931               if (!qualified_lookup_using_namespace (name, type, val, flags))
5932                 return NULL_TREE;
5933               val = select_decl (val, flags);
5934             }
5935           else if (! IS_AGGR_TYPE (type)
5936                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5937                    || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
5938                    || TREE_CODE (type) == TYPENAME_TYPE)
5939             /* Someone else will give an error about this if needed.  */
5940             val = NULL_TREE;
5941           else if (type == current_class_type)
5942             val = IDENTIFIER_CLASS_VALUE (name);
5943           else
5944             {
5945               val = lookup_member (type, name, 0, prefer_type);
5946               type_access_control (type, val);
5947
5948               /* Restore the containing TYPENAME_TYPE if we looked
5949                  through it before.  */
5950               if (got_scope && got_scope != type
5951                   && val && TREE_CODE (val) == TYPE_DECL
5952                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
5953                 TYPE_CONTEXT (TREE_TYPE (val)) = got_scope;
5954             }
5955         }
5956       else
5957         val = NULL_TREE;
5958
5959       if (got_scope)
5960         goto done;
5961       else if (got_object && val)
5962         {
5963           from_obj = val;
5964           val = NULL_TREE;
5965         }
5966     }
5967   else
5968     {
5969       flags = lookup_flags (prefer_type, namespaces_only);
5970       /* If we're not parsing, we need to complain. */
5971       flags |= LOOKUP_COMPLAIN;
5972     }
5973
5974   /* First, look in non-namespace scopes.  */
5975
5976   if (current_class_type == NULL_TREE)
5977     nonclass = 1;
5978
5979   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5980     {
5981       tree binding;
5982
5983       if (!LOCAL_BINDING_P (t) && nonclass)
5984         /* We're not looking for class-scoped bindings, so keep going.  */
5985         continue;
5986
5987       /* If this is the kind of thing we're looking for, we're done.  */
5988       if (qualify_lookup (BINDING_VALUE (t), flags))
5989         binding = BINDING_VALUE (t);
5990       else if ((flags & LOOKUP_PREFER_TYPES)
5991                && qualify_lookup (BINDING_TYPE (t), flags))
5992         binding = BINDING_TYPE (t);
5993       else
5994         binding = NULL_TREE;
5995
5996       /* Handle access control on types from enclosing or base classes.  */
5997       if (binding && ! yylex
5998           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5999         type_access_control (BINDING_LEVEL (t)->this_class, binding);
6000
6001       if (binding
6002           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
6003         {
6004           if (val_is_implicit_typename && !yylex)
6005             warn_about_implicit_typename_lookup (val, binding);
6006           val = binding;
6007           val_is_implicit_typename
6008             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
6009           if (!val_is_implicit_typename)
6010             break;
6011         }
6012     }
6013
6014   /* Now lookup in namespace scopes.  */
6015   if (!val || val_is_implicit_typename)
6016     {
6017       t = unqualified_namespace_lookup (name, flags, 0);
6018       if (t)
6019         {
6020           if (val_is_implicit_typename && !yylex)
6021             warn_about_implicit_typename_lookup (val, t);
6022           val = t;
6023         }
6024     }
6025
6026  done:
6027   if (val)
6028     {
6029       /* This should only warn about types used in qualified-ids.  */
6030       if (from_obj && from_obj != val)
6031         {
6032           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
6033               && TREE_CODE (val) == TYPE_DECL
6034               && ! same_type_p (TREE_TYPE (from_obj), TREE_TYPE (val)))
6035             cp_pedwarn ("\
6036 lookup of `%D' in the scope of `%#T' (`%#D') \
6037 does not match lookup in the current scope (`%#D')",
6038                         name, got_object, from_obj, val);
6039
6040           /* We don't change val to from_obj if got_object depends on
6041              template parms because that breaks implicit typename for
6042              destructor calls.  */
6043           if (! uses_template_parms (got_object))
6044             val = from_obj;
6045         }
6046
6047       /* If we have a single function from a using decl, pull it out.  */
6048       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6049         val = OVL_FUNCTION (val);
6050     }
6051   else if (from_obj)
6052     val = from_obj;
6053
6054   return val;
6055 }
6056
6057 tree
6058 lookup_name_nonclass (name)
6059      tree name;
6060 {
6061   return lookup_name_real (name, 0, 1, 0);
6062 }
6063
6064 tree
6065 lookup_function_nonclass (name, args)
6066      tree name;
6067      tree args;
6068 {
6069   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6070 }
6071
6072 tree
6073 lookup_name_namespace_only (name)
6074      tree name;
6075 {
6076   /* type-or-namespace, nonclass, namespace_only */
6077   return lookup_name_real (name, 1, 1, 1);
6078 }
6079
6080 tree
6081 lookup_name (name, prefer_type)
6082      tree name;
6083      int prefer_type;
6084 {
6085   return lookup_name_real (name, prefer_type, 0, 0);
6086 }
6087
6088 /* Similar to `lookup_name' but look only in the innermost non-class
6089    binding level.  */
6090
6091 tree
6092 lookup_name_current_level (name)
6093      tree name;
6094 {
6095   struct binding_level *b;
6096   tree t = NULL_TREE;
6097
6098   b = current_binding_level;
6099   while (b->parm_flag == 2)
6100     b = b->level_chain;
6101
6102   if (b->namespace_p)
6103     {
6104       t = IDENTIFIER_NAMESPACE_VALUE (name);
6105
6106       /* extern "C" function() */
6107       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6108         t = TREE_VALUE (t);
6109     }
6110   else if (IDENTIFIER_BINDING (name)
6111            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6112     {
6113       while (1)
6114         {
6115           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6116             return IDENTIFIER_VALUE (name);
6117
6118           if (b->keep == 2)
6119             b = b->level_chain;
6120           else
6121             break;
6122         }
6123     }
6124
6125   return t;
6126 }
6127
6128 /* Like lookup_name_current_level, but for types.  */
6129
6130 tree
6131 lookup_type_current_level (name)
6132      tree name;
6133 {
6134   register tree t = NULL_TREE;
6135
6136   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6137
6138   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6139       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6140     {
6141       struct binding_level *b = current_binding_level;
6142       while (1)
6143         {
6144           if (purpose_member (name, b->type_shadowed))
6145             return REAL_IDENTIFIER_TYPE_VALUE (name);
6146           if (b->keep == 2)
6147             b = b->level_chain;
6148           else
6149             break;
6150         }
6151     }
6152
6153   return t;
6154 }
6155
6156 void
6157 begin_only_namespace_names ()
6158 {
6159   only_namespace_names = 1;
6160 }
6161
6162 void
6163 end_only_namespace_names ()
6164 {
6165   only_namespace_names = 0;
6166 }
6167 \f
6168 /* Push the declarations of builtin types into the namespace.
6169    RID_INDEX is the index of the builtin type
6170    in the array RID_POINTERS.  NAME is the name used when looking
6171    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6172
6173 void
6174 record_builtin_type (rid_index, name, type)
6175      enum rid rid_index;
6176      const char *name;
6177      tree type;
6178 {
6179   tree rname = NULL_TREE, tname = NULL_TREE;
6180   tree tdecl = NULL_TREE;
6181
6182   if ((int) rid_index < (int) RID_MAX)
6183     rname = ridpointers[(int) rid_index];
6184   if (name)
6185     tname = get_identifier (name);
6186
6187   TYPE_BUILT_IN (type) = 1;
6188
6189   if (tname)
6190     {
6191       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6192       set_identifier_type_value (tname, NULL_TREE);
6193       if ((int) rid_index < (int) RID_MAX)
6194         /* Built-in types live in the global namespace. */
6195         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6196     }
6197   if (rname != NULL_TREE)
6198     {
6199       if (tname != NULL_TREE)
6200         {
6201           set_identifier_type_value (rname, NULL_TREE);
6202           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6203         }
6204       else
6205         {
6206           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6207           set_identifier_type_value (rname, NULL_TREE);
6208         }
6209     }
6210 }
6211
6212 /* Record one of the standard Java types.
6213  * Declare it as having the given NAME.
6214  * If SIZE > 0, it is the size of one of the integral types;
6215  * otherwise it is the negative of the size of one of the other types.  */
6216
6217 static tree
6218 record_builtin_java_type (name, size)
6219      const char *name;
6220      int size;
6221 {
6222   tree type, decl;
6223   if (size > 0)
6224     type = make_signed_type (size);
6225   else if (size > -32)
6226     { /* "__java_char" or ""__java_boolean". */
6227       type = make_unsigned_type (-size);
6228       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6229     }
6230   else
6231     { /* "__java_float" or ""__java_double". */
6232       type = make_node (REAL_TYPE);
6233       TYPE_PRECISION (type) = - size;
6234       layout_type (type);
6235     }
6236   record_builtin_type (RID_MAX, name, type);
6237   decl = TYPE_NAME (type);
6238
6239   /* Suppress generate debug symbol entries for these types,
6240      since for normal C++ they are just clutter.
6241      However, push_lang_context undoes this if extern "Java" is seen. */
6242   DECL_IGNORED_P (decl) = 1;
6243
6244   TYPE_FOR_JAVA (type) = 1;
6245   return type;
6246 }
6247
6248 /* Push a type into the namespace so that the back-ends ignore it. */
6249
6250 static void
6251 record_unknown_type (type, name)
6252      tree type;
6253      const char *name;
6254 {
6255   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6256   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6257   DECL_IGNORED_P (decl) = 1;
6258   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6259   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6260   TYPE_ALIGN (type) = 1;
6261   TYPE_USER_ALIGN (type) = 0;
6262   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6263 }
6264
6265 /* An string for which we should create an IDENTIFIER_NODE at
6266    startup.  */
6267
6268 typedef struct predefined_identifier
6269 {
6270   /* The name of the identifier.  */
6271   const char *name;
6272   /* The place where the IDENTIFIER_NODE should be stored.  */
6273   tree *node;
6274   /* Non-zero if this is the name of a constructor or destructor.  */
6275   int ctor_or_dtor_p;
6276 } predefined_identifier;
6277
6278 /* Create all the predefined identifiers.  */
6279
6280 static void
6281 initialize_predefined_identifiers ()
6282 {
6283   struct predefined_identifier *pid;
6284
6285   /* A table of identifiers to create at startup.  */
6286   static predefined_identifier predefined_identifiers[] = {
6287     { "C++", &lang_name_cplusplus, 0 },
6288     { "C", &lang_name_c, 0 },
6289     { "Java", &lang_name_java, 0 },
6290     { CTOR_NAME, &ctor_identifier, 1 },
6291     { "__base_ctor", &base_ctor_identifier, 1 },
6292     { "__comp_ctor", &complete_ctor_identifier, 1 },
6293     { DTOR_NAME, &dtor_identifier, 1 },
6294     { "__comp_dtor", &complete_dtor_identifier, 1 },
6295     { "__base_dtor", &base_dtor_identifier, 1 },
6296     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6297     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6298     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6299     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6300     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6301     { "nelts", &nelts_identifier, 0 },
6302     { THIS_NAME, &this_identifier, 0 },
6303     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6304     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6305     { "_vptr", &vptr_identifier, 0 },
6306     { "__vtt_parm", &vtt_parm_identifier, 0 },
6307     { "std", &std_identifier, 0 },
6308     { NULL, NULL, 0 }
6309   };
6310
6311   for (pid = predefined_identifiers; pid->name; ++pid)
6312     {
6313       *pid->node = get_identifier (pid->name);
6314       if (pid->ctor_or_dtor_p)
6315         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6316     }
6317 }
6318
6319 /* Create the predefined scalar types of C,
6320    and some nodes representing standard constants (0, 1, (void *)0).
6321    Initialize the global binding level.
6322    Make definitions for built-in primitive functions.  */
6323
6324 void
6325 init_decl_processing ()
6326 {
6327   tree fields[20];
6328
6329   /* Check to see that the user did not specify an invalid combination
6330      of command-line options.  */
6331   if (!flag_vtable_thunks)
6332     error ("the ABI requires vtable thunks");
6333
6334   /* Create all the identifiers we need.  */
6335   initialize_predefined_identifiers ();
6336
6337   /* Fill in back-end hooks.  */
6338   init_lang_status = &push_cp_function_context;
6339   free_lang_status = &pop_cp_function_context;
6340   mark_lang_status = &mark_cp_function_context;
6341   lang_safe_from_p = &c_safe_from_p;
6342   lang_dump_tree = &cp_dump_tree;
6343   lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
6344
6345   cp_parse_init ();
6346   init_decl2 ();
6347   init_pt ();
6348
6349   /* Create the global variables.  */
6350   push_to_top_level ();
6351
6352   /* Enter the global namespace. */
6353   my_friendly_assert (global_namespace == NULL_TREE, 375);
6354   push_namespace (get_identifier ("::"));
6355   global_namespace = current_namespace;
6356   current_lang_name = NULL_TREE;
6357
6358   /* Adjust various flags based on command-line settings.  */
6359   if (! flag_permissive && ! pedantic)
6360     flag_pedantic_errors = 1;
6361   if (!flag_no_inline)
6362     {
6363       flag_inline_trees = 1;
6364       flag_no_inline = 1;
6365     }
6366   if (flag_inline_functions)
6367     {
6368       flag_inline_trees = 2;
6369       flag_inline_functions = 0;
6370     }
6371
6372   /* In C++, we never create builtin functions whose name does not
6373      begin with `__'.  Users should be using headers to get prototypes
6374      in C++.  It would be nice if we could warn when `-fbuiltin' is
6375      used explicitly, but we do not have that information.  */
6376   flag_no_builtin = 1;
6377
6378   /* Initially, C.  */
6379   current_lang_name = lang_name_c;
6380
6381   current_function_decl = NULL_TREE;
6382   current_binding_level = NULL_BINDING_LEVEL;
6383   free_binding_level = NULL_BINDING_LEVEL;
6384
6385   build_common_tree_nodes (flag_signed_char);
6386
6387   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6388   TREE_TYPE (error_mark_list) = error_mark_node;
6389
6390   /* Make the binding_level structure for global names.  */
6391   pushlevel (0);
6392   global_binding_level = current_binding_level;
6393   /* The global level is the namespace level of ::.  */
6394   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6395   declare_namespace_level ();
6396
6397   /* Create the `std' namespace.  */
6398   if (flag_honor_std)
6399     {
6400       push_namespace (std_identifier);
6401       std_node = current_namespace;
6402       pop_namespace ();
6403       fake_std_node = error_mark_node;
6404     }
6405   else
6406     {
6407       fake_std_node = build_decl (NAMESPACE_DECL,
6408                                   std_identifier,
6409                                   void_type_node);
6410       pushdecl (fake_std_node);
6411     }
6412
6413   c_common_nodes_and_builtins ();
6414
6415   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6416   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6417   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6418   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6419   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6420   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6421   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6422   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6423
6424   integer_two_node = build_int_2 (2, 0);
6425   TREE_TYPE (integer_two_node) = integer_type_node;
6426   integer_three_node = build_int_2 (3, 0);
6427   TREE_TYPE (integer_three_node) = integer_type_node;
6428
6429   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6430   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6431   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6432   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6433   TYPE_PRECISION (boolean_type_node) = 1;
6434   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6435   boolean_false_node = build_int_2 (0, 0);
6436   TREE_TYPE (boolean_false_node) = boolean_type_node;
6437   boolean_true_node = build_int_2 (1, 0);
6438   TREE_TYPE (boolean_true_node) = boolean_type_node;
6439
6440   signed_size_zero_node = build_int_2 (0, 0);
6441   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6442
6443   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6444
6445 #if 0
6446   record_builtin_type (RID_MAX, NULL, string_type_node);
6447 #endif
6448
6449   delta_type_node = ptrdiff_type_node;
6450   vtable_index_type = ptrdiff_type_node;
6451
6452   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6453   lang_type_promotes_to = convert_type_from_ellipsis;
6454
6455   void_ftype_ptr
6456     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6457
6458   /* C++ extensions */
6459
6460   unknown_type_node = make_node (UNKNOWN_TYPE);
6461   record_unknown_type (unknown_type_node, "unknown type");
6462
6463   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6464   TREE_TYPE (unknown_type_node) = unknown_type_node;
6465
6466   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6467
6468   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6469      result.  */
6470   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6471   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6472
6473   if (flag_vtable_thunks)
6474     {
6475       /* Make sure we get a unique function type, so we can give
6476          its pointer type a name.  (This wins for gdb.) */
6477       tree vfunc_type = make_node (FUNCTION_TYPE);
6478       TREE_TYPE (vfunc_type) = integer_type_node;
6479       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6480       layout_type (vfunc_type);
6481
6482       vtable_entry_type = build_pointer_type (vfunc_type);
6483     }
6484   else
6485     {
6486       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6487       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6488                               delta_type_node);
6489       fields[1] = build_decl (FIELD_DECL, index_identifier,
6490                               delta_type_node);
6491       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6492                               ptr_type_node);
6493       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6494                            double_type_node);
6495
6496       /* Make this part of an invisible union.  */
6497       fields[3] = copy_node (fields[2]);
6498       TREE_TYPE (fields[3]) = delta_type_node;
6499       DECL_NAME (fields[3]) = delta2_identifier;
6500       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6501       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6502       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6503       TREE_UNSIGNED (fields[3]) = 0;
6504       TREE_CHAIN (fields[2]) = fields[3];
6505       vtable_entry_type = build_qualified_type (vtable_entry_type,
6506                                                 TYPE_QUAL_CONST);
6507     }
6508   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6509
6510   vtbl_type_node
6511     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6512   layout_type (vtbl_type_node);
6513   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6514   record_builtin_type (RID_MAX, NULL, vtbl_type_node);
6515   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6516   layout_type (vtbl_ptr_type_node);
6517   record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
6518
6519   push_namespace (get_identifier ("__cxxabiv1"));
6520   abi_node = current_namespace;
6521   pop_namespace ();
6522
6523   global_type_node = make_node (LANG_TYPE);
6524   record_unknown_type (global_type_node, "global type");
6525
6526   /* Now, C++.  */
6527   current_lang_name = lang_name_cplusplus;
6528
6529   {
6530     tree bad_alloc_type_node, newtype, deltype;
6531
6532     if (flag_honor_std)
6533       push_namespace (std_identifier);
6534     bad_alloc_type_node = xref_tag
6535       (class_type_node, get_identifier ("bad_alloc"), 1);
6536     if (flag_honor_std)
6537       pop_namespace ();
6538     newtype = build_exception_variant
6539       (ptr_ftype_sizetype, add_exception_specifier
6540        (NULL_TREE, bad_alloc_type_node, -1));
6541     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6542     push_cp_library_fn (NEW_EXPR, newtype);
6543     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6544     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6545     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6546   }
6547
6548   abort_fndecl
6549     = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
6550
6551   /* Perform other language dependent initializations.  */
6552   init_class_processing ();
6553   init_init_processing ();
6554   init_search_processing ();
6555   init_rtti_processing ();
6556
6557   if (flag_exceptions)
6558     init_exception_processing ();
6559
6560   if (! supports_one_only ())
6561     flag_weak = 0;
6562
6563   make_fname_decl = cp_make_fname_decl;
6564   start_fname_decls ();
6565
6566   /* Prepare to check format strings against argument lists.  */
6567   init_function_format_info ();
6568
6569   /* Show we use EH for cleanups.  */
6570   using_eh_for_cleanups ();
6571
6572   valid_lang_attribute = cp_valid_lang_attribute;
6573
6574   /* Maintain consistency.  Perhaps we should just complain if they
6575      say -fwritable-strings?  */
6576   if (flag_writable_strings)
6577     flag_const_strings = 0;
6578
6579   /* Add GC roots for all of our global variables.  */
6580   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6581   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6582   ggc_add_tree_root (&integer_three_node, 1);
6583   ggc_add_tree_root (&integer_two_node, 1);
6584   ggc_add_tree_root (&signed_size_zero_node, 1);
6585   ggc_add_tree_root (&size_one_node, 1);
6586   ggc_add_tree_root (&size_zero_node, 1);
6587   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6588                 mark_binding_level);
6589   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6590   ggc_add_tree_root (&static_ctors, 1);
6591   ggc_add_tree_root (&static_dtors, 1);
6592   ggc_add_tree_root (&lastiddecl, 1);
6593
6594   ggc_add_tree_root (&last_function_parm_tags, 1);
6595   ggc_add_tree_root (&current_function_return_value, 1);
6596   ggc_add_tree_root (&current_function_parm_tags, 1);
6597   ggc_add_tree_root (&last_function_parms, 1);
6598   ggc_add_tree_root (&error_mark_list, 1);
6599
6600   ggc_add_tree_root (&global_namespace, 1);
6601   ggc_add_tree_root (&global_type_node, 1);
6602   ggc_add_tree_root (&anonymous_namespace_name, 1);
6603
6604   ggc_add_tree_root (&got_object, 1);
6605   ggc_add_tree_root (&got_scope, 1);
6606
6607   ggc_add_tree_root (&current_lang_name, 1);
6608   ggc_add_tree_root (&static_aggregates, 1);
6609   ggc_add_tree_root (&free_bindings, 1);
6610 }
6611
6612 /* Generate an initializer for a function naming variable from
6613    NAME. NAME may be NULL, in which case we generate a special
6614    ERROR_MARK node which should be replaced later. */
6615
6616 tree
6617 cp_fname_init (name)
6618      const char *name;
6619 {
6620   tree domain = NULL_TREE;
6621   tree type;
6622   tree init = NULL_TREE;
6623   size_t length = 0;
6624
6625   if (name)
6626     {
6627       length = strlen (name);
6628       domain = build_index_type (size_int (length));
6629       init = build_string (length + 1, name);
6630     }
6631
6632   type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
6633   type = build_cplus_array_type (type, domain);
6634
6635   if (init)
6636     TREE_TYPE (init) = type;
6637   else
6638     /* We don't know the value until instantiation time. Make
6639        something which will be digested now, but replaced later. */
6640     init = build (ERROR_MARK, type);
6641
6642   return init;
6643 }
6644
6645 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6646    decl, NAME is the initialization string and TYPE_DEP indicates whether
6647    NAME depended on the type of the function. We make use of that to detect
6648    __PRETTY_FUNCTION__ inside a template fn. This is being done
6649    lazily at the point of first use, so we musn't push the decl now.  */
6650
6651 static tree
6652 cp_make_fname_decl (id, type_dep)
6653      tree id;
6654      int type_dep;
6655 {
6656   const char *name = (type_dep && processing_template_decl
6657                       ? NULL : fname_as_string (type_dep));
6658   tree init = cp_fname_init (name);
6659   tree decl = build_decl (VAR_DECL, id, TREE_TYPE (init));
6660
6661   /* As we don't push the decl here, we must set the context. */
6662   DECL_CONTEXT (decl) = current_function_decl;
6663   DECL_PRETTY_FUNCTION_P (decl) = type_dep;
6664
6665   TREE_STATIC (decl) = 1;
6666   TREE_READONLY (decl) = 1;
6667   DECL_ARTIFICIAL (decl) = 1;
6668   DECL_INITIAL (decl) = init;
6669
6670   TREE_USED (decl) = 1;
6671
6672   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6673
6674   return decl;
6675 }
6676
6677 /* Entry point for the benefit of c_common_nodes_and_builtins.
6678
6679    Make a definition for a builtin function named NAME and whose data type
6680    is TYPE.  TYPE should be a function type with argument types.
6681
6682    CLASS and CODE tell later passes how to compile calls to this function.
6683    See tree.h for possible values.
6684
6685    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6686    the name to be called if we can't opencode the function.  */
6687
6688 tree
6689 builtin_function (name, type, code, class, libname)
6690      const char *name;
6691      tree type;
6692      int code;
6693      enum built_in_class class;
6694      const char *libname;
6695 {
6696   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6697   DECL_BUILT_IN_CLASS (decl) = class;
6698   DECL_FUNCTION_CODE (decl) = code;
6699
6700   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6701
6702   /* All builtins that don't begin with an `_' should go in the `std'
6703      namespace.  */
6704   if (flag_honor_std && name[0] != '_')
6705     {
6706       push_namespace (std_identifier);
6707       DECL_CONTEXT (decl) = std_node;
6708     }
6709   pushdecl (decl);
6710   if (flag_honor_std && name[0] != '_')
6711     pop_namespace ();
6712
6713   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6714      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6715      function in the namespace.  */
6716   if (libname)
6717     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
6718   make_decl_rtl (decl, NULL);
6719
6720   /* Warn if a function in the namespace for users
6721      is used without an occasion to consider it declared.  */
6722   if (name[0] != '_' || name[1] != '_')
6723     DECL_ANTICIPATED (decl) = 1;
6724
6725   return decl;
6726 }
6727
6728 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6729    function.  Not called directly.  */
6730
6731 static tree
6732 build_library_fn_1 (name, operator_code, type)
6733      tree name;
6734      enum tree_code operator_code;
6735      tree type;
6736 {
6737   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6738   DECL_EXTERNAL (fn) = 1;
6739   TREE_PUBLIC (fn) = 1;
6740   DECL_ARTIFICIAL (fn) = 1;
6741   TREE_NOTHROW (fn) = 1;
6742   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6743   SET_DECL_LANGUAGE (fn, lang_c);
6744   return fn;
6745 }
6746
6747 /* Returns the _DECL for a library function with C linkage.
6748    We assume that such functions never throw; if this is incorrect,
6749    callers should unset TREE_NOTHROW.  */
6750
6751 tree
6752 build_library_fn (name, type)
6753      tree name;
6754      tree type;
6755 {
6756   return build_library_fn_1 (name, ERROR_MARK, type);
6757 }
6758
6759 /* Returns the _DECL for a library function with C++ linkage.  */
6760
6761 static tree
6762 build_cp_library_fn (name, operator_code, type)
6763      tree name;
6764      enum tree_code operator_code;
6765      tree type;
6766 {
6767   tree fn = build_library_fn_1 (name, operator_code, type);
6768   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6769   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6770   SET_DECL_LANGUAGE (fn, lang_cplusplus);
6771   set_mangled_name_for_decl (fn);
6772   return fn;
6773 }
6774
6775 /* Like build_library_fn, but takes a C string instead of an
6776    IDENTIFIER_NODE.  */
6777
6778 tree
6779 build_library_fn_ptr (name, type)
6780      const char *name;
6781      tree type;
6782 {
6783   return build_library_fn (get_identifier (name), type);
6784 }
6785
6786 /* Like build_cp_library_fn, but takes a C string instead of an
6787    IDENTIFIER_NODE.  */
6788
6789 tree
6790 build_cp_library_fn_ptr (name, type)
6791      const char *name;
6792      tree type;
6793 {
6794   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6795 }
6796
6797 /* Like build_library_fn, but also pushes the function so that we will
6798    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6799
6800 tree
6801 push_library_fn (name, type)
6802      tree name, type;
6803 {
6804   tree fn = build_library_fn (name, type);
6805   pushdecl_top_level (fn);
6806   return fn;
6807 }
6808
6809 /* Like build_cp_library_fn, but also pushes the function so that it
6810    will be found by normal lookup.  */
6811
6812 static tree
6813 push_cp_library_fn (operator_code, type)
6814      enum tree_code operator_code;
6815      tree type;
6816 {
6817   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6818                                  operator_code,
6819                                  type);
6820   pushdecl (fn);
6821   return fn;
6822 }
6823
6824 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6825    a FUNCTION_TYPE.  */
6826
6827 tree
6828 push_void_library_fn (name, parmtypes)
6829      tree name, parmtypes;
6830 {
6831   tree type = build_function_type (void_type_node, parmtypes);
6832   return push_library_fn (name, type);
6833 }
6834
6835 /* Like push_library_fn, but also note that this function throws
6836    and does not return.  Used for __throw_foo and the like.  */
6837
6838 tree
6839 push_throw_library_fn (name, type)
6840      tree name, type;
6841 {
6842   tree fn = push_library_fn (name, type);
6843   TREE_THIS_VOLATILE (fn) = 1;
6844   TREE_NOTHROW (fn) = 0;
6845   return fn;
6846 }
6847 \f
6848 /* When we call finish_struct for an anonymous union, we create
6849    default copy constructors and such.  But, an anonymous union
6850    shouldn't have such things; this function undoes the damage to the
6851    anonymous union type T.
6852
6853    (The reason that we create the synthesized methods is that we don't
6854    distinguish `union { int i; }' from `typedef union { int i; } U'.
6855    The first is an anonymous union; the second is just an ordinary
6856    union type.)  */
6857
6858 void
6859 fixup_anonymous_aggr (t)
6860      tree t;
6861 {
6862   tree *q;
6863
6864   /* Wipe out memory of synthesized methods */
6865   TYPE_HAS_CONSTRUCTOR (t) = 0;
6866   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6867   TYPE_HAS_INIT_REF (t) = 0;
6868   TYPE_HAS_CONST_INIT_REF (t) = 0;
6869   TYPE_HAS_ASSIGN_REF (t) = 0;
6870   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6871
6872   /* Splice the implicitly generated functions out of the TYPE_METHODS
6873      list.  */
6874   q = &TYPE_METHODS (t);
6875   while (*q)
6876     {
6877       if (DECL_ARTIFICIAL (*q))
6878         *q = TREE_CHAIN (*q);
6879       else
6880         q = &TREE_CHAIN (*q);
6881     }
6882
6883   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6884   if (TYPE_METHODS (t))
6885     cp_error_at ("an anonymous union cannot have function members", t);
6886
6887   /* Anonymous aggregates cannot have fields with ctors, dtors or complex
6888      assignment operators (because they cannot have these methods themselves).
6889      For anonymous unions this is already checked because they are not allowed
6890      in any union, otherwise we have to check it.  */
6891   if (TREE_CODE (t) != UNION_TYPE)
6892     {
6893       tree field, type;
6894
6895       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
6896         if (TREE_CODE (field) == FIELD_DECL)
6897           {
6898             type = TREE_TYPE (field);
6899             if (CLASS_TYPE_P (type))
6900               {
6901                 if (TYPE_NEEDS_CONSTRUCTING (type))
6902                   cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
6903                                field);
6904                 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6905                   cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
6906                                field);
6907                 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
6908                   cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
6909                                field);
6910               }
6911           }
6912     }
6913 }
6914
6915 /* Make sure that a declaration with no declarator is well-formed, i.e.
6916    just defines a tagged type or anonymous union.
6917
6918    Returns the type defined, if any.  */
6919
6920 tree
6921 check_tag_decl (declspecs)
6922      tree declspecs;
6923 {
6924   int found_type = 0;
6925   int saw_friend = 0;
6926   int saw_typedef = 0;
6927   tree ob_modifier = NULL_TREE;
6928   register tree link;
6929   register tree t = NULL_TREE;
6930
6931   for (link = declspecs; link; link = TREE_CHAIN (link))
6932     {
6933       register tree value = TREE_VALUE (link);
6934
6935       if (TYPE_P (value)
6936           || TREE_CODE (value) == TYPE_DECL
6937           || (TREE_CODE (value) == IDENTIFIER_NODE
6938               && IDENTIFIER_GLOBAL_VALUE (value)
6939               && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value)) == TYPE_DECL))
6940         {
6941           ++found_type;
6942
6943           if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
6944             {
6945               if (! in_system_header)
6946                 cp_pedwarn ("redeclaration of C++ built-in type `%T'", value);
6947               return NULL_TREE;
6948             }
6949
6950           if (TYPE_P (value)
6951               && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
6952                   || TREE_CODE (value) == ENUMERAL_TYPE))
6953             {
6954               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6955               t = value;
6956             }
6957         }
6958       else if (value == ridpointers[(int) RID_TYPEDEF])
6959         saw_typedef = 1;
6960       else if (value == ridpointers[(int) RID_FRIEND])
6961         {
6962           if (current_class_type == NULL_TREE
6963               || current_scope () != current_class_type)
6964             ob_modifier = value;
6965           else
6966             saw_friend = 1;
6967         }
6968       else if (value == ridpointers[(int) RID_STATIC]
6969                || value == ridpointers[(int) RID_EXTERN]
6970                || value == ridpointers[(int) RID_AUTO]
6971                || value == ridpointers[(int) RID_REGISTER]
6972                || value == ridpointers[(int) RID_INLINE]
6973                || value == ridpointers[(int) RID_VIRTUAL]
6974                || value == ridpointers[(int) RID_CONST]
6975                || value == ridpointers[(int) RID_VOLATILE]
6976                || value == ridpointers[(int) RID_EXPLICIT])
6977         ob_modifier = value;
6978     }
6979
6980   if (found_type > 1)
6981     error ("multiple types in one declaration");
6982
6983   if (t == NULL_TREE && ! saw_friend)
6984     pedwarn ("declaration does not declare anything");
6985
6986   /* Check for an anonymous union.  */
6987   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
6988            && TYPE_ANONYMOUS_P (t))
6989     {
6990       /* 7/3 In a simple-declaration, the optional init-declarator-list
6991          can be omitted only when declaring a class (clause 9) or
6992          enumeration (7.2), that is, when the decl-specifier-seq contains
6993          either a class-specifier, an elaborated-type-specifier with
6994          a class-key (9.1), or an enum-specifier.  In these cases and
6995          whenever a class-specifier or enum-specifier is present in the
6996          decl-specifier-seq, the identifiers in these specifiers are among
6997          the names being declared by the declaration (as class-name,
6998          enum-names, or enumerators, depending on the syntax).  In such
6999          cases, and except for the declaration of an unnamed bit-field (9.6),
7000          the decl-specifier-seq shall introduce one or more names into the
7001          program, or shall redeclare a name introduced by a previous
7002          declaration.  [Example:
7003              enum { };            // ill-formed
7004              typedef class { };   // ill-formed
7005          --end example]  */
7006       if (saw_typedef)
7007         {
7008           error ("Missing type-name in typedef-declaration.");
7009           return NULL_TREE;
7010         }
7011       /* Anonymous unions are objects, so they can have specifiers.  */;
7012       SET_ANON_AGGR_TYPE_P (t);
7013
7014       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7015         pedwarn ("ISO C++ prohibits anonymous structs");
7016     }
7017
7018   else if (ob_modifier)
7019     {
7020       if (ob_modifier == ridpointers[(int) RID_INLINE]
7021           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7022         cp_error ("`%D' can only be specified for functions", ob_modifier);
7023       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7024         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7025       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7026         cp_error ("`%D' can only be specified for constructors",
7027                   ob_modifier);
7028       else
7029         cp_error ("`%D' can only be specified for objects and functions",
7030                   ob_modifier);
7031     }
7032
7033   return t;
7034 }
7035
7036 /* Called when a declaration is seen that contains no names to declare.
7037    If its type is a reference to a structure, union or enum inherited
7038    from a containing scope, shadow that tag name for the current scope
7039    with a forward reference.
7040    If its type defines a new named structure or union
7041    or defines an enum, it is valid but we need not do anything here.
7042    Otherwise, it is an error.
7043
7044    C++: may have to grok the declspecs to learn about static,
7045    complain for anonymous unions.  */
7046
7047 void
7048 shadow_tag (declspecs)
7049      tree declspecs;
7050 {
7051   tree t = check_tag_decl (declspecs);
7052
7053   if (t)
7054     maybe_process_partial_specialization (t);
7055
7056   /* This is where the variables in an anonymous union are
7057      declared.  An anonymous union declaration looks like:
7058      union { ... } ;
7059      because there is no declarator after the union, the parser
7060      sends that declaration here.  */
7061   if (t && ANON_AGGR_TYPE_P (t))
7062     {
7063       fixup_anonymous_aggr (t);
7064
7065       if (TYPE_FIELDS (t))
7066         {
7067           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7068                                       NULL_TREE);
7069           finish_anon_union (decl);
7070         }
7071     }
7072 }
7073 \f
7074 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7075
7076 tree
7077 groktypename (typename)
7078      tree typename;
7079 {
7080   if (TREE_CODE (typename) != TREE_LIST)
7081     return typename;
7082   return grokdeclarator (TREE_VALUE (typename),
7083                          TREE_PURPOSE (typename),
7084                          TYPENAME, 0, NULL_TREE);
7085 }
7086
7087 /* Decode a declarator in an ordinary declaration or data definition.
7088    This is called as soon as the type information and variable name
7089    have been parsed, before parsing the initializer if any.
7090    Here we create the ..._DECL node, fill in its type,
7091    and put it on the list of decls for the current context.
7092    The ..._DECL node is returned as the value.
7093
7094    Exception: for arrays where the length is not specified,
7095    the type is left null, to be filled in by `cp_finish_decl'.
7096
7097    Function definitions do not come here; they go to start_function
7098    instead.  However, external and forward declarations of functions
7099    do go through here.  Structure field declarations are done by
7100    grokfield and not through here.  */
7101
7102 tree
7103 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7104      tree declarator, declspecs;
7105      int initialized;
7106      tree attributes, prefix_attributes;
7107 {
7108   register tree decl;
7109   register tree type, tem;
7110   tree context;
7111   extern int have_extern_spec;
7112   extern int used_extern_spec;
7113   tree attrlist;
7114
7115 #if 0
7116   /* See code below that used this.  */
7117   int init_written = initialized;
7118 #endif
7119
7120   /* This should only be done once on the top most decl.  */
7121   if (have_extern_spec && !used_extern_spec)
7122     {
7123       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7124                              declspecs);
7125       used_extern_spec = 1;
7126     }
7127
7128   if (attributes || prefix_attributes)
7129     attrlist = build_tree_list (attributes, prefix_attributes);
7130   else
7131     attrlist = NULL_TREE;
7132
7133   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7134                          attrlist);
7135
7136   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7137     return NULL_TREE;
7138
7139   type = TREE_TYPE (decl);
7140
7141   if (type == error_mark_node)
7142     return NULL_TREE;
7143
7144   context = DECL_CONTEXT (decl);
7145
7146   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7147       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7148     {
7149       /* When parsing the initializer, lookup should use the object's
7150          namespace. */
7151       push_decl_namespace (context);
7152     }
7153
7154   /* We are only interested in class contexts, later. */
7155   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7156     context = NULL_TREE;
7157
7158   if (initialized)
7159     /* Is it valid for this decl to have an initializer at all?
7160        If not, set INITIALIZED to zero, which will indirectly
7161        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7162     switch (TREE_CODE (decl))
7163       {
7164       case TYPE_DECL:
7165         /* typedef foo = bar  means give foo the same type as bar.
7166            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7167            Any other case of an initialization in a TYPE_DECL is an error.  */
7168         if (pedantic || list_length (declspecs) > 1)
7169           {
7170             cp_error ("typedef `%D' is initialized", decl);
7171             initialized = 0;
7172           }
7173         break;
7174
7175       case FUNCTION_DECL:
7176         cp_error ("function `%#D' is initialized like a variable", decl);
7177         initialized = 0;
7178         break;
7179
7180       default:
7181         break;
7182       }
7183
7184   if (initialized)
7185     {
7186       if (! toplevel_bindings_p ()
7187           && DECL_EXTERNAL (decl))
7188         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7189                     decl);
7190       DECL_EXTERNAL (decl) = 0;
7191       if (toplevel_bindings_p ())
7192         TREE_STATIC (decl) = 1;
7193
7194       /* Tell `pushdecl' this is an initialized decl
7195          even though we don't yet have the initializer expression.
7196          Also tell `cp_finish_decl' it may store the real initializer.  */
7197       DECL_INITIAL (decl) = error_mark_node;
7198     }
7199
7200 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7201   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7202 #endif
7203
7204   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7205   cplus_decl_attributes (decl, attributes, prefix_attributes);
7206
7207   if (context && COMPLETE_TYPE_P (complete_type (context)))
7208     {
7209       push_nested_class (context, 2);
7210
7211       if (TREE_CODE (decl) == VAR_DECL)
7212         {
7213           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7214           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7215             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7216           else
7217             {
7218               if (DECL_CONTEXT (field) != context)
7219                 {
7220                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7221                               DECL_CONTEXT (field), DECL_NAME (decl),
7222                               context, DECL_NAME (decl));
7223                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7224                 }
7225               /* Static data member are tricky; an in-class initialization
7226                  still doesn't provide a definition, so the in-class
7227                  declaration will have DECL_EXTERNAL set, but will have an
7228                  initialization.  Thus, duplicate_decls won't warn
7229                  about this situation, and so we check here.  */
7230               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7231                 cp_error ("duplicate initialization of %D", decl);
7232               if (duplicate_decls (decl, field))
7233                 decl = field;
7234             }
7235         }
7236       else
7237         {
7238           tree field = check_classfn (context, decl);
7239           if (field && duplicate_decls (decl, field))
7240             decl = field;
7241         }
7242
7243       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7244       DECL_IN_AGGR_P (decl) = 0;
7245       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7246           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7247         {
7248           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7249           /* [temp.expl.spec] An explicit specialization of a static data
7250              member of a template is a definition if the declaration
7251              includes an initializer; otherwise, it is a declaration.
7252
7253              We check for processing_specialization so this only applies
7254              to the new specialization syntax.  */
7255           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7256             DECL_EXTERNAL (decl) = 1;
7257         }
7258
7259       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7260         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7261                     decl);
7262     }
7263
7264   /* Enter this declaration into the symbol table.  */
7265   tem = maybe_push_decl (decl);
7266
7267   if (processing_template_decl)
7268     tem = push_template_decl (tem);
7269
7270 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7271   /* Tell the back-end to use or not use .common as appropriate.  If we say
7272      -fconserve-space, we want this to save .data space, at the expense of
7273      wrong semantics.  If we say -fno-conserve-space, we want this to
7274      produce errors about redefs; to do this we force variables into the
7275      data segment.  */
7276   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7277 #endif
7278
7279   if (! processing_template_decl)
7280     start_decl_1 (tem);
7281
7282   return tem;
7283 }
7284
7285 void
7286 start_decl_1 (decl)
7287      tree decl;
7288 {
7289   tree type = TREE_TYPE (decl);
7290   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7291
7292   if (type == error_mark_node)
7293     return;
7294
7295   maybe_push_cleanup_level (type);
7296
7297   if (initialized)
7298     /* Is it valid for this decl to have an initializer at all?
7299        If not, set INITIALIZED to zero, which will indirectly
7300        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7301     {
7302       /* Don't allow initializations for incomplete types except for
7303          arrays which might be completed by the initialization.  */
7304       if (COMPLETE_TYPE_P (complete_type (type)))
7305         ;                       /* A complete type is ok.  */
7306       else if (TREE_CODE (type) != ARRAY_TYPE)
7307         {
7308           cp_error ("variable `%#D' has initializer but incomplete type",
7309                     decl);
7310           initialized = 0;
7311           type = TREE_TYPE (decl) = error_mark_node;
7312         }
7313       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7314         {
7315           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7316             cp_error ("elements of array `%#D' have incomplete type", decl);
7317           /* else we already gave an error in start_decl.  */
7318           initialized = 0;
7319         }
7320     }
7321
7322   if (!initialized
7323       && TREE_CODE (decl) != TYPE_DECL
7324       && TREE_CODE (decl) != TEMPLATE_DECL
7325       && type != error_mark_node
7326       && IS_AGGR_TYPE (type)
7327       && ! DECL_EXTERNAL (decl))
7328     {
7329       if ((! processing_template_decl || ! uses_template_parms (type))
7330           && !COMPLETE_TYPE_P (complete_type (type)))
7331         {
7332           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7333                  decl);
7334           /* Change the type so that assemble_variable will give
7335              DECL an rtl we can live with: (mem (const_int 0)).  */
7336           type = TREE_TYPE (decl) = error_mark_node;
7337         }
7338       else
7339         {
7340           /* If any base type in the hierarchy of TYPE needs a constructor,
7341              then we set initialized to 1.  This way any nodes which are
7342              created for the purposes of initializing this aggregate
7343              will live as long as it does.  This is necessary for global
7344              aggregates which do not have their initializers processed until
7345              the end of the file.  */
7346           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7347         }
7348     }
7349
7350   if (! initialized)
7351     DECL_INITIAL (decl) = NULL_TREE;
7352 }
7353
7354 /* Handle initialization of references.
7355    These three arguments are from `cp_finish_decl', and have the
7356    same meaning here that they do there.
7357
7358    Quotes on semantics can be found in ARM 8.4.3.  */
7359
7360 static tree
7361 grok_reference_init (decl, type, init)
7362      tree decl, type, init;
7363 {
7364   tree tmp;
7365
7366   if (init == NULL_TREE)
7367     {
7368       if ((DECL_LANG_SPECIFIC (decl) == 0
7369            || DECL_IN_AGGR_P (decl) == 0)
7370           && ! DECL_THIS_EXTERN (decl))
7371         cp_error ("`%D' declared as reference but not initialized", decl);
7372       return NULL_TREE;
7373     }
7374
7375   if (init == error_mark_node)
7376     return NULL_TREE;
7377
7378   if (TREE_CODE (init) == CONSTRUCTOR)
7379     {
7380       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7381       return NULL_TREE;
7382     }
7383
7384   if (TREE_CODE (init) == TREE_LIST)
7385     init = build_compound_expr (init);
7386
7387   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7388     init = convert_from_reference (init);
7389
7390   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7391       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7392     {
7393       /* Note: default conversion is only called in very special cases.  */
7394       init = default_conversion (init);
7395     }
7396
7397   /* Convert INIT to the reference type TYPE.  This may involve the
7398      creation of a temporary, whose lifetime must be the same as that
7399      of the reference.  If so, a DECL_STMT for the temporary will be
7400      added just after the DECL_STMT for DECL.  That's why we don't set
7401      DECL_INITIAL for local references (instead assigning to them
7402      explicitly); we need to allow the temporary to be initialized
7403      first.  */
7404   tmp = convert_to_reference
7405     (type, init, CONV_IMPLICIT,
7406      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7407      decl);
7408
7409   if (tmp == error_mark_node)
7410     return NULL_TREE;
7411   else if (tmp == NULL_TREE)
7412     {
7413       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7414       return NULL_TREE;
7415     }
7416
7417   if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
7418     return tmp;
7419
7420   if (building_stmt_tree ())
7421     {
7422       /* Initialize the declaration.  */
7423       tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7424       finish_expr_stmt (tmp);
7425     }
7426   else
7427     DECL_INITIAL (decl) = tmp;
7428
7429   return NULL_TREE;
7430 }
7431
7432 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7433    mucking with forces it does not comprehend (i.e. initialization with a
7434    constructor).  If we are at global scope and won't go into COMMON, fill
7435    it in with a dummy CONSTRUCTOR to force the variable into .data;
7436    otherwise we can use error_mark_node.  */
7437
7438 static tree
7439 obscure_complex_init (decl, init)
7440      tree decl, init;
7441 {
7442   if (! flag_no_inline && TREE_STATIC (decl))
7443     {
7444       if (extract_init (decl, init))
7445         return NULL_TREE;
7446     }
7447
7448 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7449   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7450     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7451                                  NULL_TREE);
7452   else
7453 #endif
7454     DECL_INITIAL (decl) = error_mark_node;
7455
7456   return init;
7457 }
7458
7459 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7460    array until we finish parsing the initializer.  If that's the
7461    situation we're in, update DECL accordingly.  */
7462
7463 static void
7464 maybe_deduce_size_from_array_init (decl, init)
7465      tree decl;
7466      tree init;
7467 {
7468   tree type = TREE_TYPE (decl);
7469
7470   if (TREE_CODE (type) == ARRAY_TYPE
7471       && TYPE_DOMAIN (type) == NULL_TREE
7472       && TREE_CODE (decl) != TYPE_DECL)
7473     {
7474       /* do_default is really a C-ism to deal with tentative definitions.
7475          But let's leave it here to ease the eventual merge.  */
7476       int do_default = !DECL_EXTERNAL (decl);
7477       tree initializer = init ? init : DECL_INITIAL (decl);
7478       int failure = complete_array_type (type, initializer, do_default);
7479
7480       if (failure == 1)
7481         cp_error ("initializer fails to determine size of `%D'", decl);
7482
7483       if (failure == 2)
7484         {
7485           if (do_default)
7486             cp_error ("array size missing in `%D'", decl);
7487           /* If a `static' var's size isn't known, make it extern as
7488              well as static, so it does not get allocated.  If it's not
7489              `static', then don't mark it extern; finish_incomplete_decl
7490              will give it a default size and it will get allocated.  */
7491           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7492             DECL_EXTERNAL (decl) = 1;
7493         }
7494
7495       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7496           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7497                               integer_zero_node))
7498         cp_error ("zero-size array `%D'", decl);
7499
7500       layout_decl (decl, 0);
7501     }
7502 }
7503
7504 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7505    any appropriate error messages regarding the layout.  */
7506
7507 static void
7508 layout_var_decl (decl)
7509      tree decl;
7510 {
7511   tree type = TREE_TYPE (decl);
7512 #if 0
7513   tree ttype = target_type (type);
7514 #endif
7515
7516   /* If we haven't already layed out this declaration, do so now.
7517      Note that we must not call complete type for an external object
7518      because it's type might involve templates that we are not
7519      supposed to isntantiate yet.  (And it's perfectly legal to say
7520      `extern X x' for some incomplete type `X'.)  */
7521   if (!DECL_EXTERNAL (decl))
7522     complete_type (type);
7523   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7524     layout_decl (decl, 0);
7525
7526   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7527     {
7528       /* An automatic variable with an incomplete type: that is an error.
7529          Don't talk about array types here, since we took care of that
7530          message in grokdeclarator.  */
7531       cp_error ("storage size of `%D' isn't known", decl);
7532       TREE_TYPE (decl) = error_mark_node;
7533     }
7534 #if 0
7535   /* Keep this code around in case we later want to control debug info
7536      based on whether a type is "used".  (jason 1999-11-11) */
7537
7538   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7539     /* Let debugger know it should output info for this type.  */
7540     note_debug_info_needed (ttype);
7541
7542   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7543     note_debug_info_needed (DECL_CONTEXT (decl));
7544 #endif
7545
7546   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7547       && DECL_SIZE (decl) != NULL_TREE
7548       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7549     {
7550       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7551         constant_expression_warning (DECL_SIZE (decl));
7552       else
7553         cp_error ("storage size of `%D' isn't constant", decl);
7554     }
7555
7556   if (TREE_STATIC (decl)
7557       && !DECL_ARTIFICIAL (decl)
7558       && current_function_decl
7559       && DECL_CONTEXT (decl) == current_function_decl)
7560     push_local_name (decl);
7561 }
7562
7563 /* If a local static variable is declared in an inline function, or if
7564    we have a weak definition, we must endeavor to create only one
7565    instance of the variable at link-time.  */
7566
7567 static void
7568 maybe_commonize_var (decl)
7569      tree decl;
7570 {
7571   /* Static data in a function with comdat linkage also has comdat
7572      linkage.  */
7573   if (TREE_STATIC (decl)
7574       /* Don't mess with __FUNCTION__.  */
7575       && ! DECL_ARTIFICIAL (decl)
7576       && current_function_decl
7577       && DECL_CONTEXT (decl) == current_function_decl
7578       && (DECL_DECLARED_INLINE_P (current_function_decl)
7579           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7580       && TREE_PUBLIC (current_function_decl))
7581     {
7582       /* If flag_weak, we don't need to mess with this, as we can just
7583          make the function weak, and let it refer to its unique local
7584          copy.  This works because we don't allow the function to be
7585          inlined.  */
7586       if (! flag_weak)
7587         {
7588           if (DECL_INTERFACE_KNOWN (current_function_decl))
7589             {
7590               TREE_PUBLIC (decl) = 1;
7591               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7592             }
7593           else if (DECL_INITIAL (decl) == NULL_TREE
7594                    || DECL_INITIAL (decl) == error_mark_node)
7595             {
7596               TREE_PUBLIC (decl) = 1;
7597               DECL_COMMON (decl) = 1;
7598             }
7599           /* else we lose. We can only do this if we can use common,
7600              which we can't if it has been initialized.  */
7601
7602           if (!TREE_PUBLIC (decl))
7603             {
7604               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7605               cp_warning_at ("  you can work around this by removing the initializer", decl);
7606             }
7607         }
7608       else
7609         comdat_linkage (decl);
7610     }
7611   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7612     /* Set it up again; we might have set DECL_INITIAL since the last
7613        time.  */
7614     comdat_linkage (decl);
7615 }
7616
7617 /* Issue an error message if DECL is an uninitialized const variable.  */
7618
7619 static void
7620 check_for_uninitialized_const_var (decl)
7621      tree decl;
7622 {
7623   tree type = TREE_TYPE (decl);
7624
7625   /* ``Unless explicitly declared extern, a const object does not have
7626      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7627      7.1.6 */
7628   if (TREE_CODE (decl) == VAR_DECL
7629       && TREE_CODE (type) != REFERENCE_TYPE
7630       && CP_TYPE_CONST_P (type)
7631       && !TYPE_NEEDS_CONSTRUCTING (type)
7632       && !DECL_INITIAL (decl))
7633     cp_error ("uninitialized const `%D'", decl);
7634 }
7635
7636 /* Verify INIT (the initializer for DECL), and record the
7637    initialization in DECL_INITIAL, if appropriate.  Returns a new
7638    value for INIT.  */
7639
7640 static tree
7641 check_initializer (decl, init)
7642      tree decl;
7643      tree init;
7644 {
7645   tree type;
7646
7647   if (TREE_CODE (decl) == FIELD_DECL)
7648     return init;
7649
7650   type = TREE_TYPE (decl);
7651
7652   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7653   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7654     init = NULL_TREE;
7655
7656   /* Check the initializer.  */
7657   if (init)
7658     {
7659       /* Things that are going to be initialized need to have complete
7660          type.  */
7661       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7662
7663       if (type == error_mark_node)
7664         /* We will have already complained.  */
7665         init = NULL_TREE;
7666       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7667         {
7668           cp_error ("variable-sized object `%D' may not be initialized", decl);
7669           init = NULL_TREE;
7670         }
7671       else if (TREE_CODE (type) == ARRAY_TYPE
7672                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7673         {
7674           cp_error ("elements of array `%#D' have incomplete type", decl);
7675           init = NULL_TREE;
7676         }
7677       else if (!COMPLETE_TYPE_P (type))
7678         {
7679           cp_error ("`%D' has incomplete type", decl);
7680           TREE_TYPE (decl) = error_mark_node;
7681           init = NULL_TREE;
7682         }
7683     }
7684
7685   if (TREE_CODE (decl) == CONST_DECL)
7686     {
7687       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7688
7689       DECL_INITIAL (decl) = init;
7690
7691       my_friendly_assert (init != NULL_TREE, 149);
7692       init = NULL_TREE;
7693     }
7694   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7695     {
7696       init = grok_reference_init (decl, type, init);
7697       if (init)
7698         init = obscure_complex_init (decl, init);
7699     }
7700   else if (init)
7701     {
7702       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7703         {
7704           if (TREE_CODE (type) == ARRAY_TYPE)
7705             init = digest_init (type, init, (tree *) 0);
7706           else if (TREE_CODE (init) == CONSTRUCTOR
7707                    && TREE_HAS_CONSTRUCTOR (init))
7708             {
7709               if (TYPE_NON_AGGREGATE_CLASS (type))
7710                 {
7711                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7712                             decl);
7713                   init = error_mark_node;
7714                 }
7715               else
7716                 goto dont_use_constructor;
7717             }
7718         }
7719       else
7720         {
7721         dont_use_constructor:
7722           if (TREE_CODE (init) != TREE_VEC)
7723             init = store_init_value (decl, init);
7724         }
7725
7726       if (init)
7727         /* We must hide the initializer so that expand_decl
7728            won't try to do something it does not understand.  */
7729         init = obscure_complex_init (decl, init);
7730     }
7731   else if (DECL_EXTERNAL (decl))
7732     ;
7733   else if (TYPE_P (type)
7734            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7735     {
7736       tree core_type = strip_array_types (type);
7737
7738       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7739         {
7740           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7741             cp_error ("structure `%D' with uninitialized const members", decl);
7742           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7743             cp_error ("structure `%D' with uninitialized reference members",
7744                       decl);
7745         }
7746
7747       check_for_uninitialized_const_var (decl);
7748
7749       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7750         init = obscure_complex_init (decl, NULL_TREE);
7751
7752     }
7753   else
7754     check_for_uninitialized_const_var (decl);
7755
7756   return init;
7757 }
7758
7759 /* If DECL is not a local variable, give it RTL.  */
7760
7761 static void
7762 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7763      tree decl;
7764      tree init;
7765      const char *asmspec;
7766 {
7767   int toplev = toplevel_bindings_p ();
7768   int defer_p;
7769
7770   /* Handle non-variables up front.  */
7771   if (TREE_CODE (decl) != VAR_DECL)
7772     {
7773       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7774       return;
7775     }
7776
7777   /* If we see a class member here, it should be a static data
7778      member.  */
7779   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7780     {
7781       my_friendly_assert (TREE_STATIC (decl), 19990828);
7782       /* An in-class declaration of a static data member should be
7783          external; it is only a declaration, and not a definition.  */
7784       if (init == NULL_TREE)
7785         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7786     }
7787
7788   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7789   if (asmspec)
7790     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
7791
7792   /* We don't create any RTL for local variables.  */
7793   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7794     return;
7795
7796   /* We defer emission of local statics until the corresponding
7797      DECL_STMT is expanded.  */
7798   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7799
7800   /* We try to defer namespace-scope static constants so that they are
7801      not emitted into the object file unncessarily.  */
7802   if (!DECL_VIRTUAL_P (decl)
7803       && TREE_READONLY (decl)
7804       && DECL_INITIAL (decl) != NULL_TREE
7805       && DECL_INITIAL (decl) != error_mark_node
7806       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7807       && toplev
7808       && !TREE_PUBLIC (decl))
7809     {
7810       /* Fool with the linkage according to #pragma interface.  */
7811       if (!interface_unknown)
7812         {
7813           TREE_PUBLIC (decl) = 1;
7814           DECL_EXTERNAL (decl) = interface_only;
7815         }
7816
7817       defer_p = 1;
7818     }
7819
7820   /* If we're deferring the variable, we only need to make RTL if
7821      there's an ASMSPEC.  Otherwise, we'll lazily create it later when
7822      we need it.  (There's no way to lazily create RTL for things that
7823      have assembly specs because the information about the specifier
7824      isn't stored in the tree, yet)  */
7825   if (defer_p && asmspec)
7826     make_decl_rtl (decl, asmspec);
7827   /* If we're not deferring, go ahead and assemble the variable.  */
7828   else if (!defer_p)
7829     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7830 }
7831
7832 /* The old ARM scoping rules injected variables declared in the
7833    initialization statement of a for-statement into the surrounding
7834    scope.  We support this usage, in order to be backward-compatible.
7835    DECL is a just-declared VAR_DECL; if necessary inject its
7836    declaration into the surrounding scope.  */
7837
7838 void
7839 maybe_inject_for_scope_var (decl)
7840      tree decl;
7841 {
7842   if (!DECL_NAME (decl))
7843     return;
7844
7845   if (current_binding_level->is_for_scope)
7846     {
7847       struct binding_level *outer
7848         = current_binding_level->level_chain;
7849
7850       /* Check to see if the same name is already bound at the outer
7851          level, either because it was directly declared, or because a
7852          dead for-decl got preserved.  In either case, the code would
7853          not have been valid under the ARM scope rules, so clear
7854          is_for_scope for the current_binding_level.
7855
7856          Otherwise, we need to preserve the temp slot for decl to last
7857          into the outer binding level.  */
7858
7859       tree outer_binding
7860         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7861
7862       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7863           && (TREE_CODE (BINDING_VALUE (outer_binding))
7864               == VAR_DECL)
7865           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7866         {
7867           BINDING_VALUE (outer_binding)
7868             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7869           current_binding_level->is_for_scope = 0;
7870         }
7871       else if (DECL_IN_MEMORY_P (decl))
7872         preserve_temp_slots (DECL_RTL (decl));
7873     }
7874 }
7875
7876 /* Generate code to initialize DECL (a local variable).  */
7877
7878 void
7879 initialize_local_var (decl, init, flags)
7880      tree decl;
7881      tree init;
7882      int flags;
7883 {
7884   tree type = TREE_TYPE (decl);
7885
7886   /* If the type is bogus, don't bother initializing the variable.  */
7887   if (type == error_mark_node)
7888     return;
7889
7890   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7891     {
7892       /* If we used it already as memory, it must stay in memory.  */
7893       DECL_INITIAL (decl) = NULL_TREE;
7894       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7895     }
7896
7897   /* Local statics are handled differently from ordinary automatic
7898      variables.  */
7899   if (TREE_STATIC (decl))
7900     {
7901       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7902           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7903         expand_static_init (decl, init);
7904       return;
7905     }
7906
7907   if (DECL_SIZE (decl) && type != error_mark_node)
7908     {
7909       int already_used;
7910
7911       /* Compute and store the initial value.  */
7912       already_used = TREE_USED (decl) || TREE_USED (type);
7913
7914       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7915         {
7916           int saved_stmts_are_full_exprs_p;
7917
7918           my_friendly_assert (building_stmt_tree (), 20000906);
7919           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7920           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
7921           finish_expr_stmt (build_aggr_init (decl, init, flags));
7922           current_stmt_tree ()->stmts_are_full_exprs_p =
7923             saved_stmts_are_full_exprs_p;
7924         }
7925
7926       /* Set this to 0 so we can tell whether an aggregate which was
7927          initialized was ever used.  Don't do this if it has a
7928          destructor, so we don't complain about the 'resource
7929          allocation is initialization' idiom.  Now set
7930          attribute((unused)) on types so decls of that type will be
7931          marked used. (see TREE_USED, above.)  */
7932       if (TYPE_NEEDS_CONSTRUCTING (type)
7933           && ! already_used
7934           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7935           && DECL_NAME (decl))
7936         TREE_USED (decl) = 0;
7937       else if (already_used)
7938         TREE_USED (decl) = 1;
7939     }
7940 }
7941
7942 /* Generate code to destroy DECL (a local variable).  */
7943
7944 static void
7945 destroy_local_var (decl)
7946      tree decl;
7947 {
7948   tree type = TREE_TYPE (decl);
7949   tree cleanup;
7950
7951   /* Only variables get cleaned up.  */
7952   if (TREE_CODE (decl) != VAR_DECL)
7953     return;
7954
7955   /* And only things with destructors need cleaning up.  */
7956   if (type == error_mark_node
7957       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7958     return;
7959
7960   if (TREE_CODE (decl) == VAR_DECL &&
7961       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7962     /* We don't clean up things that aren't defined in this
7963        translation unit, or that need a static cleanup.  The latter
7964        are handled by finish_file.  */
7965     return;
7966
7967   /* Compute the cleanup.  */
7968   cleanup = maybe_build_cleanup (decl);
7969
7970   /* Record the cleanup required for this declaration.  */
7971   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7972       && cleanup)
7973     finish_decl_cleanup (decl, cleanup);
7974 }
7975
7976 /* Finish processing of a declaration;
7977    install its line number and initial value.
7978    If the length of an array type is not known before,
7979    it must be determined now, from the initial value, or it is an error.
7980
7981    INIT holds the value of an initializer that should be allowed to escape
7982    the normal rules.
7983
7984    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
7985    if the (init) syntax was used.  */
7986
7987 void
7988 cp_finish_decl (decl, init, asmspec_tree, flags)
7989      tree decl, init;
7990      tree asmspec_tree;
7991      int flags;
7992 {
7993   register tree type;
7994   tree ttype = NULL_TREE;
7995   const char *asmspec = NULL;
7996   int was_readonly = 0;
7997
7998   if (! decl)
7999     {
8000       if (init)
8001         error ("assignment (not initialization) in declaration");
8002       return;
8003     }
8004
8005   /* If a name was specified, get the string.  */
8006   if (asmspec_tree)
8007       asmspec = TREE_STRING_POINTER (asmspec_tree);
8008
8009   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8010     {
8011       cp_error ("cannot initialize `%D' to namespace `%D'",
8012                 decl, init);
8013       init = NULL_TREE;
8014     }
8015
8016   if (current_class_type
8017       && CP_DECL_CONTEXT (decl) == current_class_type
8018       && TYPE_BEING_DEFINED (current_class_type)
8019       && (DECL_INITIAL (decl) || init))
8020     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
8021
8022   if (TREE_CODE (decl) == VAR_DECL
8023       && DECL_CONTEXT (decl)
8024       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8025       && DECL_CONTEXT (decl) != current_namespace
8026       && init)
8027     {
8028       /* Leave the namespace of the object. */
8029       pop_decl_namespace ();
8030     }
8031
8032   type = TREE_TYPE (decl);
8033
8034   if (type == error_mark_node)
8035     return;
8036
8037   /* Add this declaration to the statement-tree.  */
8038   if (building_stmt_tree ()
8039       && at_function_scope_p ()
8040       && TREE_CODE (decl) != RESULT_DECL)
8041     add_decl_stmt (decl);
8042
8043   if (TYPE_HAS_MUTABLE_P (type))
8044     TREE_READONLY (decl) = 0;
8045
8046   if (processing_template_decl)
8047     {
8048       if (init && DECL_INITIAL (decl))
8049         DECL_INITIAL (decl) = init;
8050       goto finish_end0;
8051     }
8052
8053   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8054   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8055
8056   /* Take care of TYPE_DECLs up front.  */
8057   if (TREE_CODE (decl) == TYPE_DECL)
8058     {
8059       if (init && DECL_INITIAL (decl))
8060         {
8061           /* typedef foo = bar; store the type of bar as the type of foo.  */
8062           TREE_TYPE (decl) = type = TREE_TYPE (init);
8063           DECL_INITIAL (decl) = init = NULL_TREE;
8064         }
8065       if (type != error_mark_node
8066           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8067         {
8068           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8069             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8070           set_identifier_type_value (DECL_NAME (decl), type);
8071           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8072         }
8073       GNU_xref_decl (current_function_decl, decl);
8074
8075       /* If we have installed this as the canonical typedef for this
8076          type, and that type has not been defined yet, delay emitting
8077          the debug information for it, as we will emit it later.  */
8078       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8079           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8080         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8081
8082       rest_of_decl_compilation (decl, NULL,
8083                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8084       goto finish_end;
8085     }
8086
8087   if (TREE_CODE (decl) != FUNCTION_DECL)
8088     ttype = target_type (type);
8089
8090   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8091       && TYPE_NEEDS_CONSTRUCTING (type))
8092     {
8093       /* Currently, GNU C++ puts constants in text space, making them
8094          impossible to initialize.  In the future, one would hope for
8095          an operating system which understood the difference between
8096          initialization and the running of a program.  */
8097       was_readonly = 1;
8098       TREE_READONLY (decl) = 0;
8099     }
8100
8101   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8102     {
8103       /* This must override the asm specifier which was placed by
8104          grokclassfn.  Lay this out fresh.  */
8105       SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
8106       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8107       make_decl_rtl (decl, asmspec);
8108     }
8109
8110   /* Deduce size of array from initialization, if not already known.  */
8111   maybe_deduce_size_from_array_init (decl, init);
8112   init = check_initializer (decl, init);
8113
8114   GNU_xref_decl (current_function_decl, decl);
8115
8116   if (TREE_CODE (decl) == VAR_DECL)
8117     layout_var_decl (decl);
8118
8119   /* Output the assembler code and/or RTL code for variables and functions,
8120      unless the type is an undefined structure or union.
8121      If not, it will get done when the type is completed.  */
8122   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8123       || TREE_CODE (decl) == RESULT_DECL)
8124     {
8125       if (TREE_CODE (decl) == VAR_DECL)
8126         maybe_commonize_var (decl);
8127
8128       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8129
8130       if (TREE_CODE (type) == FUNCTION_TYPE
8131           || TREE_CODE (type) == METHOD_TYPE)
8132         abstract_virtuals_error (decl,
8133                                  strip_array_types (TREE_TYPE (type)));
8134       else
8135         abstract_virtuals_error (decl, strip_array_types (type));
8136
8137       if (TREE_CODE (decl) == FUNCTION_DECL)
8138         ;
8139       else if (DECL_EXTERNAL (decl)
8140                && ! (DECL_LANG_SPECIFIC (decl)
8141                      && DECL_NOT_REALLY_EXTERN (decl)))
8142         {
8143           if (init)
8144             DECL_INITIAL (decl) = init;
8145         }
8146       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8147         {
8148           /* This is a local declaration.  */
8149           if (doing_semantic_analysis_p ())
8150             maybe_inject_for_scope_var (decl);
8151           /* Initialize the local variable.  But, if we're building a
8152              statement-tree, we'll do the initialization when we
8153              expand the tree.  */
8154           if (processing_template_decl)
8155             {
8156               if (init || DECL_INITIAL (decl) == error_mark_node)
8157                 DECL_INITIAL (decl) = init;
8158             }
8159           else
8160             {
8161               /* If we're not building RTL, then we need to do so
8162                  now.  */
8163               my_friendly_assert (building_stmt_tree (), 20000906);
8164               /* Initialize the variable.  */
8165               initialize_local_var (decl, init, flags);
8166               /* Clean up the variable.  */
8167               destroy_local_var (decl);
8168             }
8169         }
8170       else if (TREE_STATIC (decl) && type != error_mark_node)
8171         {
8172           /* Cleanups for static variables are handled by `finish_file'.  */
8173           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8174               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8175             expand_static_init (decl, init);
8176         }
8177     finish_end0:
8178
8179       /* Undo call to `pushclass' that was done in `start_decl'
8180          due to initialization of qualified member variable.
8181          I.e., Foo::x = 10;  */
8182       {
8183         tree context = CP_DECL_CONTEXT (decl);
8184         if (context
8185             && TYPE_P (context)
8186             && (TREE_CODE (decl) == VAR_DECL
8187                 /* We also have a pushclass done that we need to undo here
8188                    if we're at top level and declare a method.  */
8189                 || TREE_CODE (decl) == FUNCTION_DECL)
8190             /* If size hasn't been set, we're still defining it,
8191                and therefore inside the class body; don't pop
8192                the binding level..  */
8193             && COMPLETE_TYPE_P (context)
8194             && context == current_class_type)
8195           pop_nested_class ();
8196       }
8197     }
8198
8199  finish_end:
8200
8201   if (was_readonly)
8202     TREE_READONLY (decl) = 1;
8203 }
8204
8205 /* This is here for a midend callback from c-common.c */
8206
8207 void
8208 finish_decl (decl, init, asmspec_tree)
8209      tree decl, init;
8210      tree asmspec_tree;
8211 {
8212   cp_finish_decl (decl, init, asmspec_tree, 0);
8213 }
8214
8215 /* Returns a declaration for a VAR_DECL as if:
8216
8217      extern "C" TYPE NAME;
8218
8219    had been seen.  Used to create compiler-generated global
8220    variables.  */
8221
8222 tree
8223 declare_global_var (name, type)
8224      tree name;
8225      tree type;
8226 {
8227   tree decl;
8228
8229   push_to_top_level ();
8230   decl = build_decl (VAR_DECL, name, type);
8231   TREE_PUBLIC (decl) = 1;
8232   DECL_EXTERNAL (decl) = 1;
8233   DECL_ARTIFICIAL (decl) = 1;
8234   pushdecl (decl);
8235   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8236   pop_from_top_level ();
8237
8238   return decl;
8239 }
8240
8241 /* Returns a pointer to the `atexit' function.  Note that if
8242    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8243    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8244
8245 static tree
8246 get_atexit_node ()
8247 {
8248   tree atexit_fndecl;
8249   tree arg_types;
8250   tree fn_type;
8251   tree fn_ptr_type;
8252   const char *name;
8253
8254   if (atexit_node)
8255     return atexit_node;
8256
8257   if (flag_use_cxa_atexit)
8258     {
8259       /* The declaration for `__cxa_atexit' is:
8260
8261            int __cxa_atexit (void (*)(void *), void *, void *)
8262
8263          We build up the argument types and then then function type
8264          itself.  */
8265
8266       /* First, build the pointer-to-function type for the first
8267          argument.  */
8268       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8269       fn_type = build_function_type (void_type_node, arg_types);
8270       fn_ptr_type = build_pointer_type (fn_type);
8271       /* Then, build the rest of the argument types.  */
8272       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8273       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8274       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8275       /* And the final __cxa_atexit type.  */
8276       fn_type = build_function_type (integer_type_node, arg_types);
8277       fn_ptr_type = build_pointer_type (fn_type);
8278       name = "__cxa_atexit";
8279     }
8280   else
8281     {
8282       /* The declaration for `atexit' is:
8283
8284            int atexit (void (*)());
8285
8286          We build up the argument types and then then function type
8287          itself.  */
8288       fn_type = build_function_type (void_type_node, void_list_node);
8289       fn_ptr_type = build_pointer_type (fn_type);
8290       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8291       /* Build the final atexit type.  */
8292       fn_type = build_function_type (integer_type_node, arg_types);
8293       name = "atexit";
8294     }
8295
8296   /* Now, build the function declaration.  */
8297   push_lang_context (lang_name_c);
8298   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8299   mark_used (atexit_fndecl);
8300   pop_lang_context ();
8301   atexit_node = default_conversion (atexit_fndecl);
8302
8303   return atexit_node;
8304 }
8305
8306 /* Returns the __dso_handle VAR_DECL.  */
8307
8308 static tree
8309 get_dso_handle_node ()
8310 {
8311   if (dso_handle_node)
8312     return dso_handle_node;
8313
8314   /* Declare the variable.  */
8315   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8316                                         ptr_type_node);
8317
8318   return dso_handle_node;
8319 }
8320
8321 /* Begin a new function with internal linkage whose job will be simply
8322    to destroy some particular variable.  */
8323
8324 static tree
8325 start_cleanup_fn ()
8326 {
8327   static int counter = 0;
8328   int old_interface_unknown = interface_unknown;
8329   char name[32];
8330   tree parmtypes;
8331   tree fntype;
8332   tree fndecl;
8333
8334   push_to_top_level ();
8335
8336   /* No need to mangle this.  */
8337   push_lang_context (lang_name_c);
8338
8339   interface_unknown = 1;
8340
8341   /* Build the parameter-types.  */
8342   parmtypes = void_list_node;
8343   /* Functions passed to __cxa_atexit take an additional parameter.
8344      We'll just ignore it.  After we implement the new calling
8345      convention for destructors, we can eliminate the use of
8346      additional cleanup functions entirely in the -fnew-abi case.  */
8347   if (flag_use_cxa_atexit)
8348     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8349   /* Build the function type itself.  */
8350   fntype = build_function_type (void_type_node, parmtypes);
8351   /* Build the name of the function.  */
8352   sprintf (name, "__tcf_%d", counter++);
8353   /* Build the function declaration.  */
8354   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8355   /* It's a function with internal linkage, generated by the
8356      compiler.  */
8357   TREE_PUBLIC (fndecl) = 0;
8358   DECL_ARTIFICIAL (fndecl) = 1;
8359   /* Make the function `inline' so that it is only emitted if it is
8360      actually needed.  It is unlikely that it will be inlined, since
8361      it is only called via a function pointer, but we avoid unncessary
8362      emissions this way.  */
8363   DECL_INLINE (fndecl) = 1;
8364   /* Build the parameter.  */
8365   if (flag_use_cxa_atexit)
8366     {
8367       tree parmdecl;
8368
8369       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8370       DECL_CONTEXT (parmdecl) = fndecl;
8371       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8372       TREE_USED (parmdecl) = 1;
8373       DECL_ARGUMENTS (fndecl) = parmdecl;
8374     }
8375
8376   pushdecl (fndecl);
8377   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8378   do_pushlevel ();
8379
8380   interface_unknown = old_interface_unknown;
8381
8382   pop_lang_context ();
8383
8384   return current_function_decl;
8385 }
8386
8387 /* Finish the cleanup function begun by start_cleanup_fn.  */
8388
8389 static void
8390 end_cleanup_fn ()
8391 {
8392   do_poplevel ();
8393
8394   expand_body (finish_function (0));
8395
8396   pop_from_top_level ();
8397 }
8398
8399 /* Generate code to handle the destruction of DECL, an object with
8400    static storage duration.  */
8401
8402 void
8403 register_dtor_fn (decl)
8404      tree decl;
8405 {
8406   tree cleanup;
8407   tree compound_stmt;
8408   tree args;
8409   tree fcall;
8410
8411   int saved_flag_access_control;
8412
8413   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8414     return;
8415
8416   /* Call build_cleanup before we enter the anonymous function so that
8417      any access checks will be done relative to the current scope,
8418      rather than the scope of the anonymous function.  */
8419   build_cleanup (decl);
8420
8421   /* Now start the function.  */
8422   cleanup = start_cleanup_fn ();
8423
8424   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8425      to the original function, rather than the anonymous one.  That
8426      will make the back-end think that nested functions are in use,
8427      which causes confusion.  */
8428   saved_flag_access_control = flag_access_control;
8429   flag_access_control = 0;
8430   fcall = build_cleanup (decl);
8431   flag_access_control = saved_flag_access_control;
8432
8433   /* Create the body of the anonymous function.  */
8434   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8435   finish_expr_stmt (fcall);
8436   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8437   end_cleanup_fn ();
8438
8439   /* Call atexit with the cleanup function.  */
8440   mark_addressable (cleanup);
8441   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8442   if (flag_use_cxa_atexit)
8443     {
8444       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8445       args = tree_cons (NULL_TREE, null_pointer_node, args);
8446       args = tree_cons (NULL_TREE, cleanup, args);
8447     }
8448   else
8449     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8450   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8451 }
8452
8453 void
8454 expand_static_init (decl, init)
8455      tree decl;
8456      tree init;
8457 {
8458   tree oldstatic = value_member (decl, static_aggregates);
8459
8460   if (oldstatic)
8461     {
8462       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8463         cp_error ("multiple initializations given for `%D'", decl);
8464     }
8465   else if (! toplevel_bindings_p ())
8466     {
8467       /* Emit code to perform this initialization but once.  */
8468       tree if_stmt;
8469       tree then_clause;
8470       tree assignment;
8471       tree guard;
8472       tree guard_init;
8473
8474       /* Emit code to perform this initialization but once.  This code
8475          looks like:
8476
8477            static int guard = 0;
8478            if (!guard) {
8479              // Do initialization.
8480              guard = 1;
8481              // Register variable for destruction at end of program.
8482            }
8483
8484          Note that the `temp' variable is only set to 1 *after* the
8485          initialization is complete.  This ensures that an exception,
8486          thrown during the construction, will cause the variable to
8487          reinitialized when we pass through this code again, as per:
8488
8489            [stmt.dcl]
8490
8491            If the initialization exits by throwing an exception, the
8492            initialization is not complete, so it will be tried again
8493            the next time control enters the declaration.
8494
8495          In theory, this process should be thread-safe, too; multiple
8496          threads should not be able to initialize the variable more
8497          than once.  We don't yet attempt to ensure thread-safety.  */
8498
8499       /* Create the guard variable.  */
8500       guard = get_guard (decl);
8501
8502       /* Begin the conditional initialization.  */
8503       if_stmt = begin_if_stmt ();
8504       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8505       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8506
8507       /* Do the initialization itself.  */
8508       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8509           || (init && TREE_CODE (init) == TREE_LIST))
8510         assignment = build_aggr_init (decl, init, 0);
8511       else if (init)
8512         /* The initialization we're doing here is just a bitwise
8513            copy.  */
8514         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8515       else
8516         assignment = NULL_TREE;
8517
8518       /* Once the assignment is complete, set TEMP to 1.  Since the
8519          construction of the static object is complete at this point,
8520          we want to make sure TEMP is set to 1 even if a temporary
8521          constructed during the initialization throws an exception
8522          when it is destroyed.  So, we combine the initialization and
8523          the assignment to TEMP into a single expression, ensuring
8524          that when we call finish_expr_stmt the cleanups will not be
8525          run until after TEMP is set to 1.  */
8526       guard_init = set_guard (guard);
8527       if (assignment)
8528         {
8529           assignment = tree_cons (NULL_TREE, assignment,
8530                                   build_tree_list (NULL_TREE,
8531                                                    guard_init));
8532           assignment = build_compound_expr (assignment);
8533         }
8534       else
8535         assignment = guard_init;
8536       finish_expr_stmt (assignment);
8537
8538       /* Use atexit to register a function for destroying this static
8539          variable.  */
8540       register_dtor_fn (decl);
8541
8542       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8543       finish_then_clause (if_stmt);
8544       finish_if_stmt ();
8545     }
8546   else
8547     static_aggregates = tree_cons (init, decl, static_aggregates);
8548 }
8549
8550 /* Finish the declaration of a catch-parameter.  */
8551
8552 tree
8553 start_handler_parms (declspecs, declarator)
8554      tree declspecs;
8555      tree declarator;
8556 {
8557   tree decl;
8558   if (declspecs)
8559     {
8560       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8561                              1, NULL_TREE);
8562       if (decl == NULL_TREE)
8563         error ("invalid catch parameter");
8564     }
8565   else
8566     decl = NULL_TREE;
8567
8568   return decl;
8569 }
8570
8571 \f
8572 /* Make TYPE a complete type based on INITIAL_VALUE.
8573    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8574    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8575
8576 int
8577 complete_array_type (type, initial_value, do_default)
8578      tree type, initial_value;
8579      int do_default;
8580 {
8581   register tree maxindex = NULL_TREE;
8582   int value = 0;
8583
8584   if (initial_value)
8585     {
8586       /* An array of character type can be initialized from a
8587          brace-enclosed string constant.  */
8588       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8589           && TREE_CODE (initial_value) == CONSTRUCTOR
8590           && CONSTRUCTOR_ELTS (initial_value)
8591           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8592               == STRING_CST)
8593           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8594         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8595
8596       /* Note MAXINDEX is really the maximum index, one less than the
8597          size.  */
8598       if (TREE_CODE (initial_value) == STRING_CST)
8599         {
8600           int eltsize
8601             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8602           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8603                                    / eltsize) - 1, 0);
8604         }
8605       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8606         {
8607           tree elts = CONSTRUCTOR_ELTS (initial_value);
8608
8609           maxindex = ssize_int (-1);
8610           for (; elts; elts = TREE_CHAIN (elts))
8611             {
8612               if (TREE_PURPOSE (elts))
8613                 maxindex = TREE_PURPOSE (elts);
8614               else
8615                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8616             }
8617           maxindex = copy_node (maxindex);
8618         }
8619       else
8620         {
8621           /* Make an error message unless that happened already.  */
8622           if (initial_value != error_mark_node)
8623             value = 1;
8624           else
8625             initial_value = NULL_TREE;
8626
8627           /* Prevent further error messages.  */
8628           maxindex = build_int_2 (0, 0);
8629         }
8630     }
8631
8632   if (!maxindex)
8633     {
8634       if (do_default)
8635         maxindex = build_int_2 (0, 0);
8636       value = 2;
8637     }
8638
8639   if (maxindex)
8640     {
8641       tree itype;
8642       tree domain;
8643
8644       domain = build_index_type (maxindex);
8645       TYPE_DOMAIN (type) = domain;
8646
8647       if (! TREE_TYPE (maxindex))
8648         TREE_TYPE (maxindex) = domain;
8649       if (initial_value)
8650         itype = TREE_TYPE (initial_value);
8651       else
8652         itype = NULL;
8653       if (itype && !TYPE_DOMAIN (itype))
8654         TYPE_DOMAIN (itype) = domain;
8655       /* The type of the main variant should never be used for arrays
8656          of different sizes.  It should only ever be completed with the
8657          size of the array.  */
8658       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8659         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8660     }
8661
8662   /* Lay out the type now that we can get the real answer.  */
8663
8664   layout_type (type);
8665
8666   return value;
8667 }
8668 \f
8669 /* Return zero if something is declared to be a member of type
8670    CTYPE when in the context of CUR_TYPE.  STRING is the error
8671    message to print in that case.  Otherwise, quietly return 1.  */
8672
8673 static int
8674 member_function_or_else (ctype, cur_type, flags)
8675      tree ctype, cur_type;
8676      enum overload_flags flags;
8677 {
8678   if (ctype && ctype != cur_type)
8679     {
8680       if (flags == DTOR_FLAG)
8681         cp_error ("destructor for alien class `%T' cannot be a member",
8682                   ctype);
8683       else
8684         cp_error ("constructor for alien class `%T' cannot be a member",
8685                   ctype);
8686       return 0;
8687     }
8688   return 1;
8689 }
8690 \f
8691 /* Subroutine of `grokdeclarator'.  */
8692
8693 /* Generate errors possibly applicable for a given set of specifiers.
8694    This is for ARM $7.1.2.  */
8695
8696 static void
8697 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8698      tree object;
8699      const char *type;
8700      int virtualp, quals, friendp, raises, inlinep;
8701 {
8702   if (virtualp)
8703     cp_error ("`%D' declared as a `virtual' %s", object, type);
8704   if (inlinep)
8705     cp_error ("`%D' declared as an `inline' %s", object, type);
8706   if (quals)
8707     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8708               object, type);
8709   if (friendp)
8710     cp_error_at ("`%D' declared as a friend", object);
8711   if (raises && !TYPE_PTRFN_P (TREE_TYPE (object))
8712       && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))
8713     cp_error_at ("`%D' declared with an exception specification", object);
8714 }
8715
8716 /* CTYPE is class type, or null if non-class.
8717    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8718    or METHOD_TYPE.
8719    DECLARATOR is the function's name.
8720    VIRTUALP is truthvalue of whether the function is virtual or not.
8721    FLAGS are to be passed through to `grokclassfn'.
8722    QUALS are qualifiers indicating whether the function is `const'
8723    or `volatile'.
8724    RAISES is a list of exceptions that this function can raise.
8725    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8726    not look, and -1 if we should not call `grokclassfn' at all.
8727
8728    Returns `NULL_TREE' if something goes wrong, after issuing
8729    applicable error messages.  */
8730
8731 static tree
8732 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8733             raises, check, friendp, publicp, inlinep, funcdef_flag,
8734             template_count, in_namespace)
8735      tree ctype, type;
8736      tree declarator;
8737      tree orig_declarator;
8738      int virtualp;
8739      enum overload_flags flags;
8740      tree quals, raises;
8741      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8742      tree in_namespace;
8743 {
8744   tree decl;
8745   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8746   int has_default_arg = 0;
8747   tree t;
8748
8749   if (raises)
8750     {
8751       type = build_exception_variant (type, raises);
8752     }
8753
8754   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8755   /* Propagate volatile out from type to decl. */
8756   if (TYPE_VOLATILE (type))
8757     TREE_THIS_VOLATILE (decl) = 1;
8758
8759   /* If this decl has namespace scope, set that up.  */
8760   if (in_namespace)
8761     set_decl_namespace (decl, in_namespace, friendp);
8762   else if (!ctype)
8763     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8764
8765   /* `main' and builtins have implicit 'C' linkage.  */
8766   if ((MAIN_NAME_P (declarator)
8767        || (IDENTIFIER_LENGTH (declarator) > 10
8768            && IDENTIFIER_POINTER (declarator)[0] == '_'
8769            && IDENTIFIER_POINTER (declarator)[1] == '_'
8770            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8771       && current_lang_name == lang_name_cplusplus
8772       && ctype == NULL_TREE
8773       /* NULL_TREE means global namespace.  */
8774       && DECL_CONTEXT (decl) == NULL_TREE)
8775     SET_DECL_LANGUAGE (decl, lang_c);
8776
8777   /* Should probably propagate const out from type to decl I bet (mrs).  */
8778   if (staticp)
8779     {
8780       DECL_STATIC_FUNCTION_P (decl) = 1;
8781       DECL_CONTEXT (decl) = ctype;
8782     }
8783
8784   if (ctype)
8785     DECL_CONTEXT (decl) = ctype;
8786
8787   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8788     {
8789       if (processing_template_decl)
8790         error ("cannot declare `::main' to be a template");
8791       if (inlinep)
8792         error ("cannot declare `::main' to be inline");
8793       if (!publicp)
8794         error ("cannot declare `::main' to be static");
8795       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8796                         integer_type_node))
8797         error ("`main' must return `int'");
8798       inlinep = 0;
8799       publicp = 1;
8800     }
8801
8802   /* Members of anonymous types and local classes have no linkage; make
8803      them internal.  */
8804   /* FIXME what if it gets a name from typedef?  */
8805   if (ctype && (TYPE_ANONYMOUS_P (ctype)
8806                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8807     publicp = 0;
8808
8809   if (publicp)
8810     {
8811       /* [basic.link]: A name with no linkage (notably, the name of a class
8812          or enumeration declared in a local scope) shall not be used to
8813          declare an entity with linkage.
8814
8815          Only check this for public decls for now.  */
8816       t = no_linkage_check (TREE_TYPE (decl));
8817       if (t)
8818         {
8819           if (TYPE_ANONYMOUS_P (t))
8820             {
8821               if (DECL_EXTERN_C_P (decl))
8822                 /* Allow this; it's pretty common in C.  */;
8823               else
8824                 {
8825                   cp_pedwarn ("non-local function `%#D' uses anonymous type",
8826                               decl);
8827                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
8828                     cp_pedwarn_at ("\
8829 `%#D' does not refer to the unqualified type, so it is not used for linkage",
8830                                 TYPE_NAME (t));
8831                 }
8832             }
8833           else
8834             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8835                         decl, t);
8836         }
8837     }
8838
8839   TREE_PUBLIC (decl) = publicp;
8840   if (! publicp)
8841     {
8842       DECL_INTERFACE_KNOWN (decl) = 1;
8843       DECL_NOT_REALLY_EXTERN (decl) = 1;
8844     }
8845
8846   /* If the declaration was declared inline, mark it as such.  */
8847   if (inlinep)
8848     DECL_DECLARED_INLINE_P (decl) = 1;
8849   /* We inline functions that are explicitly declared inline, or, when
8850      the user explicitly asks us to, all functions.  */
8851   if (DECL_DECLARED_INLINE_P (decl) || flag_inline_trees == 2)
8852     DECL_INLINE (decl) = 1;
8853
8854   DECL_EXTERNAL (decl) = 1;
8855   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8856     {
8857       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8858                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8859       quals = NULL_TREE;
8860     }
8861
8862   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8863     grok_op_properties (decl, virtualp, check < 0);
8864
8865   if (ctype && decl_function_context (decl))
8866     DECL_NO_STATIC_CHAIN (decl) = 1;
8867
8868   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8869     if (TREE_PURPOSE (t)
8870         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8871       {
8872         has_default_arg = 1;
8873         break;
8874       }
8875
8876   if (friendp
8877       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8878     {
8879       if (funcdef_flag)
8880         cp_error
8881           ("defining explicit specialization `%D' in friend declaration",
8882            orig_declarator);
8883       else
8884         {
8885           tree fns = TREE_OPERAND (orig_declarator, 0);
8886           tree args = TREE_OPERAND (orig_declarator, 1);
8887
8888           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8889             {
8890               /* Something like `template <class T> friend void f<T>()'.  */
8891               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8892                         orig_declarator);
8893               return NULL_TREE;
8894             }
8895
8896
8897           /* A friend declaration of the form friend void f<>().  Record
8898              the information in the TEMPLATE_ID_EXPR.  */
8899           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8900
8901           if (TREE_CODE (fns) == COMPONENT_REF)
8902             {
8903               /* Due to bison parser ickiness, we will have already looked
8904                  up an operator_name or PFUNCNAME within the current class
8905                  (see template_id in parse.y). If the current class contains
8906                  such a name, we'll get a COMPONENT_REF here. Undo that. */
8907
8908               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
8909                                   == current_class_type, 20001120);
8910               fns = TREE_OPERAND (fns, 1);
8911             }
8912           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
8913                               || TREE_CODE (fns) == LOOKUP_EXPR
8914                               || TREE_CODE (fns) == OVERLOAD, 20001120);
8915           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
8916
8917           if (has_default_arg)
8918             {
8919               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8920                         decl);
8921               return NULL_TREE;
8922             }
8923
8924           if (inlinep)
8925             {
8926               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8927                         decl);
8928               return NULL_TREE;
8929             }
8930         }
8931     }
8932
8933   if (has_default_arg)
8934     add_defarg_fn (decl);
8935
8936   if (funcdef_flag)
8937     /* Make the init_value nonzero so pushdecl knows this is not
8938        tentative.  error_mark_node is replaced later with the BLOCK.  */
8939     DECL_INITIAL (decl) = error_mark_node;
8940
8941   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8942     TREE_NOTHROW (decl) = 1;
8943
8944   /* Caller will do the rest of this.  */
8945   if (check < 0)
8946     return decl;
8947
8948   if (flags == NO_SPECIAL && ctype && constructor_name (ctype) == declarator)
8949     DECL_CONSTRUCTOR_P (decl) = 1;
8950
8951   /* Function gets the ugly name, field gets the nice one.  This call
8952      may change the type of the function (because of default
8953      parameters)!  */
8954   if (ctype != NULL_TREE)
8955     grokclassfn (ctype, decl, flags, quals);
8956
8957   decl = check_explicit_specialization (orig_declarator, decl,
8958                                         template_count,
8959                                         2 * (funcdef_flag != 0) +
8960                                         4 * (friendp != 0));
8961   if (decl == error_mark_node)
8962     return NULL_TREE;
8963
8964   if (ctype != NULL_TREE
8965       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8966       && check)
8967     {
8968       tree old_decl;
8969
8970       old_decl = check_classfn (ctype, decl);
8971
8972       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
8973         /* Because grokfndecl is always supposed to return a
8974            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8975            here.  We depend on our callers to figure out that its
8976            really a template that's being returned.  */
8977         old_decl = DECL_TEMPLATE_RESULT (old_decl);
8978
8979       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
8980           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8981         {
8982           /* Remove the `this' parm added by grokclassfn.
8983              XXX Isn't this done in start_function, too?  */
8984           revert_static_member_fn (decl);
8985           last_function_parms = TREE_CHAIN (last_function_parms);
8986         }
8987       if (old_decl && DECL_ARTIFICIAL (old_decl))
8988         cp_error ("definition of implicitly-declared `%D'", old_decl);
8989
8990       if (old_decl)
8991         {
8992           /* Since we've smashed OLD_DECL to its
8993              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
8994           if (TREE_CODE (decl) == TEMPLATE_DECL)
8995             decl = DECL_TEMPLATE_RESULT (decl);
8996
8997           /* Attempt to merge the declarations.  This can fail, in
8998              the case of some illegal specialization declarations.  */
8999           if (!duplicate_decls (decl, old_decl))
9000             cp_error ("no `%#D' member function declared in class `%T'",
9001                       decl, ctype);
9002           return old_decl;
9003         }
9004     }
9005
9006   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9007     return NULL_TREE;
9008
9009   if (ctype == NULL_TREE || check)
9010     return decl;
9011
9012   if (virtualp)
9013     DECL_VIRTUAL_P (decl) = 1;
9014
9015   return decl;
9016 }
9017
9018 static tree
9019 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9020      tree type;
9021      tree declarator;
9022      RID_BIT_TYPE *specbits_in;
9023      int initialized;
9024      int constp;
9025      tree in_namespace;
9026 {
9027   tree decl;
9028   RID_BIT_TYPE specbits;
9029
9030   specbits = *specbits_in;
9031
9032   if (TREE_CODE (type) == OFFSET_TYPE)
9033     {
9034       /* If you declare a static member so that it
9035          can be initialized, the code will reach here.  */
9036       tree basetype = TYPE_OFFSET_BASETYPE (type);
9037       type = TREE_TYPE (type);
9038       decl = build_lang_decl (VAR_DECL, declarator, type);
9039       DECL_CONTEXT (decl) = basetype;
9040     }
9041   else
9042     {
9043       tree context;
9044
9045       if (in_namespace)
9046         context = in_namespace;
9047       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9048         context = current_namespace;
9049       else
9050         context = NULL_TREE;
9051
9052       /* For namespace-scope variables, declared in a template, we
9053          need the full lang_decl.  The same is true for
9054          namespace-scope variables that do not have C++ language
9055          linkage.  */
9056       if (context
9057           && (processing_template_decl
9058               || current_lang_name != lang_name_cplusplus))
9059         decl = build_lang_decl (VAR_DECL, declarator, type);
9060       else
9061         decl = build_decl (VAR_DECL, declarator, type);
9062
9063       if (context)
9064         set_decl_namespace (decl, context, 0);
9065
9066       context = DECL_CONTEXT (decl);
9067       if (declarator && context && current_lang_name != lang_name_c)
9068         /* We can't mangle lazily here because we don't have any
9069            way to recover whether or not a variable was `extern
9070            "C"' later.  */
9071         mangle_decl (decl);
9072     }
9073
9074   if (in_namespace)
9075     set_decl_namespace (decl, in_namespace, 0);
9076
9077   if (RIDBIT_SETP (RID_EXTERN, specbits))
9078     {
9079       DECL_THIS_EXTERN (decl) = 1;
9080       DECL_EXTERNAL (decl) = !initialized;
9081     }
9082
9083   /* In class context, static means one per class,
9084      public access, and static storage.  */
9085   if (DECL_CLASS_SCOPE_P (decl))
9086     {
9087       TREE_PUBLIC (decl) = 1;
9088       TREE_STATIC (decl) = 1;
9089       DECL_EXTERNAL (decl) = 0;
9090     }
9091   /* At top level, either `static' or no s.c. makes a definition
9092      (perhaps tentative), and absence of `static' makes it public.  */
9093   else if (toplevel_bindings_p ())
9094     {
9095       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9096                             && (DECL_THIS_EXTERN (decl) || ! constp));
9097       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9098     }
9099   /* Not at top level, only `static' makes a static definition.  */
9100   else
9101     {
9102       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9103       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9104     }
9105
9106   if (TREE_PUBLIC (decl))
9107     {
9108       /* [basic.link]: A name with no linkage (notably, the name of a class
9109          or enumeration declared in a local scope) shall not be used to
9110          declare an entity with linkage.
9111
9112          Only check this for public decls for now.  */
9113       tree t = no_linkage_check (TREE_TYPE (decl));
9114       if (t)
9115         {
9116           if (TYPE_ANONYMOUS_P (t))
9117             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9118           else
9119             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9120                         decl, t);
9121         }
9122     }
9123
9124   return decl;
9125 }
9126
9127 /* Create and return a canonical pointer to member function type, for
9128    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9129
9130 tree
9131 build_ptrmemfunc_type (type)
9132      tree type;
9133 {
9134   tree fields[4];
9135   tree t;
9136   tree unqualified_variant = NULL_TREE;
9137
9138   if (type == error_mark_node)
9139     return type;
9140
9141   /* If a canonical type already exists for this type, use it.  We use
9142      this method instead of type_hash_canon, because it only does a
9143      simple equality check on the list of field members.  */
9144
9145   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9146     return t;
9147
9148   /* Make sure that we always have the unqualified pointer-to-member
9149      type first.  */
9150   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9151     unqualified_variant
9152       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9153
9154   t = make_aggr_type (RECORD_TYPE);
9155   /* Let the front-end know this is a pointer to member function...  */
9156   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9157   /* ... and not really an aggregate.  */
9158   SET_IS_AGGR_TYPE (t, 0);
9159
9160   fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9161   fields[1] = build_decl (FIELD_DECL, delta_identifier,
9162                           delta_type_node);
9163   finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9164
9165   /* Zap out the name so that the back-end will give us the debugging
9166      information for this anonymous RECORD_TYPE.  */
9167   TYPE_NAME (t) = NULL_TREE;
9168
9169   /* If this is not the unqualified form of this pointer-to-member
9170      type, set the TYPE_MAIN_VARIANT for this type to be the
9171      unqualified type.  Since they are actually RECORD_TYPEs that are
9172      not variants of each other, we must do this manually.  */
9173   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9174     {
9175       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9176       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9177       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9178       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9179     }
9180
9181   /* Cache this pointer-to-member type so that we can find it again
9182      later.  */
9183   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9184
9185   /* Seems to be wanted.  */
9186   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9187
9188   return t;
9189 }
9190
9191 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9192    Check to see that the definition is valid.  Issue appropriate error
9193    messages.  Return 1 if the definition is particularly bad, or 0
9194    otherwise.  */
9195
9196 int
9197 check_static_variable_definition (decl, type)
9198      tree decl;
9199      tree type;
9200 {
9201   /* Motion 10 at San Diego: If a static const integral data member is
9202      initialized with an integral constant expression, the initializer
9203      may appear either in the declaration (within the class), or in
9204      the definition, but not both.  If it appears in the class, the
9205      member is a member constant.  The file-scope definition is always
9206      required.  */
9207   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9208     {
9209       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9210                 type);
9211       /* If we just return the declaration, crashes will sometimes
9212          occur.  We therefore return void_type_node, as if this was a
9213          friend declaration, to cause callers to completely ignore
9214          this declaration.  */
9215       return 1;
9216     }
9217   else if (!CP_TYPE_CONST_P (type))
9218     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9219               decl);
9220   else if (pedantic && !INTEGRAL_TYPE_P (type))
9221     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9222
9223   return 0;
9224 }
9225
9226 /* Given the SIZE (i.e., number of elements) in an array, compute an
9227    appropriate index type for the array.  If non-NULL, NAME is the
9228    name of the thing being declared.  */
9229
9230 tree
9231 compute_array_index_type (name, size)
9232      tree name;
9233      tree size;
9234 {
9235   tree itype;
9236
9237   /* If this involves a template parameter, it will be a constant at
9238      instantiation time, but we don't know what the value is yet.
9239      Even if no template parameters are involved, we may an expression
9240      that is not a constant; we don't even simplify `1 + 2' when
9241      processing a template.  */
9242   if (processing_template_decl)
9243     {
9244       /* Resolve a qualified reference to an enumerator or static
9245          const data member of ours.  */
9246       if (TREE_CODE (size) == SCOPE_REF
9247           && TREE_OPERAND (size, 0) == current_class_type)
9248         {
9249           tree t = lookup_field (current_class_type,
9250                                  TREE_OPERAND (size, 1), 0, 0);
9251           if (t)
9252             size = t;
9253         }
9254
9255       return build_index_type (build_min (MINUS_EXPR, sizetype,
9256                                           size, integer_one_node));
9257     }
9258
9259   /* The size might be the result of a cast. */
9260   STRIP_TYPE_NOPS (size);
9261
9262   /* It might be a const variable or enumeration constant.  */
9263   size = decl_constant_value (size);
9264
9265   /* The array bound must be an integer type.  */
9266   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9267       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9268       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9269     {
9270       if (name)
9271         cp_error ("size of array `%D' has non-integer type", name);
9272       else
9273         cp_error ("size of array has non-integer type");
9274       size = integer_one_node;
9275     }
9276
9277   /* Normally, the array-bound will be a constant.  */
9278   if (TREE_CODE (size) == INTEGER_CST)
9279     {
9280       /* Check to see if the array bound overflowed.  Make that an
9281          error, no matter how generous we're being.  */
9282       int old_flag_pedantic_errors = flag_pedantic_errors;
9283       int old_pedantic = pedantic;
9284       pedantic = flag_pedantic_errors = 1;
9285       constant_expression_warning (size);
9286       pedantic = old_pedantic;
9287       flag_pedantic_errors = old_flag_pedantic_errors;
9288
9289       /* An array must have a positive number of elements.  */
9290       if (INT_CST_LT (size, integer_zero_node))
9291         {
9292           if (name)
9293             cp_error ("size of array `%D' is negative", name);
9294           else
9295             cp_error ("size of array is negative");
9296           size = integer_one_node;
9297         }
9298       /* Except that an extension we allow zero-sized arrays.  We
9299          always allow them in system headers because glibc uses
9300          them.  */
9301       else if (integer_zerop (size) && pedantic && !in_system_header)
9302         {
9303           if (name)
9304             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9305           else
9306             cp_pedwarn ("ISO C++ forbids zero-size array");
9307         }
9308     }
9309   else if (TREE_CONSTANT (size))
9310     {
9311       /* `(int) &fn' is not a valid array bound.  */
9312       if (name)
9313         cp_error ("size of array `%D' is not an integral constant-expression",
9314                   name);
9315       else
9316         cp_error ("size of array is not an integral constant-expression");
9317     }
9318
9319   /* Compute the index of the largest element in the array.  It is
9320      one less than the number of elements in the array.  */
9321   itype
9322     = fold (cp_build_binary_op (MINUS_EXPR,
9323                                 cp_convert (ssizetype, size),
9324                                 cp_convert (ssizetype,
9325                                             integer_one_node)));
9326
9327   /* Check for variable-sized arrays.  We allow such things as an
9328      extension, even though they are not allowed in ANSI/ISO C++.  */
9329   if (!TREE_CONSTANT (itype))
9330     {
9331       if (pedantic)
9332         {
9333           if (name)
9334             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9335                         name);
9336           else
9337             cp_pedwarn ("ISO C++ forbids variable-size array");
9338         }
9339
9340       /* Create a variable-sized array index type.  */
9341       itype = variable_size (itype);
9342     }
9343   /* Make sure that there was no overflow when creating to a signed
9344      index type.  (For example, on a 32-bit machine, an array with
9345      size 2^32 - 1 is too big.)  */
9346   else if (TREE_OVERFLOW (itype))
9347     {
9348       error ("overflow in array dimension");
9349       TREE_OVERFLOW (itype) = 0;
9350     }
9351
9352   /* Create and return the appropriate index type.  */
9353   return build_index_type (itype);
9354 }
9355
9356 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9357    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9358    with this type.  */
9359
9360 static tree
9361 create_array_type_for_decl (name, type, size)
9362      tree name;
9363      tree type;
9364      tree size;
9365 {
9366   tree itype = NULL_TREE;
9367   const char* error_msg;
9368
9369   /* If things have already gone awry, bail now.  */
9370   if (type == error_mark_node || size == error_mark_node)
9371     return error_mark_node;
9372
9373   /* Assume that everything will go OK.  */
9374   error_msg = NULL;
9375
9376   /* There are some types which cannot be array elements.  */
9377   switch (TREE_CODE (type))
9378     {
9379     case VOID_TYPE:
9380       error_msg = "array of void";
9381       break;
9382
9383     case FUNCTION_TYPE:
9384       error_msg = "array of functions";
9385       break;
9386
9387     case REFERENCE_TYPE:
9388       error_msg = "array of references";
9389       break;
9390
9391     case OFFSET_TYPE:
9392       error_msg = "array of data members";
9393       break;
9394
9395     case METHOD_TYPE:
9396       error_msg = "array of function members";
9397       break;
9398
9399     default:
9400       break;
9401     }
9402
9403   /* If something went wrong, issue an error-message and return.  */
9404   if (error_msg)
9405     {
9406       if (name)
9407         cp_error ("declaration of `%D' as %s", name, error_msg);
9408       else
9409         cp_error ("creating %s", error_msg);
9410
9411       return error_mark_node;
9412     }
9413
9414   /* [dcl.array]
9415
9416      The constant expressions that specify the bounds of the arrays
9417      can be omitted only for the first member of the sequence.  */
9418   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9419     {
9420       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9421                 name);
9422
9423       return error_mark_node;
9424     }
9425
9426   /* Figure out the index type for the array.  */
9427   if (size)
9428     itype = compute_array_index_type (name, size);
9429
9430   return build_cplus_array_type (type, itype);
9431 }
9432
9433 /* Check that it's OK to declare a function with the indicated TYPE.
9434    SFK indicates the kind of special function (if any) that this
9435    function is.  OPTYPE is the type given in a conversion operator
9436    declaration.  Returns the actual return type of the function; that
9437    may be different than TYPE if an error occurs, or for certain
9438    special functions.  */
9439
9440 static tree
9441 check_special_function_return_type (sfk, type, optype)
9442      special_function_kind sfk;
9443      tree type;
9444      tree optype;
9445 {
9446   switch (sfk)
9447     {
9448     case sfk_constructor:
9449       if (type)
9450         cp_error ("return type specification for constructor invalid");
9451
9452       /* In the new ABI constructors do not return a value.  */
9453       type = void_type_node;
9454       break;
9455
9456     case sfk_destructor:
9457       if (type)
9458         cp_error ("return type specification for destructor invalid");
9459       type = void_type_node;
9460       break;
9461
9462     case sfk_conversion:
9463       if (type && !same_type_p (type, optype))
9464         cp_error ("operator `%T' declared to return `%T'", optype, type);
9465       else if (type)
9466         cp_pedwarn ("return type specified for `operator %T'",  optype);
9467       type = optype;
9468       break;
9469
9470     default:
9471       my_friendly_abort (20000408);
9472       break;
9473     }
9474
9475   return type;
9476 }
9477
9478 /* Given declspecs and a declarator,
9479    determine the name and type of the object declared
9480    and construct a ..._DECL node for it.
9481    (In one case we can return a ..._TYPE node instead.
9482     For invalid input we sometimes return 0.)
9483
9484    DECLSPECS is a chain of tree_list nodes whose value fields
9485     are the storage classes and type specifiers.
9486
9487    DECL_CONTEXT says which syntactic context this declaration is in:
9488      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9489      FUNCDEF for a function definition.  Like NORMAL but a few different
9490       error messages in each case.  Return value may be zero meaning
9491       this definition is too screwy to try to parse.
9492      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9493       handle member functions (which have FIELD context).
9494       Return value may be zero meaning this definition is too screwy to
9495       try to parse.
9496      PARM for a parameter declaration (either within a function prototype
9497       or before a function body).  Make a PARM_DECL, or return void_type_node.
9498      CATCHPARM for a parameter declaration before a catch clause.
9499      TYPENAME if for a typename (in a cast or sizeof).
9500       Don't make a DECL node; just return the ..._TYPE node.
9501      FIELD for a struct or union field; make a FIELD_DECL.
9502      BITFIELD for a field with specified width.
9503    INITIALIZED is 1 if the decl has an initializer.
9504
9505    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9506    normal attributes in TREE_PURPOSE, or NULL_TREE.
9507
9508    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9509    It may also be so in the PARM case, for a prototype where the
9510    argument type is specified but not the name.
9511
9512    This function is where the complicated C meanings of `static'
9513    and `extern' are interpreted.
9514
9515    For C++, if there is any monkey business to do, the function which
9516    calls this one must do it, i.e., prepending instance variables,
9517    renaming overloaded function names, etc.
9518
9519    Note that for this C++, it is an error to define a method within a class
9520    which does not belong to that class.
9521
9522    Except in the case where SCOPE_REFs are implicitly known (such as
9523    methods within a class being redundantly qualified),
9524    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9525    (class_name::decl_name).  The caller must also deal with this.
9526
9527    If a constructor or destructor is seen, and the context is FIELD,
9528    then the type gains the attribute TREE_HAS_x.  If such a declaration
9529    is erroneous, NULL_TREE is returned.
9530
9531    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9532    function, these are the qualifiers to give to the `this' pointer. We
9533    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9534
9535    May return void_type_node if the declarator turned out to be a friend.
9536    See grokfield for details.  */
9537
9538 tree
9539 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9540      tree declspecs;
9541      tree declarator;
9542      enum decl_context decl_context;
9543      int initialized;
9544      tree attrlist;
9545 {
9546   RID_BIT_TYPE specbits;
9547   int nclasses = 0;
9548   tree spec;
9549   tree type = NULL_TREE;
9550   int longlong = 0;
9551   int constp;
9552   int restrictp;
9553   int volatilep;
9554   int type_quals;
9555   int virtualp, explicitp, friendp, inlinep, staticp;
9556   int explicit_int = 0;
9557   int explicit_char = 0;
9558   int defaulted_int = 0;
9559   tree typedef_decl = NULL_TREE;
9560   const char *name;
9561   tree typedef_type = NULL_TREE;
9562   int funcdef_flag = 0;
9563   enum tree_code innermost_code = ERROR_MARK;
9564   int bitfield = 0;
9565 #if 0
9566   /* See the code below that used this.  */
9567   tree decl_machine_attr = NULL_TREE;
9568 #endif
9569   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9570      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9571   tree init = NULL_TREE;
9572
9573   /* Keep track of what sort of function is being processed
9574      so that we can warn about default return values, or explicit
9575      return values which do not match prescribed defaults.  */
9576   special_function_kind sfk = sfk_none;
9577
9578   tree dname = NULL_TREE;
9579   tree ctype = current_class_type;
9580   tree ctor_return_type = NULL_TREE;
9581   enum overload_flags flags = NO_SPECIAL;
9582   tree quals = NULL_TREE;
9583   tree raises = NULL_TREE;
9584   int template_count = 0;
9585   tree in_namespace = NULL_TREE;
9586   tree inner_attrs;
9587   int ignore_attrs;
9588
9589   RIDBIT_RESET_ALL (specbits);
9590   if (decl_context == FUNCDEF)
9591     funcdef_flag = 1, decl_context = NORMAL;
9592   else if (decl_context == MEMFUNCDEF)
9593     funcdef_flag = -1, decl_context = FIELD;
9594   else if (decl_context == BITFIELD)
9595     bitfield = 1, decl_context = FIELD;
9596
9597   /* Look inside a declarator for the name being declared
9598      and get it as a string, for an error message.  */
9599   {
9600     tree *next = &declarator;
9601     register tree decl;
9602     name = NULL;
9603
9604     while (next && *next)
9605       {
9606         decl = *next;
9607         switch (TREE_CODE (decl))
9608           {
9609           case TREE_LIST:
9610             /* For attributes.  */
9611             next = &TREE_VALUE (decl);
9612             break;
9613
9614           case COND_EXPR:
9615             ctype = NULL_TREE;
9616             next = &TREE_OPERAND (decl, 0);
9617             break;
9618
9619           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9620             {
9621               tree name = TREE_OPERAND (decl, 0);
9622               tree rename = NULL_TREE;
9623
9624               my_friendly_assert (flags == NO_SPECIAL, 152);
9625               flags = DTOR_FLAG;
9626               sfk = sfk_destructor;
9627               if (TREE_CODE (name) == TYPE_DECL)
9628                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9629               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9630               if (ctype == NULL_TREE)
9631                 {
9632                   if (current_class_type == NULL_TREE)
9633                     {
9634                       error ("destructors must be member functions");
9635                       flags = NO_SPECIAL;
9636                     }
9637                   else
9638                     {
9639                       tree t = constructor_name (current_class_name);
9640                       if (t != name)
9641                         rename = t;
9642                     }
9643                 }
9644               else
9645                 {
9646                   tree t = constructor_name (ctype);
9647                   if (t != name)
9648                     rename = t;
9649                 }
9650
9651               if (rename)
9652                 {
9653                   cp_error ("destructor `%T' must match class name `%T'",
9654                             name, rename);
9655                   TREE_OPERAND (decl, 0) = rename;
9656                 }
9657               next = &name;
9658             }
9659             break;
9660
9661           case ADDR_EXPR:       /* C++ reference declaration */
9662             /* Fall through. */
9663           case ARRAY_REF:
9664           case INDIRECT_REF:
9665             ctype = NULL_TREE;
9666             innermost_code = TREE_CODE (decl);
9667             next = &TREE_OPERAND (decl, 0);
9668             break;
9669
9670           case CALL_EXPR:
9671             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9672               {
9673                 /* This is actually a variable declaration using
9674                    constructor syntax.  We need to call start_decl and
9675                    cp_finish_decl so we can get the variable
9676                    initialized...  */
9677
9678                 tree attributes, prefix_attributes;
9679
9680                 *next = TREE_OPERAND (decl, 0);
9681                 init = CALL_DECLARATOR_PARMS (decl);
9682
9683                 if (attrlist)
9684                   {
9685                     attributes = TREE_PURPOSE (attrlist);
9686                     prefix_attributes = TREE_VALUE (attrlist);
9687                   }
9688                 else
9689                   {
9690                     attributes = NULL_TREE;
9691                     prefix_attributes = NULL_TREE;
9692                   }
9693
9694                 decl = start_decl (declarator, declspecs, 1,
9695                                    attributes, prefix_attributes);
9696                 decl_type_access_control (decl);
9697                 if (decl)
9698                   {
9699                     /* Look for __unused__ attribute */
9700                     if (TREE_USED (TREE_TYPE (decl)))
9701                       TREE_USED (decl) = 1;
9702                     finish_decl (decl, init, NULL_TREE);
9703                   }
9704                 else
9705                   cp_error ("invalid declarator");
9706                 return 0;
9707               }
9708             innermost_code = TREE_CODE (decl);
9709             if (decl_context == FIELD && ctype == NULL_TREE)
9710               ctype = current_class_type;
9711             if (ctype
9712                 && TREE_OPERAND (decl, 0)
9713                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9714                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9715                          == constructor_name_full (ctype))
9716                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9717                             == constructor_name (ctype)))))
9718               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9719             next = &TREE_OPERAND (decl, 0);
9720             decl = *next;
9721             if (ctype != NULL_TREE
9722                 && decl != NULL_TREE && flags != DTOR_FLAG
9723                 && decl == constructor_name (ctype))
9724               {
9725                 sfk = sfk_constructor;
9726                 ctor_return_type = ctype;
9727               }
9728             ctype = NULL_TREE;
9729             break;
9730
9731           case TEMPLATE_ID_EXPR:
9732               {
9733                 tree fns = TREE_OPERAND (decl, 0);
9734
9735                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9736                   fns = TREE_OPERAND (fns, 0);
9737
9738                 dname = fns;
9739                 if (TREE_CODE (dname) == COMPONENT_REF)
9740                   dname = TREE_OPERAND (dname, 1);
9741                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9742                   {
9743                     my_friendly_assert (is_overloaded_fn (dname),
9744                                         19990331);
9745                     dname = DECL_NAME (get_first_fn (dname));
9746                   }
9747               }
9748           /* Fall through. */
9749
9750           case IDENTIFIER_NODE:
9751             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9752               dname = decl;
9753
9754             next = 0;
9755
9756             if (C_IS_RESERVED_WORD (dname))
9757               {
9758                 cp_error ("declarator-id missing; using reserved word `%D'",
9759                           dname);
9760                 name = IDENTIFIER_POINTER (dname);
9761               }
9762             else if (!IDENTIFIER_TYPENAME_P (dname))
9763               name = IDENTIFIER_POINTER (dname);
9764             else
9765               {
9766                 my_friendly_assert (flags == NO_SPECIAL, 154);
9767                 flags = TYPENAME_FLAG;
9768                 ctor_return_type = TREE_TYPE (dname);
9769                 sfk = sfk_conversion;
9770                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9771                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9772                         == TYPE_DECL))
9773                   name = IDENTIFIER_POINTER (dname);
9774                 else
9775                   name = "<invalid operator>";
9776               }
9777             break;
9778
9779             /* C++ extension */
9780           case SCOPE_REF:
9781             {
9782               /* Perform error checking, and decide on a ctype.  */
9783               tree cname = TREE_OPERAND (decl, 0);
9784               if (cname == NULL_TREE)
9785                 ctype = NULL_TREE;
9786               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9787                 {
9788                   ctype = NULL_TREE;
9789                   in_namespace = TREE_OPERAND (decl, 0);
9790                   TREE_OPERAND (decl, 0) = NULL_TREE;
9791                 }
9792               else if (! is_aggr_type (cname, 1))
9793                 TREE_OPERAND (decl, 0) = NULL_TREE;
9794               /* Must test TREE_OPERAND (decl, 1), in case user gives
9795                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9796               else if (TREE_OPERAND (decl, 1)
9797                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9798                 ctype = cname;
9799               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9800                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9801                 {
9802                   cp_error ("`%T::%D' is not a valid declarator", cname,
9803                             TREE_OPERAND (decl, 1));
9804                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9805                             cname, TREE_OPERAND (decl, 1));
9806                   return void_type_node;
9807                 }
9808               else if (ctype == NULL_TREE)
9809                 ctype = cname;
9810               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9811                 TREE_OPERAND (decl, 0) = ctype;
9812               else
9813                 {
9814                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9815                     {
9816                       cp_error ("type `%T' is not derived from type `%T'",
9817                                 cname, ctype);
9818                       TREE_OPERAND (decl, 0) = NULL_TREE;
9819                     }
9820                   else
9821                     ctype = cname;
9822                 }
9823
9824               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9825                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9826                        == constructor_name_full (ctype))
9827                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9828                           == constructor_name (ctype))))
9829                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9830               next = &TREE_OPERAND (decl, 1);
9831               decl = *next;
9832               if (ctype)
9833                 {
9834                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9835                       && constructor_name (ctype) == decl)
9836                     {
9837                       sfk = sfk_constructor;
9838                       ctor_return_type = ctype;
9839                     }
9840                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9841                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9842                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9843                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9844                     {
9845                       sfk = sfk_destructor;
9846                       ctor_return_type = ctype;
9847                       flags = DTOR_FLAG;
9848                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9849                       next = &TREE_OPERAND (decl, 0);
9850                     }
9851                 }
9852             }
9853             break;
9854
9855           case ERROR_MARK:
9856             next = 0;
9857             break;
9858
9859           case TYPE_DECL:
9860             /* Parse error puts this typespec where
9861                a declarator should go.  */
9862             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9863             if (TREE_TYPE (decl) == current_class_type)
9864               cp_error ("  perhaps you want `%T' for a constructor",
9865                         current_class_name);
9866             dname = DECL_NAME (decl);
9867             name = IDENTIFIER_POINTER (dname);
9868
9869             /* Avoid giving two errors for this.  */
9870             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9871
9872             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9873             *next = dname;
9874             next = 0;
9875             break;
9876
9877           default:
9878             cp_compiler_error ("`%D' as declarator", decl);
9879             return 0; /* We used to do a 155 abort here.  */
9880           }
9881       }
9882   }
9883
9884   /* A function definition's declarator must have the form of
9885      a function declarator.  */
9886
9887   if (funcdef_flag && innermost_code != CALL_EXPR)
9888     return 0;
9889
9890   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9891       && innermost_code != CALL_EXPR
9892       && ! (ctype && declspecs == NULL_TREE))
9893     {
9894       cp_error ("declaration of `%D' as non-function", dname);
9895       return void_type_node;
9896     }
9897
9898   /* Anything declared one level down from the top level
9899      must be one of the parameters of a function
9900      (because the body is at least two levels down).  */
9901
9902   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9903      by not allowing C++ class definitions to specify their parameters
9904      with xdecls (must be spec.d in the parmlist).
9905
9906      Since we now wait to push a class scope until we are sure that
9907      we are in a legitimate method context, we must set oldcname
9908      explicitly (since current_class_name is not yet alive).
9909
9910      We also want to avoid calling this a PARM if it is in a namespace.  */
9911
9912   if (decl_context == NORMAL && !toplevel_bindings_p ())
9913     {
9914       struct binding_level *b = current_binding_level;
9915       current_binding_level = b->level_chain;
9916       if (current_binding_level != 0 && toplevel_bindings_p ())
9917         decl_context = PARM;
9918       current_binding_level = b;
9919     }
9920
9921   if (name == NULL)
9922     name = decl_context == PARM ? "parameter" : "type name";
9923
9924   /* Look through the decl specs and record which ones appear.
9925      Some typespecs are defined as built-in typenames.
9926      Others, the ones that are modifiers of other types,
9927      are represented by bits in SPECBITS: set the bits for
9928      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9929
9930      If there is a typedef name or a type, store the type in TYPE.
9931      This includes builtin typedefs such as `int'.
9932
9933      Set EXPLICIT_INT if the type is `int' or `char' and did not
9934      come from a user typedef.
9935
9936      Set LONGLONG if `long' is mentioned twice.
9937
9938      For C++, constructors and destructors have their own fast treatment.  */
9939
9940   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9941     {
9942       register int i;
9943       register tree id;
9944
9945       /* Certain parse errors slip through.  For example,
9946          `int class;' is not caught by the parser. Try
9947          weakly to recover here.  */
9948       if (TREE_CODE (spec) != TREE_LIST)
9949         return 0;
9950
9951       id = TREE_VALUE (spec);
9952
9953       if (TREE_CODE (id) == IDENTIFIER_NODE)
9954         {
9955           if (id == ridpointers[(int) RID_INT]
9956               || id == ridpointers[(int) RID_CHAR]
9957               || id == ridpointers[(int) RID_BOOL]
9958               || id == ridpointers[(int) RID_WCHAR])
9959             {
9960               if (type)
9961                 {
9962                   if (id == ridpointers[(int) RID_BOOL])
9963                     error ("`bool' is now a keyword");
9964                   else
9965                     cp_error ("extraneous `%T' ignored", id);
9966                 }
9967               else
9968                 {
9969                   if (id == ridpointers[(int) RID_INT])
9970                     explicit_int = 1;
9971                   else if (id == ridpointers[(int) RID_CHAR])
9972                     explicit_char = 1;
9973                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9974                 }
9975               goto found;
9976             }
9977           /* C++ aggregate types.  */
9978           if (IDENTIFIER_HAS_TYPE_VALUE (id))
9979             {
9980               if (type)
9981                 cp_error ("multiple declarations `%T' and `%T'", type, id);
9982               else
9983                 type = IDENTIFIER_TYPE_VALUE (id);
9984               goto found;
9985             }
9986
9987           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
9988             {
9989               if (ridpointers[i] == id)
9990                 {
9991                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
9992                     {
9993                       if (pedantic && ! in_system_header && warn_long_long)
9994                         pedwarn ("ISO C++ does not support `long long'");
9995                       if (longlong)
9996                         error ("`long long long' is too long for GCC");
9997                       else
9998                         longlong = 1;
9999                     }
10000                   else if (RIDBIT_SETP (i, specbits))
10001                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10002                   RIDBIT_SET (i, specbits);
10003                   goto found;
10004                 }
10005             }
10006         }
10007       /* C++ aggregate types.  */
10008       else if (TREE_CODE (id) == TYPE_DECL)
10009         {
10010           if (type)
10011             cp_error ("multiple declarations `%T' and `%T'", type,
10012                       TREE_TYPE (id));
10013           else
10014             {
10015               type = TREE_TYPE (id);
10016               TREE_VALUE (spec) = type;
10017             }
10018           goto found;
10019         }
10020       if (type)
10021         error ("two or more data types in declaration of `%s'", name);
10022       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10023         {
10024           register tree t = lookup_name (id, 1);
10025           if (!t || TREE_CODE (t) != TYPE_DECL)
10026             error ("`%s' fails to be a typedef or built in type",
10027                    IDENTIFIER_POINTER (id));
10028           else
10029             {
10030               type = TREE_TYPE (t);
10031 #if 0
10032               /* See the code below that used this.  */
10033               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10034 #endif
10035               typedef_decl = t;
10036             }
10037         }
10038       else if (id != error_mark_node)
10039         /* Can't change CLASS nodes into RECORD nodes here!  */
10040         type = id;
10041
10042     found: ;
10043     }
10044
10045   typedef_type = type;
10046
10047   /* No type at all: default to `int', and set DEFAULTED_INT
10048      because it was not a user-defined typedef.  */
10049
10050   if (type == NULL_TREE
10051       && (RIDBIT_SETP (RID_SIGNED, specbits)
10052           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10053           || RIDBIT_SETP (RID_LONG, specbits)
10054           || RIDBIT_SETP (RID_SHORT, specbits)))
10055     {
10056       /* These imply 'int'.  */
10057       type = integer_type_node;
10058       defaulted_int = 1;
10059     }
10060
10061   if (sfk != sfk_none)
10062     type = check_special_function_return_type (sfk, type,
10063                                                ctor_return_type);
10064   else if (type == NULL_TREE)
10065     {
10066       int is_main;
10067
10068       explicit_int = -1;
10069
10070       /* We handle `main' specially here, because 'main () { }' is so
10071          common.  With no options, it is allowed.  With -Wreturn-type,
10072          it is a warning.  It is only an error with -pedantic-errors.  */
10073       is_main = (funcdef_flag
10074                  && MAIN_NAME_P (dname)
10075                  && ctype == NULL_TREE
10076                  && in_namespace == NULL_TREE
10077                  && current_namespace == global_namespace);
10078
10079       if (in_system_header || flag_ms_extensions)
10080         /* Allow it, sigh.  */;
10081       else if (pedantic || ! is_main)
10082         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10083                     name);
10084       else if (warn_return_type)
10085         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10086                     name);
10087
10088       type = integer_type_node;
10089     }
10090
10091   ctype = NULL_TREE;
10092
10093   /* Now process the modifiers that were specified
10094      and check for invalid combinations.  */
10095
10096   /* Long double is a special combination.  */
10097
10098   if (RIDBIT_SETP (RID_LONG, specbits)
10099       && TYPE_MAIN_VARIANT (type) == double_type_node)
10100     {
10101       RIDBIT_RESET (RID_LONG, specbits);
10102       type = build_qualified_type (long_double_type_node,
10103                                    CP_TYPE_QUALS (type));
10104     }
10105
10106   /* Check all other uses of type modifiers.  */
10107
10108   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10109       || RIDBIT_SETP (RID_SIGNED, specbits)
10110       || RIDBIT_SETP (RID_LONG, specbits)
10111       || RIDBIT_SETP (RID_SHORT, specbits))
10112     {
10113       int ok = 0;
10114
10115       if (TREE_CODE (type) == REAL_TYPE)
10116         error ("short, signed or unsigned invalid for `%s'", name);
10117       else if (TREE_CODE (type) != INTEGER_TYPE)
10118         error ("long, short, signed or unsigned invalid for `%s'", name);
10119       else if (RIDBIT_SETP (RID_LONG, specbits)
10120                && RIDBIT_SETP (RID_SHORT, specbits))
10121         error ("long and short specified together for `%s'", name);
10122       else if ((RIDBIT_SETP (RID_LONG, specbits)
10123                 || RIDBIT_SETP (RID_SHORT, specbits))
10124                && explicit_char)
10125         error ("long or short specified with char for `%s'", name);
10126       else if ((RIDBIT_SETP (RID_LONG, specbits)
10127                 || RIDBIT_SETP (RID_SHORT, specbits))
10128                && TREE_CODE (type) == REAL_TYPE)
10129         error ("long or short specified with floating type for `%s'", name);
10130       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10131                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10132         error ("signed and unsigned given together for `%s'", name);
10133       else
10134         {
10135           ok = 1;
10136           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10137             {
10138               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10139                        name);
10140               if (flag_pedantic_errors)
10141                 ok = 0;
10142             }
10143         }
10144
10145       /* Discard the type modifiers if they are invalid.  */
10146       if (! ok)
10147         {
10148           RIDBIT_RESET (RID_UNSIGNED, specbits);
10149           RIDBIT_RESET (RID_SIGNED, specbits);
10150           RIDBIT_RESET (RID_LONG, specbits);
10151           RIDBIT_RESET (RID_SHORT, specbits);
10152           longlong = 0;
10153         }
10154     }
10155
10156   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10157       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10158     {
10159       error ("complex invalid for `%s'", name);
10160       RIDBIT_RESET (RID_COMPLEX, specbits);
10161     }
10162
10163   /* Decide whether an integer type is signed or not.
10164      Optionally treat bitfields as signed by default.  */
10165   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10166       /* [class.bit]
10167
10168          It is implementation-defined whether a plain (neither
10169          explicitly signed or unsigned) char, short, int, or long
10170          bit-field is signed or unsigned.
10171
10172          Naturally, we extend this to long long as well.  Note that
10173          this does not include wchar_t.  */
10174       || (bitfield && !flag_signed_bitfields
10175           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10176           /* A typedef for plain `int' without `signed' can be
10177              controlled just like plain `int', but a typedef for
10178              `signed int' cannot be so controlled.  */
10179           && !(typedef_decl
10180                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10181           && (TREE_CODE (type) == INTEGER_TYPE
10182               || TREE_CODE (type) == CHAR_TYPE)
10183           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10184     {
10185       if (longlong)
10186         type = long_long_unsigned_type_node;
10187       else if (RIDBIT_SETP (RID_LONG, specbits))
10188         type = long_unsigned_type_node;
10189       else if (RIDBIT_SETP (RID_SHORT, specbits))
10190         type = short_unsigned_type_node;
10191       else if (type == char_type_node)
10192         type = unsigned_char_type_node;
10193       else if (typedef_decl)
10194         type = unsigned_type (type);
10195       else
10196         type = unsigned_type_node;
10197     }
10198   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10199            && type == char_type_node)
10200     type = signed_char_type_node;
10201   else if (longlong)
10202     type = long_long_integer_type_node;
10203   else if (RIDBIT_SETP (RID_LONG, specbits))
10204     type = long_integer_type_node;
10205   else if (RIDBIT_SETP (RID_SHORT, specbits))
10206     type = short_integer_type_node;
10207
10208   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10209     {
10210       /* If we just have "complex", it is equivalent to
10211          "complex double", but if any modifiers at all are specified it is
10212          the complex form of TYPE.  E.g, "complex short" is
10213          "complex short int".  */
10214
10215       if (defaulted_int && ! longlong
10216           && ! (RIDBIT_SETP (RID_LONG, specbits)
10217                 || RIDBIT_SETP (RID_SHORT, specbits)
10218                 || RIDBIT_SETP (RID_SIGNED, specbits)
10219                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10220         type = complex_double_type_node;
10221       else if (type == integer_type_node)
10222         type = complex_integer_type_node;
10223       else if (type == float_type_node)
10224         type = complex_float_type_node;
10225       else if (type == double_type_node)
10226         type = complex_double_type_node;
10227       else if (type == long_double_type_node)
10228         type = complex_long_double_type_node;
10229       else
10230         type = build_complex_type (type);
10231     }
10232
10233   if (sfk == sfk_conversion
10234       && (RIDBIT_SETP (RID_CONST, specbits)
10235           || RIDBIT_SETP (RID_VOLATILE, specbits)
10236           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10237     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10238               ctor_return_type);
10239
10240   /* Set CONSTP if this declaration is `const', whether by
10241      explicit specification or via a typedef.
10242      Likewise for VOLATILEP.  */
10243
10244   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10245   restrictp =
10246     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10247   volatilep =
10248     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10249   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10250                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10251                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10252   type = cp_build_qualified_type (type, type_quals);
10253   staticp = 0;
10254   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10255   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10256   RIDBIT_RESET (RID_VIRTUAL, specbits);
10257   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10258   RIDBIT_RESET (RID_EXPLICIT, specbits);
10259
10260   if (RIDBIT_SETP (RID_STATIC, specbits))
10261     staticp = 1 + (decl_context == FIELD);
10262
10263   if (virtualp && staticp == 2)
10264     {
10265       cp_error ("member `%D' cannot be declared both virtual and static",
10266                 dname);
10267       staticp = 0;
10268     }
10269   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10270   RIDBIT_RESET (RID_FRIEND, specbits);
10271
10272   /* Warn if two storage classes are given. Default to `auto'.  */
10273
10274   if (RIDBIT_ANY_SET (specbits))
10275     {
10276       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10277       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10278       if (decl_context == PARM && nclasses > 0)
10279         error ("storage class specifiers invalid in parameter declarations");
10280       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10281         {
10282           if (decl_context == PARM)
10283             error ("typedef declaration invalid in parameter declaration");
10284           nclasses++;
10285         }
10286       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10287       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10288     }
10289
10290   /* Give error if `virtual' is used outside of class declaration.  */
10291   if (virtualp
10292       && (current_class_name == NULL_TREE || decl_context != FIELD))
10293     {
10294       error ("virtual outside class declaration");
10295       virtualp = 0;
10296     }
10297
10298   /* Static anonymous unions are dealt with here.  */
10299   if (staticp && decl_context == TYPENAME
10300       && TREE_CODE (declspecs) == TREE_LIST
10301       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10302     decl_context = FIELD;
10303
10304   /* Warn about storage classes that are invalid for certain
10305      kinds of declarations (parameters, typenames, etc.).  */
10306
10307   if (nclasses > 1)
10308     error ("multiple storage classes in declaration of `%s'", name);
10309   else if (decl_context != NORMAL && nclasses > 0)
10310     {
10311       if ((decl_context == PARM || decl_context == CATCHPARM)
10312           && (RIDBIT_SETP (RID_REGISTER, specbits)
10313               || RIDBIT_SETP (RID_AUTO, specbits)))
10314         ;
10315       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10316         ;
10317       else if (decl_context == FIELD
10318                /* C++ allows static class elements  */
10319                && RIDBIT_SETP (RID_STATIC, specbits))
10320         /* C++ also allows inlines and signed and unsigned elements,
10321            but in those cases we don't come in here.  */
10322         ;
10323       else
10324         {
10325           if (decl_context == FIELD)
10326             {
10327               tree tmp = NULL_TREE;
10328               register int op = 0;
10329
10330               if (declarator)
10331                 {
10332                   /* Avoid trying to get an operand off an identifier node.  */
10333                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10334                     tmp = declarator;
10335                   else
10336                     tmp = TREE_OPERAND (declarator, 0);
10337                   op = IDENTIFIER_OPNAME_P (tmp);
10338                   if (IDENTIFIER_TYPENAME_P (tmp))
10339                     {
10340                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10341                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10342                               == TYPE_DECL))
10343                         name = IDENTIFIER_POINTER (tmp);
10344                       else
10345                         name = "<invalid operator>";
10346                     }
10347                 }
10348               error ("storage class specified for %s `%s'",
10349                      op ? "member operator" : "field",
10350                      name);
10351             }
10352           else
10353             {
10354               if (decl_context == PARM || decl_context == CATCHPARM)
10355                 error ("storage class specified for parameter `%s'", name);
10356               else
10357                 error ("storage class specified for typename");
10358             }
10359           RIDBIT_RESET (RID_REGISTER, specbits);
10360           RIDBIT_RESET (RID_AUTO, specbits);
10361           RIDBIT_RESET (RID_EXTERN, specbits);
10362         }
10363     }
10364   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10365     {
10366       if (toplevel_bindings_p ())
10367         {
10368           /* It's common practice (and completely valid) to have a const
10369              be initialized and declared extern.  */
10370           if (!(type_quals & TYPE_QUAL_CONST))
10371             warning ("`%s' initialized and declared `extern'", name);
10372         }
10373       else
10374         error ("`%s' has both `extern' and initializer", name);
10375     }
10376   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10377            && ! toplevel_bindings_p ())
10378     error ("nested function `%s' declared `extern'", name);
10379   else if (toplevel_bindings_p ())
10380     {
10381       if (RIDBIT_SETP (RID_AUTO, specbits))
10382         error ("top-level declaration of `%s' specifies `auto'", name);
10383     }
10384
10385   if (nclasses > 0 && friendp)
10386     error ("storage class specifiers invalid in friend function declarations");
10387
10388   /* Now figure out the structure of the declarator proper.
10389      Descend through it, creating more complex types, until we reach
10390      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10391
10392   inner_attrs = NULL_TREE;
10393   ignore_attrs = 0;
10394
10395   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10396          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10397     {
10398       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10399          an INDIRECT_REF (for *...),
10400          a CALL_EXPR (for ...(...)),
10401          an identifier (for the name being declared)
10402          or a null pointer (for the place in an absolute declarator
10403          where the name was omitted).
10404          For the last two cases, we have just exited the loop.
10405
10406          For C++ it could also be
10407          a SCOPE_REF (for class :: ...).  In this case, we have converted
10408          sensible names to types, and those are the values we use to
10409          qualify the member name.
10410          an ADDR_EXPR (for &...),
10411          a BIT_NOT_EXPR (for destructors)
10412
10413          At this point, TYPE is the type of elements of an array,
10414          or for a function to return, or for a pointer to point to.
10415          After this sequence of ifs, TYPE is the type of the
10416          array or function or pointer, and DECLARATOR has had its
10417          outermost layer removed.  */
10418
10419       if (type == error_mark_node)
10420         {
10421           if (TREE_CODE (declarator) == SCOPE_REF)
10422             declarator = TREE_OPERAND (declarator, 1);
10423           else
10424             declarator = TREE_OPERAND (declarator, 0);
10425           continue;
10426         }
10427       if (quals != NULL_TREE
10428           && (declarator == NULL_TREE
10429               || TREE_CODE (declarator) != SCOPE_REF))
10430         {
10431           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10432             ctype = TYPE_METHOD_BASETYPE (type);
10433           if (ctype != NULL_TREE)
10434             {
10435               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10436               grok_method_quals (ctype, dummy, quals);
10437               type = TREE_TYPE (dummy);
10438               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10439               quals = NULL_TREE;
10440             }
10441         }
10442
10443       /* See the comment for the TREE_LIST case, below.  */
10444       if (ignore_attrs)
10445         ignore_attrs = 0;
10446       else if (inner_attrs)
10447         {
10448           decl_attributes (type, inner_attrs, NULL_TREE);
10449           inner_attrs = NULL_TREE;
10450         }
10451
10452       switch (TREE_CODE (declarator))
10453         {
10454         case TREE_LIST:
10455           {
10456             /* We encode a declarator with embedded attributes using
10457                a TREE_LIST.  The attributes apply to the declarator
10458                directly inside them, so we have to skip an iteration
10459                before applying them to the type.  If the declarator just
10460                inside is the declarator-id, we apply the attrs to the
10461                decl itself.  */
10462             inner_attrs = TREE_PURPOSE (declarator);
10463             ignore_attrs = 1;
10464             declarator = TREE_VALUE (declarator);
10465           }
10466           break;
10467
10468         case ARRAY_REF:
10469           {
10470             register tree size;
10471
10472             size = TREE_OPERAND (declarator, 1);
10473
10474             /* VC++ spells a zero-sized array with [].  */
10475             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10476                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10477               size = integer_zero_node;
10478
10479             declarator = TREE_OPERAND (declarator, 0);
10480
10481             type = create_array_type_for_decl (dname, type, size);
10482
10483             /* VLAs never work as fields. */
10484             if (decl_context == FIELD && !processing_template_decl
10485                 && TREE_CODE (type) == ARRAY_TYPE
10486                 && TYPE_DOMAIN (type) != NULL_TREE
10487                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10488               {
10489                 cp_error ("size of member `%D' is not constant", dname);
10490                 /* Proceed with arbitrary constant size, so that offset
10491                    computations don't get confused. */
10492                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10493                                                    integer_one_node);
10494               }
10495
10496             ctype = NULL_TREE;
10497           }
10498           break;
10499
10500         case CALL_EXPR:
10501           {
10502             tree arg_types;
10503             int funcdecl_p;
10504             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10505             tree inner_decl = TREE_OPERAND (declarator, 0);
10506
10507             /* Declaring a function type.
10508                Make sure we have a valid type for the function to return.  */
10509
10510             /* We now know that the TYPE_QUALS don't apply to the
10511                decl, but to its return type.  */
10512             type_quals = TYPE_UNQUALIFIED;
10513
10514             /* Warn about some types functions can't return.  */
10515
10516             if (TREE_CODE (type) == FUNCTION_TYPE)
10517               {
10518                 error ("`%s' declared as function returning a function", name);
10519                 type = integer_type_node;
10520               }
10521             if (TREE_CODE (type) == ARRAY_TYPE)
10522               {
10523                 error ("`%s' declared as function returning an array", name);
10524                 type = integer_type_node;
10525               }
10526
10527             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10528               inner_decl = TREE_OPERAND (inner_decl, 1);
10529
10530             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10531               inner_decl = dname;
10532
10533             /* Pick up type qualifiers which should be applied to `this'.  */
10534             quals = CALL_DECLARATOR_QUALS (declarator);
10535
10536             /* Pick up the exception specifications.  */
10537             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10538
10539             /* Say it's a definition only for the CALL_EXPR
10540                closest to the identifier.  */
10541             funcdecl_p
10542               = inner_decl
10543               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10544                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10545                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10546
10547             if (ctype == NULL_TREE
10548                 && decl_context == FIELD
10549                 && funcdecl_p
10550                 && (friendp == 0 || dname == current_class_name))
10551               ctype = current_class_type;
10552
10553             if (ctype && sfk == sfk_conversion)
10554               TYPE_HAS_CONVERSION (ctype) = 1;
10555             if (ctype && constructor_name (ctype) == dname)
10556               {
10557                 /* We are within a class's scope. If our declarator name
10558                    is the same as the class name, and we are defining
10559                    a function, then it is a constructor/destructor, and
10560                    therefore returns a void type.  */
10561
10562                 if (flags == DTOR_FLAG)
10563                   {
10564                     /* ISO C++ 12.4/2.  A destructor may not be
10565                        declared const or volatile.  A destructor may
10566                        not be static.  */
10567                     if (staticp == 2)
10568                       error ("destructor cannot be static member function");
10569                     if (quals)
10570                       {
10571                         cp_error ("destructors may not be `%s'",
10572                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10573                         quals = NULL_TREE;
10574                       }
10575                     if (decl_context == FIELD)
10576                       {
10577                         if (! member_function_or_else (ctype,
10578                                                        current_class_type,
10579                                                        flags))
10580                           return void_type_node;
10581                       }
10582                   }
10583                 else            /* It's a constructor.  */
10584                   {
10585                     if (explicitp == 1)
10586                       explicitp = 2;
10587                     /* ISO C++ 12.1.  A constructor may not be
10588                        declared const or volatile.  A constructor may
10589                        not be virtual.  A constructor may not be
10590                        static.  */
10591                     if (staticp == 2)
10592                       error ("constructor cannot be static member function");
10593                     if (virtualp)
10594                       {
10595                         pedwarn ("constructors cannot be declared virtual");
10596                         virtualp = 0;
10597                       }
10598                     if (quals)
10599                       {
10600                         cp_error ("constructors may not be `%s'",
10601                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10602                         quals = NULL_TREE;
10603                       }
10604                     {
10605                       RID_BIT_TYPE tmp_bits;
10606                       memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
10607                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10608                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10609                       if (RIDBIT_ANY_SET (tmp_bits))
10610                         error ("return value type specifier for constructor ignored");
10611                     }
10612                     if (decl_context == FIELD)
10613                       {
10614                         if (! member_function_or_else (ctype,
10615                                                        current_class_type,
10616                                                        flags))
10617                           return void_type_node;
10618                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10619                         if (sfk != sfk_constructor)
10620                           return NULL_TREE;
10621                       }
10622                   }
10623                 if (decl_context == FIELD)
10624                   staticp = 0;
10625               }
10626             else if (friendp)
10627               {
10628                 if (initialized)
10629                   error ("can't initialize friend function `%s'", name);
10630                 if (virtualp)
10631                   {
10632                     /* Cannot be both friend and virtual.  */
10633                     error ("virtual functions cannot be friends");
10634                     RIDBIT_RESET (RID_FRIEND, specbits);
10635                     friendp = 0;
10636                   }
10637                 if (decl_context == NORMAL)
10638                   error ("friend declaration not in class definition");
10639                 if (current_function_decl && funcdef_flag)
10640                   cp_error ("can't define friend function `%s' in a local class definition",
10641                             name);
10642               }
10643
10644             /* Construct the function type and go to the next
10645                inner layer of declarator.  */
10646
10647             declarator = TREE_OPERAND (declarator, 0);
10648
10649             /* FIXME: This is where default args should be fully
10650                processed.  */
10651
10652             arg_types = grokparms (inner_parms);
10653
10654             if (declarator && flags == DTOR_FLAG)
10655               {
10656                 /* A destructor declared in the body of a class will
10657                    be represented as a BIT_NOT_EXPR.  But, we just
10658                    want the underlying IDENTIFIER.  */
10659                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10660                   declarator = TREE_OPERAND (declarator, 0);
10661
10662                 if (arg_types != void_list_node)
10663                   {
10664                     cp_error ("destructors may not have parameters");
10665                     arg_types = void_list_node;
10666                     last_function_parms = NULL_TREE;
10667                   }
10668               }
10669
10670             /* ANSI says that `const int foo ();'
10671                does not make the function foo const.  */
10672             type = build_function_type (type, arg_types);
10673
10674             {
10675               tree t;
10676               for (t = arg_types; t; t = TREE_CHAIN (t))
10677                 if (TREE_PURPOSE (t)
10678                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10679                   {
10680                     add_defarg_fn (type);
10681                     break;
10682                   }
10683             }
10684           }
10685           break;
10686
10687         case ADDR_EXPR:
10688         case INDIRECT_REF:
10689           /* Filter out pointers-to-references and references-to-references.
10690              We can get these if a TYPE_DECL is used.  */
10691
10692           if (TREE_CODE (type) == REFERENCE_TYPE)
10693             {
10694               error ("cannot declare %s to references",
10695                      TREE_CODE (declarator) == ADDR_EXPR
10696                      ? "references" : "pointers");
10697               declarator = TREE_OPERAND (declarator, 0);
10698               continue;
10699             }
10700
10701           if (TREE_CODE (type) == OFFSET_TYPE
10702               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10703                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10704             {
10705               cp_error ("cannot declare pointer to `%#T' member",
10706                         TREE_TYPE (type));
10707               type = TREE_TYPE (type);
10708             }
10709
10710           /* Merge any constancy or volatility into the target type
10711              for the pointer.  */
10712
10713           /* We now know that the TYPE_QUALS don't apply to the decl,
10714              but to the target of the pointer.  */
10715           type_quals = TYPE_UNQUALIFIED;
10716
10717           if (TREE_CODE (declarator) == ADDR_EXPR)
10718             {
10719               if (TREE_CODE (type) == VOID_TYPE)
10720                 error ("invalid type: `void &'");
10721               else
10722                 type = build_reference_type (type);
10723             }
10724           else if (TREE_CODE (type) == METHOD_TYPE)
10725             type = build_ptrmemfunc_type (build_pointer_type (type));
10726           else
10727             type = build_pointer_type (type);
10728
10729           /* Process a list of type modifier keywords (such as
10730              const or volatile) that were given inside the `*' or `&'.  */
10731
10732           if (TREE_TYPE (declarator))
10733             {
10734               register tree typemodlist;
10735               int erred = 0;
10736
10737               constp = 0;
10738               volatilep = 0;
10739               restrictp = 0;
10740               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10741                    typemodlist = TREE_CHAIN (typemodlist))
10742                 {
10743                   tree qualifier = TREE_VALUE (typemodlist);
10744
10745                   if (qualifier == ridpointers[(int) RID_CONST])
10746                     constp++;
10747                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10748                     volatilep++;
10749                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10750                     restrictp++;
10751                   else if (!erred)
10752                     {
10753                       erred = 1;
10754                       error ("invalid type modifier within pointer declarator");
10755                     }
10756                 }
10757               if (constp > 1)
10758                 pedwarn ("duplicate `const'");
10759               if (volatilep > 1)
10760                 pedwarn ("duplicate `volatile'");
10761               if (restrictp > 1)
10762                 pedwarn ("duplicate `restrict'");
10763
10764               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10765                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10766                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10767               if (TREE_CODE (declarator) == ADDR_EXPR
10768                   && (constp || volatilep))
10769                 {
10770                   if (constp)
10771                     pedwarn ("discarding `const' applied to a reference");
10772                   if (volatilep)
10773                     pedwarn ("discarding `volatile' applied to a reference");
10774                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10775                 }
10776               type = cp_build_qualified_type (type, type_quals);
10777             }
10778           declarator = TREE_OPERAND (declarator, 0);
10779           ctype = NULL_TREE;
10780           break;
10781
10782         case SCOPE_REF:
10783           {
10784             /* We have converted type names to NULL_TREE if the
10785                name was bogus, or to a _TYPE node, if not.
10786
10787                The variable CTYPE holds the type we will ultimately
10788                resolve to.  The code here just needs to build
10789                up appropriate member types.  */
10790             tree sname = TREE_OPERAND (declarator, 1);
10791             tree t;
10792
10793             /* Destructors can have their visibilities changed as well.  */
10794             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10795               sname = TREE_OPERAND (sname, 0);
10796
10797             if (TREE_COMPLEXITY (declarator) == 0)
10798               /* This needs to be here, in case we are called
10799                  multiple times.  */ ;
10800             else if (TREE_COMPLEXITY (declarator) == -1)
10801               /* Namespace member. */
10802               pop_decl_namespace ();
10803             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10804               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10805             else if (! IS_AGGR_TYPE_CODE
10806                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10807               ;
10808             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10809               {
10810                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10811                    that refer to ctype.  They couldn't be resolved earlier
10812                    because we hadn't pushed into the class yet.
10813                    Example: resolve 'B<T>::type' in
10814                    'B<typename B<T>::type> B<T>::f () { }'.  */
10815                 if (current_template_parms
10816                     && uses_template_parms (type)
10817                     && uses_template_parms (current_class_type))
10818                   {
10819                     tree args = current_template_args ();
10820                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10821                   }
10822
10823                 /* This pop_nested_class corresponds to the
10824                    push_nested_class used to push into class scope for
10825                    parsing the argument list of a function decl, in
10826                    qualified_id.  */
10827                 pop_nested_class ();
10828                 TREE_COMPLEXITY (declarator) = current_class_depth;
10829               }
10830             else
10831               my_friendly_abort (16);
10832
10833             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10834               {
10835                 /* We had a reference to a global decl, or
10836                    perhaps we were given a non-aggregate typedef,
10837                    in which case we cleared this out, and should just
10838                    keep going as though it wasn't there.  */
10839                 declarator = sname;
10840                 continue;
10841               }
10842             ctype = TREE_OPERAND (declarator, 0);
10843
10844             t = ctype;
10845             while (t != NULL_TREE && CLASS_TYPE_P (t))
10846               {
10847                 /* You're supposed to have one `template <...>'
10848                    for every template class, but you don't need one
10849                    for a full specialization.  For example:
10850
10851                      template <class T> struct S{};
10852                      template <> struct S<int> { void f(); };
10853                      void S<int>::f () {}
10854
10855                    is correct; there shouldn't be a `template <>' for
10856                    the definition of `S<int>::f'.  */
10857                 if (CLASSTYPE_TEMPLATE_INFO (t)
10858                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10859                         || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
10860                     && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
10861                   template_count += 1;
10862
10863                 t = TYPE_MAIN_DECL (t);
10864                 t = DECL_CONTEXT (t);
10865               }
10866
10867             if (sname == NULL_TREE)
10868               goto done_scoping;
10869
10870             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10871               {
10872                 /* This is the `standard' use of the scoping operator:
10873                    basetype :: member .  */
10874
10875                 if (ctype == current_class_type)
10876                   {
10877                     /* class A {
10878                          void A::f ();
10879                        };
10880
10881                        Is this ill-formed?  */
10882
10883                     if (pedantic)
10884                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10885                                   ctype, name);
10886                   }
10887                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10888                   {
10889                     if (current_class_type == NULL_TREE || friendp)
10890                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10891                                                       TYPE_ARG_TYPES (type));
10892                     else
10893                       {
10894                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10895                                   ctype, name, current_class_type);
10896                         return void_type_node;
10897                       }
10898                   }
10899                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10900                          || COMPLETE_TYPE_P (complete_type (ctype)))
10901                   {
10902                     /* Have to move this code elsewhere in this function.
10903                        this code is used for i.e., typedef int A::M; M *pm;
10904
10905                        It is?  How? jason 10/2/94 */
10906
10907                     if (current_class_type)
10908                       {
10909                         cp_error ("cannot declare member `%T::%s' within `%T'",
10910                                   ctype, name, current_class_type);
10911                         return void_type_node;
10912                       }
10913                     type = build_offset_type (ctype, type);
10914                   }
10915                 else
10916                   {
10917                     incomplete_type_error (NULL_TREE, ctype);
10918                     return error_mark_node;
10919                   }
10920
10921                 declarator = sname;
10922               }
10923             else if (TREE_CODE (sname) == SCOPE_REF)
10924               my_friendly_abort (17);
10925             else
10926               {
10927               done_scoping:
10928                 declarator = TREE_OPERAND (declarator, 1);
10929                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10930                   /* In this case, we will deal with it later.  */
10931                   ;
10932                 else
10933                   {
10934                     if (TREE_CODE (type) == FUNCTION_TYPE)
10935                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10936                                                       TYPE_ARG_TYPES (type));
10937                     else
10938                       type = build_offset_type (ctype, type);
10939                   }
10940               }
10941           }
10942           break;
10943
10944         case BIT_NOT_EXPR:
10945           declarator = TREE_OPERAND (declarator, 0);
10946           break;
10947
10948         case RECORD_TYPE:
10949         case UNION_TYPE:
10950         case ENUMERAL_TYPE:
10951           declarator = NULL_TREE;
10952           break;
10953
10954         case ERROR_MARK:
10955           declarator = NULL_TREE;
10956           break;
10957
10958         default:
10959           my_friendly_abort (158);
10960         }
10961     }
10962
10963   /* See the comment for the TREE_LIST case, above.  */
10964   if (inner_attrs)
10965     {
10966       if (! ignore_attrs)
10967         decl_attributes (type, inner_attrs, NULL_TREE);
10968       else if (attrlist)
10969         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10970       else
10971         attrlist = build_tree_list (NULL_TREE, inner_attrs);
10972     }
10973
10974   /* Now TYPE has the actual type.  */
10975
10976   if (explicitp == 1 || (explicitp && friendp))
10977     {
10978       /* [dcl.fct.spec] The explicit specifier shall only be used in
10979          declarations of constructors within a class definition.  */
10980       error ("only declarations of constructors can be `explicit'");
10981       explicitp = 0;
10982     }
10983
10984   if (RIDBIT_SETP (RID_MUTABLE, specbits))
10985     {
10986       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
10987         {
10988           error ("non-member `%s' cannot be declared `mutable'", name);
10989           RIDBIT_RESET (RID_MUTABLE, specbits);
10990         }
10991       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
10992         {
10993           error ("non-object member `%s' cannot be declared `mutable'", name);
10994           RIDBIT_RESET (RID_MUTABLE, specbits);
10995         }
10996       else if (TREE_CODE (type) == FUNCTION_TYPE
10997                || TREE_CODE (type) == METHOD_TYPE)
10998         {
10999           error ("function `%s' cannot be declared `mutable'", name);
11000           RIDBIT_RESET (RID_MUTABLE, specbits);
11001         }
11002       else if (staticp)
11003         {
11004           error ("static `%s' cannot be declared `mutable'", name);
11005           RIDBIT_RESET (RID_MUTABLE, specbits);
11006         }
11007       else if (type_quals & TYPE_QUAL_CONST)
11008         {
11009           error ("const `%s' cannot be declared `mutable'", name);
11010           RIDBIT_RESET (RID_MUTABLE, specbits);
11011         }
11012     }
11013
11014   if (declarator == NULL_TREE
11015       || TREE_CODE (declarator) == IDENTIFIER_NODE
11016       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11017           && (TREE_CODE (type) == FUNCTION_TYPE
11018               || TREE_CODE (type) == METHOD_TYPE)))
11019     /* OK */;
11020   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11021     {
11022       cp_error ("template-id `%D' used as a declarator", declarator);
11023       declarator = dname;
11024     }
11025   else
11026     /* Unexpected declarator format.  */
11027     my_friendly_abort (990210);
11028
11029   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11030
11031   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11032     {
11033       tree decl;
11034
11035       /* Note that the grammar rejects storage classes
11036          in typenames, fields or parameters.  */
11037       if (current_lang_name == lang_name_java)
11038         TYPE_FOR_JAVA (type) = 1;
11039
11040       if (decl_context == FIELD)
11041         {
11042           if (declarator == constructor_name (current_class_type))
11043             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11044                         declarator);
11045           decl = build_lang_decl (TYPE_DECL, declarator, type);
11046         }
11047       else
11048         {
11049           decl = build_decl (TYPE_DECL, declarator, type);
11050           if (!current_function_decl)
11051             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11052         }
11053
11054       /* If the user declares "typedef struct {...} foo" then the
11055          struct will have an anonymous name.  Fill that name in now.
11056          Nothing can refer to it, so nothing needs know about the name
11057          change.  */
11058       if (type != error_mark_node
11059           && declarator
11060           && TYPE_NAME (type)
11061           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11062           && TYPE_ANONYMOUS_P (type)
11063           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11064         {
11065           tree oldname = TYPE_NAME (type);
11066           tree t;
11067
11068           /* Replace the anonymous name with the real name everywhere.  */
11069           lookup_tag_reverse (type, declarator);
11070           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11071             if (TYPE_NAME (t) == oldname)
11072               TYPE_NAME (t) = decl;
11073
11074           if (TYPE_LANG_SPECIFIC (type))
11075             TYPE_WAS_ANONYMOUS (type) = 1;
11076
11077           /* If this is a typedef within a template class, the nested
11078              type is a (non-primary) template.  The name for the
11079              template needs updating as well.  */
11080           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11081             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11082               = TYPE_IDENTIFIER (type);
11083
11084           /* FIXME remangle member functions; member functions of a
11085              type with external linkage have external linkage.  */
11086         }
11087
11088       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11089         {
11090           cp_error_at ("typedef name may not be class-qualified", decl);
11091           return NULL_TREE;
11092         }
11093       else if (quals)
11094         {
11095           if (ctype == NULL_TREE)
11096             {
11097               if (TREE_CODE (type) != METHOD_TYPE)
11098                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11099               else
11100                 ctype = TYPE_METHOD_BASETYPE (type);
11101             }
11102           if (ctype != NULL_TREE)
11103             grok_method_quals (ctype, decl, quals);
11104         }
11105
11106       if (RIDBIT_SETP (RID_SIGNED, specbits)
11107           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11108         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11109
11110       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11111                       inlinep, friendp, raises != NULL_TREE);
11112
11113       if (initialized)
11114         error ("typedef declaration includes an initializer");
11115
11116       return decl;
11117     }
11118
11119   /* Detect the case of an array type of unspecified size
11120      which came, as such, direct from a typedef name.
11121      We must copy the type, so that each identifier gets
11122      a distinct type, so that each identifier's size can be
11123      controlled separately by its own initializer.  */
11124
11125   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11126       && TYPE_DOMAIN (type) == NULL_TREE)
11127     {
11128       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11129     }
11130
11131   /* If this is a type name (such as, in a cast or sizeof),
11132      compute the type and return it now.  */
11133
11134   if (decl_context == TYPENAME)
11135     {
11136       /* Note that the grammar rejects storage classes
11137          in typenames, fields or parameters.  */
11138       if (type_quals != TYPE_UNQUALIFIED)
11139         type_quals = TYPE_UNQUALIFIED;
11140
11141       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11142       if (friendp)
11143         {
11144           if (type_quals != TYPE_UNQUALIFIED)
11145             {
11146               cp_error ("type qualifiers specified for friend class declaration");
11147               type_quals = TYPE_UNQUALIFIED;
11148             }
11149           if (inlinep)
11150             {
11151               cp_error ("`inline' specified for friend class declaration");
11152               inlinep = 0;
11153             }
11154
11155           /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11156              But don't allow implicit typenames except with a class-key.  */
11157           if (!current_aggr && (TREE_CODE (type) != TYPENAME_TYPE
11158                                 || IMPLICIT_TYPENAME_P (type)))
11159             {
11160               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11161                 cp_pedwarn ("template parameters cannot be friends");
11162               else if (TREE_CODE (type) == TYPENAME_TYPE)
11163                 cp_pedwarn ("\
11164 friend declaration requires class-key, i.e. `friend class %T::%T'",
11165                             constructor_name (current_class_type),
11166                             TYPE_IDENTIFIER (type));
11167               else
11168                 cp_pedwarn ("\
11169 friend declaration requires class-key, i.e. `friend %#T'",
11170                             type);
11171             }
11172
11173           /* Only try to do this stuff if we didn't already give up.  */
11174           if (type != integer_type_node)
11175             {
11176               /* DR 209. The friendly class does not need to be accessible
11177                  in the scope of the class granting friendship. */
11178               skip_type_access_control ();
11179
11180               /* A friendly class?  */
11181               if (current_class_type)
11182                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11183               else
11184                 cp_error ("trying to make class `%T' a friend of global scope",
11185                           type);
11186
11187               type = void_type_node;
11188             }
11189         }
11190       else if (quals)
11191         {
11192           if (ctype == NULL_TREE)
11193             {
11194               if (TREE_CODE (type) != METHOD_TYPE)
11195                 cp_error ("invalid qualifiers on non-member function type");
11196               else
11197                 ctype = TYPE_METHOD_BASETYPE (type);
11198             }
11199           if (ctype)
11200             {
11201               tree dummy = build_decl (TYPE_DECL, declarator, type);
11202               grok_method_quals (ctype, dummy, quals);
11203               type = TREE_TYPE (dummy);
11204             }
11205         }
11206
11207       return type;
11208     }
11209   else if (declarator == NULL_TREE && decl_context != PARM
11210            && decl_context != CATCHPARM
11211            && TREE_CODE (type) != UNION_TYPE
11212            && ! bitfield)
11213     {
11214       cp_error ("abstract declarator `%T' used as declaration", type);
11215       declarator = make_anon_name ();
11216     }
11217
11218   /* `void' at top level (not within pointer)
11219      is allowed only in typedefs or type names.
11220      We don't complain about parms either, but that is because
11221      a better error message can be made later.  */
11222
11223   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11224     {
11225       if (! declarator)
11226         error ("unnamed variable or field declared void");
11227       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11228         {
11229           if (IDENTIFIER_OPNAME_P (declarator))
11230             my_friendly_abort (356);
11231           else
11232             error ("variable or field `%s' declared void", name);
11233         }
11234       else
11235         error ("variable or field declared void");
11236       type = integer_type_node;
11237     }
11238
11239   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11240      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11241
11242   if (decl_context == PARM || decl_context == CATCHPARM)
11243     {
11244       if (ctype || in_namespace)
11245         error ("cannot use `::' in parameter declaration");
11246
11247       /* A parameter declared as an array of T is really a pointer to T.
11248          One declared as a function is really a pointer to a function.
11249          One declared as a member is really a pointer to member.  */
11250
11251       if (TREE_CODE (type) == ARRAY_TYPE)
11252         {
11253           /* Transfer const-ness of array into that of type pointed to.  */
11254           type = build_pointer_type (TREE_TYPE (type));
11255           type_quals = TYPE_UNQUALIFIED;
11256         }
11257       else if (TREE_CODE (type) == FUNCTION_TYPE)
11258         type = build_pointer_type (type);
11259       else if (TREE_CODE (type) == OFFSET_TYPE)
11260         type = build_pointer_type (type);
11261     }
11262
11263   {
11264     register tree decl;
11265
11266     if (decl_context == PARM)
11267       {
11268         decl = build_decl (PARM_DECL, declarator, type);
11269
11270         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11271                         inlinep, friendp, raises != NULL_TREE);
11272
11273         /* Compute the type actually passed in the parmlist,
11274            for the case where there is no prototype.
11275            (For example, shorts and chars are passed as ints.)
11276            When there is a prototype, this is overridden later.  */
11277
11278         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11279       }
11280     else if (decl_context == FIELD)
11281       {
11282         if (type == error_mark_node)
11283           {
11284             /* Happens when declaring arrays of sizes which
11285                are error_mark_node, for example.  */
11286             decl = NULL_TREE;
11287           }
11288         else if (in_namespace && !friendp)
11289           {
11290             /* Something like struct S { int N::j; };  */
11291             cp_error ("invalid use of `::'");
11292             decl = NULL_TREE;
11293           }
11294         else if (TREE_CODE (type) == FUNCTION_TYPE)
11295           {
11296             int publicp = 0;
11297             tree function_context;
11298
11299             /* We catch the others as conflicts with the builtin
11300                typedefs.  */
11301             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11302               {
11303                 cp_error ("function `%D' cannot be declared friend",
11304                           declarator);
11305                 friendp = 0;
11306               }
11307
11308             if (friendp == 0)
11309               {
11310                 if (ctype == NULL_TREE)
11311                   ctype = current_class_type;
11312
11313                 if (ctype == NULL_TREE)
11314                   {
11315                     cp_error ("can't make `%D' into a method -- not in a class",
11316                               declarator);
11317                     return void_type_node;
11318                   }
11319
11320                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11321                    ARM 9.5 */
11322                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11323                   {
11324                     cp_error ("function `%D' declared virtual inside a union",
11325                               declarator);
11326                     return void_type_node;
11327                   }
11328
11329                 if (declarator == ansi_opname (NEW_EXPR)
11330                     || declarator == ansi_opname (VEC_NEW_EXPR)
11331                     || declarator == ansi_opname (DELETE_EXPR)
11332                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11333                   {
11334                     if (virtualp)
11335                       {
11336                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11337                                   declarator);
11338                         virtualp = 0;
11339                       }
11340                   }
11341                 else if (staticp < 2)
11342                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11343                                                   TYPE_ARG_TYPES (type));
11344               }
11345
11346             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11347             function_context = (ctype != NULL_TREE) ?
11348               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11349             publicp = (! friendp || ! staticp)
11350               && function_context == NULL_TREE;
11351             decl = grokfndecl (ctype, type,
11352                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11353                                ? declarator : dname,
11354                                declarator,
11355                                virtualp, flags, quals, raises,
11356                                friendp ? -1 : 0, friendp, publicp, inlinep,
11357                                funcdef_flag, template_count, in_namespace);
11358             if (decl == NULL_TREE)
11359               return decl;
11360 #if 0
11361             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11362             /* The decl and setting of decl_machine_attr is also turned off.  */
11363             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11364 #endif
11365
11366             /* [class.conv.ctor]
11367
11368                A constructor declared without the function-specifier
11369                explicit that can be called with a single parameter
11370                specifies a conversion from the type of its first
11371                parameter to the type of its class.  Such a constructor
11372                is called a converting constructor.  */
11373             if (explicitp == 2)
11374               DECL_NONCONVERTING_P (decl) = 1;
11375             else if (DECL_CONSTRUCTOR_P (decl))
11376               {
11377                 /* The constructor can be called with exactly one
11378                    parameter if there is at least one parameter, and
11379                    any subsequent parameters have default arguments.
11380                    Ignore any compiler-added parms.  */
11381                 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
11382
11383                 if (arg_types == void_list_node
11384                     || (arg_types
11385                         && TREE_CHAIN (arg_types)
11386                         && TREE_CHAIN (arg_types) != void_list_node
11387                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11388                   DECL_NONCONVERTING_P (decl) = 1;
11389               }
11390           }
11391         else if (TREE_CODE (type) == METHOD_TYPE)
11392           {
11393             /* We only get here for friend declarations of
11394                members of other classes.  */
11395             /* All method decls are public, so tell grokfndecl to set
11396                TREE_PUBLIC, also.  */
11397             decl = grokfndecl (ctype, type, declarator, declarator,
11398                                virtualp, flags, quals, raises,
11399                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11400                                template_count, in_namespace);
11401             if (decl == NULL_TREE)
11402               return NULL_TREE;
11403           }
11404         else if (!staticp && ! processing_template_decl
11405                  && !COMPLETE_TYPE_P (complete_type (type))
11406                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11407           {
11408             if (declarator)
11409               cp_error ("field `%D' has incomplete type", declarator);
11410             else
11411               cp_error ("name `%T' has incomplete type", type);
11412
11413             /* If we're instantiating a template, tell them which
11414                instantiation made the field's type be incomplete.  */
11415             if (current_class_type
11416                 && TYPE_NAME (current_class_type)
11417                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11418                 && declspecs && TREE_VALUE (declspecs)
11419                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11420               cp_error ("  in instantiation of template `%T'",
11421                         current_class_type);
11422
11423             type = error_mark_node;
11424             decl = NULL_TREE;
11425           }
11426         else
11427           {
11428             if (friendp)
11429               {
11430                 error ("`%s' is neither function nor member function; cannot be declared friend",
11431                        IDENTIFIER_POINTER (declarator));
11432                 friendp = 0;
11433               }
11434             decl = NULL_TREE;
11435           }
11436
11437         if (friendp)
11438           {
11439             /* Friends are treated specially.  */
11440             tree t = NULL_TREE;
11441
11442             /* DR 209. The friend does not need to be accessible at this
11443                point. */
11444             skip_type_access_control ();
11445
11446             if (ctype == current_class_type)
11447               warning ("member functions are implicitly friends of their class");
11448
11449             if (decl && DECL_NAME (decl))
11450               {
11451                 if (template_class_depth (current_class_type) == 0)
11452                   {
11453                     decl = check_explicit_specialization
11454                             (declarator, decl,
11455                              template_count, 2 * (funcdef_flag != 0) + 4);
11456                     if (decl == error_mark_node)
11457                       return error_mark_node;
11458                   }
11459
11460                 t = do_friend (ctype, declarator, decl,
11461                                last_function_parms, attrlist, flags, quals,
11462                                funcdef_flag);
11463               }
11464             if (t && funcdef_flag)
11465               return t;
11466             return void_type_node;
11467           }
11468
11469         /* Structure field.  It may not be a function, except for C++ */
11470
11471         if (decl == NULL_TREE)
11472           {
11473             if (initialized)
11474               {
11475                 if (!staticp)
11476                   {
11477                     /* An attempt is being made to initialize a non-static
11478                        member.  But, from [class.mem]:
11479
11480                        4 A member-declarator can contain a
11481                        constant-initializer only if it declares a static
11482                        member (_class.static_) of integral or enumeration
11483                        type, see _class.static.data_.
11484
11485                        This used to be relatively common practice, but
11486                        the rest of the compiler does not correctly
11487                        handle the initialization unless the member is
11488                        static so we make it static below.  */
11489                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11490                                 declarator);
11491                     cp_pedwarn ("making `%D' static", declarator);
11492                     staticp = 1;
11493                   }
11494
11495                 if (uses_template_parms (type))
11496                   /* We'll check at instantiation time.  */
11497                   ;
11498                 else if (check_static_variable_definition (declarator,
11499                                                            type))
11500                   /* If we just return the declaration, crashes
11501                      will sometimes occur.  We therefore return
11502                      void_type_node, as if this was a friend
11503                      declaration, to cause callers to completely
11504                      ignore this declaration.  */
11505                   return void_type_node;
11506               }
11507
11508             /* 9.2p13 [class.mem] */
11509             if (declarator == constructor_name (current_class_type)
11510                 /* The standard does not allow non-static data members
11511                    here either, but we agreed at the 10/99 meeting
11512                    to change that in TC 1 so that they are allowed in
11513                    classes with no user-defined constructors.  */
11514                 && staticp)
11515               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11516                           declarator);
11517
11518             if (staticp)
11519               {
11520                 /* C++ allows static class members.  All other work
11521                    for this is done by grokfield.  */
11522                 decl = build_lang_decl (VAR_DECL, declarator, type);
11523                 TREE_STATIC (decl) = 1;
11524                 /* In class context, 'static' means public access.  */
11525                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11526               }
11527             else
11528               {
11529                 decl = build_decl (FIELD_DECL, declarator, type);
11530                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11531                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11532                   {
11533                     DECL_MUTABLE_P (decl) = 1;
11534                     RIDBIT_RESET (RID_MUTABLE, specbits);
11535                   }
11536               }
11537
11538             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11539                             inlinep, friendp, raises != NULL_TREE);
11540           }
11541       }
11542     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11543       {
11544         tree original_name;
11545         int publicp = 0;
11546
11547         if (! declarator)
11548           return NULL_TREE;
11549
11550         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11551           original_name = dname;
11552         else
11553           original_name = declarator;
11554
11555         if (RIDBIT_SETP (RID_AUTO, specbits))
11556           error ("storage class `auto' invalid for function `%s'", name);
11557         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11558           error ("storage class `register' invalid for function `%s'", name);
11559
11560         /* Function declaration not at top level.
11561            Storage classes other than `extern' are not allowed
11562            and `extern' makes no difference.  */
11563         if (! toplevel_bindings_p ()
11564             && (RIDBIT_SETP (RID_STATIC, specbits)
11565                 || RIDBIT_SETP (RID_INLINE, specbits))
11566             && pedantic)
11567           {
11568             if (RIDBIT_SETP (RID_STATIC, specbits))
11569               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11570             else
11571               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11572           }
11573
11574         if (ctype == NULL_TREE)
11575           {
11576             if (virtualp)
11577               {
11578                 error ("virtual non-class function `%s'", name);
11579                 virtualp = 0;
11580               }
11581           }
11582         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11583           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11584                                           TYPE_ARG_TYPES (type));
11585
11586         /* Record presence of `static'.  */
11587         publicp = (ctype != NULL_TREE
11588                    || RIDBIT_SETP (RID_EXTERN, specbits)
11589                    || !RIDBIT_SETP (RID_STATIC, specbits));
11590
11591         decl = grokfndecl (ctype, type, original_name, declarator,
11592                            virtualp, flags, quals, raises,
11593                            1, friendp,
11594                            publicp, inlinep, funcdef_flag,
11595                            template_count, in_namespace);
11596         if (decl == NULL_TREE)
11597           return NULL_TREE;
11598
11599         if (staticp == 1)
11600           {
11601             int illegal_static = 0;
11602
11603             /* Don't allow a static member function in a class, and forbid
11604                declaring main to be static.  */
11605             if (TREE_CODE (type) == METHOD_TYPE)
11606               {
11607                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11608                 illegal_static = 1;
11609               }
11610             else if (current_function_decl)
11611               {
11612                 /* FIXME need arm citation */
11613                 error ("cannot declare static function inside another function");
11614                 illegal_static = 1;
11615               }
11616
11617             if (illegal_static)
11618               {
11619                 staticp = 0;
11620                 RIDBIT_RESET (RID_STATIC, specbits);
11621               }
11622           }
11623       }
11624     else
11625       {
11626         /* It's a variable.  */
11627
11628         /* An uninitialized decl with `extern' is a reference.  */
11629         decl = grokvardecl (type, declarator, &specbits,
11630                             initialized,
11631                             (type_quals & TYPE_QUAL_CONST) != 0,
11632                             in_namespace);
11633         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11634                         inlinep, friendp, raises != NULL_TREE);
11635
11636         if (ctype)
11637           {
11638             DECL_CONTEXT (decl) = ctype;
11639             if (staticp == 1)
11640               {
11641                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11642                 staticp = 0;
11643                 RIDBIT_RESET (RID_STATIC, specbits);
11644               }
11645             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11646               {
11647                 cp_error ("static member `%D' declared `register'", decl);
11648                 RIDBIT_RESET (RID_REGISTER, specbits);
11649               }
11650             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11651               {
11652                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11653                             decl);
11654                 RIDBIT_RESET (RID_EXTERN, specbits);
11655               }
11656           }
11657       }
11658
11659     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11660
11661     /* Record `register' declaration for warnings on &
11662        and in case doing stupid register allocation.  */
11663
11664     if (RIDBIT_SETP (RID_REGISTER, specbits))
11665       DECL_REGISTER (decl) = 1;
11666
11667     if (RIDBIT_SETP (RID_EXTERN, specbits))
11668       DECL_THIS_EXTERN (decl) = 1;
11669
11670     if (RIDBIT_SETP (RID_STATIC, specbits))
11671       DECL_THIS_STATIC (decl) = 1;
11672
11673     /* Record constancy and volatility.  There's no need to do this
11674        when processing a template; we'll do this for the instantiated
11675        declaration based on the type of DECL.  */
11676     if (!processing_template_decl)
11677       c_apply_type_quals_to_decl (type_quals, decl);
11678
11679     return decl;
11680   }
11681 }
11682 \f
11683 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11684    An empty exprlist is a parmlist.  An exprlist which
11685    contains only identifiers at the global level
11686    is a parmlist.  Otherwise, it is an exprlist.  */
11687
11688 int
11689 parmlist_is_exprlist (exprs)
11690      tree exprs;
11691 {
11692   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11693     return 0;
11694
11695   if (toplevel_bindings_p ())
11696     {
11697       /* At the global level, if these are all identifiers,
11698          then it is a parmlist.  */
11699       while (exprs)
11700         {
11701           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11702             return 1;
11703           exprs = TREE_CHAIN (exprs);
11704         }
11705       return 0;
11706     }
11707   return 1;
11708 }
11709
11710 /* Subroutine of start_function.  Ensure that each of the parameter
11711    types (as listed in PARMS) is complete, as is required for a
11712    function definition.  */
11713
11714 static void
11715 require_complete_types_for_parms (parms)
11716      tree parms;
11717 {
11718   for (; parms; parms = TREE_CHAIN (parms))
11719     {
11720       if (VOID_TYPE_P (TREE_TYPE (parms)))
11721         /* grokparms will have already issued an error */
11722         TREE_TYPE (parms) = error_mark_node;
11723       else if (complete_type_or_else (TREE_TYPE (parms), parms))
11724         layout_decl (parms, 0);
11725       else
11726         TREE_TYPE (parms) = error_mark_node;
11727     }
11728 }
11729
11730 /* Returns non-zero if T is a local variable.  */
11731
11732 int
11733 local_variable_p (t)
11734      tree t;
11735 {
11736   if ((TREE_CODE (t) == VAR_DECL
11737        /* A VAR_DECL with a context that is a _TYPE is a static data
11738           member.  */
11739        && !TYPE_P (CP_DECL_CONTEXT (t))
11740        /* Any other non-local variable must be at namespace scope.  */
11741        && !DECL_NAMESPACE_SCOPE_P (t))
11742       || (TREE_CODE (t) == PARM_DECL))
11743     return 1;
11744
11745   return 0;
11746 }
11747
11748 /* Returns non-zero if T is an automatic local variable or a label.
11749    (These are the declarations that need to be remapped when the code
11750    containing them is duplicated.)  */
11751
11752 int
11753 nonstatic_local_decl_p (t)
11754      tree t;
11755 {
11756   return ((local_variable_p (t) && !TREE_STATIC (t))
11757           || TREE_CODE (t) == LABEL_DECL
11758           || TREE_CODE (t) == RESULT_DECL);
11759 }
11760
11761 /* Like local_variable_p, but suitable for use as a tree-walking
11762    function.  */
11763
11764 static tree
11765 local_variable_p_walkfn (tp, walk_subtrees, data)
11766      tree *tp;
11767      int *walk_subtrees ATTRIBUTE_UNUSED;
11768      void *data ATTRIBUTE_UNUSED;
11769 {
11770   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11771           ? *tp : NULL_TREE);
11772 }
11773
11774 /* Check that ARG, which is a default-argument expression for a
11775    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11776    something goes wrong.  DECL may also be a _TYPE node, rather than a
11777    DECL, if there is no DECL available.  */
11778
11779 tree
11780 check_default_argument (decl, arg)
11781      tree decl;
11782      tree arg;
11783 {
11784   tree var;
11785   tree decl_type;
11786
11787   if (TREE_CODE (arg) == DEFAULT_ARG)
11788     /* We get a DEFAULT_ARG when looking at an in-class declaration
11789        with a default argument.  Ignore the argument for now; we'll
11790        deal with it after the class is complete.  */
11791     return arg;
11792
11793   if (processing_template_decl || uses_template_parms (arg))
11794     /* We don't do anything checking until instantiation-time.  Note
11795        that there may be uninstantiated arguments even for an
11796        instantiated function, since default arguments are not
11797        instantiated until they are needed.  */
11798     return arg;
11799
11800   if (TYPE_P (decl))
11801     {
11802       decl_type = decl;
11803       decl = NULL_TREE;
11804     }
11805   else
11806     decl_type = TREE_TYPE (decl);
11807
11808   if (arg == error_mark_node
11809       || decl == error_mark_node
11810       || TREE_TYPE (arg) == error_mark_node
11811       || decl_type == error_mark_node)
11812     /* Something already went wrong.  There's no need to check
11813        further.  */
11814     return error_mark_node;
11815
11816   /* [dcl.fct.default]
11817
11818      A default argument expression is implicitly converted to the
11819      parameter type.  */
11820   if (!TREE_TYPE (arg)
11821       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11822     {
11823       if (decl)
11824         cp_error ("default argument for `%#D' has type `%T'",
11825                   decl, TREE_TYPE (arg));
11826       else
11827         cp_error ("default argument for parameter of type `%T' has type `%T'",
11828                   decl_type, TREE_TYPE (arg));
11829
11830       return error_mark_node;
11831     }
11832
11833   /* [dcl.fct.default]
11834
11835      Local variables shall not be used in default argument
11836      expressions.
11837
11838      The keyword `this' shall not be used in a default argument of a
11839      member function.  */
11840   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
11841                                       NULL);
11842   if (var)
11843     {
11844       cp_error ("default argument `%E' uses local variable `%D'",
11845                 arg, var);
11846       return error_mark_node;
11847     }
11848
11849   /* All is well.  */
11850   return arg;
11851 }
11852
11853 /* Decode the list of parameter types for a function type.
11854    Given the list of things declared inside the parens,
11855    return a list of types.
11856
11857    We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
11858    flag. If unset, we append void_list_node. A parmlist declared
11859    as `(void)' is accepted as the empty parmlist.
11860
11861    Also set last_function_parms to the chain of PARM_DECLs.  */
11862
11863 static tree
11864 grokparms (first_parm)
11865      tree first_parm;
11866 {
11867   tree result = NULL_TREE;
11868   tree decls = NULL_TREE;
11869   int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
11870   tree parm, chain;
11871   int any_error = 0;
11872
11873   my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
11874
11875   for (parm = first_parm; parm != NULL_TREE; parm = chain)
11876     {
11877       tree type = NULL_TREE;
11878       register tree decl = TREE_VALUE (parm);
11879       tree init = TREE_PURPOSE (parm);
11880
11881       chain = TREE_CHAIN (parm);
11882       /* @@ weak defense against parse errors.  */
11883       if (TREE_CODE (decl) != VOID_TYPE
11884           && TREE_CODE (decl) != TREE_LIST)
11885         {
11886           /* Give various messages as the need arises.  */
11887           if (TREE_CODE (decl) == STRING_CST)
11888             cp_error ("invalid string constant `%E'", decl);
11889           else if (TREE_CODE (decl) == INTEGER_CST)
11890             error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11891           continue;
11892         }
11893
11894       if (parm == void_list_node)
11895         break;
11896
11897       decl = grokdeclarator (TREE_VALUE (decl), TREE_PURPOSE (decl),
11898                      PARM, init != NULL_TREE, NULL_TREE);
11899       if (! decl || TREE_TYPE (decl) == error_mark_node)
11900         continue;
11901
11902       type = TREE_TYPE (decl);
11903       if (VOID_TYPE_P (type))
11904         {
11905           if (same_type_p (type, void_type_node)
11906               && !DECL_NAME (decl) && !result && !chain && !ellipsis)
11907             /* this is a parmlist of `(void)', which is ok.  */
11908             break;
11909           incomplete_type_error (decl, type);
11910           /* It's not a good idea to actually create parameters of
11911              type `void'; other parts of the compiler assume that a
11912              void type terminates the parameter list.  */
11913           type = error_mark_node;
11914           TREE_TYPE (decl) = error_mark_node;
11915         }
11916
11917       if (type != error_mark_node)
11918         {
11919           /* Top-level qualifiers on the parameters are
11920              ignored for function types.  */
11921           type = TYPE_MAIN_VARIANT (type);
11922           if (TREE_CODE (type) == METHOD_TYPE)
11923             {
11924               cp_error ("parameter `%D' invalidly declared method type", decl);
11925               type = build_pointer_type (type);
11926               TREE_TYPE (decl) = type;
11927             }
11928           else if (TREE_CODE (type) == OFFSET_TYPE)
11929             {
11930               cp_error ("parameter `%D' invalidly declared offset type", decl);
11931               type = build_pointer_type (type);
11932               TREE_TYPE (decl) = type;
11933             }
11934           else if (abstract_virtuals_error (decl, type))
11935             any_error = 1;  /* Seems like a good idea. */
11936           else if (POINTER_TYPE_P (type))
11937             {
11938               /* [dcl.fct]/6, parameter types cannot contain pointers
11939                  (references) to arrays of unknown bound.  */
11940               tree t = TREE_TYPE (type);
11941               int ptr = TYPE_PTR_P (type);
11942
11943               while (1)
11944                 {
11945                   if (TYPE_PTR_P (t))
11946                     ptr = 1;
11947                   else if (TREE_CODE (t) != ARRAY_TYPE)
11948                     break;
11949                   else if (!TYPE_DOMAIN (t))
11950                     break;
11951                   t = TREE_TYPE (t);
11952                 }
11953               if (TREE_CODE (t) == ARRAY_TYPE)
11954                 cp_error ("parameter `%D' includes %s to array of unknown bound `%T'",
11955                           decl, ptr ? "pointer" : "reference", t);
11956             }
11957
11958           DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11959           if (PROMOTE_PROTOTYPES
11960               && (TREE_CODE (type) == INTEGER_TYPE
11961                   || TREE_CODE (type) == ENUMERAL_TYPE)
11962               && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11963             DECL_ARG_TYPE (decl) = integer_type_node;
11964           if (!any_error && init)
11965             init = check_default_argument (decl, init);
11966           else
11967             init = NULL_TREE;
11968         }
11969
11970       TREE_CHAIN (decl) = decls;
11971       decls = decl;
11972       result = tree_cons (init, type, result);
11973     }
11974   decls = nreverse (decls);
11975   result = nreverse (result);
11976   if (!ellipsis)
11977     result = chainon (result, void_list_node);
11978   last_function_parms = decls;
11979
11980   return result;
11981 }
11982
11983 \f
11984 /* D is a constructor or overloaded `operator='.  Returns non-zero if
11985    D's arguments allow it to be a copy constructor, or copy assignment
11986    operator.  */
11987
11988 int
11989 copy_args_p (d)
11990      tree d;
11991 {
11992   tree t;
11993
11994   if (!DECL_FUNCTION_MEMBER_P (d))
11995     return 0;
11996
11997   t = FUNCTION_FIRST_USER_PARMTYPE (d);
11998   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
11999       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12000           == DECL_CONTEXT (d))
12001       && (TREE_CHAIN (t) == NULL_TREE
12002           || TREE_CHAIN (t) == void_list_node
12003           || TREE_PURPOSE (TREE_CHAIN (t))))
12004     return 1;
12005   return 0;
12006 }
12007
12008 /* These memoizing functions keep track of special properties which
12009    a class may have.  `grok_ctor_properties' notices whether a class
12010    has a constructor of the form X(X&), and also complains
12011    if the class has a constructor of the form X(X).
12012    `grok_op_properties' takes notice of the various forms of
12013    operator= which are defined, as well as what sorts of type conversion
12014    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12015
12016 int
12017 grok_ctor_properties (ctype, decl)
12018      tree ctype, decl;
12019 {
12020   tree parmtypes = FUNCTION_FIRST_USER_PARMTYPE (decl);
12021   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12022
12023   /* [class.copy]
12024
12025      A non-template constructor for class X is a copy constructor if
12026      its first parameter is of type X&, const X&, volatile X& or const
12027      volatile X&, and either there are no other parameters or else all
12028      other parameters have default arguments.  */
12029   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12030       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12031       && sufficient_parms_p (TREE_CHAIN (parmtypes))
12032       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12033            && is_member_template (DECL_TI_TEMPLATE (decl))))
12034     {
12035       TYPE_HAS_INIT_REF (ctype) = 1;
12036       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12037         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12038     }
12039   /* [class.copy]
12040
12041      A declaration of a constructor for a class X is ill-formed if its
12042      first parameter is of type (optionally cv-qualified) X and either
12043      there are no other parameters or else all other parameters have
12044      default arguments.
12045
12046      We *don't* complain about member template instantiations that
12047      have this form, though; they can occur as we try to decide what
12048      constructor to use during overload resolution.  Since overload
12049      resolution will never prefer such a constructor to the
12050      non-template copy constructor (which is either explicitly or
12051      implicitly defined), there's no need to worry about their
12052      existence.  Theoretically, they should never even be
12053      instantiated, but that's hard to forestall.  */
12054   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12055            && sufficient_parms_p (TREE_CHAIN (parmtypes))
12056            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12057                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12058     {
12059       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12060                 ctype, ctype);
12061       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12062       return 0;
12063     }
12064   else if (TREE_CODE (parmtype) == VOID_TYPE
12065            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12066     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12067
12068   return 1;
12069 }
12070
12071 /* An operator with this code is unary, but can also be binary.  */
12072
12073 static int
12074 ambi_op_p (code)
12075      enum tree_code code;
12076 {
12077   return (code == INDIRECT_REF
12078           || code == ADDR_EXPR
12079           || code == CONVERT_EXPR
12080           || code == NEGATE_EXPR
12081           || code == PREINCREMENT_EXPR
12082           || code == PREDECREMENT_EXPR);
12083 }
12084
12085 /* An operator with this name can only be unary.  */
12086
12087 static int
12088 unary_op_p (code)
12089      enum tree_code code;
12090 {
12091   return (code == TRUTH_NOT_EXPR
12092           || code == BIT_NOT_EXPR
12093           || code == COMPONENT_REF
12094           || code == TYPE_EXPR);
12095 }
12096
12097 /* Do a little sanity-checking on how they declared their operator.  */
12098
12099 void
12100 grok_op_properties (decl, virtualp, friendp)
12101      tree decl;
12102      int virtualp, friendp;
12103 {
12104   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12105   tree argtype;
12106   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12107   tree name = DECL_NAME (decl);
12108   enum tree_code operator_code;
12109   int arity;
12110
12111   /* Count the number of arguments.  */
12112   for (argtype = argtypes, arity = 0;
12113        argtype && argtype != void_list_node;
12114        argtype = TREE_CHAIN (argtype))
12115     ++arity;
12116
12117   if (current_class_type == NULL_TREE)
12118     friendp = 1;
12119
12120   if (DECL_CONV_FN_P (decl))
12121     operator_code = TYPE_EXPR;
12122   else
12123     do
12124       {
12125 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)       \
12126         if (ansi_opname (CODE) == name)                         \
12127           {                                                     \
12128             operator_code = CODE;                               \
12129             break;                                              \
12130           }                                                     \
12131         else if (ansi_assopname (CODE) == name)                 \
12132           {                                                     \
12133             operator_code = CODE;                               \
12134             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;              \
12135             break;                                              \
12136           }
12137
12138 #include "operators.def"
12139 #undef DEF_OPERATOR
12140
12141         my_friendly_abort (20000527);
12142       }
12143     while (0);
12144   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12145   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12146
12147   if (! friendp)
12148     {
12149       switch (operator_code)
12150         {
12151         case CALL_EXPR:
12152           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12153           break;
12154
12155         case ARRAY_REF:
12156           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12157           break;
12158
12159         case COMPONENT_REF:
12160         case MEMBER_REF:
12161           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12162           break;
12163
12164         case NEW_EXPR:
12165           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12166           break;
12167
12168         case DELETE_EXPR:
12169           TYPE_GETS_DELETE (current_class_type) |= 1;
12170           break;
12171
12172         case VEC_NEW_EXPR:
12173           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12174           break;
12175
12176         case VEC_DELETE_EXPR:
12177           TYPE_GETS_DELETE (current_class_type) |= 2;
12178           break;
12179
12180         default:
12181           break;
12182         }
12183     }
12184
12185   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12186     {
12187       /* When the compiler encounters the definition of A::operator new, it
12188          doesn't look at the class declaration to find out if it's static.  */
12189       if (methodp)
12190         revert_static_member_fn (decl);
12191
12192       TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12193     }
12194   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12195     {
12196       if (methodp)
12197         revert_static_member_fn (decl);
12198
12199       TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12200     }
12201   else
12202     {
12203       /* An operator function must either be a non-static member function
12204          or have at least one parameter of a class, a reference to a class,
12205          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12206       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12207         {
12208           if (operator_code == TYPE_EXPR
12209               || operator_code == CALL_EXPR
12210               || operator_code == COMPONENT_REF
12211               || operator_code == ARRAY_REF
12212               || operator_code == NOP_EXPR)
12213             cp_error ("`%D' must be a nonstatic member function", decl);
12214           else
12215             {
12216               tree p = argtypes;
12217
12218               if (DECL_STATIC_FUNCTION_P (decl))
12219                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12220
12221               if (p)
12222                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12223                   {
12224                     tree arg = TREE_VALUE (p);
12225                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12226                       arg = TREE_TYPE (arg);
12227
12228                     /* This lets bad template code slip through.  */
12229                     if (IS_AGGR_TYPE (arg)
12230                         || TREE_CODE (arg) == ENUMERAL_TYPE
12231                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12232                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12233                       goto foundaggr;
12234                   }
12235               cp_error
12236                 ("`%D' must have an argument of class or enumerated type",
12237                  decl);
12238             foundaggr:
12239               ;
12240             }
12241         }
12242
12243       if (operator_code == CALL_EXPR)
12244         return;                 /* No restrictions on args. */
12245
12246       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12247         {
12248           tree t = TREE_TYPE (name);
12249           if (! friendp)
12250             {
12251               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12252               const char *what = 0;
12253
12254               if (ref)
12255                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12256
12257               if (TREE_CODE (t) == VOID_TYPE)
12258                 what = "void";
12259               else if (t == current_class_type)
12260                 what = "the same type";
12261               /* Don't force t to be complete here.  */
12262               else if (IS_AGGR_TYPE (t)
12263                        && COMPLETE_TYPE_P (t)
12264                        && DERIVED_FROM_P (t, current_class_type))
12265                 what = "a base class";
12266
12267               if (what)
12268                 warning ("conversion to %s%s will never use a type conversion operator",
12269                          ref ? "a reference to " : "", what);
12270             }
12271         }
12272
12273       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12274           && operator_code == NOP_EXPR)
12275         {
12276           tree parmtype;
12277
12278           if (arity != 2 && methodp)
12279             {
12280               cp_error ("`%D' must take exactly one argument", decl);
12281               return;
12282             }
12283           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12284
12285           /* [class.copy]
12286
12287              A user-declared copy assignment operator X::operator= is
12288              a non-static non-template member function of class X with
12289              exactly one parameter of type X, X&, const X&, volatile
12290              X& or const volatile X&.  */
12291           if (copy_assignment_arg_p (parmtype, virtualp)
12292               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12293                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12294               && ! friendp)
12295             {
12296               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12297               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12298                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12299                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12300             }
12301         }
12302       else if (operator_code == COND_EXPR)
12303         {
12304           /* 13.4.0.3 */
12305           cp_error ("ISO C++ prohibits overloading operator ?:");
12306         }
12307       else if (ambi_op_p (operator_code))
12308         {
12309           if (arity == 1)
12310             /* We pick the one-argument operator codes by default, so
12311                we don't have to change anything.  */
12312             ;
12313           else if (arity == 2)
12314             {
12315               /* If we thought this was a unary operator, we now know
12316                  it to be a binary operator.  */
12317               switch (operator_code)
12318                 {
12319                 case INDIRECT_REF:
12320                   operator_code = MULT_EXPR;
12321                   break;
12322
12323                 case ADDR_EXPR:
12324                   operator_code = BIT_AND_EXPR;
12325                   break;
12326
12327                 case CONVERT_EXPR:
12328                   operator_code = PLUS_EXPR;
12329                   break;
12330
12331                 case NEGATE_EXPR:
12332                   operator_code = MINUS_EXPR;
12333                   break;
12334
12335                 case PREINCREMENT_EXPR:
12336                   operator_code = POSTINCREMENT_EXPR;
12337                   break;
12338
12339                 case PREDECREMENT_EXPR:
12340                   operator_code = POSTDECREMENT_EXPR;
12341                   break;
12342
12343                 default:
12344                   my_friendly_abort (20000527);
12345                 }
12346
12347               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12348
12349               if ((operator_code == POSTINCREMENT_EXPR
12350                    || operator_code == POSTDECREMENT_EXPR)
12351                   && ! processing_template_decl
12352                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12353                 {
12354                   if (methodp)
12355                     cp_error ("postfix `%D' must take `int' as its argument",
12356                               decl);
12357                   else
12358                     cp_error
12359                       ("postfix `%D' must take `int' as its second argument",
12360                        decl);
12361                 }
12362             }
12363           else
12364             {
12365               if (methodp)
12366                 cp_error ("`%D' must take either zero or one argument", decl);
12367               else
12368                 cp_error ("`%D' must take either one or two arguments", decl);
12369             }
12370
12371           /* More Effective C++ rule 6.  */
12372           if (warn_ecpp
12373               && (operator_code == POSTINCREMENT_EXPR
12374                   || operator_code == POSTDECREMENT_EXPR
12375                   || operator_code == PREINCREMENT_EXPR
12376                   || operator_code == PREDECREMENT_EXPR))
12377             {
12378               tree arg = TREE_VALUE (argtypes);
12379               tree ret = TREE_TYPE (TREE_TYPE (decl));
12380               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12381                 arg = TREE_TYPE (arg);
12382               arg = TYPE_MAIN_VARIANT (arg);
12383               if (operator_code == PREINCREMENT_EXPR
12384                   || operator_code == PREDECREMENT_EXPR)
12385                 {
12386                   if (TREE_CODE (ret) != REFERENCE_TYPE
12387                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12388                                        arg))
12389                     cp_warning ("prefix `%D' should return `%T'", decl,
12390                                 build_reference_type (arg));
12391                 }
12392               else
12393                 {
12394                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12395                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12396                 }
12397             }
12398         }
12399       else if (unary_op_p (operator_code))
12400         {
12401           if (arity != 1)
12402             {
12403               if (methodp)
12404                 cp_error ("`%D' must take `void'", decl);
12405               else
12406                 cp_error ("`%D' must take exactly one argument", decl);
12407             }
12408         }
12409       else /* if (binary_op_p (operator_code)) */
12410         {
12411           if (arity != 2)
12412             {
12413               if (methodp)
12414                 cp_error ("`%D' must take exactly one argument", decl);
12415               else
12416                 cp_error ("`%D' must take exactly two arguments", decl);
12417             }
12418
12419           /* More Effective C++ rule 7.  */
12420           if (warn_ecpp
12421               && (operator_code == TRUTH_ANDIF_EXPR
12422                   || operator_code == TRUTH_ORIF_EXPR
12423                   || operator_code == COMPOUND_EXPR))
12424             cp_warning ("user-defined `%D' always evaluates both arguments",
12425                         decl);
12426         }
12427
12428       /* Effective C++ rule 23.  */
12429       if (warn_ecpp
12430           && arity == 2
12431           && (operator_code == PLUS_EXPR
12432               || operator_code == MINUS_EXPR
12433               || operator_code == TRUNC_DIV_EXPR
12434               || operator_code == MULT_EXPR)
12435           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12436         cp_warning ("`%D' should return by value", decl);
12437
12438       /* 13.4.0.8 */
12439       for (; argtypes && argtypes != void_list_node;
12440           argtypes = TREE_CHAIN (argtypes))
12441         if (TREE_PURPOSE (argtypes))
12442           {
12443             TREE_PURPOSE (argtypes) = NULL_TREE;
12444             if (operator_code == POSTINCREMENT_EXPR
12445                 || operator_code == POSTDECREMENT_EXPR)
12446               {
12447                 if (pedantic)
12448                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12449               }
12450             else
12451               cp_error ("`%D' cannot have default arguments", decl);
12452           }
12453
12454     }
12455 }
12456 \f
12457 static const char *
12458 tag_name (code)
12459      enum tag_types code;
12460 {
12461   switch (code)
12462     {
12463     case record_type:
12464       return "struct";
12465     case class_type:
12466       return "class";
12467     case union_type:
12468       return "union ";
12469     case enum_type:
12470       return "enum";
12471     default:
12472       my_friendly_abort (981122);
12473     }
12474 }
12475
12476 /* Get the struct, enum or union (CODE says which) with tag NAME.
12477    Define the tag as a forward-reference if it is not defined.
12478
12479    C++: If a class derivation is given, process it here, and report
12480    an error if multiple derivation declarations are not identical.
12481
12482    If this is a definition, come in through xref_tag and only look in
12483    the current frame for the name (since C++ allows new names in any
12484    scope.)  */
12485
12486 tree
12487 xref_tag (code_type_node, name, globalize)
12488      tree code_type_node;
12489      tree name;
12490      int globalize;
12491 {
12492   enum tag_types tag_code;
12493   enum tree_code code;
12494   register tree ref, t;
12495   struct binding_level *b = current_binding_level;
12496   int got_type = 0;
12497   tree attributes = NULL_TREE;
12498   tree context = NULL_TREE;
12499
12500   /* If we are called from the parser, code_type_node will sometimes be a
12501      TREE_LIST.  This indicates that the user wrote
12502      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12503      use them later.  */
12504   if (TREE_CODE (code_type_node) == TREE_LIST)
12505     {
12506       attributes = TREE_PURPOSE (code_type_node);
12507       code_type_node = TREE_VALUE (code_type_node);
12508     }
12509
12510   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12511   switch (tag_code)
12512     {
12513     case record_type:
12514     case class_type:
12515       code = RECORD_TYPE;
12516       break;
12517     case union_type:
12518       code = UNION_TYPE;
12519       break;
12520     case enum_type:
12521       code = ENUMERAL_TYPE;
12522       break;
12523     default:
12524       my_friendly_abort (18);
12525     }
12526
12527   /* If a cross reference is requested, look up the type
12528      already defined for this tag and return it.  */
12529   if (TYPE_P (name))
12530     {
12531       t = name;
12532       name = TYPE_IDENTIFIER (t);
12533       got_type = 1;
12534     }
12535   else
12536     t = IDENTIFIER_TYPE_VALUE (name);
12537
12538   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12539   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12540     {
12541       static int explained;
12542       tree shadowed;
12543
12544       cp_warning ("`%s %T' declares a new type at namespace scope",
12545                   tag_name (tag_code), name);
12546       if (!explained++)
12547         cp_warning ("  names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'%s",
12548                     tag_name (tag_code),
12549                     constructor_name (current_class_type),
12550                     TYPE_IDENTIFIER (t));
12551
12552       /* We need to remove the class scope binding for the
12553          TYPENAME_TYPE as otherwise poplevel_class gets confused. */
12554       for (shadowed = b->class_shadowed;
12555            shadowed;
12556            shadowed = TREE_CHAIN (shadowed))
12557         if (TREE_TYPE (shadowed) == TYPE_NAME (t))
12558           {
12559             TREE_PURPOSE (shadowed) = NULL_TREE;
12560             break;
12561           }
12562     }
12563
12564   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12565       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12566     t = NULL_TREE;
12567
12568   if (! globalize)
12569     {
12570       /* If we know we are defining this tag, only look it up in
12571          this scope and don't try to find it as a type.  */
12572       ref = lookup_tag (code, name, b, 1);
12573     }
12574   else
12575     {
12576       if (t)
12577         {
12578           /* [dcl.type.elab] If the identifier resolves to a
12579              typedef-name or a template type-parameter, the
12580              elaborated-type-specifier is ill-formed.  */
12581           if (t != TYPE_MAIN_VARIANT (t)
12582               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12583             cp_pedwarn ("using typedef-name `%D' after `%s'",
12584                         TYPE_NAME (t), tag_name (tag_code));
12585           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12586             cp_error ("using template type parameter `%T' after `%s'",
12587                       t, tag_name (tag_code));
12588
12589           ref = t;
12590         }
12591       else
12592         ref = lookup_tag (code, name, b, 0);
12593
12594       if (! ref)
12595         {
12596           /* Try finding it as a type declaration.  If that wins,
12597              use it.  */
12598           ref = lookup_name (name, 1);
12599
12600           if (ref != NULL_TREE
12601               && processing_template_decl
12602               && DECL_CLASS_TEMPLATE_P (ref)
12603               && template_class_depth (current_class_type) == 0)
12604             /* Since GLOBALIZE is true, we're declaring a global
12605                template, so we want this type.  */
12606             ref = DECL_TEMPLATE_RESULT (ref);
12607
12608           if (ref && TREE_CODE (ref) == TYPE_DECL
12609               && TREE_CODE (TREE_TYPE (ref)) == code)
12610             ref = TREE_TYPE (ref);
12611           else
12612             ref = NULL_TREE;
12613         }
12614
12615       if (ref && current_class_type
12616           && template_class_depth (current_class_type)
12617           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12618         {
12619           /* Since GLOBALIZE is non-zero, we are not looking at a
12620              definition of this tag.  Since, in addition, we are currently
12621              processing a (member) template declaration of a template
12622              class, we must be very careful; consider:
12623
12624                template <class X>
12625                struct S1
12626
12627                template <class U>
12628                struct S2
12629                { template <class V>
12630                friend struct S1; };
12631
12632              Here, the S2::S1 declaration should not be confused with the
12633              outer declaration.  In particular, the inner version should
12634              have a template parameter of level 2, not level 1.  This
12635              would be particularly important if the member declaration
12636              were instead:
12637
12638                template <class V = U> friend struct S1;
12639
12640              say, when we should tsubst into `U' when instantiating
12641              S2.  On the other hand, when presented with:
12642
12643                  template <class T>
12644                  struct S1 {
12645                    template <class U>
12646                    struct S2 {};
12647                    template <class U>
12648                    friend struct S2;
12649                  };
12650
12651               we must find the inner binding eventually.  We
12652               accomplish this by making sure that the new type we
12653               create to represent this declaration has the right
12654               TYPE_CONTEXT.  */
12655           context = TYPE_CONTEXT (ref);
12656           ref = NULL_TREE;
12657         }
12658     }
12659
12660   if (! ref)
12661     {
12662       /* If no such tag is yet defined, create a forward-reference node
12663          and record it as the "definition".
12664          When a real declaration of this type is found,
12665          the forward-reference will be altered into a real type.  */
12666       if (code == ENUMERAL_TYPE)
12667         {
12668           cp_error ("use of enum `%#D' without previous declaration", name);
12669
12670           ref = make_node (ENUMERAL_TYPE);
12671
12672           /* Give the type a default layout like unsigned int
12673              to avoid crashing if it does not get defined.  */
12674           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12675           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12676           TYPE_USER_ALIGN (ref) = 0;
12677           TREE_UNSIGNED (ref) = 1;
12678           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12679           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12680           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12681
12682           /* Enable us to recognize when a type is created in class context.
12683              To do nested classes correctly, this should probably be cleared
12684              out when we leave this classes scope.  Currently this in only
12685              done in `start_enum'.  */
12686
12687           pushtag (name, ref, globalize);
12688         }
12689       else
12690         {
12691           struct binding_level *old_b = class_binding_level;
12692
12693           ref = make_aggr_type (code);
12694           TYPE_CONTEXT (ref) = context;
12695
12696 #ifdef NONNESTED_CLASSES
12697           /* Class types don't nest the way enums do.  */
12698           class_binding_level = (struct binding_level *)0;
12699 #endif
12700           pushtag (name, ref, globalize);
12701           class_binding_level = old_b;
12702         }
12703     }
12704   else
12705     {
12706       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12707         redeclare_class_template (ref, current_template_parms);
12708     }
12709
12710   /* Until the type is defined, tentatively accept whatever
12711      structure tag the user hands us.  */
12712   if (!COMPLETE_TYPE_P (ref)
12713       && ref != current_class_type
12714       /* Have to check this, in case we have contradictory tag info.  */
12715       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12716     {
12717       if (tag_code == class_type)
12718         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12719       else if (tag_code == record_type)
12720         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12721     }
12722
12723   TREE_TYPE (ref) = attributes;
12724
12725   return ref;
12726 }
12727
12728 tree
12729 xref_tag_from_type (old, id, globalize)
12730      tree old, id;
12731      int globalize;
12732 {
12733   tree code_type_node;
12734
12735   if (TREE_CODE (old) == RECORD_TYPE)
12736     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12737                       ? class_type_node : record_type_node);
12738   else
12739     code_type_node = union_type_node;
12740
12741   if (id == NULL_TREE)
12742     id = TYPE_IDENTIFIER (old);
12743
12744   return xref_tag (code_type_node, id, globalize);
12745 }
12746
12747 /* REF is a type (named NAME), for which we have just seen some
12748    baseclasses.  BINFO is a list of those baseclasses; the
12749    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12750    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12751    struct, or union.  */
12752
12753 void
12754 xref_basetypes (code_type_node, name, ref, binfo)
12755      tree code_type_node;
12756      tree name, ref;
12757      tree binfo;
12758 {
12759   /* In the declaration `A : X, Y, ... Z' we mark all the types
12760      (A, X, Y, ..., Z) so we can check for duplicates.  */
12761   tree binfos;
12762   tree base;
12763
12764   int i, len;
12765   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12766
12767   if (tag_code == union_type)
12768     {
12769       cp_error ("derived union `%T' invalid", ref);
12770       return;
12771     }
12772
12773   len = list_length (binfo);
12774
12775   /* First, make sure that any templates in base-classes are
12776      instantiated.  This ensures that if we call ourselves recursively
12777      we do not get confused about which classes are marked and which
12778      are not.  */
12779   for (base = binfo; base; base = TREE_CHAIN (base))
12780     complete_type (TREE_VALUE (base));
12781
12782   SET_CLASSTYPE_MARKED (ref);
12783   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12784
12785   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12786     {
12787       /* The base of a derived struct is public by default.  */
12788       int via_public
12789         = (TREE_PURPOSE (binfo) == access_public_node
12790            || TREE_PURPOSE (binfo) == access_public_virtual_node
12791            || (tag_code != class_type
12792                && (TREE_PURPOSE (binfo) == access_default_node
12793                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12794       int via_protected
12795         = (TREE_PURPOSE (binfo) == access_protected_node
12796            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12797       int via_virtual
12798         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12799            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12800            || TREE_PURPOSE (binfo) == access_public_virtual_node
12801            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12802       tree basetype = TREE_VALUE (binfo);
12803       tree base_binfo;
12804
12805       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12806         basetype = TREE_TYPE (basetype);
12807       if (!basetype
12808           || (TREE_CODE (basetype) != RECORD_TYPE
12809               && TREE_CODE (basetype) != TYPENAME_TYPE
12810               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12811               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
12812         {
12813           cp_error ("base type `%T' fails to be a struct or class type",
12814                     TREE_VALUE (binfo));
12815           continue;
12816         }
12817
12818       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12819
12820       /* This code replaces similar code in layout_basetypes.
12821          We put the complete_type first for implicit `typename'.  */
12822       if (!COMPLETE_TYPE_P (basetype)
12823           && ! (current_template_parms && uses_template_parms (basetype)))
12824         {
12825           cp_error ("base class `%T' has incomplete type", basetype);
12826           continue;
12827         }
12828       else
12829         {
12830           if (CLASSTYPE_MARKED (basetype))
12831             {
12832               if (basetype == ref)
12833                 cp_error ("recursive type `%T' undefined", basetype);
12834               else
12835                 cp_error ("duplicate base type `%T' invalid", basetype);
12836               continue;
12837             }
12838
12839           if (TYPE_FOR_JAVA (basetype)
12840               && (current_lang_depth () == 0))
12841             TYPE_FOR_JAVA (ref) = 1;
12842
12843           /* Note that the BINFO records which describe individual
12844              inheritances are *not* shared in the lattice!  They
12845              cannot be shared because a given baseclass may be
12846              inherited with different `accessibility' by different
12847              derived classes.  (Each BINFO record describing an
12848              individual inheritance contains flags which say what
12849              the `accessibility' of that particular inheritance is.)  */
12850
12851           base_binfo
12852             = make_binfo (size_zero_node, basetype,
12853                           CLASS_TYPE_P (basetype)
12854                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12855                           CLASS_TYPE_P (basetype)
12856                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12857
12858           TREE_VEC_ELT (binfos, i) = base_binfo;
12859           TREE_VIA_PUBLIC (base_binfo) = via_public;
12860           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12861           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12862           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12863
12864           /* We need to unshare the binfos now so that lookups during class
12865              definition work.  */
12866           unshare_base_binfos (base_binfo);
12867
12868           SET_CLASSTYPE_MARKED (basetype);
12869
12870           /* We are free to modify these bits because they are meaningless
12871              at top level, and BASETYPE is a top-level type.  */
12872           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12873             {
12874               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12875               /* Converting to a virtual base class requires looking
12876                  up the offset of the virtual base.  */
12877               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12878             }
12879
12880           if (CLASS_TYPE_P (basetype))
12881             {
12882               TYPE_HAS_NEW_OPERATOR (ref)
12883                 |= TYPE_HAS_NEW_OPERATOR (basetype);
12884               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12885                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12886               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12887               /* If the base-class uses multiple inheritance, so do we.  */
12888               TYPE_USES_MULTIPLE_INHERITANCE (ref)
12889                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12890               /* Likewise, if converting to a base of the base may require
12891                  code, then we may need to generate code to convert to a
12892                  base as well.  */
12893               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12894                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12895             }
12896
12897           i += 1;
12898         }
12899     }
12900   if (i)
12901     TREE_VEC_LENGTH (binfos) = i;
12902   else
12903     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12904
12905   if (i > 1)
12906     {
12907       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12908       /* If there is more than one non-empty they cannot be at the same
12909          address.  */
12910       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12911     }
12912
12913   /* Unmark all the types.  */
12914   while (--i >= 0)
12915     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12916   CLEAR_CLASSTYPE_MARKED (ref);
12917
12918   /* Now that we know all the base-classes, set up the list of virtual
12919      bases.  */
12920   get_vbase_types (ref);
12921 }
12922
12923 \f
12924 /* Begin compiling the definition of an enumeration type.
12925    NAME is its name (or null if anonymous).
12926    Returns the type object, as yet incomplete.
12927    Also records info about it so that build_enumerator
12928    may be used to declare the individual values as they are read.  */
12929
12930 tree
12931 start_enum (name)
12932      tree name;
12933 {
12934   register tree enumtype = NULL_TREE;
12935   struct binding_level *b = current_binding_level;
12936
12937   /* If this is the real definition for a previous forward reference,
12938      fill in the contents in the same object that used to be the
12939      forward reference.  */
12940
12941   if (name != NULL_TREE)
12942     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12943
12944   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12945     {
12946       cp_error ("multiple definition of `%#T'", enumtype);
12947       cp_error_at ("previous definition here", enumtype);
12948       /* Clear out TYPE_VALUES, and start again.  */
12949       TYPE_VALUES (enumtype) = NULL_TREE;
12950     }
12951   else
12952     {
12953       enumtype = make_node (ENUMERAL_TYPE);
12954       pushtag (name, enumtype, 0);
12955     }
12956
12957   if (current_class_type)
12958     TREE_ADDRESSABLE (b->tags) = 1;
12959
12960   GNU_xref_decl (current_function_decl, enumtype);
12961   return enumtype;
12962 }
12963
12964 /* After processing and defining all the values of an enumeration type,
12965    install their decls in the enumeration type and finish it off.
12966    ENUMTYPE is the type object and VALUES a list of name-value pairs.  */
12967
12968 void
12969 finish_enum (enumtype)
12970      tree enumtype;
12971 {
12972   tree pair;
12973   tree minnode;
12974   tree maxnode;
12975   tree t;
12976   bool unsignedp;
12977   int lowprec;
12978   int highprec;
12979   int precision;
12980
12981   /* We built up the VALUES in reverse order.  */
12982   TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
12983
12984   /* [dcl.enum]
12985
12986      Following the closing brace of an enum-specifier, each
12987      enumerator has the type of its enumeration.  Prior to the
12988      closing brace, the type of each enumerator is the type of
12989      its initializing value.  */
12990   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
12991     TREE_TYPE (TREE_VALUE (pair)) = enumtype;
12992
12993   /* For a enum defined in a template, all further processing is
12994      postponed until the template is instantiated.  */
12995   if (processing_template_decl)
12996     {
12997       tree scope = current_scope ();
12998       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12999         add_stmt (build_min (TAG_DEFN, enumtype));
13000
13001
13002       return;
13003     }
13004
13005   /* Figure out what the minimum and maximum values of the enumerators
13006      are.  */
13007   if (TYPE_VALUES (enumtype))
13008     {
13009       minnode = maxnode = NULL_TREE;
13010
13011       for (pair = TYPE_VALUES (enumtype);
13012            pair;
13013            pair = TREE_CHAIN (pair))
13014         {
13015           tree value;
13016
13017           value = DECL_INITIAL (TREE_VALUE (pair));
13018
13019           if (!minnode)
13020             minnode = maxnode = value;
13021           else if (tree_int_cst_lt (maxnode, value))
13022             maxnode = value;
13023           else if (tree_int_cst_lt (value, minnode))
13024             minnode = value;
13025         }
13026     }
13027   else
13028     minnode = maxnode = integer_zero_node;
13029
13030   /* Compute the number of bits require to represent all values of the
13031      enumeration.  We must do this before the type of MINNODE and
13032      MAXNODE are transformed, since min_precision relies on the
13033      TREE_TYPE of the value it is passed.  */
13034   unsignedp = tree_int_cst_sgn (minnode) >= 0;
13035   lowprec = min_precision (minnode, unsignedp);
13036   highprec = min_precision (maxnode, unsignedp);
13037   precision = MAX (lowprec, highprec);
13038
13039   /* Set the TREE_TYPE for the values as well.  That's so that when we
13040      call decl_constant_value we get an entity of the right type (but
13041      with the constant value).  In addition, transform the TYPE_VALUES
13042      list to contain the values, rather than the CONST_DECLs for them.  */
13043   for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13044     {
13045       tree value = DECL_INITIAL (TREE_VALUE (pair));
13046
13047       TREE_TYPE (value) = enumtype;
13048       TREE_VALUE (pair) = value;
13049     }
13050
13051   /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13052   TYPE_SIZE (enumtype) = NULL_TREE;
13053   TYPE_PRECISION (enumtype) = precision;
13054   if (unsignedp)
13055     fixup_unsigned_type (enumtype);
13056   else
13057     fixup_signed_type (enumtype);
13058
13059   if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13060     /* Use the width of the narrowest normal C type which is wide
13061        enough.  */
13062     TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13063                                                 (precision, 1));
13064   else
13065     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13066
13067   TYPE_SIZE (enumtype) = NULL_TREE;
13068   layout_type (enumtype);
13069
13070   /* Fix up all variant types of this enum type.  */
13071   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13072     {
13073       TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13074       TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
13075       TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
13076       TYPE_SIZE (t) = TYPE_SIZE (enumtype);
13077       TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
13078       TYPE_MODE (t) = TYPE_MODE (enumtype);
13079       TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
13080       TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
13081       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
13082       TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype);
13083     }
13084
13085   /* Finish debugging output for this type.  */
13086   rest_of_type_compilation (enumtype, namespace_bindings_p ());
13087 }
13088
13089 /* Build and install a CONST_DECL for an enumeration constant of the
13090    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13091    Assignment of sequential values by default is handled here.  */
13092
13093 void
13094 build_enumerator (name, value, enumtype)
13095      tree name;
13096      tree value;
13097      tree enumtype;
13098 {
13099   tree decl;
13100   tree context;
13101   tree type;
13102   tree values;
13103
13104   /* Remove no-op casts from the value.  */
13105   if (value)
13106     STRIP_TYPE_NOPS (value);
13107
13108   if (! processing_template_decl)
13109     {
13110       /* Validate and default VALUE.  */
13111       if (value != NULL_TREE)
13112         {
13113           value = decl_constant_value (value);
13114
13115           if (TREE_CODE (value) == INTEGER_CST)
13116             {
13117               value = default_conversion (value);
13118               constant_expression_warning (value);
13119             }
13120           else
13121             {
13122               cp_error ("enumerator value for `%D' not integer constant", name);
13123               value = NULL_TREE;
13124             }
13125         }
13126
13127       /* Default based on previous value.  */
13128       if (value == NULL_TREE && ! processing_template_decl)
13129         {
13130           tree prev_value;
13131
13132           if (TYPE_VALUES (enumtype))
13133             {
13134               /* The next value is the previous value ... */
13135               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13136               /* ... plus one.  */
13137               value = cp_build_binary_op (PLUS_EXPR,
13138                                           prev_value,
13139                                           integer_one_node);
13140
13141               if (tree_int_cst_lt (value, prev_value))
13142                 cp_error ("overflow in enumeration values at `%D'", name);
13143             }
13144           else
13145             value = integer_zero_node;
13146         }
13147
13148       /* Remove no-op casts from the value.  */
13149       if (value)
13150         STRIP_TYPE_NOPS (value);
13151 #if 0
13152       /* To fix MAX_VAL enum consts. (bkoz)  */
13153       TREE_TYPE (value) = integer_type_node;
13154 #endif
13155     }
13156
13157   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13158      Even in other cases, we will later (in finish_enum) be setting
13159      the type of VALUE.  But, we don't need to make a copy if this
13160      VALUE is one of the enumeration constants for this same
13161      enumeration type.  */
13162   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13163     if (TREE_VALUE (values) == value)
13164       break;
13165   /* If we didn't break out of the loop, then we do need a copy.  */
13166   if (!values && value)
13167     value = copy_node (value);
13168
13169   /* C++ associates enums with global, function, or class declarations.  */
13170   context = current_scope ();
13171
13172   /* Build the actual enumeration constant.  Note that the enumeration
13173     constants have the type of their initializers until the
13174     enumeration is complete:
13175
13176       [ dcl.enum ]
13177
13178       Following the closing brace of an enum-specifier, each enumer-
13179       ator has the type of its enumeration.  Prior to the closing
13180       brace, the type of each enumerator is the type of its
13181       initializing value.
13182
13183     In finish_enum we will reset the type.  Of course, if we're
13184     processing a template, there may be no value.   */
13185   type = value ? TREE_TYPE (value) : NULL_TREE;
13186
13187   if (context && context == current_class_type)
13188     /* This enum declaration is local to the class.  We need the full
13189        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13190     decl = build_lang_decl (CONST_DECL, name, type);
13191   else
13192     /* It's a global enum, or it's local to a function.  (Note local to
13193       a function could mean local to a class method.  */
13194     decl = build_decl (CONST_DECL, name, type);
13195
13196   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13197   DECL_INITIAL (decl) = value;
13198   TREE_READONLY (decl) = 1;
13199
13200   if (context && context == current_class_type)
13201     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13202       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13203       things like `S::i' later.)  */
13204     finish_member_declaration (decl);
13205   else
13206     {
13207       pushdecl (decl);
13208       GNU_xref_decl (current_function_decl, decl);
13209     }
13210
13211   /* Add this enumeration constant to the list for this type.  */
13212   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13213 }
13214
13215 \f
13216 /* We're defining DECL.  Make sure that it's type is OK.  */
13217
13218 static void
13219 check_function_type (decl, current_function_parms)
13220      tree decl;
13221      tree current_function_parms;
13222 {
13223   tree fntype = TREE_TYPE (decl);
13224   tree return_type = complete_type (TREE_TYPE (fntype));
13225
13226   /* In a function definition, arg types must be complete.  */
13227   require_complete_types_for_parms (current_function_parms);
13228
13229   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13230     {
13231       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13232
13233       /* Make it return void instead, but don't change the
13234          type of the DECL_RESULT, in case we have a named return value.  */
13235       if (TREE_CODE (fntype) == METHOD_TYPE)
13236         {
13237           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13238           TREE_TYPE (decl)
13239             = build_cplus_method_type (ctype,
13240                                        void_type_node,
13241                                        FUNCTION_ARG_CHAIN (decl));
13242         }
13243       else
13244         TREE_TYPE (decl)
13245           = build_function_type (void_type_node,
13246                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13247       TREE_TYPE (decl)
13248         = build_exception_variant (fntype,
13249                                    TYPE_RAISES_EXCEPTIONS (fntype));
13250     }
13251   else
13252     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13253 }
13254
13255 /* Create the FUNCTION_DECL for a function definition.
13256    DECLSPECS and DECLARATOR are the parts of the declaration;
13257    they describe the function's name and the type it returns,
13258    but twisted together in a fashion that parallels the syntax of C.
13259
13260    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13261    DECLARATOR is really the DECL for the function we are about to
13262    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13263    indicating that the function is an inline defined in-class.
13264
13265    This function creates a binding context for the function body
13266    as well as setting up the FUNCTION_DECL in current_function_decl.
13267
13268    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13269    (it defines a datum instead), we return 0, which tells
13270    yyparse to report a parse error.
13271
13272    For C++, we must first check whether that datum makes any sense.
13273    For example, "class A local_a(1,2);" means that variable local_a
13274    is an aggregate of type A, which should have a constructor
13275    applied to it with the argument list [1, 2].  */
13276
13277 int
13278 start_function (declspecs, declarator, attrs, flags)
13279      tree declspecs, declarator, attrs;
13280      int flags;
13281 {
13282   tree decl1;
13283   tree ctype = NULL_TREE;
13284   tree fntype;
13285   tree restype;
13286   extern int have_extern_spec;
13287   extern int used_extern_spec;
13288   int doing_friend = 0;
13289   struct binding_level *bl;
13290   tree current_function_parms;
13291
13292   /* Sanity check.  */
13293   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13294   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13295
13296   /* This should only be done once on the top most decl.  */
13297   if (have_extern_spec && !used_extern_spec)
13298     {
13299       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13300       used_extern_spec = 1;
13301     }
13302
13303   if (flags & SF_PRE_PARSED)
13304     {
13305       decl1 = declarator;
13306
13307       fntype = TREE_TYPE (decl1);
13308       if (TREE_CODE (fntype) == METHOD_TYPE)
13309         ctype = TYPE_METHOD_BASETYPE (fntype);
13310
13311       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13312          the (lexical) scope of the class in which it is defined.  */
13313       if (!ctype && DECL_FRIEND_P (decl1))
13314         {
13315           ctype = DECL_FRIEND_CONTEXT (decl1);
13316
13317           /* CTYPE could be null here if we're dealing with a template;
13318              for example, `inline friend float foo()' inside a template
13319              will have no CTYPE set.  */
13320           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13321             ctype = NULL_TREE;
13322           else
13323             doing_friend = 1;
13324         }
13325
13326       last_function_parms = DECL_ARGUMENTS (decl1);
13327       last_function_parm_tags = NULL_TREE;
13328     }
13329   else
13330     {
13331       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13332       /* If the declarator is not suitable for a function definition,
13333          cause a syntax error.  */
13334       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13335
13336       fntype = TREE_TYPE (decl1);
13337
13338       restype = TREE_TYPE (fntype);
13339       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13340         {
13341           cp_error ("semicolon missing after declaration of `%#T'", restype);
13342           shadow_tag (build_tree_list (NULL_TREE, restype));
13343           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13344           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13345             fntype = build_function_type (integer_type_node,
13346                                           TYPE_ARG_TYPES (fntype));
13347           else
13348             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13349                                               integer_type_node,
13350                                               TYPE_ARG_TYPES (fntype));
13351           TREE_TYPE (decl1) = fntype;
13352         }
13353
13354       if (TREE_CODE (fntype) == METHOD_TYPE)
13355         ctype = TYPE_METHOD_BASETYPE (fntype);
13356       else if (DECL_MAIN_P (decl1))
13357         {
13358           /* If this doesn't return integer_type, complain.  */
13359           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13360             {
13361               if (pedantic || warn_return_type)
13362                 pedwarn ("return type for `main' changed to `int'");
13363               TREE_TYPE (decl1) = fntype = default_function_type;
13364             }
13365         }
13366     }
13367
13368   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13369     /* This is a constructor, we must ensure that any default args
13370        introduced by this definition are propagated to the clones
13371        now. The clones are used directly in overload resolution.  */
13372     adjust_clone_args (decl1);
13373
13374   /* Sometimes we don't notice that a function is a static member, and
13375      build a METHOD_TYPE for it.  Fix that up now.  */
13376   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13377       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13378     {
13379       revert_static_member_fn (decl1);
13380       last_function_parms = TREE_CHAIN (last_function_parms);
13381       ctype = NULL_TREE;
13382     }
13383
13384   /* Warn if function was previously implicitly declared
13385      (but not if we warned then).  */
13386   if (! warn_implicit
13387       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13388     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13389
13390   /* Set up current_class_type, and enter the scope of the class, if
13391      appropriate.  */
13392   if (ctype)
13393     push_nested_class (ctype, 1);
13394   else if (DECL_STATIC_FUNCTION_P (decl1))
13395     push_nested_class (DECL_CONTEXT (decl1), 2);
13396
13397   /* Now that we have entered the scope of the class, we must restore
13398      the bindings for any template parameters surrounding DECL1, if it
13399      is an inline member template.  (Order is important; consider the
13400      case where a template parameter has the same name as a field of
13401      the class.)  It is not until after this point that
13402      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13403   if (flags & SF_INCLASS_INLINE)
13404     maybe_begin_member_template_processing (decl1);
13405
13406   /* Effective C++ rule 15.  */
13407   if (warn_ecpp
13408       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13409       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13410     cp_warning ("`operator=' should return a reference to `*this'");
13411
13412   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13413      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13414   if (!DECL_INITIAL (decl1))
13415     DECL_INITIAL (decl1) = error_mark_node;
13416
13417 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13418   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13419 #endif
13420
13421   /* This function exists in static storage.
13422      (This does not mean `static' in the C sense!)  */
13423   TREE_STATIC (decl1) = 1;
13424
13425   /* We must call push_template_decl after current_class_type is set
13426      up.  (If we are processing inline definitions after exiting a
13427      class scope, current_class_type will be NULL_TREE until set above
13428      by push_nested_class.)  */
13429   if (processing_template_decl)
13430     decl1 = push_template_decl (decl1);
13431
13432   /* We are now in the scope of the function being defined.  */
13433   current_function_decl = decl1;
13434
13435   /* Save the parm names or decls from this function's declarator
13436      where store_parm_decls will find them.  */
13437   current_function_parms = last_function_parms;
13438   current_function_parm_tags = last_function_parm_tags;
13439
13440   /* Make sure the parameter and return types are reasonable.  When
13441      you declare a function, these types can be incomplete, but they
13442      must be complete when you define the function.  */
13443   if (! processing_template_decl)
13444     check_function_type (decl1, current_function_parms);
13445
13446   /* Build the return declaration for the function.  */
13447   restype = TREE_TYPE (fntype);
13448   if (!processing_template_decl)
13449     {
13450       if (!DECL_RESULT (decl1))
13451         {
13452           DECL_RESULT (decl1)
13453             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13454           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13455                                       DECL_RESULT (decl1));
13456         }
13457     }
13458   else
13459     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13460     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13461
13462   /* Initialize RTL machinery.  We cannot do this until
13463      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13464      even when processing a template; this is how we get
13465      CFUN set up, and our per-function variables initialized.
13466      FIXME factor out the non-RTL stuff.  */
13467   bl = current_binding_level;
13468   init_function_start (decl1, input_filename, lineno);
13469   current_binding_level = bl;
13470
13471   /* Even though we're inside a function body, we still don't want to
13472      call expand_expr to calculate the size of a variable-sized array.
13473      We haven't necessarily assigned RTL to all variables yet, so it's
13474      not safe to try to expand expressions involving them.  */
13475   immediate_size_expand = 0;
13476   cfun->x_dont_save_pending_sizes_p = 1;
13477
13478   /* Start the statement-tree, start the tree now.  */
13479   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13480
13481   /* Let the user know we're compiling this function.  */
13482   announce_function (decl1);
13483
13484   /* Record the decl so that the function name is defined.
13485      If we already have a decl for this name, and it is a FUNCTION_DECL,
13486      use the old decl.  */
13487   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13488     {
13489       /* A specialization is not used to guide overload resolution.  */
13490       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13491           && ! DECL_FUNCTION_MEMBER_P (decl1))
13492         decl1 = pushdecl (decl1);
13493       else
13494         {
13495           /* We need to set the DECL_CONTEXT. */
13496           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13497             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13498           /* And make sure we have enough default args.  */
13499           check_default_args (decl1);
13500         }
13501       fntype = TREE_TYPE (decl1);
13502     }
13503
13504   /* Reset these in case the call to pushdecl changed them.  */
13505   current_function_decl = decl1;
13506   cfun->decl = decl1;
13507
13508   /* If we are (erroneously) defining a function that we have already
13509      defined before, wipe out what we knew before.  */
13510   if (!DECL_PENDING_INLINE_P (decl1)
13511       && DECL_SAVED_FUNCTION_DATA (decl1))
13512     {
13513       free (DECL_SAVED_FUNCTION_DATA (decl1));
13514       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13515     }
13516
13517   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13518     {
13519       /* We know that this was set up by `grokclassfn'.  We do not
13520          wait until `store_parm_decls', since evil parse errors may
13521          never get us to that point.  Here we keep the consistency
13522          between `current_class_type' and `current_class_ptr'.  */
13523       tree t = DECL_ARGUMENTS (decl1);
13524
13525       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13526                           162);
13527       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13528                           19990811);
13529
13530       cp_function_chain->x_current_class_ref
13531         = build_indirect_ref (t, NULL);
13532       cp_function_chain->x_current_class_ptr = t;
13533
13534       /* Constructors and destructors need to know whether they're "in
13535          charge" of initializing virtual base classes.  */
13536       t = TREE_CHAIN (t);
13537       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13538         {
13539           current_in_charge_parm = t;
13540           t = TREE_CHAIN (t);
13541         }
13542       if (DECL_HAS_VTT_PARM_P (decl1))
13543         {
13544           if (DECL_NAME (t) != vtt_parm_identifier)
13545             abort ();
13546           current_vtt_parm = t;
13547         }
13548     }
13549
13550   if (DECL_INTERFACE_KNOWN (decl1))
13551     {
13552       tree ctx = decl_function_context (decl1);
13553
13554       if (DECL_NOT_REALLY_EXTERN (decl1))
13555         DECL_EXTERNAL (decl1) = 0;
13556
13557       if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
13558           && TREE_PUBLIC (ctx))
13559         /* This is a function in a local class in an extern inline
13560            function.  */
13561         comdat_linkage (decl1);
13562     }
13563   /* If this function belongs to an interface, it is public.
13564      If it belongs to someone else's interface, it is also external.
13565      This only affects inlines and template instantiations.  */
13566   else if (interface_unknown == 0
13567            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13568                || flag_alt_external_templates))
13569     {
13570       if (DECL_DECLARED_INLINE_P (decl1)
13571           || DECL_TEMPLATE_INSTANTIATION (decl1)
13572           || processing_template_decl)
13573         {
13574           DECL_EXTERNAL (decl1)
13575             = (interface_only
13576                || (DECL_DECLARED_INLINE_P (decl1)
13577                    && ! flag_implement_inlines
13578                    && !DECL_VINDEX (decl1)));
13579
13580           /* For WIN32 we also want to put these in linkonce sections.  */
13581           maybe_make_one_only (decl1);
13582         }
13583       else
13584         DECL_EXTERNAL (decl1) = 0;
13585       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13586       DECL_INTERFACE_KNOWN (decl1) = 1;
13587     }
13588   else if (interface_unknown && interface_only
13589            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13590                || flag_alt_external_templates))
13591     {
13592       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13593          interface, we will have interface_only set but not
13594          interface_known.  In that case, we don't want to use the normal
13595          heuristics because someone will supply a #pragma implementation
13596          elsewhere, and deducing it here would produce a conflict.  */
13597       comdat_linkage (decl1);
13598       DECL_EXTERNAL (decl1) = 0;
13599       DECL_INTERFACE_KNOWN (decl1) = 1;
13600       DECL_DEFER_OUTPUT (decl1) = 1;
13601     }
13602   else
13603     {
13604       /* This is a definition, not a reference.
13605          So clear DECL_EXTERNAL.  */
13606       DECL_EXTERNAL (decl1) = 0;
13607
13608       if ((DECL_DECLARED_INLINE_P (decl1)
13609            || DECL_TEMPLATE_INSTANTIATION (decl1))
13610           && ! DECL_INTERFACE_KNOWN (decl1)
13611           /* Don't try to defer nested functions for now.  */
13612           && ! decl_function_context (decl1))
13613         DECL_DEFER_OUTPUT (decl1) = 1;
13614       else
13615         DECL_INTERFACE_KNOWN (decl1) = 1;
13616     }
13617
13618   pushlevel (0);
13619   current_binding_level->parm_flag = 1;
13620
13621   if (attrs)
13622     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13623
13624   /* Promote the value to int before returning it.  */
13625   if (c_promoting_integer_type_p (restype))
13626     restype = type_promotes_to (restype);
13627
13628   if (DECL_RESULT (decl1) == NULL_TREE)
13629     {
13630       DECL_RESULT (decl1)
13631         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13632       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13633       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13634     }
13635
13636   ++function_depth;
13637
13638   if (DECL_DESTRUCTOR_P (decl1))
13639     {
13640       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13641       DECL_CONTEXT (dtor_label) = current_function_decl;
13642     }
13643
13644   start_fname_decls ();
13645
13646   store_parm_decls (current_function_parms);
13647
13648   return 1;
13649 }
13650 \f
13651 /* Store the parameter declarations into the current function declaration.
13652    This is called after parsing the parameter declarations, before
13653    digesting the body of the function.
13654
13655    Also install to binding contour return value identifier, if any.  */
13656
13657 static void
13658 store_parm_decls (current_function_parms)
13659      tree current_function_parms;
13660 {
13661   register tree fndecl = current_function_decl;
13662   register tree parm;
13663   int parms_have_cleanups = 0;
13664   tree cleanups = NULL_TREE;
13665
13666   /* This is a list of types declared among parms in a prototype.  */
13667   tree parmtags = current_function_parm_tags;
13668
13669   /* This is a chain of any other decls that came in among the parm
13670      declarations.  If a parm is declared with  enum {foo, bar} x;
13671      then CONST_DECLs for foo and bar are put here.  */
13672   tree nonparms = NULL_TREE;
13673
13674   if (current_function_parms)
13675     {
13676       /* This case is when the function was defined with an ANSI prototype.
13677          The parms already have decls, so we need not do anything here
13678          except record them as in effect
13679          and complain if any redundant old-style parm decls were written.  */
13680
13681       tree specparms = current_function_parms;
13682       tree next;
13683
13684       /* Must clear this because it might contain TYPE_DECLs declared
13685              at class level.  */
13686       storedecls (NULL_TREE);
13687
13688       /* If we're doing semantic analysis, then we'll call pushdecl
13689              for each of these.  We must do them in reverse order so that
13690              they end in the correct forward order.  */
13691       specparms = nreverse (specparms);
13692
13693       for (parm = specparms; parm; parm = next)
13694         {
13695           next = TREE_CHAIN (parm);
13696           if (TREE_CODE (parm) == PARM_DECL)
13697             {
13698               tree cleanup;
13699
13700               if (DECL_NAME (parm) == NULL_TREE
13701                   || TREE_CODE (parm) != VOID_TYPE)
13702                 pushdecl (parm);
13703               else
13704                 cp_error ("parameter `%D' declared void", parm);
13705
13706               cleanup = (processing_template_decl
13707                          ? NULL_TREE
13708                          : maybe_build_cleanup (parm));
13709
13710               if (cleanup)
13711                 cleanups = tree_cons (parm, cleanup, cleanups);
13712             }
13713           else
13714             {
13715               /* If we find an enum constant or a type tag,
13716                  put it aside for the moment.  */
13717               TREE_CHAIN (parm) = NULL_TREE;
13718               nonparms = chainon (nonparms, parm);
13719             }
13720         }
13721
13722       /* Get the decls in their original chain order and record in the
13723          function.  This is all and only the PARM_DECLs that were
13724          pushed into scope by the loop above.  */
13725       DECL_ARGUMENTS (fndecl) = getdecls ();
13726       storetags (chainon (parmtags, gettags ()));
13727     }
13728   else
13729     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13730
13731   /* Now store the final chain of decls for the arguments
13732      as the decl-chain of the current lexical scope.
13733      Put the enumerators in as well, at the front so that
13734      DECL_ARGUMENTS is not modified.  */
13735   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13736
13737   /* Now that we have initialized the parms, we can start their
13738      cleanups.  We cannot do this before, since expand_decl_cleanup
13739      should not be called before the parm can be used.  */
13740   while (cleanups)
13741     {
13742       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13743                            TREE_VALUE (cleanups));
13744       cleanups = TREE_CHAIN (cleanups);
13745     }
13746
13747   /* Create a binding contour which can be used to catch
13748      cleanup-generated temporaries.  */
13749   if (parms_have_cleanups)
13750     pushlevel (0);
13751
13752   /* Do the starting of the exception specifications, if we have any.  */
13753   if (flag_exceptions && !processing_template_decl
13754       && flag_enforce_eh_specs
13755       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13756     current_eh_spec_block = begin_eh_spec_block ();
13757 }
13758
13759 \f
13760 /* We have finished doing semantic analysis on DECL, but have not yet
13761    generated RTL for its body.  Save away our current state, so that
13762    when we want to generate RTL later we know what to do.  */
13763
13764 static void
13765 save_function_data (decl)
13766      tree decl;
13767 {
13768   struct cp_language_function *f;
13769
13770   /* Save the language-specific per-function data so that we can
13771      get it back when we really expand this function.  */
13772   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13773                       19990908);
13774
13775   /* Make a copy.  */
13776   f = ((struct cp_language_function *)
13777        xmalloc (sizeof (struct cp_language_function)));
13778   memcpy (f, cp_function_chain, sizeof (struct cp_language_function));
13779   DECL_SAVED_FUNCTION_DATA (decl) = f;
13780
13781   /* Clear out the bits we don't need.  */
13782   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
13783   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
13784   f->x_named_label_uses = NULL;
13785   f->bindings = NULL;
13786   f->x_local_names = NULL;
13787
13788   /* When we get back here again, we will be expanding.  */
13789   f->x_expanding_p = 1;
13790
13791   /* If we've already decided that we cannot inline this function, we
13792      must remember that fact when we actually go to expand the
13793      function.  */
13794   if (current_function_cannot_inline)
13795     {
13796       f->cannot_inline = current_function_cannot_inline;
13797       DECL_INLINE (decl) = 0;
13798     }
13799 }
13800
13801 /* At the end of every constructor we generate to code to return
13802    `this'.  Do that now.  */
13803
13804 static void
13805 finish_constructor_body ()
13806 {
13807   /* Any return from a constructor will end up here.  */
13808   if (ctor_label)
13809     add_stmt (build_stmt (LABEL_STMT, ctor_label));
13810
13811   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13812      generate the return, rather than a goto to CTOR_LABEL.  */
13813   ctor_label = NULL_TREE;
13814   /* In check_return_expr we translate an empty return from a
13815      constructor to a return of `this'.  */
13816   finish_return_stmt (NULL_TREE);
13817   /* Mark the end of the constructor.  */
13818   add_stmt (build_stmt (CTOR_STMT));
13819 }
13820
13821 /* At the end of every destructor we generate code to restore virtual
13822    function tables to the values desired by base classes and to call
13823    to base class destructors.  Do that now.  */
13824
13825 static void
13826 finish_destructor_body ()
13827 {
13828   tree compound_stmt;
13829   tree exprstmt;
13830
13831   /* Create a block to contain all the extra code.  */
13832   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13833
13834   /* Any return from a destructor will end up here.  */
13835   add_stmt (build_stmt (LABEL_STMT, dtor_label));
13836
13837   /* Generate the code to call destructor on base class.  If this
13838      destructor belongs to a class with virtual functions, then set
13839      the virtual function table pointer to represent the type of our
13840      base class.  */
13841
13842   /* This side-effect makes call to `build_delete' generate the code
13843      we have to have at the end of this destructor.  `build_delete'
13844      will set the flag again.  */
13845   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13846
13847   exprstmt = build_delete (current_class_type,
13848                            current_class_ref,
13849                            sfk_base_destructor,
13850                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13851                            0);
13852
13853   if (exprstmt != error_mark_node
13854       && (TREE_CODE (exprstmt) != NOP_EXPR
13855           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13856           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13857     {
13858       if (exprstmt != void_zero_node)
13859         /* Don't call `expand_expr_stmt' if we're not going to do
13860            anything, since -Wall will give a diagnostic.  */
13861         finish_expr_stmt (exprstmt);
13862
13863       /* Run destructors for all virtual baseclasses.  */
13864       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13865         {
13866           tree vbases;
13867           tree if_stmt;
13868
13869           if_stmt = begin_if_stmt ();
13870           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13871                                       current_in_charge_parm,
13872                                       integer_two_node),
13873                                if_stmt);
13874
13875           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
13876           /* The CLASSTYPE_VBASECLASSES list is in initialization
13877              order, so we have to march through it in reverse order.  */
13878           for (vbases = nreverse (copy_list (vbases));
13879                vbases;
13880                vbases = TREE_CHAIN (vbases))
13881             {
13882               tree vbase = TREE_VALUE (vbases);
13883               tree base_type = BINFO_TYPE (vbase);
13884
13885               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (base_type))
13886                 {
13887                   tree base_ptr_type = build_pointer_type (base_type);
13888                   tree expr = current_class_ptr;
13889
13890                   /* Convert to the basetype here, as we know the layout is
13891                      fixed. What is more, if we let build_method_call do it,
13892                      it will use the vtable, which may have been clobbered
13893                      by the deletion of our primary base.  */
13894
13895                   expr = build1 (NOP_EXPR, base_ptr_type, expr);
13896                   expr = build (PLUS_EXPR, base_ptr_type, expr,
13897                                 BINFO_OFFSET (vbase));
13898                   expr = build_indirect_ref (expr, NULL);
13899                   expr = build_method_call (expr, base_dtor_identifier,
13900                                             NULL_TREE, vbase,
13901                                             LOOKUP_NORMAL);
13902                   finish_expr_stmt (expr);
13903                 }
13904             }
13905
13906           finish_then_clause (if_stmt);
13907           finish_if_stmt ();
13908         }
13909     }
13910
13911   /* In a virtual destructor, we must call delete.  */
13912   if (DECL_VIRTUAL_P (current_function_decl))
13913     {
13914       tree if_stmt;
13915       tree virtual_size = c_sizeof (current_class_type);
13916
13917       /* [class.dtor]
13918
13919          At the point of definition of a virtual destructor (including
13920          an implicit definition), non-placement operator delete shall
13921          be looked up in the scope of the destructor's class and if
13922          found shall be accessible and unambiguous.  */
13923       exprstmt = build_op_delete_call
13924         (DELETE_EXPR, current_class_ptr, virtual_size,
13925          LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13926
13927       if_stmt = begin_if_stmt ();
13928       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13929                                   current_in_charge_parm,
13930                                   integer_one_node),
13931                            if_stmt);
13932       finish_expr_stmt (exprstmt);
13933       finish_then_clause (if_stmt);
13934       finish_if_stmt ();
13935     }
13936
13937   /* Close the block we started above.  */
13938   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13939 }
13940
13941 /* Finish up a function declaration and compile that function
13942    all the way to assembler language output.  The free the storage
13943    for the function definition.
13944
13945    FLAGS is a bitwise or of the following values:
13946      1 - CALL_POPLEVEL
13947        An extra call to poplevel (and expand_end_bindings) must be
13948        made to take care of the binding contour for the base
13949        initializers.  This is only relevant for constructors.
13950      2 - INCLASS_INLINE
13951        We just finished processing the body of an in-class inline
13952        function definition.  (This processing will have taken place
13953        after the class definition is complete.)  */
13954
13955 tree
13956 finish_function (flags)
13957      int flags;
13958 {
13959   register tree fndecl = current_function_decl;
13960   tree fntype, ctype = NULL_TREE;
13961   int call_poplevel = (flags & 1) != 0;
13962   int inclass_inline = (flags & 2) != 0;
13963   int nested;
13964
13965   /* When we get some parse errors, we can end up without a
13966      current_function_decl, so cope.  */
13967   if (fndecl == NULL_TREE)
13968     return error_mark_node;
13969
13970   nested = function_depth > 1;
13971   fntype = TREE_TYPE (fndecl);
13972
13973   /*  TREE_READONLY (fndecl) = 1;
13974       This caused &foo to be of type ptr-to-const-function
13975       which then got a warning when stored in a ptr-to-function variable.  */
13976
13977   my_friendly_assert (building_stmt_tree (), 20000911);
13978
13979   finish_fname_decls ();
13980
13981   /* For a cloned function, we've already got all the code we need;
13982      there's no need to add any extra bits.  */
13983   if (!DECL_CLONED_FUNCTION_P (fndecl))
13984     {
13985       if (DECL_CONSTRUCTOR_P (fndecl))
13986         {
13987           finish_constructor_body ();
13988           if (call_poplevel)
13989             do_poplevel ();
13990         }
13991       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
13992         finish_destructor_body ();
13993       else if (DECL_MAIN_P (fndecl))
13994         {
13995           /* Make it so that `main' always returns 0 by default.  */
13996 #ifdef VMS
13997           finish_return_stmt (integer_one_node);
13998 #else
13999           finish_return_stmt (integer_zero_node);
14000 #endif
14001         }
14002
14003       /* Finish dealing with exception specifiers.  */
14004       if (flag_exceptions && !processing_template_decl
14005           && flag_enforce_eh_specs
14006           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14007         finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14008                               (TREE_TYPE (current_function_decl)),
14009                               current_eh_spec_block);
14010     }
14011
14012   /* If we're saving up tree structure, tie off the function now.  */
14013   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14014
14015   /* This must come after expand_function_end because cleanups might
14016      have declarations (from inline functions) that need to go into
14017      this function's blocks.  */
14018   if (current_binding_level->parm_flag != 1)
14019     my_friendly_abort (122);
14020   poplevel (1, 0, 1);
14021
14022   /* Remember that we were in class scope.  */
14023   if (current_class_name)
14024     ctype = current_class_type;
14025
14026   /* Must mark the RESULT_DECL as being in this function.  */
14027   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14028
14029   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14030      to the FUNCTION_DECL node itself.  */
14031   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14032
14033   /* Save away current state, if appropriate.  */
14034   if (!processing_template_decl)
14035     save_function_data (fndecl);
14036
14037   /* If this function calls `setjmp' it cannot be inlined.  When
14038      `longjmp' is called it is not guaranteed to restore the value of
14039      local variables that have been modified since the call to
14040      `setjmp'.  So, if were to inline this function into some caller
14041      `c', then when we `longjmp', we might not restore all variables
14042      in `c'.  (It might seem, at first blush, that there's no way for
14043      this function to modify local variables in `c', but their
14044      addresses may have been stored somewhere accessible to this
14045      function.)  */
14046   if (!processing_template_decl && calls_setjmp_p (fndecl))
14047     DECL_UNINLINABLE (fndecl) = 1;
14048
14049   /* Clear out memory we no longer need.  */
14050   free_after_parsing (cfun);
14051   /* Since we never call rest_of_compilation, we never clear
14052      CFUN.  Do so explicitly.  */
14053   free_after_compilation (cfun);
14054   cfun = NULL;
14055
14056   /* If this is a in-class inline definition, we may have to pop the
14057      bindings for the template parameters that we added in
14058      maybe_begin_member_template_processing when start_function was
14059      called.  */
14060   if (inclass_inline)
14061     maybe_end_member_template_processing ();
14062
14063   /* Leave the scope of the class.  */
14064   if (ctype)
14065     pop_nested_class ();
14066
14067   --function_depth;
14068
14069   /* Clean up.  */
14070   if (! nested)
14071     /* Let the error reporting routines know that we're outside a
14072        function.  For a nested function, this value is used in
14073        pop_cp_function_context and then reset via pop_function_context.  */
14074     current_function_decl = NULL_TREE;
14075
14076   return fndecl;
14077 }
14078 \f
14079 /* Create the FUNCTION_DECL for a function definition.
14080    DECLSPECS and DECLARATOR are the parts of the declaration;
14081    they describe the return type and the name of the function,
14082    but twisted together in a fashion that parallels the syntax of C.
14083
14084    This function creates a binding context for the function body
14085    as well as setting up the FUNCTION_DECL in current_function_decl.
14086
14087    Returns a FUNCTION_DECL on success.
14088
14089    If the DECLARATOR is not suitable for a function (it defines a datum
14090    instead), we return 0, which tells yyparse to report a parse error.
14091
14092    May return void_type_node indicating that this method is actually
14093    a friend.  See grokfield for more details.
14094
14095    Came here with a `.pushlevel' .
14096
14097    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14098    CHANGES TO CODE IN `grokfield'.  */
14099
14100 tree
14101 start_method (declspecs, declarator, attrlist)
14102      tree declarator, declspecs, attrlist;
14103 {
14104   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14105                                 attrlist);
14106
14107   /* Something too ugly to handle.  */
14108   if (fndecl == NULL_TREE)
14109     return NULL_TREE;
14110
14111   /* Pass friends other than inline friend functions back.  */
14112   if (fndecl == void_type_node)
14113     return fndecl;
14114
14115   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14116     /* Not a function, tell parser to report parse error.  */
14117     return NULL_TREE;
14118
14119   if (DECL_IN_AGGR_P (fndecl))
14120     {
14121       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14122         {
14123           if (DECL_CONTEXT (fndecl)
14124               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14125             cp_error ("`%D' is already defined in class `%T'", fndecl,
14126                       DECL_CONTEXT (fndecl));
14127         }
14128       return void_type_node;
14129     }
14130
14131   check_template_shadow (fndecl);
14132
14133   DECL_DECLARED_INLINE_P (fndecl) = 1;
14134
14135   if (flag_default_inline)
14136     DECL_INLINE (fndecl) = 1;
14137
14138   /* We process method specializations in finish_struct_1.  */
14139   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14140     fndecl = push_template_decl (fndecl);
14141
14142   if (! DECL_FRIEND_P (fndecl))
14143     {
14144       if (TREE_CHAIN (fndecl))
14145         {
14146           fndecl = copy_node (fndecl);
14147           TREE_CHAIN (fndecl) = NULL_TREE;
14148         }
14149
14150       if (DECL_CONSTRUCTOR_P (fndecl))
14151         {
14152           if (! grok_ctor_properties (current_class_type, fndecl))
14153             return void_type_node;
14154         }
14155       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14156         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14157     }
14158
14159   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14160
14161   /* Make a place for the parms */
14162   pushlevel (0);
14163   current_binding_level->parm_flag = 1;
14164
14165   DECL_IN_AGGR_P (fndecl) = 1;
14166   return fndecl;
14167 }
14168
14169 /* Go through the motions of finishing a function definition.
14170    We don't compile this method until after the whole class has
14171    been processed.
14172
14173    FINISH_METHOD must return something that looks as though it
14174    came from GROKFIELD (since we are defining a method, after all).
14175
14176    This is called after parsing the body of the function definition.
14177    STMTS is the chain of statements that makes up the function body.
14178
14179    DECL is the ..._DECL that `start_method' provided.  */
14180
14181 tree
14182 finish_method (decl)
14183      tree decl;
14184 {
14185   register tree fndecl = decl;
14186   tree old_initial;
14187
14188   register tree link;
14189
14190   if (decl == void_type_node)
14191     return decl;
14192
14193   old_initial = DECL_INITIAL (fndecl);
14194
14195   /* Undo the level for the parms (from start_method).
14196      This is like poplevel, but it causes nothing to be
14197      saved.  Saving information here confuses symbol-table
14198      output routines.  Besides, this information will
14199      be correctly output when this method is actually
14200      compiled.  */
14201
14202   /* Clear out the meanings of the local variables of this level;
14203      also record in each decl which block it belongs to.  */
14204
14205   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14206     {
14207       if (DECL_NAME (link) != NULL_TREE)
14208         pop_binding (DECL_NAME (link), link);
14209       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14210       DECL_CONTEXT (link) = NULL_TREE;
14211     }
14212
14213   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14214                       (HOST_WIDE_INT) current_binding_level->level_chain,
14215                       current_binding_level->parm_flag,
14216                       current_binding_level->keep);
14217
14218   poplevel (0, 0, 0);
14219
14220   DECL_INITIAL (fndecl) = old_initial;
14221
14222   /* We used to check if the context of FNDECL was different from
14223      current_class_type as another way to get inside here.  This didn't work
14224      for String.cc in libg++.  */
14225   if (DECL_FRIEND_P (fndecl))
14226     {
14227       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14228         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14229       decl = void_type_node;
14230     }
14231
14232   return decl;
14233 }
14234 \f
14235 /* Called when a new struct TYPE is defined.
14236    If this structure or union completes the type of any previous
14237    variable declaration, lay it out and output its rtl.  */
14238
14239 void
14240 hack_incomplete_structures (type)
14241      tree type;
14242 {
14243   tree *list;
14244   struct binding_level *level;
14245
14246   if (!type) /* Don't do this for class templates.  */
14247     return;
14248
14249   if (namespace_bindings_p ())
14250     {
14251       level = 0;
14252       list = &namespace_scope_incomplete;
14253     }
14254   else
14255     {
14256       level = innermost_nonclass_level ();
14257       list = &level->incomplete;
14258     }
14259
14260   while (1)
14261     {
14262       while (*list)
14263         {
14264           tree decl = TREE_VALUE (*list);
14265           if ((decl && TREE_TYPE (decl) == type)
14266               || (TREE_TYPE (decl)
14267                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14268                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14269             {
14270               int toplevel = toplevel_bindings_p ();
14271               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14272                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14273                 layout_type (TREE_TYPE (decl));
14274               layout_decl (decl, 0);
14275               rest_of_decl_compilation (decl, NULL, toplevel, 0);
14276               if (! toplevel)
14277                 {
14278                   tree cleanup;
14279                   expand_decl (decl);
14280                   cleanup = maybe_build_cleanup (decl);
14281                   expand_decl_init (decl);
14282                   if (! expand_decl_cleanup (decl, cleanup))
14283                     cp_error ("parser lost in parsing declaration of `%D'",
14284                               decl);
14285                 }
14286               *list = TREE_CHAIN (*list);
14287             }
14288           else
14289             list = &TREE_CHAIN (*list);
14290         }
14291
14292       /* Keep looking through artificial binding levels generated
14293          for local variables.  */
14294       if (level && level->keep == 2)
14295         {
14296           level = level->level_chain;
14297           list = &level->incomplete;
14298         }
14299       else
14300         break;
14301     }
14302 }
14303
14304 /* If DECL is of a type which needs a cleanup, build that cleanup
14305    here.  */
14306
14307 tree
14308 maybe_build_cleanup (decl)
14309      tree decl;
14310 {
14311   tree type = TREE_TYPE (decl);
14312
14313   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14314     {
14315       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14316       tree rval;
14317
14318       if (TREE_CODE (type) == ARRAY_TYPE)
14319         rval = decl;
14320       else
14321         {
14322           mark_addressable (decl);
14323           rval = build_unary_op (ADDR_EXPR, decl, 0);
14324         }
14325
14326       /* Optimize for space over speed here.  */
14327       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14328           || flag_expensive_optimizations)
14329         flags |= LOOKUP_NONVIRTUAL;
14330
14331       rval = build_delete (TREE_TYPE (rval), rval,
14332                            sfk_complete_destructor, flags, 0);
14333
14334       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14335           && ! TYPE_HAS_DESTRUCTOR (type))
14336         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14337                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14338
14339       return rval;
14340     }
14341   return 0;
14342 }
14343 \f
14344 /* When a stmt has been parsed, this function is called.  */
14345
14346 void
14347 finish_stmt ()
14348 {
14349   /* Always assume this statement was not an expression statement.  If
14350      it actually was an expression statement, its our callers
14351      responsibility to fix this up.  */
14352   last_expr_type = NULL_TREE;
14353 }
14354
14355 /* DECL was originally constructed as a non-static member function,
14356    but turned out to be static.  Update it accordingly.  */
14357
14358 void
14359 revert_static_member_fn (decl)
14360      tree decl;
14361 {
14362   tree tmp;
14363   tree function = TREE_TYPE (decl);
14364   tree args = TYPE_ARG_TYPES (function);
14365
14366   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14367       != TYPE_UNQUALIFIED)
14368     cp_error ("static member function `%#D' declared with type qualifiers",
14369               decl);
14370
14371   args = TREE_CHAIN (args);
14372   tmp = build_function_type (TREE_TYPE (function), args);
14373   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14374   tmp = build_exception_variant (tmp,
14375                                  TYPE_RAISES_EXCEPTIONS (function));
14376   TREE_TYPE (decl) = tmp;
14377   if (DECL_ARGUMENTS (decl))
14378     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14379   DECL_STATIC_FUNCTION_P (decl) = 1;
14380 }
14381
14382 /* Initialize the variables used during compilation of a C++
14383    function.  */
14384
14385 static void
14386 push_cp_function_context (f)
14387      struct function *f;
14388 {
14389   struct cp_language_function *p
14390     = ((struct cp_language_function *)
14391        xcalloc (1, sizeof (struct cp_language_function)));
14392   f->language = (struct language_function *) p;
14393
14394   /* It takes an explicit call to expand_body to generate RTL for a
14395      function.  */
14396   expanding_p = 0;
14397
14398   /* Whenever we start a new function, we destroy temporaries in the
14399      usual way.  */
14400   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14401 }
14402
14403 /* Free the language-specific parts of F, now that we've finished
14404    compiling the function.  */
14405
14406 static void
14407 pop_cp_function_context (f)
14408      struct function *f;
14409 {
14410   if (f->language)
14411     {
14412       struct cp_language_function *cp =
14413         (struct cp_language_function *) f->language;
14414       if (cp->x_local_names)
14415         VARRAY_FREE (cp->x_local_names);
14416       free (f->language);
14417     }
14418   f->language = 0;
14419 }
14420
14421 /* Mark P for GC.  */
14422
14423 static void
14424 mark_lang_function (p)
14425      struct cp_language_function *p;
14426 {
14427   if (!p)
14428     return;
14429
14430   mark_c_language_function (&p->base);
14431
14432   ggc_mark_tree (p->x_ctor_label);
14433   ggc_mark_tree (p->x_dtor_label);
14434   ggc_mark_tree (p->x_current_class_ptr);
14435   ggc_mark_tree (p->x_current_class_ref);
14436   ggc_mark_tree (p->x_eh_spec_block);
14437   ggc_mark_tree_varray (p->x_local_names);
14438
14439   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14440   mark_binding_level (&p->bindings);
14441 }
14442
14443 /* Mark the language-specific data in F for GC.  */
14444
14445 static void
14446 mark_cp_function_context (f)
14447      struct function *f;
14448 {
14449   mark_lang_function ((struct cp_language_function *) f->language);
14450 }
14451
14452 void
14453 lang_mark_tree (t)
14454      tree t;
14455 {
14456   enum tree_code code = TREE_CODE (t);
14457   if (code == IDENTIFIER_NODE)
14458     {
14459       struct lang_identifier *li = (struct lang_identifier *) t;
14460       struct lang_id2 *li2 = li->x;
14461       ggc_mark_tree (li->namespace_bindings);
14462       ggc_mark_tree (li->bindings);
14463       ggc_mark_tree (li->class_value);
14464       ggc_mark_tree (li->class_template_info);
14465
14466       if (li2)
14467         {
14468           ggc_mark_tree (li2->label_value);
14469           ggc_mark_tree (li2->implicit_decl);
14470           ggc_mark_tree (li2->error_locus);
14471         }
14472     }
14473   else if (code == CPLUS_BINDING)
14474     {
14475       if (BINDING_HAS_LEVEL_P (t))
14476         mark_binding_level (&BINDING_LEVEL (t));
14477       else
14478         ggc_mark_tree (BINDING_SCOPE (t));
14479       ggc_mark_tree (BINDING_VALUE (t));
14480     }
14481   else if (code == OVERLOAD)
14482     ggc_mark_tree (OVL_FUNCTION (t));
14483   else if (code == TEMPLATE_PARM_INDEX)
14484     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14485   else if (TREE_CODE_CLASS (code) == 'd')
14486     {
14487       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14488
14489       if (ld)
14490         {
14491           ggc_mark (ld);
14492           c_mark_lang_decl (&ld->decl_flags.base);
14493           if (!DECL_GLOBAL_CTOR_P (t)
14494               && !DECL_GLOBAL_DTOR_P (t)
14495               && !DECL_THUNK_P (t)
14496               && !DECL_DISCRIMINATOR_P (t))
14497             ggc_mark_tree (ld->decl_flags.u2.access);
14498           else if (DECL_THUNK_P (t))
14499             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14500           if (TREE_CODE (t) != NAMESPACE_DECL)
14501             ggc_mark_tree (ld->decl_flags.u.template_info);
14502           else
14503             mark_binding_level (&NAMESPACE_LEVEL (t));
14504           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14505             {
14506               ggc_mark_tree (ld->befriending_classes);
14507               ggc_mark_tree (ld->context);
14508               ggc_mark_tree (ld->cloned_function);
14509               ggc_mark_tree (ld->inlined_fns);
14510               if (TREE_CODE (t) == TYPE_DECL)
14511                 ggc_mark_tree (ld->u.sorted_fields);
14512               else if (TREE_CODE (t) == FUNCTION_DECL
14513                        && !DECL_PENDING_INLINE_P (t))
14514                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14515             }
14516         }
14517     }
14518   else if (TREE_CODE_CLASS (code) == 't')
14519     {
14520       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14521
14522       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14523                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14524         {
14525           ggc_mark (lt);
14526           ggc_mark_tree (lt->primary_base);
14527           ggc_mark_tree (lt->vfields);
14528           ggc_mark_tree (lt->vbases);
14529           ggc_mark_tree (lt->tags);
14530           ggc_mark_tree (lt->size);
14531           ggc_mark_tree (lt->pure_virtuals);
14532           ggc_mark_tree (lt->friend_classes);
14533           ggc_mark_tree (lt->rtti);
14534           ggc_mark_tree (lt->methods);
14535           ggc_mark_tree (lt->template_info);
14536           ggc_mark_tree (lt->befriending_classes);
14537         }
14538       else if (lt)
14539         /* In the case of pointer-to-member function types, the
14540            TYPE_LANG_SPECIFIC is really just a tree.  */
14541         ggc_mark_tree ((tree) lt);
14542     }
14543 }
14544
14545 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14546    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
14547
14548 tree
14549 identifier_global_value (t)
14550      tree t;
14551 {
14552   return IDENTIFIER_GLOBAL_VALUE (t);
14553 }
14554
14555 /* Build the void_list_node (void_type_node having been created).  */
14556 tree
14557 build_void_list_node ()
14558 {
14559   tree t = build_tree_list (NULL_TREE, void_type_node);
14560   TREE_PARMLIST (t) = 1;
14561   return t;
14562 }
14563
14564 static int
14565 cp_missing_noreturn_ok_p (decl)
14566      tree decl;
14567 {
14568   /* A missing noreturn is ok for the `main' function.  */
14569   return DECL_MAIN_P (decl);
14570 }