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 current_class_depth;
  48
  49 extern tree global_namespace;
  50
  51 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  52
  53 #ifndef BOOL_TYPE_SIZE
  54 /* In the new ABI, `bool' has size and alignment `1', on all
  55    platforms.  */
  56 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  57 #endif
  58
  59 static tree grokparms                           PARAMS ((tree));
  60 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  61
  62 static void push_binding_level PARAMS ((struct binding_level *, int,
  63                                       int));
  64 static void pop_binding_level PARAMS ((void));
  65 static void suspend_binding_level PARAMS ((void));
  66 static void resume_binding_level PARAMS ((struct binding_level *));
  67 static struct binding_level *make_binding_level PARAMS ((void));
  68 static void declare_namespace_level PARAMS ((void));
  69 static int decl_jump_unsafe PARAMS ((tree));
  70 static void storedecls PARAMS ((tree));
  71 static void require_complete_types_for_parms PARAMS ((tree));
  72 static int ambi_op_p PARAMS ((enum tree_code));
  73 static int unary_op_p PARAMS ((enum tree_code));
  74 static tree store_bindings PARAMS ((tree, tree));
  75 static tree lookup_tag_reverse PARAMS ((tree, tree));
  76 static tree obscure_complex_init PARAMS ((tree, tree));
  77 static tree lookup_name_real PARAMS ((tree, int, int, int));
  78 static void warn_extern_redeclared_static PARAMS ((tree, tree));
  79 static void grok_reference_init PARAMS ((tree, tree, tree));
  80 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
  81                               enum overload_flags, tree,
  82                               tree, int, int, int, int, int, int, tree));
  83 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
  84 static tree lookup_tag PARAMS ((enum tree_code, tree,
  85                               struct binding_level *, int));
  86 static void set_identifier_type_value_with_scope
  87         PARAMS ((tree, tree, struct binding_level *));
  88 static void record_unknown_type PARAMS ((tree, const char *));
  89 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
  90 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
  91 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
  92                                   int));
  93 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
  94 static void check_for_uninitialized_const_var PARAMS ((tree));
  95 static unsigned long typename_hash PARAMS ((hash_table_key));
  96 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
  97 static void push_binding PARAMS ((tree, tree, struct binding_level*));
  98 static int add_binding PARAMS ((tree, tree));
  99 static void pop_binding PARAMS ((tree, tree));
 100 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 101 static tree find_binding PARAMS ((tree, tree));
 102 static tree select_decl PARAMS ((tree, int));
 103 static int lookup_flags PARAMS ((int, int));
 104 static tree qualify_lookup PARAMS ((tree, int));
 105 static tree record_builtin_java_type PARAMS ((const char *, int));
 106 static const char *tag_name PARAMS ((enum tag_types code));
 107 static void find_class_binding_level PARAMS ((void));
 108 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 109 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 110 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 111 static int walk_globals_r PARAMS ((tree, void *));
 112 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 113 static tree make_label_decl PARAMS ((tree, int));
 114 static void use_label PARAMS ((tree));
 115 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 116                                            const char *, int));
 117 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 118 static void check_switch_goto PARAMS ((struct binding_level *));
 119 static void check_previous_gotos PARAMS ((tree));
 120 static void pop_label PARAMS ((tree, tree));
 121 static void pop_labels PARAMS ((tree));
 122 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 123 static void layout_var_decl PARAMS ((tree));
 124 static void maybe_commonize_var PARAMS ((tree));
 125 static tree check_initializer PARAMS ((tree, tree));
 126 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 127 static void push_cp_function_context PARAMS ((struct function *));
 128 static void pop_cp_function_context PARAMS ((struct function *));
 129 static void mark_binding_level PARAMS ((void *));
 130 static void mark_named_label_lists PARAMS ((void *, void *));
 131 static void mark_cp_function_context PARAMS ((struct function *));
 132 static void mark_saved_scope PARAMS ((void *));
 133 static void mark_lang_function PARAMS ((struct cp_language_function *));
 134 static void save_function_data PARAMS ((tree));
 135 static void check_function_type PARAMS ((tree, tree));
 136 static void destroy_local_var PARAMS ((tree));
 137 static void finish_constructor_body PARAMS ((void));
 138 static void finish_destructor_body PARAMS ((void));
 139 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 140 static tree get_atexit_node PARAMS ((void));
 141 static tree get_dso_handle_node PARAMS ((void));
 142 static tree start_cleanup_fn PARAMS ((void));
 143 static void end_cleanup_fn PARAMS ((void));
 144 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
 145 static void initialize_predefined_identifiers PARAMS ((void));
 146 static tree check_special_function_return_type
 147   PARAMS ((special_function_kind, tree, tree));
 148 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 149 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 150 static void store_parm_decls PARAMS ((tree));
 151 static int cp_missing_noreturn_ok_p PARAMS ((tree));
 152
 153 #if defined (DEBUG_CP_BINDING_LEVELS)
 154 static void indent PARAMS ((void));
 155 #endif
 156
 157 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 158 tree error_mark_list;
 159
 160 /* The following symbols are subsumed in the cp_global_trees array, and
 161    listed here individually for documentation purposes.
 162
 163    C++ extensions
 164         tree wchar_decl_node;
 165
 166         tree vtable_entry_type;
 167         tree delta_type_node;
 168 #if 0
 169    Old rtti stuff.
 170         tree __baselist_desc_type_node;
 171         tree __i_desc_type_node, __m_desc_type_node;
 172         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 173 #endif
 174         tree __t_desc_type_node;
 175 #if 0
 176         tree __tp_desc_type_node;
 177 #endif
 178         tree ti_desc_type_node;
 179         tree bltn_desc_type_node, ptr_desc_type_node;
 180         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 181         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 182         tree ptm_desc_type_node;
 183         tree base_desc_type_node;
 184 #if 0
 185    Not needed yet?  May be needed one day?
 186         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 187         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 188         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 189 #endif
 190
 191         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 192         tree unknown_type_node;
 193
 194    Array type `vtable_entry_type[]'
 195
 196         tree vtbl_type_node;
 197         tree vtbl_ptr_type_node;
 198
 199    Namespaces,
 200
 201         tree std_node;
 202         tree abi_node;
 203
 204    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 205    one that the user will declare, but sufficient to be called
 206    by routines that want to abort the program.
 207
 208         tree abort_fndecl;
 209
 210    The FUNCTION_DECL for the default `::operator delete'.
 211
 212         tree global_delete_fndecl;
 213
 214    Used by RTTI
 215         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 216         tree tinfo_var_id;
 217
 218 */
 219
 220 tree cp_global_trees[CPTI_MAX];
 221
 222 /* Indicates that there is a type value in some namespace, although
 223    that is not necessarily in scope at the moment.  */
 224
 225 static tree global_type_node;
 226
 227 /* If non-zero, this is the number of times we have entered the `std'
 228    namespace when we are treating that namespace as an alias for the
 229    global namespace.  */
 230 static int in_fake_std;
 231
 232 /* Expect only namespace names now. */
 233 static int only_namespace_names;
 234
 235 /* Used only for jumps to as-yet undefined labels, since jumps to
 236    defined labels can have their validity checked immediately.  */
 237
 238 struct named_label_use_list
 239 {
 240   struct binding_level *binding_level;
 241   tree names_in_scope;
 242   tree label_decl;
 243   const char *filename_o_goto;
 244   int lineno_o_goto;
 245   struct named_label_use_list *next;
 246 };
 247
 248 #define named_label_uses cp_function_chain->x_named_label_uses
 249
 250 /* A list of objects which have constructors or destructors
 251    which reside in the global scope.  The decl is stored in
 252    the TREE_VALUE slot and the initializer is stored
 253    in the TREE_PURPOSE slot.  */
 254 tree static_aggregates;
 255
 256 /* -- end of C++ */
 257
 258 /* A node for the integer constants 2, and 3.  */
 259
 260 tree integer_two_node, integer_three_node;
 261
 262 /* Parsing a function declarator leaves here a chain of structure
 263    and enum types declared in the parmlist.  */
 264
 265 static tree last_function_parm_tags;
 266
 267 /* Similar, for last_function_parm_tags.  */
 268 tree last_function_parms;
 269 static tree current_function_parm_tags;
 270
 271 /* A list of all LABEL_DECLs in the function that have names.  Here so
 272    we can clear out their names' definitions at the end of the
 273    function, and so we can check the validity of jumps to these labels.  */
 274
 275 struct named_label_list
 276 {
 277   struct binding_level *binding_level;
 278   tree names_in_scope;
 279   tree old_value;
 280   tree label_decl;
 281   tree bad_decls;
 282   int eh_region;
 283   struct named_label_list *next;
 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 an EH region, as for a try block.
 457        Currently this information is only available while building the
 458        tree structure.  */
 459     unsigned eh_region : 1;
 460
 461     /* Four bits left for this word.  */
 462
 463 #if defined(DEBUG_CP_BINDING_LEVELS)
 464     /* Binding depth at which this level began.  */
 465     unsigned binding_depth;
 466 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 467   };
 468
 469 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 470
 471 /* The binding level currently in effect.  */
 472
 473 #define current_binding_level                   \
 474   (cfun                                         \
 475    ? cp_function_chain->bindings                \
 476    : scope_chain->bindings)
 477
 478 /* The binding level of the current class, if any.  */
 479
 480 #define class_binding_level scope_chain->class_bindings
 481
 482 /* A chain of binding_level structures awaiting reuse.  */
 483
 484 static struct binding_level *free_binding_level;
 485
 486 /* The outermost binding level, for names of file scope.
 487    This is created when the compiler is started and exists
 488    through the entire run.  */
 489
 490 static struct binding_level *global_binding_level;
 491
 492 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 493
 494 static int keep_next_level_flag;
 495
 496 #if defined(DEBUG_CP_BINDING_LEVELS)
 497 static int binding_depth = 0;
 498 static int is_class_level = 0;
 499
 500 static void
 501 indent ()
 502 {
 503   register unsigned i;
 504
 505   for (i = 0; i < binding_depth*2; i++)
 506     putc (' ', stderr);
 507 }
 508 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 509
 510 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 511
 512 static void
 513 push_binding_level (newlevel, tag_transparent, keep)
 514      struct binding_level *newlevel;
 515      int tag_transparent, keep;
 516 {
 517   /* Add this level to the front of the chain (stack) of levels that
 518      are active.  */
 519   memset ((char*) newlevel, 0, sizeof (struct binding_level));
 520   newlevel->level_chain = current_binding_level;
 521   current_binding_level = newlevel;
 522   newlevel->tag_transparent = tag_transparent;
 523   newlevel->more_cleanups_ok = 1;
 524
 525   newlevel->keep = keep;
 526 #if defined(DEBUG_CP_BINDING_LEVELS)
 527   newlevel->binding_depth = binding_depth;
 528   indent ();
 529   fprintf (stderr, "push %s level 0x%08x line %d\n",
 530            (is_class_level) ? "class" : "block", newlevel, lineno);
 531   is_class_level = 0;
 532   binding_depth++;
 533 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 534 }
 535
 536 /* Find the innermost enclosing class scope, and reset
 537    CLASS_BINDING_LEVEL appropriately.  */
 538
 539 static void
 540 find_class_binding_level ()
 541 {
 542   struct binding_level *level = current_binding_level;
 543
 544   while (level && level->parm_flag != 2)
 545     level = level->level_chain;
 546   if (level && level->parm_flag == 2)
 547     class_binding_level = level;
 548   else
 549     class_binding_level = 0;
 550 }
 551
 552 static void
 553 pop_binding_level ()
 554 {
 555   if (global_binding_level)
 556     {
 557       /* Cannot pop a level, if there are none left to pop.  */
 558       if (current_binding_level == global_binding_level)
 559         my_friendly_abort (123);
 560     }
 561   /* Pop the current level, and free the structure for reuse.  */
 562 #if defined(DEBUG_CP_BINDING_LEVELS)
 563   binding_depth--;
 564   indent ();
 565   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 566           (is_class_level) ? "class" : "block",
 567           current_binding_level, lineno);
 568   if (is_class_level != (current_binding_level == class_binding_level))
 569     {
 570       indent ();
 571       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 572     }
 573   is_class_level = 0;
 574 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 575   {
 576     register struct binding_level *level = current_binding_level;
 577     current_binding_level = current_binding_level->level_chain;
 578     level->level_chain = free_binding_level;
 579 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 580     if (level->binding_depth != binding_depth)
 581       abort ();
 582 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 583     free_binding_level = level;
 584     find_class_binding_level ();
 585   }
 586 }
 587
 588 static void
 589 suspend_binding_level ()
 590 {
 591   if (class_binding_level)
 592     current_binding_level = class_binding_level;
 593
 594   if (global_binding_level)
 595     {
 596       /* Cannot suspend a level, if there are none left to suspend.  */
 597       if (current_binding_level == global_binding_level)
 598         my_friendly_abort (123);
 599     }
 600   /* Suspend the current level.  */
 601 #if defined(DEBUG_CP_BINDING_LEVELS)
 602   binding_depth--;
 603   indent ();
 604   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 605           (is_class_level) ? "class" : "block",
 606           current_binding_level, lineno);
 607   if (is_class_level != (current_binding_level == class_binding_level))
 608     {
 609       indent ();
 610       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 611     }
 612   is_class_level = 0;
 613 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 614   current_binding_level = current_binding_level->level_chain;
 615   find_class_binding_level ();
 616 }
 617
 618 static void
 619 resume_binding_level (b)
 620      struct binding_level *b;
 621 {
 622   /* Resuming binding levels is meant only for namespaces,
 623      and those cannot nest into classes. */
 624   my_friendly_assert(!class_binding_level, 386);
 625   /* Also, resuming a non-directly nested namespace is a no-no.  */
 626   my_friendly_assert(b->level_chain == current_binding_level, 386);
 627   current_binding_level = b;
 628 #if defined(DEBUG_CP_BINDING_LEVELS)
 629   b->binding_depth = binding_depth;
 630   indent ();
 631   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 632            (is_class_level) ? "class" : "block", b, lineno);
 633   is_class_level = 0;
 634   binding_depth++;
 635 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 636 }
 637 \f
 638 /* Create a new `struct binding_level'.  */
 639
 640 static
 641 struct binding_level *
 642 make_binding_level ()
 643 {
 644   /* NOSTRICT */
 645   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 646 }
 647
 648 /* Nonzero if we are currently in the global binding level.  */
 649
 650 int
 651 global_bindings_p ()
 652 {
 653   return current_binding_level == global_binding_level;
 654 }
 655
 656 /* Return the innermost binding level that is not for a class scope.  */
 657
 658 static struct binding_level *
 659 innermost_nonclass_level ()
 660 {
 661   struct binding_level *b;
 662
 663   b = current_binding_level;
 664   while (b->parm_flag == 2)
 665     b = b->level_chain;
 666
 667   return b;
 668 }
 669
 670 /* Nonzero if we are currently in a toplevel binding level.  This
 671    means either the global binding level or a namespace in a toplevel
 672    binding level.  Since there are no non-toplevel namespace levels,
 673    this really means any namespace or template parameter level.  We
 674    also include a class whose context is toplevel.  */
 675
 676 int
 677 toplevel_bindings_p ()
 678 {
 679   struct binding_level *b = innermost_nonclass_level ();
 680
 681   return b->namespace_p || b->template_parms_p;
 682 }
 683
 684 /* Nonzero if this is a namespace scope, or if we are defining a class
 685    which is itself at namespace scope, or whose enclosing class is
 686    such a class, etc.  */
 687
 688 int
 689 namespace_bindings_p ()
 690 {
 691   struct binding_level *b = innermost_nonclass_level ();
 692
 693   return b->namespace_p;
 694 }
 695
 696 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 697    unconditionally.  Otherwise, use the normal logic to decide whether
 698    or not to create a BLOCK.  */
 699
 700 void
 701 keep_next_level (keep)
 702      int keep;
 703 {
 704   keep_next_level_flag = keep;
 705 }
 706
 707 /* Nonzero if the current level needs to have a BLOCK made.  */
 708
 709 int
 710 kept_level_p ()
 711 {
 712   return (current_binding_level->blocks != NULL_TREE
 713           || current_binding_level->keep
 714           || current_binding_level->names != NULL_TREE
 715           || (current_binding_level->tags != NULL_TREE
 716               && !current_binding_level->tag_transparent));
 717 }
 718
 719 static void
 720 declare_namespace_level ()
 721 {
 722   current_binding_level->namespace_p = 1;
 723 }
 724
 725 /* Returns non-zero if this scope was created to store template
 726    parameters.  */
 727
 728 int
 729 template_parm_scope_p ()
 730 {
 731   return current_binding_level->template_parms_p;
 732 }
 733
 734 /* Returns the kind of template specialization we are currently
 735    processing, given that it's declaration contained N_CLASS_SCOPES
 736    explicit scope qualifications.  */
 737
 738 tmpl_spec_kind
 739 current_tmpl_spec_kind (n_class_scopes)
 740      int n_class_scopes;
 741 {
 742   int n_template_parm_scopes = 0;
 743   int seen_specialization_p = 0;
 744   int innermost_specialization_p = 0;
 745   struct binding_level *b;
 746
 747   /* Scan through the template parameter scopes.  */
 748   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 749     {
 750       /* If we see a specialization scope inside a parameter scope,
 751          then something is wrong.  That corresponds to a declaration
 752          like:
 753
 754             template <class T> template <> ...
 755
 756          which is always illegal since [temp.expl.spec] forbids the
 757          specialization of a class member template if the enclosing
 758          class templates are not explicitly specialized as well.  */
 759       if (b->template_spec_p)
 760         {
 761           if (n_template_parm_scopes == 0)
 762             innermost_specialization_p = 1;
 763           else
 764             seen_specialization_p = 1;
 765         }
 766       else if (seen_specialization_p == 1)
 767         return tsk_invalid_member_spec;
 768
 769       ++n_template_parm_scopes;
 770     }
 771
 772   /* Handle explicit instantiations.  */
 773   if (processing_explicit_instantiation)
 774     {
 775       if (n_template_parm_scopes != 0)
 776         /* We've seen a template parameter list during an explicit
 777            instantiation.  For example:
 778
 779              template <class T> template void f(int);
 780
 781            This is erroneous.  */
 782         return tsk_invalid_expl_inst;
 783       else
 784         return tsk_expl_inst;
 785     }
 786
 787   if (n_template_parm_scopes < n_class_scopes)
 788     /* We've not seen enough template headers to match all the
 789        specialized classes present.  For example:
 790
 791          template <class T> void R<T>::S<T>::f(int);
 792
 793        This is illegal; there needs to be one set of template
 794        parameters for each class.  */
 795     return tsk_insufficient_parms;
 796   else if (n_template_parm_scopes == n_class_scopes)
 797     /* We're processing a non-template declaration (even though it may
 798        be a member of a template class.)  For example:
 799
 800          template <class T> void S<T>::f(int);
 801
 802        The `class T' maches the `S<T>', leaving no template headers
 803        corresponding to the `f'.  */
 804     return tsk_none;
 805   else if (n_template_parm_scopes > n_class_scopes + 1)
 806     /* We've got too many template headers.  For example:
 807
 808          template <> template <class T> void f (T);
 809
 810        There need to be more enclosing classes.  */
 811     return tsk_excessive_parms;
 812   else
 813     /* This must be a template.  It's of the form:
 814
 815          template <class T> template <class U> void S<T>::f(U);
 816
 817        This is a specialization if the innermost level was a
 818        specialization; otherwise it's just a definition of the
 819        template.  */
 820     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 821 }
 822
 823 void
 824 set_class_shadows (shadows)
 825      tree shadows;
 826 {
 827   class_binding_level->class_shadowed = shadows;
 828 }
 829
 830 /* Enter a new binding level.
 831    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 832    not for that of tags.  */
 833
 834 void
 835 pushlevel (tag_transparent)
 836      int tag_transparent;
 837 {
 838   struct binding_level *newlevel;
 839
 840   if (cfun && !doing_semantic_analysis_p ())
 841     return;
 842
 843   /* Reuse or create a struct for this binding level.  */
 844 #if defined(DEBUG_CP_BINDING_LEVELS)
 845   if (0)
 846 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 847   if (free_binding_level)
 848 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 849     {
 850       newlevel = free_binding_level;
 851       free_binding_level = free_binding_level->level_chain;
 852     }
 853   else
 854     newlevel = make_binding_level ();
 855
 856   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 857   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 858   keep_next_level_flag = 0;
 859 }
 860
 861 /* We're defining an object of type TYPE.  If it needs a cleanup, but
 862    we're not allowed to add any more objects with cleanups to the current
 863    scope, create a new binding level.  */
 864
 865 void
 866 maybe_push_cleanup_level (type)
 867      tree type;
 868 {
 869   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
 870       && current_binding_level->more_cleanups_ok == 0)
 871     {
 872       keep_next_level (2);
 873       pushlevel (1);
 874       clear_last_expr ();
 875       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
 876     }
 877 }
 878
 879 /* Enter a new scope.  The KIND indicates what kind of scope is being
 880    created.  */
 881
 882 void
 883 begin_scope (sk)
 884      scope_kind sk;
 885 {
 886   pushlevel (0);
 887
 888   switch (sk)
 889     {
 890     case sk_template_spec:
 891       current_binding_level->template_spec_p = 1;
 892       /* Fall through.  */
 893
 894     case sk_template_parms:
 895       current_binding_level->template_parms_p = 1;
 896       break;
 897
 898     default:
 899       my_friendly_abort (20000309);
 900     }
 901 }
 902
 903 /* Exit the current scope.  */
 904
 905 void
 906 finish_scope ()
 907 {
 908   poplevel (0, 0, 0);
 909 }
 910
 911 void
 912 note_level_for_for ()
 913 {
 914   current_binding_level->is_for_scope = 1;
 915 }
 916
 917 /* Record that the current binding level represents a try block.  */
 918
 919 void
 920 note_level_for_eh ()
 921 {
 922   current_binding_level->eh_region = 1;
 923 }
 924
 925 /* For a binding between a name and an entity at a block scope,
 926    this is the `struct binding_level' for the block.  */
 927 #define BINDING_LEVEL(NODE) \
 928    (((struct tree_binding*)NODE)->scope.level)
 929
 930 /* A free list of CPLUS_BINDING nodes, connected by their
 931    TREE_CHAINs.  */
 932
 933 static tree free_bindings;
 934
 935 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 936    level at which this declaration is being bound.  */
 937
 938 static void
 939 push_binding (id, decl, level)
 940      tree id;
 941      tree decl;
 942      struct binding_level* level;
 943 {
 944   tree binding;
 945
 946   if (free_bindings)
 947     {
 948       binding = free_bindings;
 949       free_bindings = TREE_CHAIN (binding);
 950     }
 951   else
 952     binding = make_node (CPLUS_BINDING);
 953
 954   /* Now, fill in the binding information.  */
 955   BINDING_VALUE (binding) = decl;
 956   BINDING_TYPE (binding) = NULL_TREE;
 957   BINDING_LEVEL (binding) = level;
 958   INHERITED_VALUE_BINDING_P (binding) = 0;
 959   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 960   BINDING_HAS_LEVEL_P (binding) = 1;
 961
 962   /* And put it on the front of the list of bindings for ID.  */
 963   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 964   IDENTIFIER_BINDING (id) = binding;
 965 }
 966
 967 /* ID is already bound in the current scope.  But, DECL is an
 968    additional binding for ID in the same scope.  This is the `struct
 969    stat' hack whereby a non-typedef class-name or enum-name can be
 970    bound at the same level as some other kind of entity.  It's the
 971    responsibility of the caller to check that inserting this name is
 972    legal here.  Returns nonzero if the new binding was successful.  */
 973 static int
 974 add_binding (id, decl)
 975      tree id;
 976      tree decl;
 977 {
 978   tree binding = IDENTIFIER_BINDING (id);
 979   int ok = 1;
 980
 981   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 982     /* The new name is the type name.  */
 983     BINDING_TYPE (binding) = decl;
 984   else if (!BINDING_VALUE (binding))
 985     /* This situation arises when push_class_level_binding moves an
 986        inherited type-binding out of the way to make room for a new
 987        value binding.  */
 988     BINDING_VALUE (binding) = decl;
 989   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 990            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 991     {
 992       /* The old binding was a type name.  It was placed in
 993          BINDING_VALUE because it was thought, at the point it was
 994          declared, to be the only entity with such a name.  Move the
 995          type name into the type slot; it is now hidden by the new
 996          binding.  */
 997       BINDING_TYPE (binding) = BINDING_VALUE (binding);
 998       BINDING_VALUE (binding) = decl;
 999       INHERITED_VALUE_BINDING_P (binding) = 0;
1000     }
1001   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1002            && TREE_CODE (decl) == TYPE_DECL
1003            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1004            && same_type_p (TREE_TYPE (decl),
1005                            TREE_TYPE (BINDING_VALUE (binding))))
1006     /* We have two typedef-names, both naming the same type to have
1007        the same name.  This is OK because of:
1008
1009          [dcl.typedef]
1010
1011          In a given scope, a typedef specifier can be used to redefine
1012          the name of any type declared in that scope to refer to the
1013          type to which it already refers.  */
1014     ok = 0;
1015   /* There can be two block-scope declarations of the same variable,
1016      so long as they are `extern' declarations.  */
1017   else if (TREE_CODE (decl) == VAR_DECL
1018            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1019            && DECL_EXTERNAL (decl)
1020            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1021     {
1022       duplicate_decls (decl, BINDING_VALUE (binding));
1023       ok = 0;
1024     }
1025   else
1026     {
1027       cp_error ("declaration of `%#D'", decl);
1028       cp_error_at ("conflicts with previous declaration `%#D'",
1029                    BINDING_VALUE (binding));
1030       ok = 0;
1031     }
1032
1033   return ok;
1034 }
1035
1036 /* Add DECL to the list of things declared in B.  */
1037
1038 static void
1039 add_decl_to_level (decl, b)
1040      tree decl;
1041      struct binding_level *b;
1042 {
1043   /* We build up the list in reverse order, and reverse it later if
1044      necessary.  */
1045   TREE_CHAIN (decl) = b->names;
1046   b->names = decl;
1047 }
1048
1049 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1050    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1051    doesn't really belong to this binding level, that it got here
1052    through a using-declaration.  */
1053
1054 void
1055 push_local_binding (id, decl, flags)
1056      tree id;
1057      tree decl;
1058      int flags;
1059 {
1060   struct binding_level *b;
1061
1062   /* Skip over any local classes.  This makes sense if we call
1063      push_local_binding with a friend decl of a local class.  */
1064   b = current_binding_level;
1065   while (b->parm_flag == 2)
1066     b = b->level_chain;
1067
1068   if (lookup_name_current_level (id))
1069     {
1070       /* Supplement the existing binding.  */
1071       if (!add_binding (id, decl))
1072         /* It didn't work.  Something else must be bound at this
1073            level.  Do not add DECL to the list of things to pop
1074            later.  */
1075         return;
1076     }
1077   else
1078     /* Create a new binding.  */
1079     push_binding (id, decl, b);
1080
1081   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1082     /* We must put the OVERLOAD into a TREE_LIST since the
1083        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1084        decls that got here through a using-declaration.  */
1085     decl = build_tree_list (NULL_TREE, decl);
1086
1087   /* And put DECL on the list of things declared by the current
1088      binding level.  */
1089   add_decl_to_level (decl, b);
1090 }
1091
1092 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1093    binding was successful.  */
1094
1095 int
1096 push_class_binding (id, decl)
1097      tree id;
1098      tree decl;
1099 {
1100   int result = 1;
1101   tree binding = IDENTIFIER_BINDING (id);
1102   tree context;
1103
1104   /* Note that we declared this value so that we can issue an error if
1105      this an illegal redeclaration of a name already used for some
1106      other purpose.  */
1107   note_name_declared_in_class (id, decl);
1108
1109   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1110     /* Supplement the existing binding.  */
1111     result = add_binding (id, decl);
1112   else
1113     /* Create a new binding.  */
1114     push_binding (id, decl, class_binding_level);
1115
1116   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1117      class-level declaration.  Note that we do not use DECL here
1118      because of the possibility of the `struct stat' hack; if DECL is
1119      a class-name or enum-name we might prefer a field-name, or some
1120      such.  */
1121   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1122
1123   /* If this is a binding from a base class, mark it as such.  */
1124   binding = IDENTIFIER_BINDING (id);
1125   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1126     {
1127       /* Any implicit typename must be from a base-class.  The
1128          context for an implicit typename declaration is always
1129          the derived class in which the lookup was done, so the checks
1130          based on the context of DECL below will not trigger.  */
1131       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1132         INHERITED_VALUE_BINDING_P (binding) = 1;
1133       else
1134         {
1135           if (TREE_CODE (decl) == OVERLOAD)
1136             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1137           else
1138             {
1139               my_friendly_assert (DECL_P (decl), 0);
1140               context = context_for_name_lookup (decl);
1141             }
1142
1143           if (is_properly_derived_from (current_class_type, context))
1144             INHERITED_VALUE_BINDING_P (binding) = 1;
1145           else
1146             INHERITED_VALUE_BINDING_P (binding) = 0;
1147         }
1148     }
1149   else if (BINDING_VALUE (binding) == decl)
1150     /* We only encounter a TREE_LIST when push_class_decls detects an
1151        ambiguity.  Such an ambiguity can be overridden by a definition
1152        in this class.  */
1153     INHERITED_VALUE_BINDING_P (binding) = 1;
1154
1155   return result;
1156 }
1157
1158 /* Remove the binding for DECL which should be the innermost binding
1159    for ID.  */
1160
1161 static void
1162 pop_binding (id, decl)
1163      tree id;
1164      tree decl;
1165 {
1166   tree binding;
1167
1168   if (id == NULL_TREE)
1169     /* It's easiest to write the loops that call this function without
1170        checking whether or not the entities involved have names.  We
1171        get here for such an entity.  */
1172     return;
1173
1174   /* Get the innermost binding for ID.  */
1175   binding = IDENTIFIER_BINDING (id);
1176
1177   /* The name should be bound.  */
1178   my_friendly_assert (binding != NULL_TREE, 0);
1179
1180   /* The DECL will be either the ordinary binding or the type
1181      binding for this identifier.  Remove that binding.  */
1182   if (BINDING_VALUE (binding) == decl)
1183     BINDING_VALUE (binding) = NULL_TREE;
1184   else if (BINDING_TYPE (binding) == decl)
1185     BINDING_TYPE (binding) = NULL_TREE;
1186   else
1187     my_friendly_abort (0);
1188
1189   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1190     {
1191       /* We're completely done with the innermost binding for this
1192          identifier.  Unhook it from the list of bindings.  */
1193       IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1194
1195       /* Add it to the free list.  */
1196       TREE_CHAIN (binding) = free_bindings;
1197       free_bindings = binding;
1198
1199       /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
1200          it.  */
1201       BINDING_LEVEL (binding) = NULL;
1202     }
1203 }
1204
1205 /* When a label goes out of scope, check to see if that label was used
1206    in a valid manner, and issue any appropriate warnings or errors.  */
1207
1208 static void
1209 pop_label (label, old_value)
1210      tree label;
1211      tree old_value;
1212 {
1213   if (!processing_template_decl && doing_semantic_analysis_p ())
1214     {
1215       if (DECL_INITIAL (label) == NULL_TREE)
1216         {
1217           cp_error_at ("label `%D' used but not defined", label);
1218           /* Avoid crashing later.  */
1219           define_label (input_filename, 1, DECL_NAME (label));
1220         }
1221       else if (warn_unused_label && !TREE_USED (label))
1222         cp_warning_at ("label `%D' defined but not used", label);
1223     }
1224
1225   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1226 }
1227
1228 /* At the end of a function, all labels declared within the function
1229    go out of scope.  BLOCK is the top-level block for the
1230    function.  */
1231
1232 static void
1233 pop_labels (block)
1234      tree block;
1235 {
1236   struct named_label_list *link;
1237
1238   /* Clear out the definitions of all label names, since their scopes
1239      end here.  */
1240   for (link = named_labels; link; link = link->next)
1241     {
1242       pop_label (link->label_decl, link->old_value);
1243       /* Put the labels into the "variables" of the top-level block,
1244          so debugger can see them.  */
1245       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1246       BLOCK_VARS (block) = link->label_decl;
1247     }
1248
1249   named_labels = NULL;
1250 }
1251
1252 /* Exit a binding level.
1253    Pop the level off, and restore the state of the identifier-decl mappings
1254    that were in effect when this level was entered.
1255
1256    If KEEP == 1, this level had explicit declarations, so
1257    and create a "block" (a BLOCK node) for the level
1258    to record its declarations and subblocks for symbol table output.
1259
1260    If FUNCTIONBODY is nonzero, this level is the body of a function,
1261    so create a block as if KEEP were set and also clear out all
1262    label names.
1263
1264    If REVERSE is nonzero, reverse the order of decls before putting
1265    them into the BLOCK.  */
1266
1267 tree
1268 poplevel (keep, reverse, functionbody)
1269      int keep;
1270      int reverse;
1271      int functionbody;
1272 {
1273   register tree link;
1274   /* The chain of decls was accumulated in reverse order.
1275      Put it into forward order, just for cleanliness.  */
1276   tree decls;
1277   int tmp = functionbody;
1278   int real_functionbody;
1279   tree tags;
1280   tree subblocks;
1281   tree block = NULL_TREE;
1282   tree decl;
1283   int leaving_for_scope;
1284
1285   if (cfun && !doing_semantic_analysis_p ())
1286     return NULL_TREE;
1287
1288   my_friendly_assert (current_binding_level->parm_flag != 2,
1289                       19990916);
1290
1291   real_functionbody = (current_binding_level->keep == 2
1292                        ? ((functionbody = 0), tmp) : functionbody);
1293   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1294   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1295
1296   my_friendly_assert (!current_binding_level->class_shadowed,
1297                       19990414);
1298
1299   /* We used to use KEEP == 2 to indicate that the new block should go
1300      at the beginning of the list of blocks at this binding level,
1301      rather than the end.  This hack is no longer used.  */
1302   my_friendly_assert (keep == 0 || keep == 1, 0);
1303
1304   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1305                       (HOST_WIDE_INT) current_binding_level->level_chain,
1306                       current_binding_level->parm_flag,
1307                       current_binding_level->keep);
1308
1309   if (current_binding_level->keep == 1)
1310     keep = 1;
1311
1312   /* Any uses of undefined labels, and any defined labels, now operate
1313      under constraints of next binding contour.  */
1314   if (cfun && !functionbody)
1315     {
1316       struct binding_level *level_chain;
1317       level_chain = current_binding_level->level_chain;
1318       if (level_chain)
1319         {
1320           struct named_label_use_list *uses;
1321           struct named_label_list *labels;
1322           for (labels = named_labels; labels; labels = labels->next)
1323             if (labels->binding_level == current_binding_level)
1324               {
1325                 tree decl;
1326                 if (current_binding_level->eh_region)
1327                   labels->eh_region = 1;
1328                 for (decl = labels->names_in_scope; decl;
1329                      decl = TREE_CHAIN (decl))
1330                   if (decl_jump_unsafe (decl))
1331                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1332                                                    labels->bad_decls);
1333                 labels->binding_level = level_chain;
1334                 labels->names_in_scope = level_chain->names;
1335               }
1336
1337           for (uses = named_label_uses; uses; uses = uses->next)
1338             if (uses->binding_level == current_binding_level)
1339               {
1340                 uses->binding_level = level_chain;
1341                 uses->names_in_scope = level_chain->names;
1342               }
1343         }
1344     }
1345
1346   /* Get the decls in the order they were written.
1347      Usually current_binding_level->names is in reverse order.
1348      But parameter decls were previously put in forward order.  */
1349
1350   if (reverse)
1351     current_binding_level->names
1352       = decls = nreverse (current_binding_level->names);
1353   else
1354     decls = current_binding_level->names;
1355
1356   /* Output any nested inline functions within this block
1357      if they weren't already output.  */
1358   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1359     if (TREE_CODE (decl) == FUNCTION_DECL
1360         && ! TREE_ASM_WRITTEN (decl)
1361         && DECL_INITIAL (decl) != NULL_TREE
1362         && TREE_ADDRESSABLE (decl)
1363         && decl_function_context (decl) == current_function_decl)
1364       {
1365         /* If this decl was copied from a file-scope decl
1366            on account of a block-scope extern decl,
1367            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1368         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1369           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1370         else
1371           {
1372             push_function_context ();
1373             output_inline_function (decl);
1374             pop_function_context ();
1375           }
1376       }
1377
1378   /* When not in function-at-a-time mode, expand_end_bindings will
1379      warn about unused variables.  But, in function-at-a-time mode
1380      expand_end_bindings is not passed the list of variables in the
1381      current scope, and therefore no warning is emitted.  So, we
1382      explicitly warn here.  */
1383   if (!processing_template_decl)
1384     warn_about_unused_variables (getdecls ());
1385
1386   /* If there were any declarations or structure tags in that level,
1387      or if this level is a function body,
1388      create a BLOCK to record them for the life of this function.  */
1389   block = NULL_TREE;
1390   if (keep == 1 || functionbody)
1391     block = make_node (BLOCK);
1392   if (block != NULL_TREE)
1393     {
1394       BLOCK_VARS (block) = decls;
1395       BLOCK_SUBBLOCKS (block) = subblocks;
1396     }
1397
1398   /* In each subblock, record that this is its superior.  */
1399   if (keep >= 0)
1400     for (link = subblocks; link; link = TREE_CHAIN (link))
1401       BLOCK_SUPERCONTEXT (link) = block;
1402
1403   /* We still support the old for-scope rules, whereby the variables
1404      in a for-init statement were in scope after the for-statement
1405      ended.  We only use the new rules in flag_new_for_scope is
1406      nonzero.  */
1407   leaving_for_scope
1408     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1409
1410   /* Remove declarations for all the DECLs in this level.  */
1411   for (link = decls; link; link = TREE_CHAIN (link))
1412     {
1413       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1414           && DECL_NAME (link))
1415         {
1416           tree outer_binding
1417             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1418           tree ns_binding;
1419
1420           if (!outer_binding)
1421             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1422           else
1423             ns_binding = NULL_TREE;
1424
1425           if (outer_binding
1426               && (BINDING_LEVEL (outer_binding)
1427                   == current_binding_level->level_chain))
1428             /* We have something like:
1429
1430                  int i;
1431                  for (int i; ;);
1432
1433                and we are leaving the `for' scope.  There's no reason to
1434                keep the binding of the inner `i' in this case.  */
1435             pop_binding (DECL_NAME (link), link);
1436           else if ((outer_binding
1437                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1438                         == TYPE_DECL))
1439                    || (ns_binding
1440                        && TREE_CODE (ns_binding) == TYPE_DECL))
1441             /* Here, we have something like:
1442
1443                  typedef int I;
1444
1445                  void f () {
1446                    for (int I; ;);
1447                  }
1448
1449                We must pop the for-scope binding so we know what's a
1450                type and what isn't.  */
1451             pop_binding (DECL_NAME (link), link);
1452           else
1453             {
1454               /* Mark this VAR_DECL as dead so that we can tell we left it
1455                  there only for backward compatibility.  */
1456               DECL_DEAD_FOR_LOCAL (link) = 1;
1457
1458               /* Keep track of what should of have happenned when we
1459                  popped the binding.  */
1460               if (outer_binding && BINDING_VALUE (outer_binding))
1461                 DECL_SHADOWED_FOR_VAR (link)
1462                   = BINDING_VALUE (outer_binding);
1463
1464               /* Add it to the list of dead variables in the next
1465                  outermost binding to that we can remove these when we
1466                  leave that binding.  */
1467               current_binding_level->level_chain->dead_vars_from_for
1468                 = tree_cons (NULL_TREE, link,
1469                              current_binding_level->level_chain->
1470                              dead_vars_from_for);
1471
1472               /* Although we don't pop the CPLUS_BINDING, we do clear
1473                  its BINDING_LEVEL since the level is going away now.  */
1474               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1475                 = 0;
1476             }
1477         }
1478       else
1479         {
1480           /* Remove the binding.  */
1481           decl = link;
1482           if (TREE_CODE (decl) == TREE_LIST)
1483             decl = TREE_VALUE (decl);
1484           if (DECL_P (decl))
1485             pop_binding (DECL_NAME (decl), decl);
1486           else if (TREE_CODE (decl) == OVERLOAD)
1487             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1488           else
1489             my_friendly_abort (0);
1490         }
1491     }
1492
1493   /* Remove declarations for any `for' variables from inner scopes
1494      that we kept around.  */
1495   for (link = current_binding_level->dead_vars_from_for;
1496        link; link = TREE_CHAIN (link))
1497     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1498
1499   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1500   for (link = current_binding_level->type_shadowed;
1501        link; link = TREE_CHAIN (link))
1502     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1503
1504   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1505   for (link = current_binding_level->shadowed_labels;
1506        link;
1507        link = TREE_CHAIN (link))
1508     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1509
1510   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1511      list if a `using' declaration put them there.  The debugging
1512      back-ends won't understand OVERLOAD, so we remove them here.
1513      Because the BLOCK_VARS are (temporarily) shared with
1514      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1515      popped all the bindings.  */
1516   if (block)
1517     {
1518       tree* d;
1519
1520       for (d = &BLOCK_VARS (block); *d; )
1521         {
1522           if (TREE_CODE (*d) == TREE_LIST)
1523             *d = TREE_CHAIN (*d);
1524           else
1525             d = &TREE_CHAIN (*d);
1526         }
1527     }
1528
1529   /* If the level being exited is the top level of a function,
1530      check over all the labels.  */
1531   if (functionbody)
1532     {
1533       /* Since this is the top level block of a function, the vars are
1534          the function's parameters.  Don't leave them in the BLOCK
1535          because they are found in the FUNCTION_DECL instead.  */
1536       BLOCK_VARS (block) = 0;
1537       pop_labels (block);
1538     }
1539
1540   tmp = current_binding_level->keep;
1541
1542   pop_binding_level ();
1543   if (functionbody)
1544     DECL_INITIAL (current_function_decl) = block;
1545   else if (block)
1546     current_binding_level->blocks
1547       = chainon (current_binding_level->blocks, block);
1548
1549   /* If we did not make a block for the level just exited,
1550      any blocks made for inner levels
1551      (since they cannot be recorded as subblocks in that level)
1552      must be carried forward so they will later become subblocks
1553      of something else.  */
1554   else if (subblocks)
1555     current_binding_level->blocks
1556       = chainon (current_binding_level->blocks, subblocks);
1557
1558   /* Each and every BLOCK node created here in `poplevel' is important
1559      (e.g. for proper debugging information) so if we created one
1560      earlier, mark it as "used".  */
1561   if (block)
1562     TREE_USED (block) = 1;
1563
1564   /* Take care of compiler's internal binding structures.  */
1565   if (tmp == 2)
1566     {
1567       tree scope_stmts;
1568
1569       scope_stmts
1570         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1571       if (block)
1572         {
1573           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1574           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1575         }
1576
1577       block = poplevel (keep, reverse, functionbody);
1578     }
1579
1580   return block;
1581 }
1582
1583 /* Delete the node BLOCK from the current binding level.
1584    This is used for the block inside a stmt expr ({...})
1585    so that the block can be reinserted where appropriate.  */
1586
1587 void
1588 delete_block (block)
1589      tree block;
1590 {
1591   tree t;
1592   if (current_binding_level->blocks == block)
1593     current_binding_level->blocks = TREE_CHAIN (block);
1594   for (t = current_binding_level->blocks; t;)
1595     {
1596       if (TREE_CHAIN (t) == block)
1597         TREE_CHAIN (t) = TREE_CHAIN (block);
1598       else
1599         t = TREE_CHAIN (t);
1600     }
1601   TREE_CHAIN (block) = NULL_TREE;
1602   /* Clear TREE_USED which is always set by poplevel.
1603      The flag is set again if insert_block is called.  */
1604   TREE_USED (block) = 0;
1605 }
1606
1607 /* Insert BLOCK at the end of the list of subblocks of the
1608    current binding level.  This is used when a BIND_EXPR is expanded,
1609    to handle the BLOCK node inside the BIND_EXPR.  */
1610
1611 void
1612 insert_block (block)
1613      tree block;
1614 {
1615   TREE_USED (block) = 1;
1616   current_binding_level->blocks
1617     = chainon (current_binding_level->blocks, block);
1618 }
1619
1620 /* Set the BLOCK node for the innermost scope
1621    (the one we are currently in).  */
1622
1623 void
1624 set_block (block)
1625     tree block ATTRIBUTE_UNUSED;
1626 {
1627   /* The RTL expansion machinery requires us to provide this callback,
1628      but it is not applicable in function-at-a-time mode.  */
1629   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1630 }
1631
1632 /* Do a pushlevel for class declarations.  */
1633
1634 void
1635 pushlevel_class ()
1636 {
1637   register struct binding_level *newlevel;
1638
1639   /* Reuse or create a struct for this binding level.  */
1640 #if defined(DEBUG_CP_BINDING_LEVELS)
1641   if (0)
1642 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1643   if (free_binding_level)
1644 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1645     {
1646       newlevel = free_binding_level;
1647       free_binding_level = free_binding_level->level_chain;
1648     }
1649   else
1650     newlevel = make_binding_level ();
1651
1652 #if defined(DEBUG_CP_BINDING_LEVELS)
1653   is_class_level = 1;
1654 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1655
1656   push_binding_level (newlevel, 0, 0);
1657
1658   class_binding_level = current_binding_level;
1659   class_binding_level->parm_flag = 2;
1660   class_binding_level->this_class = current_class_type;
1661 }
1662
1663 /* ...and a poplevel for class declarations.  */
1664
1665 void
1666 poplevel_class ()
1667 {
1668   register struct binding_level *level = class_binding_level;
1669   tree shadowed;
1670
1671   my_friendly_assert (level != 0, 354);
1672
1673   /* If we're leaving a toplevel class, don't bother to do the setting
1674      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1675      shouldn't even be used when current_class_type isn't set, and second,
1676      if we don't touch it here, we're able to use the cache effect if the
1677      next time we're entering a class scope, it is the same class.  */
1678   if (current_class_depth != 1)
1679     {
1680       struct binding_level* b;
1681
1682       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1683       for (shadowed = level->class_shadowed;
1684            shadowed;
1685            shadowed = TREE_CHAIN (shadowed))
1686         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1687
1688       /* Find the next enclosing class, and recreate
1689          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1690       b = level->level_chain;
1691       while (b && b->parm_flag != 2)
1692         b = b->level_chain;
1693
1694       if (b)
1695         for (shadowed = b->class_shadowed;
1696              shadowed;
1697              shadowed = TREE_CHAIN (shadowed))
1698           {
1699             tree t;
1700
1701             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1702             while (t && BINDING_LEVEL (t) != b)
1703               t = TREE_CHAIN (t);
1704
1705             if (t)
1706               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1707                 = BINDING_VALUE (t);
1708           }
1709     }
1710   else
1711     /* Remember to save what IDENTIFIER's were bound in this scope so we
1712        can recover from cache misses.  */
1713     {
1714       previous_class_type = current_class_type;
1715       previous_class_values = class_binding_level->class_shadowed;
1716     }
1717   for (shadowed = level->type_shadowed;
1718        shadowed;
1719        shadowed = TREE_CHAIN (shadowed))
1720     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1721
1722   /* Remove the bindings for all of the class-level declarations.  */
1723   for (shadowed = level->class_shadowed;
1724        shadowed;
1725        shadowed = TREE_CHAIN (shadowed))
1726     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1727
1728   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1729                       (HOST_WIDE_INT) class_binding_level->level_chain,
1730                       class_binding_level->parm_flag,
1731                       class_binding_level->keep);
1732
1733   /* Now, pop out of the binding level which we created up in the
1734      `pushlevel_class' routine.  */
1735 #if defined(DEBUG_CP_BINDING_LEVELS)
1736   is_class_level = 1;
1737 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1738
1739   pop_binding_level ();
1740 }
1741
1742 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1743    for any names in enclosing classes.  */
1744
1745 void
1746 clear_identifier_class_values ()
1747 {
1748   tree t;
1749
1750   if (!class_binding_level)
1751     return;
1752
1753   for (t = class_binding_level->class_shadowed;
1754        t;
1755        t = TREE_CHAIN (t))
1756     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1757 }
1758
1759 /* Returns non-zero if T is a virtual function table.  */
1760
1761 int
1762 vtable_decl_p (t, data)
1763      tree t;
1764      void *data ATTRIBUTE_UNUSED;
1765 {
1766   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1767 }
1768
1769 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1770    functions.  */
1771
1772 int
1773 vtype_decl_p (t, data)
1774      tree t;
1775      void *data ATTRIBUTE_UNUSED;
1776 {
1777   return (TREE_CODE (t) == TYPE_DECL
1778           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1779           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1780 }
1781
1782 /* Return the declarations that are members of the namespace NS.  */
1783
1784 tree
1785 cp_namespace_decls (ns)
1786      tree ns;
1787 {
1788   return NAMESPACE_LEVEL (ns)->names;
1789 }
1790
1791 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1792    itself, calling F for each.  The DATA is passed to F as well.  */
1793
1794 static int
1795 walk_namespaces_r (namespace, f, data)
1796      tree namespace;
1797      walk_namespaces_fn f;
1798      void *data;
1799 {
1800   tree current;
1801   int result = 0;
1802
1803   result |= (*f) (namespace, data);
1804
1805   for (current = cp_namespace_decls (namespace);
1806        current;
1807        current = TREE_CHAIN (current))
1808     {
1809       if (TREE_CODE (current) != NAMESPACE_DECL
1810           || DECL_NAMESPACE_ALIAS (current))
1811         continue;
1812       if (!DECL_LANG_SPECIFIC (current))
1813         {
1814           /* Hmm. std. */
1815           my_friendly_assert (current == fake_std_node, 393);
1816           continue;
1817         }
1818
1819       /* We found a namespace.  */
1820       result |= walk_namespaces_r (current, f, data);
1821     }
1822
1823   return result;
1824 }
1825
1826 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1827    F as well.  */
1828
1829 int
1830 walk_namespaces (f, data)
1831      walk_namespaces_fn f;
1832      void *data;
1833 {
1834   return walk_namespaces_r (global_namespace, f, data);
1835 }
1836
1837 struct walk_globals_data {
1838   walk_globals_pred p;
1839   walk_globals_fn f;
1840   void *data;
1841 };
1842
1843 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1844    for which P returns non-zero, call F with its address.  If any call
1845    to F returns a non-zero value, return a non-zero value.  */
1846
1847 static int
1848 walk_globals_r (namespace, data)
1849      tree namespace;
1850      void *data;
1851 {
1852   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1853   walk_globals_pred p = wgd->p;
1854   walk_globals_fn f = wgd->f;
1855   void *d = wgd->data;
1856   tree *t;
1857   int result = 0;
1858
1859   t = &NAMESPACE_LEVEL (namespace)->names;
1860
1861   while (*t)
1862     {
1863       tree glbl = *t;
1864
1865       if ((*p) (glbl, d))
1866         result |= (*f) (t, d);
1867
1868       /* If F changed *T, then *T still points at the next item to
1869          examine.  */
1870       if (*t == glbl)
1871         t = &TREE_CHAIN (*t);
1872     }
1873
1874   return result;
1875 }
1876
1877 /* Walk the global declarations.  Whenever one is found for which P
1878    returns non-zero, call F with its address.  If any call to F
1879    returns a non-zero value, return a non-zero value.  */
1880
1881 int
1882 walk_globals (p, f, data)
1883      walk_globals_pred p;
1884      walk_globals_fn f;
1885      void *data;
1886 {
1887   struct walk_globals_data wgd;
1888   wgd.p = p;
1889   wgd.f = f;
1890   wgd.data = data;
1891
1892   return walk_namespaces (walk_globals_r, &wgd);
1893 }
1894
1895 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1896    DATA is non-NULL, this is the last time we will call
1897    wrapup_global_declarations for this NAMESPACE.  */
1898
1899 int
1900 wrapup_globals_for_namespace (namespace, data)
1901      tree namespace;
1902      void *data;
1903 {
1904   tree globals = cp_namespace_decls (namespace);
1905   int len = list_length (globals);
1906   tree *vec = (tree *) alloca (sizeof (tree) * len);
1907   int i;
1908   int result;
1909   tree decl;
1910   int last_time = (data != 0);
1911
1912   if (last_time && namespace == global_namespace)
1913     /* Let compile_file handle the global namespace.  */
1914     return 0;
1915
1916   /* Process the decls in reverse order--earliest first.
1917      Put them into VEC from back to front, then take out from front.  */
1918   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1919     vec[len - i - 1] = decl;
1920
1921   if (last_time)
1922     {
1923       check_global_declarations (vec, len);
1924       return 0;
1925     }
1926
1927   /* Temporarily mark vtables as external.  That prevents
1928      wrapup_global_declarations from writing them out; we must process
1929      them ourselves in finish_vtable_vardecl.  */
1930   for (i = 0; i < len; ++i)
1931     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1932       {
1933         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1934         DECL_EXTERNAL (vec[i]) = 1;
1935       }
1936
1937   /* Write out any globals that need to be output.  */
1938   result = wrapup_global_declarations (vec, len);
1939
1940   /* Undo the hack to DECL_EXTERNAL above.  */
1941   for (i = 0; i < len; ++i)
1942     if (vtable_decl_p (vec[i], /*data=*/0)
1943         && DECL_NOT_REALLY_EXTERN (vec[i]))
1944       {
1945         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1946         DECL_EXTERNAL (vec[i]) = 0;
1947       }
1948
1949   return result;
1950 }
1951
1952 \f
1953 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1954
1955 static void
1956 mark_binding_level (arg)
1957      void *arg;
1958 {
1959   struct binding_level *lvl = *(struct binding_level **)arg;
1960
1961   for (; lvl; lvl = lvl->level_chain)
1962     {
1963       ggc_mark_tree (lvl->names);
1964       ggc_mark_tree (lvl->tags);
1965       ggc_mark_tree (lvl->usings);
1966       ggc_mark_tree (lvl->using_directives);
1967       ggc_mark_tree (lvl->class_shadowed);
1968       ggc_mark_tree (lvl->type_shadowed);
1969       ggc_mark_tree (lvl->shadowed_labels);
1970       ggc_mark_tree (lvl->blocks);
1971       ggc_mark_tree (lvl->this_class);
1972       ggc_mark_tree (lvl->incomplete);
1973       ggc_mark_tree (lvl->dead_vars_from_for);
1974     }
1975 }
1976
1977 static void
1978 mark_named_label_lists (labs, uses)
1979      void *labs;
1980      void *uses;
1981 {
1982   struct named_label_list *l = *(struct named_label_list **)labs;
1983   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
1984
1985   for (; l; l = l->next)
1986     {
1987       ggc_mark (l);
1988       mark_binding_level (l->binding_level);
1989       ggc_mark_tree (l->old_value);
1990       ggc_mark_tree (l->label_decl);
1991       ggc_mark_tree (l->bad_decls);
1992     }
1993
1994   for (; u; u = u->next)
1995     ggc_mark (u);
1996 }
1997 \f
1998 /* For debugging.  */
1999 static int no_print_functions = 0;
2000 static int no_print_builtins = 0;
2001
2002 void
2003 print_binding_level (lvl)
2004      struct binding_level *lvl;
2005 {
2006   tree t;
2007   int i = 0, len;
2008   fprintf (stderr, " blocks=");
2009   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2010   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2011            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2012   if (lvl->tag_transparent)
2013     fprintf (stderr, " tag-transparent");
2014   if (lvl->more_cleanups_ok)
2015     fprintf (stderr, " more-cleanups-ok");
2016   if (lvl->have_cleanups)
2017     fprintf (stderr, " have-cleanups");
2018   fprintf (stderr, "\n");
2019   if (lvl->names)
2020     {
2021       fprintf (stderr, " names:\t");
2022       /* We can probably fit 3 names to a line?  */
2023       for (t = lvl->names; t; t = TREE_CHAIN (t))
2024         {
2025           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2026             continue;
2027           if (no_print_builtins
2028               && (TREE_CODE (t) == TYPE_DECL)
2029               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2030             continue;
2031
2032           /* Function decls tend to have longer names.  */
2033           if (TREE_CODE (t) == FUNCTION_DECL)
2034             len = 3;
2035           else
2036             len = 2;
2037           i += len;
2038           if (i > 6)
2039             {
2040               fprintf (stderr, "\n\t");
2041               i = len;
2042             }
2043           print_node_brief (stderr, "", t, 0);
2044           if (t == error_mark_node)
2045             break;
2046         }
2047       if (i)
2048         fprintf (stderr, "\n");
2049     }
2050   if (lvl->tags)
2051     {
2052       fprintf (stderr, " tags:\t");
2053       i = 0;
2054       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2055         {
2056           if (TREE_PURPOSE (t) == NULL_TREE)
2057             len = 3;
2058           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2059             len = 2;
2060           else
2061             len = 4;
2062           i += len;
2063           if (i > 5)
2064             {
2065               fprintf (stderr, "\n\t");
2066               i = len;
2067             }
2068           if (TREE_PURPOSE (t) == NULL_TREE)
2069             {
2070               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2071               fprintf (stderr, ">");
2072             }
2073           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2074             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2075           else
2076             {
2077               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2078               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2079               fprintf (stderr, ">");
2080             }
2081         }
2082       if (i)
2083         fprintf (stderr, "\n");
2084     }
2085   if (lvl->class_shadowed)
2086     {
2087       fprintf (stderr, " class-shadowed:");
2088       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2089         {
2090           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2091         }
2092       fprintf (stderr, "\n");
2093     }
2094   if (lvl->type_shadowed)
2095     {
2096       fprintf (stderr, " type-shadowed:");
2097       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2098         {
2099           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2100         }
2101       fprintf (stderr, "\n");
2102     }
2103 }
2104
2105 void
2106 print_other_binding_stack (stack)
2107      struct binding_level *stack;
2108 {
2109   struct binding_level *level;
2110   for (level = stack; level != global_binding_level; level = level->level_chain)
2111     {
2112       fprintf (stderr, "binding level ");
2113       fprintf (stderr, HOST_PTR_PRINTF, level);
2114       fprintf (stderr, "\n");
2115       print_binding_level (level);
2116     }
2117 }
2118
2119 void
2120 print_binding_stack ()
2121 {
2122   struct binding_level *b;
2123   fprintf (stderr, "current_binding_level=");
2124   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2125   fprintf (stderr, "\nclass_binding_level=");
2126   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2127   fprintf (stderr, "\nglobal_binding_level=");
2128   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2129   fprintf (stderr, "\n");
2130   if (class_binding_level)
2131     {
2132       for (b = class_binding_level; b; b = b->level_chain)
2133         if (b == current_binding_level)
2134           break;
2135       if (b)
2136         b = class_binding_level;
2137       else
2138         b = current_binding_level;
2139     }
2140   else
2141     b = current_binding_level;
2142   print_other_binding_stack (b);
2143   fprintf (stderr, "global:\n");
2144   print_binding_level (global_binding_level);
2145 }
2146
2147 /* Namespace binding access routines: The namespace_bindings field of
2148    the identifier is polymorphic, with three possible values:
2149    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2150    indicating the BINDING_VALUE of global_namespace. */
2151
2152 /* Check whether the a binding for the name to scope is known.
2153    Assumes that the bindings of the name are already a list
2154    of bindings. Returns the binding found, or NULL_TREE. */
2155
2156 static tree
2157 find_binding (name, scope)
2158      tree name;
2159      tree scope;
2160 {
2161   tree iter, prev = NULL_TREE;
2162
2163   scope = ORIGINAL_NAMESPACE (scope);
2164
2165   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2166        iter = TREE_CHAIN (iter))
2167     {
2168       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2169       if (BINDING_SCOPE (iter) == scope)
2170         {
2171           /* Move binding found to the front of the list, so
2172              subsequent lookups will find it faster. */
2173           if (prev)
2174             {
2175               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2176               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2177               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2178             }
2179           return iter;
2180         }
2181       prev = iter;
2182     }
2183   return NULL_TREE;
2184 }
2185
2186 /* Always returns a binding for name in scope. If the
2187    namespace_bindings is not a list, convert it to one first.
2188    If no binding is found, make a new one. */
2189
2190 tree
2191 binding_for_name (name, scope)
2192      tree name;
2193      tree scope;
2194 {
2195   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2196   tree result;
2197
2198   scope = ORIGINAL_NAMESPACE (scope);
2199
2200   if (b && TREE_CODE (b) != CPLUS_BINDING)
2201     {
2202       /* Get rid of optimization for global scope. */
2203       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2204       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2205       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2206     }
2207   if (b && (result = find_binding (name, scope)))
2208     return result;
2209   /* Not found, make a new one. */
2210   result = make_node (CPLUS_BINDING);
2211   TREE_CHAIN (result) = b;
2212   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2213   BINDING_SCOPE (result) = scope;
2214   BINDING_TYPE (result) = NULL_TREE;
2215   BINDING_VALUE (result) = NULL_TREE;
2216   return result;
2217 }
2218
2219 /* Return the binding value for name in scope, considering that
2220    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2221
2222 tree
2223 namespace_binding (name, scope)
2224      tree name;
2225      tree scope;
2226 {
2227   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2228   if (b == NULL_TREE)
2229     return NULL_TREE;
2230   if (scope == NULL_TREE)
2231     scope = global_namespace;
2232   if (TREE_CODE (b) != CPLUS_BINDING)
2233     return (scope == global_namespace) ? b : NULL_TREE;
2234   name = find_binding (name,scope);
2235   if (name == NULL_TREE)
2236     return name;
2237   return BINDING_VALUE (name);
2238 }
2239
2240 /* Set the binding value for name in scope. If modifying the binding
2241    of global_namespace is attempted, try to optimize it. */
2242
2243 void
2244 set_namespace_binding (name, scope, val)
2245      tree name;
2246      tree scope;
2247      tree val;
2248 {
2249   tree b;
2250
2251   if (scope == NULL_TREE)
2252     scope = global_namespace;
2253
2254   if (scope == global_namespace)
2255     {
2256       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2257       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2258         {
2259           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2260           return;
2261         }
2262     }
2263   b = binding_for_name (name, scope);
2264   BINDING_VALUE (b) = val;
2265 }
2266
2267 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2268    select a name that is unique to this compilation unit.  */
2269
2270 void
2271 push_namespace (name)
2272      tree name;
2273 {
2274   tree d = NULL_TREE;
2275   int need_new = 1;
2276   int implicit_use = 0;
2277   int global = 0;
2278   if (!global_namespace)
2279     {
2280       /* This must be ::. */
2281       my_friendly_assert (name == get_identifier ("::"), 377);
2282       global = 1;
2283     }
2284   else if (!name)
2285     {
2286       /* The name of anonymous namespace is unique for the translation
2287          unit.  */
2288       if (!anonymous_namespace_name)
2289         anonymous_namespace_name = get_file_function_name ('N');
2290       name = anonymous_namespace_name;
2291       d = IDENTIFIER_NAMESPACE_VALUE (name);
2292       if (d)
2293         /* Reopening anonymous namespace.  */
2294         need_new = 0;
2295       implicit_use = 1;
2296     }
2297   else if (current_namespace == global_namespace
2298            && !flag_honor_std
2299            && name == std_identifier)
2300     {
2301       in_fake_std++;
2302       return;
2303     }
2304   else
2305     {
2306       /* Check whether this is an extended namespace definition. */
2307       d = IDENTIFIER_NAMESPACE_VALUE (name);
2308       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2309         {
2310           need_new = 0;
2311           if (DECL_NAMESPACE_ALIAS (d))
2312             {
2313               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2314                         d, DECL_NAMESPACE_ALIAS (d));
2315               d = DECL_NAMESPACE_ALIAS (d);
2316             }
2317         }
2318     }
2319
2320   if (need_new)
2321     {
2322       /* Make a new namespace, binding the name to it. */
2323       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2324       /* The global namespace is not pushed, and the global binding
2325          level is set elsewhere.  */
2326       if (!global)
2327         {
2328           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2329           d = pushdecl (d);
2330           pushlevel (0);
2331           declare_namespace_level ();
2332           NAMESPACE_LEVEL (d) = current_binding_level;
2333         }
2334     }
2335   else
2336     resume_binding_level (NAMESPACE_LEVEL (d));
2337
2338   if (implicit_use)
2339     do_using_directive (d);
2340   /* Enter the name space. */
2341   current_namespace = d;
2342 }
2343
2344 /* Pop from the scope of the current namespace.  */
2345
2346 void
2347 pop_namespace ()
2348 {
2349   if (current_namespace == global_namespace)
2350     {
2351       my_friendly_assert (in_fake_std > 0, 980421);
2352       in_fake_std--;
2353       return;
2354     }
2355   current_namespace = CP_DECL_CONTEXT (current_namespace);
2356   /* The binding level is not popped, as it might be re-opened later.  */
2357   suspend_binding_level ();
2358 }
2359
2360 /* Push into the scope of the namespace NS, even if it is deeply
2361    nested within another namespace.  */
2362
2363 void
2364 push_nested_namespace (ns)
2365      tree ns;
2366 {
2367   if (ns == global_namespace)
2368     push_to_top_level ();
2369   else
2370     {
2371       push_nested_namespace (CP_DECL_CONTEXT (ns));
2372       push_namespace (DECL_NAME (ns));
2373     }
2374 }
2375
2376 /* Pop back from the scope of the namespace NS, which was previously
2377    entered with push_nested_namespace.  */
2378
2379 void
2380 pop_nested_namespace (ns)
2381      tree ns;
2382 {
2383   while (ns != global_namespace)
2384     {
2385       pop_namespace ();
2386       ns = CP_DECL_CONTEXT (ns);
2387     }
2388
2389   pop_from_top_level ();
2390 }
2391
2392 \f
2393 /* Subroutines for reverting temporarily to top-level for instantiation
2394    of templates and such.  We actually need to clear out the class- and
2395    local-value slots of all identifiers, so that only the global values
2396    are at all visible.  Simply setting current_binding_level to the global
2397    scope isn't enough, because more binding levels may be pushed.  */
2398 struct saved_scope *scope_chain;
2399
2400 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2401
2402 static void
2403 mark_saved_scope (arg)
2404      void *arg;
2405 {
2406   struct saved_scope *t = *(struct saved_scope **)arg;
2407   while (t)
2408     {
2409       mark_binding_level (&t->class_bindings);
2410       ggc_mark_tree (t->old_bindings);
2411       ggc_mark_tree (t->old_namespace);
2412       ggc_mark_tree (t->class_name);
2413       ggc_mark_tree (t->class_type);
2414       ggc_mark_tree (t->access_specifier);
2415       ggc_mark_tree (t->function_decl);
2416       if (t->lang_base)
2417         ggc_mark_tree_varray (t->lang_base);
2418       ggc_mark_tree (t->lang_name);
2419       ggc_mark_tree (t->template_parms);
2420       ggc_mark_tree (t->x_previous_class_type);
2421       ggc_mark_tree (t->x_previous_class_values);
2422       ggc_mark_tree (t->x_saved_tree);
2423       ggc_mark_tree (t->incomplete);
2424       ggc_mark_tree (t->lookups);
2425
2426       mark_stmt_tree (&t->x_stmt_tree);
2427       mark_binding_level (&t->bindings);
2428       t = t->prev;
2429     }
2430 }
2431
2432 static tree
2433 store_bindings (names, old_bindings)
2434      tree names, old_bindings;
2435 {
2436   tree t;
2437   tree search_bindings = old_bindings;
2438
2439   for (t = names; t; t = TREE_CHAIN (t))
2440     {
2441       tree binding, t1, id;
2442
2443       if (TREE_CODE (t) == TREE_LIST)
2444         id = TREE_PURPOSE (t);
2445       else
2446         id = DECL_NAME (t);
2447
2448       if (!id
2449           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2450              we have no IDENTIFIER_BINDING if we have left the class
2451              scope, but cached the class-level declarations.  */
2452           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2453         continue;
2454
2455       for (t1 = search_bindings; t1; t1 = TREE_CHAIN (t1))
2456         if (TREE_VEC_ELT (t1, 0) == id)
2457           goto skip_it;
2458
2459       my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2460       binding = make_tree_vec (4);
2461       TREE_VEC_ELT (binding, 0) = id;
2462       TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2463       TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2464       TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2465       IDENTIFIER_BINDING (id) = NULL_TREE;
2466       IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2467       TREE_CHAIN (binding) = old_bindings;
2468       old_bindings = binding;
2469     skip_it:
2470       ;
2471     }
2472   return old_bindings;
2473 }
2474
2475 void
2476 maybe_push_to_top_level (pseudo)
2477      int pseudo;
2478 {
2479   struct saved_scope *s;
2480   struct binding_level *b;
2481   tree old_bindings;
2482   int need_pop;
2483
2484   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2485
2486   b = scope_chain ? current_binding_level : 0;
2487
2488   /* If we're in the middle of some function, save our state.  */
2489   if (cfun)
2490     {
2491       need_pop = 1;
2492       push_function_context_to (NULL_TREE);
2493     }
2494   else
2495     need_pop = 0;
2496
2497   old_bindings = NULL_TREE;
2498   if (scope_chain && previous_class_type)
2499     old_bindings = store_bindings (previous_class_values, old_bindings);
2500
2501   /* Have to include global_binding_level, because class-level decls
2502      aren't listed anywhere useful.  */
2503   for (; b; b = b->level_chain)
2504     {
2505       tree t;
2506
2507       /* Template IDs are inserted into the global level. If they were
2508          inserted into namespace level, finish_file wouldn't find them
2509          when doing pending instantiations. Therefore, don't stop at
2510          namespace level, but continue until :: .  */
2511       if (b == global_binding_level || (pseudo && b->template_parms_p))
2512         break;
2513
2514       old_bindings = store_bindings (b->names, old_bindings);
2515       /* We also need to check class_shadowed to save class-level type
2516          bindings, since pushclass doesn't fill in b->names.  */
2517       if (b->parm_flag == 2)
2518         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2519
2520       /* Unwind type-value slots back to top level.  */
2521       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2522         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2523     }
2524   s->prev = scope_chain;
2525   s->old_bindings = old_bindings;
2526   s->bindings = b;
2527   s->need_pop_function_context = need_pop;
2528   s->function_decl = current_function_decl;
2529
2530   scope_chain = s;
2531   current_function_decl = NULL_TREE;
2532   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2533   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2534   current_lang_name = lang_name_cplusplus;
2535   current_namespace = global_namespace;
2536 }
2537
2538 void
2539 push_to_top_level ()
2540 {
2541   maybe_push_to_top_level (0);
2542 }
2543
2544 void
2545 pop_from_top_level ()
2546 {
2547   struct saved_scope *s = scope_chain;
2548   tree t;
2549
2550   /* Clear out class-level bindings cache.  */
2551   if (previous_class_type)
2552     invalidate_class_lookup_cache ();
2553
2554   VARRAY_FREE (current_lang_base);
2555
2556   scope_chain = s->prev;
2557   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2558     {
2559       tree id = TREE_VEC_ELT (t, 0);
2560
2561       SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2562       IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2563       IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2564     }
2565
2566   /* If we were in the middle of compiling a function, restore our
2567      state.  */
2568   if (s->need_pop_function_context)
2569     pop_function_context_from (NULL_TREE);
2570   current_function_decl = s->function_decl;
2571
2572   free (s);
2573 }
2574 \f
2575 /* Push a definition of struct, union or enum tag "name".
2576    into binding_level "b".   "type" should be the type node,
2577    We assume that the tag "name" is not already defined.
2578
2579    Note that the definition may really be just a forward reference.
2580    In that case, the TYPE_SIZE will be a NULL_TREE.
2581
2582    C++ gratuitously puts all these tags in the name space.  */
2583
2584 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2585    record the shadowed value for this binding contour.  TYPE is
2586    the type that ID maps to.  */
2587
2588 static void
2589 set_identifier_type_value_with_scope (id, type, b)
2590      tree id;
2591      tree type;
2592      struct binding_level *b;
2593 {
2594   if (!b->namespace_p)
2595     {
2596       /* Shadow the marker, not the real thing, so that the marker
2597          gets restored later. */
2598       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2599       b->type_shadowed
2600         = tree_cons (id, old_type_value, b->type_shadowed);
2601     }
2602   else
2603     {
2604       tree binding = binding_for_name (id, current_namespace);
2605       BINDING_TYPE (binding) = type;
2606       /* Store marker instead of real type. */
2607       type = global_type_node;
2608     }
2609   SET_IDENTIFIER_TYPE_VALUE (id, type);
2610 }
2611
2612 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2613
2614 void
2615 set_identifier_type_value (id, type)
2616      tree id;
2617      tree type;
2618 {
2619   set_identifier_type_value_with_scope (id, type, current_binding_level);
2620 }
2621
2622 /* Return the type associated with id. */
2623
2624 tree
2625 identifier_type_value (id)
2626      tree id;
2627 {
2628   /* There is no type with that name, anywhere. */
2629   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2630     return NULL_TREE;
2631   /* This is not the type marker, but the real thing. */
2632   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2633     return REAL_IDENTIFIER_TYPE_VALUE (id);
2634   /* Have to search for it. It must be on the global level, now.
2635      Ask lookup_name not to return non-types. */
2636   id = lookup_name_real (id, 2, 1, 0);
2637   if (id)
2638     return TREE_TYPE (id);
2639   return NULL_TREE;
2640 }
2641
2642 /* Pop off extraneous binding levels left over due to syntax errors.
2643
2644    We don't pop past namespaces, as they might be valid.  */
2645
2646 void
2647 pop_everything ()
2648 {
2649 #ifdef DEBUG_CP_BINDING_LEVELS
2650   fprintf (stderr, "XXX entering pop_everything ()\n");
2651 #endif
2652   while (!toplevel_bindings_p ())
2653     {
2654       if (current_binding_level->parm_flag == 2)
2655         pop_nested_class ();
2656       else
2657         poplevel (0, 0, 0);
2658     }
2659 #ifdef DEBUG_CP_BINDING_LEVELS
2660   fprintf (stderr, "XXX leaving pop_everything ()\n");
2661 #endif
2662 }
2663
2664 /* The type TYPE is being declared.  If it is a class template, or a
2665    specialization of a class template, do any processing required and
2666    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2667    being declared a friend.  B is the binding level at which this TYPE
2668    should be bound.
2669
2670    Returns the TYPE_DECL for TYPE, which may have been altered by this
2671    processing.  */
2672
2673 static tree
2674 maybe_process_template_type_declaration (type, globalize, b)
2675      tree type;
2676      int globalize;
2677      struct binding_level* b;
2678 {
2679   tree decl = TYPE_NAME (type);
2680
2681   if (processing_template_parmlist)
2682     /* You can't declare a new template type in a template parameter
2683        list.  But, you can declare a non-template type:
2684
2685          template <class A*> struct S;
2686
2687        is a forward-declaration of `A'.  */
2688     ;
2689   else
2690     {
2691       maybe_check_template_type (type);
2692
2693       my_friendly_assert (IS_AGGR_TYPE (type)
2694                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2695
2696
2697       if (processing_template_decl)
2698         {
2699           /* This may change after the call to
2700              push_template_decl_real, but we want the original value.  */
2701           tree name = DECL_NAME (decl);
2702
2703           decl = push_template_decl_real (decl, globalize);
2704           /* If the current binding level is the binding level for the
2705              template parameters (see the comment in
2706              begin_template_parm_list) and the enclosing level is a class
2707              scope, and we're not looking at a friend, push the
2708              declaration of the member class into the class scope.  In the
2709              friend case, push_template_decl will already have put the
2710              friend into global scope, if appropriate.  */
2711           if (TREE_CODE (type) != ENUMERAL_TYPE
2712               && !globalize && b->template_parms_p
2713               && b->level_chain->parm_flag == 2)
2714             {
2715               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2716               /* Put this tag on the list of tags for the class, since
2717                  that won't happen below because B is not the class
2718                  binding level, but is instead the pseudo-global level.  */
2719               b->level_chain->tags =
2720                 tree_cons (name, type, b->level_chain->tags);
2721               if (!COMPLETE_TYPE_P (current_class_type))
2722                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2723             }
2724         }
2725     }
2726
2727   return decl;
2728 }
2729
2730 /* In C++, you don't have to write `struct S' to refer to `S'; you
2731    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2732    if the user had written `typedef struct S S'.  Create and return
2733    the TYPE_DECL for TYPE.  */
2734
2735 tree
2736 create_implicit_typedef (name, type)
2737      tree name;
2738      tree type;
2739 {
2740   tree decl;
2741
2742   decl = build_decl (TYPE_DECL, name, type);
2743   DECL_ARTIFICIAL (decl) = 1;
2744   /* There are other implicit type declarations, like the one *within*
2745      a class that allows you to write `S::S'.  We must distinguish
2746      amongst these.  */
2747   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2748   TYPE_NAME (type) = decl;
2749
2750   return decl;
2751 }
2752
2753 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2754    Normally put it into the inner-most non-tag-transparent scope,
2755    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2756    The latter is needed for implicit declarations.  */
2757
2758 void
2759 pushtag (name, type, globalize)
2760      tree name, type;
2761      int globalize;
2762 {
2763   register struct binding_level *b;
2764
2765   b = current_binding_level;
2766   while (b->tag_transparent
2767          || (globalize && b->parm_flag == 2))
2768     b = b->level_chain;
2769
2770   b->tags = tree_cons (name, type, b->tags);
2771
2772   if (name)
2773     {
2774       /* Do C++ gratuitous typedefing.  */
2775       if (IDENTIFIER_TYPE_VALUE (name) != type)
2776         {
2777           register tree d = NULL_TREE;
2778           int in_class = 0;
2779           tree context = TYPE_CONTEXT (type);
2780
2781           if (! context)
2782             {
2783               tree cs = current_scope ();
2784
2785               if (! globalize)
2786                 context = cs;
2787               else if (cs != NULL_TREE && TYPE_P (cs))
2788                 /* When declaring a friend class of a local class, we want
2789                    to inject the newly named class into the scope
2790                    containing the local class, not the namespace scope.  */
2791                 context = decl_function_context (get_type_decl (cs));
2792             }
2793           if (!context)
2794             context = current_namespace;
2795
2796           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2797               || b->parm_flag == 2)
2798             in_class = 1;
2799
2800           if (current_lang_name == lang_name_java)
2801             TYPE_FOR_JAVA (type) = 1;
2802
2803           d = create_implicit_typedef (name, type);
2804           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2805           if (! in_class)
2806             set_identifier_type_value_with_scope (name, type, b);
2807
2808           d = maybe_process_template_type_declaration (type,
2809                                                        globalize, b);
2810
2811           if (b->parm_flag == 2)
2812             {
2813               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2814                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2815                    class.  But if it's a member template class, we
2816                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2817                    is done later.  */
2818                 finish_member_declaration (d);
2819               else
2820                 pushdecl_class_level (d);
2821             }
2822           else
2823             d = pushdecl_with_scope (d, b);
2824
2825           if (ANON_AGGRNAME_P (name))
2826             DECL_IGNORED_P (d) = 1;
2827
2828           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2829           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2830
2831           /* If this is a local class, keep track of it.  We need this
2832              information for name-mangling, and so that it is possible to find
2833              all function definitions in a translation unit in a convenient
2834              way.  (It's otherwise tricky to find a member function definition
2835              it's only pointed to from within a local class.)  */
2836           if (TYPE_CONTEXT (type)
2837               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2838               && !processing_template_decl)
2839             VARRAY_PUSH_TREE (local_classes, type);
2840
2841           if (!uses_template_parms (type))
2842             DECL_ASSEMBLER_NAME (d) = mangle_type (type);
2843         }
2844       if (b->parm_flag == 2)
2845         {
2846           if (!COMPLETE_TYPE_P (current_class_type))
2847             CLASSTYPE_TAGS (current_class_type) = b->tags;
2848         }
2849     }
2850
2851   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2852     /* Use the canonical TYPE_DECL for this node.  */
2853     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2854   else
2855     {
2856       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2857          will be the tagged type we just added to the current
2858          binding level.  This fake NULL-named TYPE_DECL node helps
2859          dwarfout.c to know when it needs to output a
2860          representation of a tagged type, and it also gives us a
2861          convenient place to record the "scope start" address for
2862          the tagged type.  */
2863
2864       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2865       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2866     }
2867 }
2868
2869 /* Counter used to create anonymous type names.  */
2870
2871 static int anon_cnt = 0;
2872
2873 /* Return an IDENTIFIER which can be used as a name for
2874    anonymous structs and unions.  */
2875
2876 tree
2877 make_anon_name ()
2878 {
2879   char buf[32];
2880
2881   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2882   return get_identifier (buf);
2883 }
2884
2885 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2886    This keeps dbxout from getting confused.  */
2887
2888 void
2889 clear_anon_tags ()
2890 {
2891   register struct binding_level *b;
2892   register tree tags;
2893   static int last_cnt = 0;
2894
2895   /* Fast out if no new anon names were declared.  */
2896   if (last_cnt == anon_cnt)
2897     return;
2898
2899   b = current_binding_level;
2900   while (b->tag_transparent)
2901     b = b->level_chain;
2902   tags = b->tags;
2903   while (tags)
2904     {
2905       /* A NULL purpose means we have already processed all tags
2906          from here to the end of the list.  */
2907       if (TREE_PURPOSE (tags) == NULL_TREE)
2908         break;
2909       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2910         TREE_PURPOSE (tags) = NULL_TREE;
2911       tags = TREE_CHAIN (tags);
2912     }
2913   last_cnt = anon_cnt;
2914 }
2915 \f
2916 /* Subroutine of duplicate_decls: return truthvalue of whether
2917    or not types of these decls match.
2918
2919    For C++, we must compare the parameter list so that `int' can match
2920    `int&' in a parameter position, but `int&' is not confused with
2921    `const int&'.  */
2922
2923 int
2924 decls_match (newdecl, olddecl)
2925      tree newdecl, olddecl;
2926 {
2927   int types_match;
2928
2929   if (newdecl == olddecl)
2930     return 1;
2931
2932   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2933     /* If the two DECLs are not even the same kind of thing, we're not
2934        interested in their types.  */
2935     return 0;
2936
2937   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2938     {
2939       tree f1 = TREE_TYPE (newdecl);
2940       tree f2 = TREE_TYPE (olddecl);
2941       tree p1 = TYPE_ARG_TYPES (f1);
2942       tree p2 = TYPE_ARG_TYPES (f2);
2943
2944       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2945           && ! (DECL_EXTERN_C_P (newdecl)
2946                 && DECL_EXTERN_C_P (olddecl)))
2947         return 0;
2948
2949       if (TREE_CODE (f1) != TREE_CODE (f2))
2950         return 0;
2951
2952       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2953         {
2954           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
2955               && (DECL_BUILT_IN (olddecl)
2956 #ifndef NO_IMPLICIT_EXTERN_C
2957                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
2958                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
2959 #endif
2960               ))
2961             {
2962               types_match = self_promoting_args_p (p1);
2963               if (p1 == void_list_node)
2964                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2965             }
2966 #ifndef NO_IMPLICIT_EXTERN_C
2967           else if (p1 == NULL_TREE
2968                    && (DECL_EXTERN_C_P (olddecl)
2969                        && DECL_IN_SYSTEM_HEADER (olddecl)
2970                        && !DECL_CLASS_SCOPE_P (olddecl))
2971                    && (DECL_EXTERN_C_P (newdecl)
2972                        && DECL_IN_SYSTEM_HEADER (newdecl)
2973                        && !DECL_CLASS_SCOPE_P (newdecl)))
2974             {
2975               types_match = self_promoting_args_p (p2);
2976               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2977             }
2978 #endif
2979           else
2980             types_match = compparms (p1, p2);
2981         }
2982       else
2983         types_match = 0;
2984     }
2985   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2986     {
2987       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2988                                 DECL_TEMPLATE_PARMS (olddecl)))
2989         return 0;
2990
2991       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
2992           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
2993         return 0;
2994
2995       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2996         types_match = 1;
2997       else
2998         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2999                                    DECL_TEMPLATE_RESULT (newdecl));
3000     }
3001   else
3002     {
3003       if (TREE_TYPE (newdecl) == error_mark_node)
3004         types_match = TREE_TYPE (olddecl) == error_mark_node;
3005       else if (TREE_TYPE (olddecl) == NULL_TREE)
3006         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3007       else if (TREE_TYPE (newdecl) == NULL_TREE)
3008         types_match = 0;
3009       else
3010         types_match = comptypes (TREE_TYPE (newdecl),
3011                                  TREE_TYPE (olddecl),
3012                                  COMPARE_REDECLARATION);
3013     }
3014
3015   return types_match;
3016 }
3017
3018 /* If NEWDECL is `static' and an `extern' was seen previously,
3019    warn about it.  OLDDECL is the previous declaration.
3020
3021    Note that this does not apply to the C++ case of declaring
3022    a variable `extern const' and then later `const'.
3023
3024    Don't complain about built-in functions, since they are beyond
3025    the user's control.  */
3026
3027 static void
3028 warn_extern_redeclared_static (newdecl, olddecl)
3029      tree newdecl, olddecl;
3030 {
3031   static const char *explicit_extern_static_warning
3032     = "`%D' was declared `extern' and later `static'";
3033   static const char *implicit_extern_static_warning
3034     = "`%D' was declared implicitly `extern' and later `static'";
3035
3036   tree name;
3037
3038   if (TREE_CODE (newdecl) == TYPE_DECL
3039       || TREE_CODE (newdecl) == TEMPLATE_DECL
3040       || TREE_CODE (newdecl) == CONST_DECL)
3041     return;
3042
3043   /* Don't get confused by static member functions; that's a different
3044      use of `static'.  */
3045   if (TREE_CODE (newdecl) == FUNCTION_DECL
3046       && DECL_STATIC_FUNCTION_P (newdecl))
3047     return;
3048
3049   /* If the old declaration was `static', or the new one isn't, then
3050      then everything is OK.  */
3051   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3052     return;
3053
3054   /* It's OK to declare a builtin function as `static'.  */
3055   if (TREE_CODE (olddecl) == FUNCTION_DECL
3056       && DECL_ARTIFICIAL (olddecl))
3057     return;
3058
3059   name = DECL_ASSEMBLER_NAME (newdecl);
3060   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3061               ? implicit_extern_static_warning
3062               : explicit_extern_static_warning, newdecl);
3063   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3064 }
3065
3066 /* Handle when a new declaration NEWDECL has the same name as an old
3067    one OLDDECL in the same binding contour.  Prints an error message
3068    if appropriate.
3069
3070    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3071    Otherwise, return 0.  */
3072
3073 int
3074 duplicate_decls (newdecl, olddecl)
3075      tree newdecl, olddecl;
3076 {
3077   unsigned olddecl_uid = DECL_UID (olddecl);
3078   int olddecl_friend = 0, types_match = 0;
3079   int new_defines_function = 0;
3080
3081   if (newdecl == olddecl)
3082     return 1;
3083
3084   types_match = decls_match (newdecl, olddecl);
3085
3086   /* If either the type of the new decl or the type of the old decl is an
3087      error_mark_node, then that implies that we have already issued an
3088      error (earlier) for some bogus type specification, and in that case,
3089      it is rather pointless to harass the user with yet more error message
3090      about the same declaration, so just pretend the types match here.  */
3091   if (TREE_TYPE (newdecl) == error_mark_node
3092       || TREE_TYPE (olddecl) == error_mark_node)
3093     types_match = 1;
3094
3095   /* Check for redeclaration and other discrepancies. */
3096   if (TREE_CODE (olddecl) == FUNCTION_DECL
3097       && DECL_ARTIFICIAL (olddecl))
3098     {
3099       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3100         {
3101           /* If you declare a built-in or predefined function name as static,
3102              the old definition is overridden, but optionally warn this was a
3103              bad choice of name.  */
3104           if (! TREE_PUBLIC (newdecl))
3105             {
3106               if (warn_shadow)
3107                 cp_warning ("shadowing %s function `%#D'",
3108                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3109                             olddecl);
3110               /* Discard the old built-in function.  */
3111               return 0;
3112             }
3113           /* If the built-in is not ansi, then programs can override
3114              it even globally without an error.  */
3115           else if (! DECL_BUILT_IN (olddecl))
3116             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3117                         olddecl, newdecl);
3118           else
3119             {
3120               cp_error ("declaration of `%#D'", newdecl);
3121               cp_error ("conflicts with built-in declaration `%#D'",
3122                         olddecl);
3123             }
3124           return 0;
3125         }
3126       else if (!types_match)
3127         {
3128           if ((DECL_EXTERN_C_P (newdecl)
3129                && DECL_EXTERN_C_P (olddecl))
3130               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3131                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3132             {
3133               /* A near match; override the builtin.  */
3134
3135               if (TREE_PUBLIC (newdecl))
3136                 {
3137                   cp_warning ("new declaration `%#D'", newdecl);
3138                   cp_warning ("ambiguates built-in declaration `%#D'",
3139                               olddecl);
3140                 }
3141               else if (warn_shadow)
3142                 cp_warning ("shadowing %s function `%#D'",
3143                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3144                             olddecl);
3145             }
3146           else
3147             /* Discard the old built-in function.  */
3148             return 0;
3149         }
3150
3151       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3152         {
3153           /* If a builtin function is redeclared as `static', merge
3154              the declarations, but make the original one static.  */
3155           DECL_THIS_STATIC (olddecl) = 1;
3156           TREE_PUBLIC (olddecl) = 0;
3157
3158           /* Make the old declaration consistent with the new one so
3159              that all remnants of the builtin-ness of this function
3160              will be banished.  */
3161           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3162           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3163           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3164           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3165                                        newdecl);
3166         }
3167     }
3168   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3169     {
3170       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3171            && TREE_CODE (newdecl) != TYPE_DECL
3172            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3173                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3174           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3175               && TREE_CODE (olddecl) != TYPE_DECL
3176               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3177                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3178                         == TYPE_DECL))))
3179         {
3180           /* We do nothing special here, because C++ does such nasty
3181              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3182              get shadowed, and know that if we need to find a TYPE_DECL
3183              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3184              slot of the identifier.  */
3185           return 0;
3186         }
3187
3188       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3189            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3190           || (TREE_CODE (olddecl) == FUNCTION_DECL
3191               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3192         return 0;
3193
3194       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3195       if (TREE_CODE (olddecl) == TREE_LIST)
3196         olddecl = TREE_VALUE (olddecl);
3197       cp_error_at ("previous declaration of `%#D'", olddecl);
3198
3199       /* New decl is completely inconsistent with the old one =>
3200          tell caller to replace the old one.  */
3201
3202       return 0;
3203     }
3204   else if (!types_match)
3205     {
3206       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3207         /* These are certainly not duplicate declarations; they're
3208            from different scopes.  */
3209         return 0;
3210
3211       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3212         {
3213           /* The name of a class template may not be declared to refer to
3214              any other template, class, function, object, namespace, value,
3215              or type in the same scope.  */
3216           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3217               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3218             {
3219               cp_error ("declaration of template `%#D'", newdecl);
3220               cp_error_at ("conflicts with previous declaration `%#D'",
3221                            olddecl);
3222             }
3223           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3224                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3225                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3226                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3227                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3228                                            DECL_TEMPLATE_PARMS (olddecl)))
3229             {
3230               cp_error ("new declaration `%#D'", newdecl);
3231               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3232             }
3233           return 0;
3234         }
3235       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3236         {
3237           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3238             {
3239               cp_error ("declaration of C function `%#D' conflicts with",
3240                         newdecl);
3241               cp_error_at ("previous declaration `%#D' here", olddecl);
3242             }
3243           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3244                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3245             {
3246               cp_error ("new declaration `%#D'", newdecl);
3247               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3248             }
3249           else
3250             return 0;
3251         }
3252
3253       /* Already complained about this, so don't do so again.  */
3254       else if (current_class_type == NULL_TREE
3255           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3256         {
3257           cp_error ("conflicting types for `%#D'", newdecl);
3258           cp_error_at ("previous declaration as `%#D'", olddecl);
3259         }
3260     }
3261   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3262             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3263                  && (!DECL_TEMPLATE_INFO (newdecl)
3264                      || (DECL_TI_TEMPLATE (newdecl)
3265                          != DECL_TI_TEMPLATE (olddecl))))
3266                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3267                     && (!DECL_TEMPLATE_INFO (olddecl)
3268                         || (DECL_TI_TEMPLATE (olddecl)
3269                             != DECL_TI_TEMPLATE (newdecl))))))
3270     /* It's OK to have a template specialization and a non-template
3271        with the same type, or to have specializations of two
3272        different templates with the same type.  Note that if one is a
3273        specialization, and the other is an instantiation of the same
3274        template, that we do not exit at this point.  That situation
3275        can occur if we instantiate a template class, and then
3276        specialize one of its methods.  This situation is legal, but
3277        the declarations must be merged in the usual way.  */
3278     return 0;
3279   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3280            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3281                 && !DECL_USE_TEMPLATE (newdecl))
3282                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3283                    && !DECL_USE_TEMPLATE (olddecl))))
3284     /* One of the declarations is a template instantiation, and the
3285        other is not a template at all.  That's OK.  */
3286     return 0;
3287   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3288            && DECL_NAMESPACE_ALIAS (newdecl)
3289            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3290     /* Redeclaration of namespace alias, ignore it. */
3291     return 1;
3292   else
3293     {
3294       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3295       if (errmsg)
3296         {
3297           cp_error (errmsg, newdecl);
3298           if (DECL_NAME (olddecl) != NULL_TREE)
3299             cp_error_at ((DECL_INITIAL (olddecl)
3300                           && namespace_bindings_p ())
3301                          ? "`%#D' previously defined here"
3302                          : "`%#D' previously declared here", olddecl);
3303         }
3304       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3305                && DECL_INITIAL (olddecl) != NULL_TREE
3306                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3307                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3308         {
3309           /* Prototype decl follows defn w/o prototype.  */
3310           cp_warning_at ("prototype for `%#D'", newdecl);
3311           cp_warning_at ("follows non-prototype definition here", olddecl);
3312         }
3313       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3314                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3315         {
3316           /* extern "C" int foo ();
3317              int foo () { bar (); }
3318              is OK.  */
3319           if (current_lang_stack
3320               == &VARRAY_TREE (current_lang_base, 0))
3321             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3322           else
3323             {
3324               cp_error_at ("previous declaration of `%#D' with %L linkage",
3325                            olddecl, DECL_LANGUAGE (olddecl));
3326               cp_error ("conflicts with new declaration with %L linkage",
3327                         DECL_LANGUAGE (newdecl));
3328             }
3329         }
3330
3331       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3332         ;
3333       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3334         {
3335           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3336           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3337           int i = 1;
3338
3339           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3340             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3341
3342           for (; t1 && t1 != void_list_node;
3343                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3344             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3345               {
3346                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3347                                            TREE_PURPOSE (t2)))
3348                   {
3349                     if (pedantic)
3350                       {
3351                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3352                                     i, newdecl);
3353                         cp_pedwarn_at ("after previous specification in `%#D'",
3354                                        olddecl);
3355                       }
3356                   }
3357                 else
3358                   {
3359                     cp_error ("default argument given for parameter %d of `%#D'",
3360                               i, newdecl);
3361                     cp_error_at ("after previous specification in `%#D'",
3362                                  olddecl);
3363                   }
3364               }
3365
3366           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3367               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3368             {
3369               cp_warning ("`%#D' was used before it was declared inline",
3370                           newdecl);
3371               cp_warning_at ("previous non-inline declaration here",
3372                              olddecl);
3373             }
3374         }
3375     }
3376
3377   /* If new decl is `static' and an `extern' was seen previously,
3378      warn about it.  */
3379   warn_extern_redeclared_static (newdecl, olddecl);
3380
3381   /* We have committed to returning 1 at this point.  */
3382   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3383     {
3384       /* Now that functions must hold information normally held
3385          by field decls, there is extra work to do so that
3386          declaration information does not get destroyed during
3387          definition.  */
3388       if (DECL_VINDEX (olddecl))
3389         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3390       if (DECL_VIRTUAL_CONTEXT (olddecl))
3391         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3392       if (DECL_CONTEXT (olddecl))
3393         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3394       if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3395         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3396       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3397       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3398       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3399       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3400       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3401       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3402       DECL_LANG_SPECIFIC (newdecl)->u2 = DECL_LANG_SPECIFIC (olddecl)->u2;
3403       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3404
3405       /* Optionally warn about more than one declaration for the same
3406          name, but don't warn about a function declaration followed by a
3407          definition.  */
3408       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3409           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3410           /* Don't warn about extern decl followed by definition. */
3411           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3412           /* Don't warn about friends, let add_friend take care of it. */
3413           && ! DECL_FRIEND_P (newdecl))
3414         {
3415           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3416           cp_warning_at ("previous declaration of `%D'", olddecl);
3417         }
3418     }
3419
3420   /* Deal with C++: must preserve virtual function table size.  */
3421   if (TREE_CODE (olddecl) == TYPE_DECL)
3422     {
3423       register tree newtype = TREE_TYPE (newdecl);
3424       register tree oldtype = TREE_TYPE (olddecl);
3425
3426       if (newtype != error_mark_node && oldtype != error_mark_node
3427           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3428         {
3429           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3430           CLASSTYPE_FRIEND_CLASSES (newtype)
3431             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3432         }
3433
3434       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3435     }
3436
3437   /* Copy all the DECL_... slots specified in the new decl
3438      except for any that we copy here from the old type.  */
3439   DECL_MACHINE_ATTRIBUTES (newdecl)
3440     = merge_machine_decl_attributes (olddecl, newdecl);
3441
3442   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3443     {
3444       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3445       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3446         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3447                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3448
3449       return 1;
3450     }
3451
3452   if (types_match)
3453     {
3454       /* Automatically handles default parameters.  */
3455       tree oldtype = TREE_TYPE (olddecl);
3456       tree newtype;
3457
3458       /* Merge the data types specified in the two decls.  */
3459       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3460
3461       /* If common_type produces a non-typedef type, just use the old type.  */
3462       if (TREE_CODE (newdecl) == TYPE_DECL
3463           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3464         newtype = oldtype;
3465
3466       if (TREE_CODE (newdecl) == VAR_DECL)
3467         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3468       /* Do this after calling `common_type' so that default
3469          parameters don't confuse us.  */
3470       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3471           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3472               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3473         {
3474           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3475                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3476           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3477                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3478
3479           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3480               && DECL_SOURCE_LINE (olddecl) != 0
3481               && flag_exceptions
3482               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3483                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3484             {
3485               cp_error ("declaration of `%F' throws different exceptions",
3486                         newdecl);
3487               cp_error_at ("than previous declaration `%F'", olddecl);
3488             }
3489         }
3490       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3491
3492       /* Lay the type out, unless already done.  */
3493       if (! same_type_p (newtype, oldtype)
3494           && TREE_TYPE (newdecl) != error_mark_node
3495           && !(processing_template_decl && uses_template_parms (newdecl)))
3496         layout_type (TREE_TYPE (newdecl));
3497
3498       if ((TREE_CODE (newdecl) == VAR_DECL
3499            || TREE_CODE (newdecl) == PARM_DECL
3500            || TREE_CODE (newdecl) == RESULT_DECL
3501            || TREE_CODE (newdecl) == FIELD_DECL
3502            || TREE_CODE (newdecl) == TYPE_DECL)
3503           && !(processing_template_decl && uses_template_parms (newdecl)))
3504         layout_decl (newdecl, 0);
3505
3506       /* Merge the type qualifiers.  */
3507       if (TREE_READONLY (newdecl))
3508         TREE_READONLY (olddecl) = 1;
3509       if (TREE_THIS_VOLATILE (newdecl))
3510         TREE_THIS_VOLATILE (olddecl) = 1;
3511
3512       /* Merge the initialization information.  */
3513       if (DECL_INITIAL (newdecl) == NULL_TREE
3514           && DECL_INITIAL (olddecl) != NULL_TREE)
3515         {
3516           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3517           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3518           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3519           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3520               && DECL_LANG_SPECIFIC (newdecl)
3521               && DECL_LANG_SPECIFIC (olddecl))
3522             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3523         }
3524
3525       /* Merge the section attribute.
3526          We want to issue an error if the sections conflict but that must be
3527          done later in decl_attributes since we are called before attributes
3528          are assigned.  */
3529       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3530         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3531
3532       /* Keep the old rtl since we can safely use it.  */
3533       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3534
3535       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3536         {
3537           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3538             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3539           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3540             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3541           DECL_NO_LIMIT_STACK (newdecl)
3542             |= DECL_NO_LIMIT_STACK (olddecl);
3543         }
3544     }
3545   /* If cannot merge, then use the new type and qualifiers,
3546      and don't preserve the old rtl.  */
3547   else
3548     {
3549       /* Clean out any memory we had of the old declaration.  */
3550       tree oldstatic = value_member (olddecl, static_aggregates);
3551       if (oldstatic)
3552         TREE_VALUE (oldstatic) = error_mark_node;
3553
3554       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3555       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3556       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3557       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3558     }
3559
3560   /* Merge the storage class information.  */
3561   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3562   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3563   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3564   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3565   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3566   if (! DECL_EXTERNAL (olddecl))
3567     DECL_EXTERNAL (newdecl) = 0;
3568
3569   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3570     {
3571       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3572       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3573       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3574       DECL_TEMPLATE_INSTANTIATED (newdecl)
3575         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3576       /* Don't really know how much of the language-specific
3577          values we should copy from old to new.  */
3578       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3579       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3580       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3581       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3582       DECL_INITIALIZED_IN_CLASS_P (newdecl)
3583         |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
3584       olddecl_friend = DECL_FRIEND_P (olddecl);
3585
3586       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3587       if (TREE_CODE (newdecl) == FUNCTION_DECL
3588           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3589         DECL_BEFRIENDING_CLASSES (newdecl)
3590           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3591                      DECL_BEFRIENDING_CLASSES (olddecl));
3592     }
3593
3594   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3595     {
3596       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3597           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3598         {
3599           /* If newdecl is not a specialization, then it is not a
3600              template-related function at all.  And that means that we
3601              shoud have exited above, returning 0.  */
3602           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3603                               0);
3604
3605           if (TREE_USED (olddecl))
3606             /* From [temp.expl.spec]:
3607
3608                If a template, a member template or the member of a class
3609                template is explicitly specialized then that
3610                specialization shall be declared before the first use of
3611                that specialization that would cause an implicit
3612                instantiation to take place, in every translation unit in
3613                which such a use occurs.  */
3614             cp_error ("explicit specialization of %D after first use",
3615                       olddecl);
3616
3617           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3618         }
3619       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3620
3621       /* If either decl says `inline', this fn is inline, unless its
3622          definition was passed already.  */
3623       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3624         DECL_INLINE (olddecl) = 1;
3625       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3626
3627       if (! types_match)
3628         {
3629           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3630           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3631           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3632         }
3633       if (! types_match || new_defines_function)
3634         {
3635           /* These need to be copied so that the names are available.
3636              Note that if the types do match, we'll preserve inline
3637              info and other bits, but if not, we won't.  */
3638           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3639           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3640         }
3641       if (new_defines_function)
3642         /* If defining a function declared with other language
3643            linkage, use the previously declared language linkage.  */
3644         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3645       else if (types_match)
3646         {
3647           /* If redeclaring a builtin function, and not a definition,
3648              it stays built in.  */
3649           if (DECL_BUILT_IN (olddecl))
3650             {
3651               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3652               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3653               /* If we're keeping the built-in definition, keep the rtl,
3654                  regardless of declaration matches.  */
3655               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3656             }
3657           else
3658             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3659
3660           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3661           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3662             /* Previously saved insns go together with
3663                the function's previous definition.  */
3664             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3665           /* Don't clear out the arguments if we're redefining a function.  */
3666           if (DECL_ARGUMENTS (olddecl))
3667             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3668         }
3669     }
3670
3671   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3672     {
3673       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3674     }
3675
3676   /* Now preserve various other info from the definition.  */
3677   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3678   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3679   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3680   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3681
3682   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3683     {
3684       int function_size;
3685
3686       function_size = sizeof (struct tree_decl);
3687
3688       bcopy ((char *) newdecl + sizeof (struct tree_common),
3689              (char *) olddecl + sizeof (struct tree_common),
3690              function_size - sizeof (struct tree_common));
3691
3692       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3693         {
3694           /* If newdecl is a template instantiation, it is possible that
3695              the following sequence of events has occurred:
3696
3697              o A friend function was declared in a class template.  The
3698              class template was instantiated.
3699
3700              o The instantiation of the friend declaration was
3701              recorded on the instantiation list, and is newdecl.
3702
3703              o Later, however, instantiate_class_template called pushdecl
3704              on the newdecl to perform name injection.  But, pushdecl in
3705              turn called duplicate_decls when it discovered that another
3706              declaration of a global function with the same name already
3707              existed.
3708
3709              o Here, in duplicate_decls, we decided to clobber newdecl.
3710
3711              If we're going to do that, we'd better make sure that
3712              olddecl, and not newdecl, is on the list of
3713              instantiations so that if we try to do the instantiation
3714              again we won't get the clobbered declaration.  */
3715
3716           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3717           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3718
3719           for (; decls; decls = TREE_CHAIN (decls))
3720             if (TREE_VALUE (decls) == newdecl)
3721               TREE_VALUE (decls) = olddecl;
3722         }
3723     }
3724   else
3725     {
3726       bcopy ((char *) newdecl + sizeof (struct tree_common),
3727              (char *) olddecl + sizeof (struct tree_common),
3728              sizeof (struct tree_decl) - sizeof (struct tree_common)
3729              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3730     }
3731
3732   DECL_UID (olddecl) = olddecl_uid;
3733   if (olddecl_friend)
3734     DECL_FRIEND_P (olddecl) = 1;
3735
3736   /* NEWDECL contains the merged attribute lists.
3737      Update OLDDECL to be the same.  */
3738   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3739
3740   return 1;
3741 }
3742
3743 /* Record a decl-node X as belonging to the current lexical scope.
3744    Check for errors (such as an incompatible declaration for the same
3745    name already seen in the same scope).
3746
3747    Returns either X or an old decl for the same name.
3748    If an old decl is returned, it may have been smashed
3749    to agree with what X says.  */
3750
3751 tree
3752 pushdecl (x)
3753      tree x;
3754 {
3755   register tree t;
3756   register tree name;
3757   int need_new_binding;
3758
3759   /* We shouldn't be calling pushdecl when we're generating RTL for a
3760      function that we already did semantic analysis on previously.  */
3761   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3762                       19990913);
3763
3764   need_new_binding = 1;
3765
3766   if (DECL_TEMPLATE_PARM_P (x))
3767     /* Template parameters have no context; they are not X::T even
3768        when declared within a class or namespace.  */
3769     ;
3770   else
3771     {
3772       if (current_function_decl && x != current_function_decl
3773           /* A local declaration for a function doesn't constitute
3774              nesting.  */
3775           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3776           /* A local declaration for an `extern' variable is in the
3777              scope of the current namespace, not the current
3778              function.  */
3779           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3780           && !DECL_CONTEXT (x))
3781         DECL_CONTEXT (x) = current_function_decl;
3782
3783       /* If this is the declaration for a namespace-scope function,
3784          but the declaration itself is in a local scope, mark the
3785          declaration.  */
3786       if (TREE_CODE (x) == FUNCTION_DECL
3787           && DECL_NAMESPACE_SCOPE_P (x)
3788           && current_function_decl
3789           && x != current_function_decl)
3790         DECL_LOCAL_FUNCTION_P (x) = 1;
3791     }
3792
3793   name = DECL_NAME (x);
3794   if (name)
3795     {
3796       int different_binding_level = 0;
3797
3798       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3799         name = TREE_OPERAND (name, 0);
3800
3801       /* In case this decl was explicitly namespace-qualified, look it
3802          up in its namespace context.  */
3803       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3804           && namespace_bindings_p ())
3805         t = namespace_binding (name, DECL_CONTEXT (x));
3806       else
3807         t = lookup_name_current_level (name);
3808
3809       /* [basic.link] If there is a visible declaration of an entity
3810          with linkage having the same name and type, ignoring entities
3811          declared outside the innermost enclosing namespace scope, the
3812          block scope declaration declares that same entity and
3813          receives the linkage of the previous declaration.  */
3814       if (! t && current_function_decl && x != current_function_decl
3815           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3816           && DECL_EXTERNAL (x))
3817         {
3818           /* Look in block scope.  */
3819           t = IDENTIFIER_VALUE (name);
3820           /* Or in the innermost namespace.  */
3821           if (! t)
3822             t = namespace_binding (name, DECL_CONTEXT (x));
3823           /* Does it have linkage?  Note that if this isn't a DECL, it's an
3824              OVERLOAD, which is OK.  */
3825           if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3826             t = NULL_TREE;
3827           if (t)
3828             different_binding_level = 1;
3829         }
3830
3831       /* If we are declaring a function, and the result of name-lookup
3832          was an OVERLOAD, look for an overloaded instance that is
3833          actually the same as the function we are declaring.  (If
3834          there is one, we have to merge our declaration with the
3835          previous declaration.)  */
3836       if (t && TREE_CODE (t) == OVERLOAD)
3837         {
3838           tree match;
3839
3840           if (TREE_CODE (x) == FUNCTION_DECL)
3841             for (match = t; match; match = OVL_NEXT (match))
3842               {
3843                 if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t))
3844                     == DECL_ASSEMBLER_NAME (x))
3845                   break;
3846               }
3847           else
3848             /* Just choose one.  */
3849             match = t;
3850
3851           if (match)
3852             t = OVL_CURRENT (match);
3853           else
3854             t = NULL_TREE;
3855         }
3856
3857       if (t == error_mark_node)
3858         {
3859           /* error_mark_node is 0 for a while during initialization!  */
3860           t = NULL_TREE;
3861           cp_error_at ("`%#D' used prior to declaration", x);
3862         }
3863       else if (t != NULL_TREE)
3864         {
3865           if (different_binding_level)
3866             {
3867               if (decls_match (x, t))
3868                 /* The standard only says that the local extern
3869                    inherits linkage from the previous decl; in
3870                    particular, default args are not shared.  It would
3871                    be nice to propagate inlining info, though.  FIXME.  */
3872                 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3873             }
3874           else if (TREE_CODE (t) == PARM_DECL)
3875             {
3876               if (DECL_CONTEXT (t) == NULL_TREE)
3877                 /* This is probaby caused by too many errors, but calling
3878                    abort will say that if errors have occurred.  */
3879                 abort ();
3880
3881               /* Check for duplicate params.  */
3882               if (duplicate_decls (x, t))
3883                 return t;
3884             }
3885           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3886                     || DECL_FUNCTION_TEMPLATE_P (x))
3887                    && is_overloaded_fn (t))
3888             /* Don't do anything just yet. */;
3889           else if (t == wchar_decl_node)
3890             {
3891               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3892                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3893
3894               /* Throw away the redeclaration.  */
3895               return t;
3896             }
3897           else if (TREE_CODE (t) != TREE_CODE (x))
3898             {
3899               if (duplicate_decls (x, t))
3900                 return t;
3901             }
3902           else if (duplicate_decls (x, t))
3903             {
3904               if (TREE_CODE (t) == TYPE_DECL)
3905                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3906               else if (TREE_CODE (t) == FUNCTION_DECL)
3907                 check_default_args (t);
3908
3909               return t;
3910             }
3911           else if (DECL_MAIN_P (x))
3912             {
3913               /* A redeclaration of main, but not a duplicate of the
3914                  previous one.
3915
3916                  [basic.start.main]
3917
3918                  This function shall not be overloaded.  */
3919               cp_error_at ("invalid redeclaration of `%D'", t);
3920               cp_error ("as `%D'", x);
3921               /* We don't try to push this declaration since that
3922                  causes a crash.  */
3923               return x;
3924             }
3925         }
3926
3927       check_template_shadow (x);
3928
3929       /* If this is a function conjured up by the backend, massage it
3930          so it looks friendly.  */
3931       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3932         {
3933           retrofit_lang_decl (x);
3934           DECL_LANGUAGE (x) = lang_c;
3935         }
3936
3937       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3938         {
3939           t = push_overloaded_decl (x, PUSH_LOCAL);
3940           if (t != x)
3941             return t;
3942           if (!namespace_bindings_p ())
3943             /* We do not need to create a binding for this name;
3944                push_overloaded_decl will have already done so if
3945                necessary.  */
3946             need_new_binding = 0;
3947         }
3948       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3949         {
3950           t = push_overloaded_decl (x, PUSH_GLOBAL);
3951           if (t == x)
3952             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3953           return t;
3954         }
3955
3956       /* If declaring a type as a typedef, copy the type (unless we're
3957          at line 0), and install this TYPE_DECL as the new type's typedef
3958          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3959       if (TREE_CODE (x) == TYPE_DECL)
3960         {
3961           tree type = TREE_TYPE (x);
3962           if (DECL_SOURCE_LINE (x) == 0)
3963             {
3964               if (TYPE_NAME (type) == 0)
3965                 TYPE_NAME (type) = x;
3966             }
3967           else if (type != error_mark_node && TYPE_NAME (type) != x
3968                    /* We don't want to copy the type when all we're
3969                       doing is making a TYPE_DECL for the purposes of
3970                       inlining.  */
3971                    && (!TYPE_NAME (type)
3972                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3973             {
3974               DECL_ORIGINAL_TYPE (x) = type;
3975               type = build_type_copy (type);
3976               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3977               TYPE_NAME (type) = x;
3978               TREE_TYPE (x) = type;
3979             }
3980
3981           if (type != error_mark_node
3982               && TYPE_NAME (type)
3983               && TYPE_IDENTIFIER (type))
3984             set_identifier_type_value_with_scope (DECL_NAME (x), type,
3985                                                   current_binding_level);
3986
3987         }
3988
3989       /* Multiple external decls of the same identifier ought to match.
3990
3991          We get warnings about inline functions where they are defined.
3992          We get warnings about other functions from push_overloaded_decl.
3993
3994          Avoid duplicate warnings where they are used.  */
3995       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
3996         {
3997           tree decl;
3998
3999           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4000           if (decl && TREE_CODE (decl) == OVERLOAD)
4001             decl = OVL_FUNCTION (decl);
4002
4003           if (decl && decl != error_mark_node
4004               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4005               /* If different sort of thing, we already gave an error.  */
4006               && TREE_CODE (decl) == TREE_CODE (x)
4007               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4008             {
4009               cp_pedwarn ("type mismatch with previous external decl", x);
4010               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4011             }
4012         }
4013
4014       /* This name is new in its binding level.
4015          Install the new declaration and return it.  */
4016       if (namespace_bindings_p ())
4017         {
4018           /* Install a global value.  */
4019
4020           /* If the first global decl has external linkage,
4021              warn if we later see static one.  */
4022           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4023             TREE_PUBLIC (name) = 1;
4024
4025           /* Bind the mangled name for the entity.  In the future, we
4026              should not need to do this; mangled names are an
4027              implementation detail of which the front-end should not
4028              need to be aware.  */
4029           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4030                 && t != NULL_TREE)
4031               /* For an ordinary function, we create a binding from
4032                  the mangled name (i.e., NAME) to the DECL.  But, for
4033                  an `extern "C"' function, the mangled name and the
4034                  ordinary name are the same so we need not do this.  */
4035               && !DECL_EXTERN_C_FUNCTION_P (x))
4036             {
4037               tree mangled_name;
4038
4039               if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
4040                   || TREE_CODE (x) == NAMESPACE_DECL)
4041                 mangled_name = name;
4042               else
4043                 mangled_name = DECL_ASSEMBLER_NAME (x);
4044
4045               if (TREE_CODE (x) == FUNCTION_DECL)
4046                 my_friendly_assert
4047                   ((IDENTIFIER_GLOBAL_VALUE (mangled_name) == NULL_TREE)
4048                   || (IDENTIFIER_GLOBAL_VALUE (mangled_name) == x), 378);
4049               SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name, x);
4050             }
4051
4052           /* Don't forget if the function was used via an implicit decl.  */
4053           if (IDENTIFIER_IMPLICIT_DECL (name)
4054               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4055             TREE_USED (x) = 1;
4056
4057           /* Don't forget if its address was taken in that way.  */
4058           if (IDENTIFIER_IMPLICIT_DECL (name)
4059               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4060             TREE_ADDRESSABLE (x) = 1;
4061
4062           /* Warn about mismatches against previous implicit decl.  */
4063           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4064               /* If this real decl matches the implicit, don't complain.  */
4065               && ! (TREE_CODE (x) == FUNCTION_DECL
4066                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4067             cp_warning
4068               ("`%D' was previously implicitly declared to return `int'", x);
4069
4070           /* If new decl is `static' and an `extern' was seen previously,
4071              warn about it.  */
4072           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4073             warn_extern_redeclared_static (x, t);
4074         }
4075       else
4076         {
4077           /* Here to install a non-global value.  */
4078           tree oldlocal = IDENTIFIER_VALUE (name);
4079           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4080
4081           if (need_new_binding)
4082             {
4083               push_local_binding (name, x, 0);
4084               /* Because push_local_binding will hook X on to the
4085                  current_binding_level's name list, we don't want to
4086                  do that again below.  */
4087               need_new_binding = 0;
4088             }
4089
4090           /* If this is a TYPE_DECL, push it into the type value slot.  */
4091           if (TREE_CODE (x) == TYPE_DECL)
4092             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4093                                                   current_binding_level);
4094
4095           /* Clear out any TYPE_DECL shadowed by a namespace so that
4096              we won't think this is a type.  The C struct hack doesn't
4097              go through namespaces.  */
4098           if (TREE_CODE (x) == NAMESPACE_DECL)
4099             set_identifier_type_value_with_scope (name, NULL_TREE,
4100                                                   current_binding_level);
4101
4102           if (oldlocal)
4103             {
4104               tree d = oldlocal;
4105
4106               while (oldlocal
4107                      && TREE_CODE (oldlocal) == VAR_DECL
4108                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4109                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4110
4111               if (oldlocal == NULL_TREE)
4112                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4113             }
4114
4115           /* If this is an extern function declaration, see if we
4116              have a global definition or declaration for the function.  */
4117           if (oldlocal == NULL_TREE
4118               && DECL_EXTERNAL (x)
4119               && oldglobal != NULL_TREE
4120               && TREE_CODE (x) == FUNCTION_DECL
4121               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4122             {
4123               /* We have one.  Their types must agree.  */
4124               if (decls_match (x, oldglobal))
4125                 /* OK */;
4126               else
4127                 {
4128                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4129                   cp_warning_at ("global declaration `%#D'", oldglobal);
4130                 }
4131             }
4132           /* If we have a local external declaration,
4133              and no file-scope declaration has yet been seen,
4134              then if we later have a file-scope decl it must not be static.  */
4135           if (oldlocal == NULL_TREE
4136               && oldglobal == NULL_TREE
4137               && DECL_EXTERNAL (x)
4138               && TREE_PUBLIC (x))
4139             TREE_PUBLIC (name) = 1;
4140
4141           /* Warn if shadowing an argument at the top level of the body.  */
4142           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4143               /* Inline decls shadow nothing.  */
4144               && !DECL_FROM_INLINE (x)
4145               && TREE_CODE (oldlocal) == PARM_DECL
4146               /* Don't complain if it's from an enclosing function.  */
4147               && DECL_CONTEXT (oldlocal) == current_function_decl
4148               && TREE_CODE (x) != PARM_DECL)
4149             {
4150               /* Go to where the parms should be and see if we
4151                  find them there.  */
4152               struct binding_level *b = current_binding_level->level_chain;
4153
4154               if (cleanup_label)
4155                 b = b->level_chain;
4156
4157               /* ARM $8.3 */
4158               if (b->parm_flag == 1)
4159                 cp_error ("declaration of `%#D' shadows a parameter", name);
4160             }
4161
4162           /* Maybe warn if shadowing something else.  */
4163           if (warn_shadow && !DECL_EXTERNAL (x)
4164               /* Inline decls shadow nothing.  */
4165               && !DECL_FROM_INLINE (x)
4166               /* No shadow warnings for internally generated vars.  */
4167               && ! DECL_ARTIFICIAL (x)
4168               /* No shadow warnings for vars made for inlining.  */
4169               && ! DECL_FROM_INLINE (x))
4170             {
4171               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4172                 warning ("declaration of `%s' shadows a parameter",
4173                         IDENTIFIER_POINTER (name));
4174               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4175                        && current_class_ptr
4176                        && !TREE_STATIC (name))
4177                 warning ("declaration of `%s' shadows a member of `this'",
4178                         IDENTIFIER_POINTER (name));
4179               else if (oldlocal != NULL_TREE)
4180                 warning ("declaration of `%s' shadows previous local",
4181                         IDENTIFIER_POINTER (name));
4182               else if (oldglobal != NULL_TREE)
4183                 /* XXX shadow warnings in outer-more namespaces */
4184                 warning ("declaration of `%s' shadows global declaration",
4185                         IDENTIFIER_POINTER (name));
4186             }
4187         }
4188
4189       if (TREE_CODE (x) == FUNCTION_DECL)
4190         check_default_args (x);
4191
4192       /* Keep count of variables in this level with incomplete type.  */
4193       if (TREE_CODE (x) == VAR_DECL
4194           && TREE_TYPE (x) != error_mark_node
4195           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4196                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4197               /* RTTI TD entries are created while defining the type_info.  */
4198               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4199                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4200         {
4201           if (namespace_bindings_p ())
4202             namespace_scope_incomplete
4203               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4204           else
4205             current_binding_level->incomplete
4206               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4207         }
4208     }
4209
4210   if (need_new_binding)
4211     add_decl_to_level (x,
4212                        DECL_NAMESPACE_SCOPE_P (x)
4213                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4214                        : current_binding_level);
4215
4216   return x;
4217 }
4218
4219 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4220    caller to set DECL_CONTEXT properly.  */
4221
4222 static tree
4223 pushdecl_with_scope (x, level)
4224      tree x;
4225      struct binding_level *level;
4226 {
4227   register struct binding_level *b;
4228   tree function_decl = current_function_decl;
4229
4230   current_function_decl = NULL_TREE;
4231   if (level->parm_flag == 2)
4232     {
4233       b = class_binding_level;
4234       class_binding_level = level;
4235       pushdecl_class_level (x);
4236       class_binding_level = b;
4237     }
4238   else
4239     {
4240       b = current_binding_level;
4241       current_binding_level = level;
4242       x = pushdecl (x);
4243       current_binding_level = b;
4244     }
4245   current_function_decl = function_decl;
4246   return x;
4247 }
4248
4249 /* Like pushdecl, only it places X in the current namespace,
4250    if appropriate.  */
4251
4252 tree
4253 pushdecl_namespace_level (x)
4254      tree x;
4255 {
4256   register struct binding_level *b = current_binding_level;
4257   register tree t;
4258
4259   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4260
4261   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4262      what we want.  */
4263   if (TREE_CODE (x) == TYPE_DECL)
4264     {
4265       tree name = DECL_NAME (x);
4266       tree newval;
4267       tree *ptr = (tree *)0;
4268       for (; b != global_binding_level; b = b->level_chain)
4269         {
4270           tree shadowed = b->type_shadowed;
4271           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4272             if (TREE_PURPOSE (shadowed) == name)
4273               {
4274                 ptr = &TREE_VALUE (shadowed);
4275                 /* Can't break out of the loop here because sometimes
4276                    a binding level will have duplicate bindings for
4277                    PT names.  It's gross, but I haven't time to fix it.  */
4278               }
4279         }
4280       newval = TREE_TYPE (x);
4281       if (ptr == (tree *)0)
4282         {
4283           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4284              up here if this is changed to an assertion.  --KR  */
4285           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4286         }
4287       else
4288         {
4289           *ptr = newval;
4290         }
4291     }
4292   return t;
4293 }
4294
4295 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4296    if appropriate.  */
4297
4298 tree
4299 pushdecl_top_level (x)
4300      tree x;
4301 {
4302   push_to_top_level ();
4303   x = pushdecl_namespace_level (x);
4304   pop_from_top_level ();
4305   return x;
4306 }
4307
4308 /* Make the declaration of X appear in CLASS scope.  */
4309
4310 void
4311 pushdecl_class_level (x)
4312      tree x;
4313 {
4314   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4315      scope looks for the pre-mangled name.  */
4316   register tree name;
4317
4318   if (TREE_CODE (x) == OVERLOAD)
4319     x = OVL_CURRENT (x);
4320   name = DECL_NAME (x);
4321
4322   if (name)
4323     {
4324       push_class_level_binding (name, x);
4325       if (TREE_CODE (x) == TYPE_DECL)
4326         set_identifier_type_value (name, TREE_TYPE (x));
4327     }
4328   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4329     {
4330       tree f;
4331
4332       for (f = TYPE_FIELDS (TREE_TYPE (x));
4333            f;
4334            f = TREE_CHAIN (f))
4335         pushdecl_class_level (f);
4336     }
4337 }
4338
4339 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4340    DECL, or a modified version thereof.  */
4341
4342 tree
4343 maybe_push_decl (decl)
4344      tree decl;
4345 {
4346   tree type = TREE_TYPE (decl);
4347
4348   /* Add this decl to the current binding level, but not if it comes
4349      from another scope, e.g. a static member variable.  TEM may equal
4350      DECL or it may be a previous decl of the same name.  */
4351   if (decl == error_mark_node
4352       || (TREE_CODE (decl) != PARM_DECL
4353           && DECL_CONTEXT (decl) != NULL_TREE
4354           /* Definitions of namespace members outside their namespace are
4355              possible. */
4356           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4357       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4358       || TREE_CODE (type) == UNKNOWN_TYPE
4359       /* The declaration of a template specialization does not affect
4360          the functions available for overload resolution, so we do not
4361          call pushdecl.  */
4362       || (TREE_CODE (decl) == FUNCTION_DECL
4363           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4364     return decl;
4365   else
4366     return pushdecl (decl);
4367 }
4368
4369 /* Make the declaration(s) of X appear in CLASS scope
4370    under the name NAME.  */
4371
4372 void
4373 push_class_level_binding (name, x)
4374      tree name;
4375      tree x;
4376 {
4377   tree binding;
4378   /* The class_binding_level will be NULL if x is a template
4379      parameter name in a member template.  */
4380   if (!class_binding_level)
4381     return;
4382
4383   /* Make sure that this new member does not have the same name
4384      as a template parameter.  */
4385   if (TYPE_BEING_DEFINED (current_class_type))
4386     check_template_shadow (x);
4387
4388   /* If this declaration shadows a declaration from an enclosing
4389      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4390      we leave this class.  Record the shadowed declaration here.  */
4391   binding = IDENTIFIER_BINDING (name);
4392   if (binding
4393       && ((TREE_CODE (x) == OVERLOAD
4394            && BINDING_VALUE (binding)
4395            && is_overloaded_fn (BINDING_VALUE (binding)))
4396           || INHERITED_VALUE_BINDING_P (binding)))
4397     {
4398       tree shadow;
4399       tree old_decl;
4400
4401       /* If the old binding was from a base class, and was for a tag
4402          name, slide it over to make room for the new binding.  The
4403          old binding is still visible if explicitly qualified with a
4404          class-key.  */
4405       if (INHERITED_VALUE_BINDING_P (binding)
4406           && BINDING_VALUE (binding)
4407           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4408           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4409           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4410         {
4411           old_decl = BINDING_TYPE (binding);
4412           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4413           BINDING_VALUE (binding) = NULL_TREE;
4414           INHERITED_VALUE_BINDING_P (binding) = 0;
4415         }
4416       else
4417         old_decl = BINDING_VALUE (binding);
4418
4419       /* Find the previous binding of name on the class-shadowed
4420          list, and update it.  */
4421       for (shadow = class_binding_level->class_shadowed;
4422            shadow;
4423            shadow = TREE_CHAIN (shadow))
4424         if (TREE_PURPOSE (shadow) == name
4425             && TREE_TYPE (shadow) == old_decl)
4426           {
4427             BINDING_VALUE (binding) = x;
4428             INHERITED_VALUE_BINDING_P (binding) = 0;
4429             TREE_TYPE (shadow) = x;
4430             IDENTIFIER_CLASS_VALUE (name) = x;
4431             return;
4432           }
4433     }
4434
4435   /* If we didn't replace an existing binding, put the binding on the
4436      stack of bindings for the identifier, and update the shadowed list.  */
4437   if (push_class_binding (name, x))
4438     {
4439       class_binding_level->class_shadowed
4440         = tree_cons (name, NULL,
4441                      class_binding_level->class_shadowed);
4442       /* Record the value we are binding NAME to so that we can know
4443          what to pop later.  */
4444       TREE_TYPE (class_binding_level->class_shadowed) = x;
4445     }
4446 }
4447
4448 /* Insert another USING_DECL into the current binding level, returning
4449    this declaration. If this is a redeclaration, do nothing, and
4450    return NULL_TREE if this not in namespace scope (in namespace
4451    scope, a using decl might extend any previous bindings).  */
4452
4453 tree
4454 push_using_decl (scope, name)
4455      tree scope;
4456      tree name;
4457 {
4458   tree decl;
4459
4460   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4461   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4462   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4463     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4464       break;
4465   if (decl)
4466     return namespace_bindings_p () ? decl : NULL_TREE;
4467   decl = build_lang_decl (USING_DECL, name, void_type_node);
4468   DECL_INITIAL (decl) = scope;
4469   TREE_CHAIN (decl) = current_binding_level->usings;
4470   current_binding_level->usings = decl;
4471   return decl;
4472 }
4473
4474 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4475    changed (i.e. there was already a directive), or the fresh
4476    TREE_LIST otherwise.  */
4477
4478 tree
4479 push_using_directive (used)
4480      tree used;
4481 {
4482   tree ud = current_binding_level->using_directives;
4483   tree iter, ancestor;
4484
4485   /* Check if we already have this. */
4486   if (purpose_member (used, ud) != NULL_TREE)
4487     return NULL_TREE;
4488
4489   /* Recursively add all namespaces used. */
4490   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4491     push_using_directive (TREE_PURPOSE (iter));
4492
4493   ancestor = namespace_ancestor (current_decl_namespace (), used);
4494   ud = current_binding_level->using_directives;
4495   ud = tree_cons (used, ancestor, ud);
4496   current_binding_level->using_directives = ud;
4497   return ud;
4498 }
4499
4500 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4501    other definitions already in place.  We get around this by making
4502    the value of the identifier point to a list of all the things that
4503    want to be referenced by that name.  It is then up to the users of
4504    that name to decide what to do with that list.
4505
4506    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4507    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4508
4509    FLAGS is a bitwise-or of the following values:
4510      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4511                  namespace scope.
4512      PUSH_USING: DECL is being pushed as the result of a using
4513                  declaration.
4514
4515    The value returned may be a previous declaration if we guessed wrong
4516    about what language DECL should belong to (C or C++).  Otherwise,
4517    it's always DECL (and never something that's not a _DECL).  */
4518
4519 tree
4520 push_overloaded_decl (decl, flags)
4521      tree decl;
4522      int flags;
4523 {
4524   tree name = DECL_NAME (decl);
4525   tree old;
4526   tree new_binding;
4527   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4528
4529   if (doing_global)
4530     old = namespace_binding (name, DECL_CONTEXT (decl));
4531   else
4532     old = lookup_name_current_level (name);
4533
4534   if (old)
4535     {
4536       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4537         {
4538           tree t = TREE_TYPE (old);
4539           if (IS_AGGR_TYPE (t) && warn_shadow
4540               && (! DECL_IN_SYSTEM_HEADER (decl)
4541                   || ! DECL_IN_SYSTEM_HEADER (old)))
4542             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4543           old = NULL_TREE;
4544         }
4545       else if (is_overloaded_fn (old))
4546         {
4547           tree tmp;
4548
4549           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4550             {
4551               tree fn = OVL_CURRENT (tmp);
4552
4553               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4554                   && !(flags & PUSH_USING)
4555                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4556                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4557                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4558                           decl, fn);
4559
4560               if (duplicate_decls (decl, fn))
4561                 return fn;
4562             }
4563         }
4564       else if (old == error_mark_node)
4565         /* Ignore the undefined symbol marker.  */
4566         old = NULL_TREE;
4567       else
4568         {
4569           cp_error_at ("previous non-function declaration `%#D'", old);
4570           cp_error ("conflicts with function declaration `%#D'", decl);
4571           return decl;
4572         }
4573     }
4574
4575   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4576     {
4577       if (old && TREE_CODE (old) != OVERLOAD)
4578         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4579       else
4580         new_binding = ovl_cons (decl, old);
4581       if (flags & PUSH_USING)
4582         OVL_USED (new_binding) = 1;
4583     }
4584   else
4585     /* NAME is not ambiguous.  */
4586     new_binding = decl;
4587
4588   if (doing_global)
4589     set_namespace_binding (name, current_namespace, new_binding);
4590   else
4591     {
4592       /* We only create an OVERLOAD if there was a previous binding at
4593          this level, or if decl is a template. In the former case, we
4594          need to remove the old binding and replace it with the new
4595          binding.  We must also run through the NAMES on the binding
4596          level where the name was bound to update the chain.  */
4597
4598       if (TREE_CODE (new_binding) == OVERLOAD && old)
4599         {
4600           tree *d;
4601
4602           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4603                *d;
4604                d = &TREE_CHAIN (*d))
4605             if (*d == old
4606                 || (TREE_CODE (*d) == TREE_LIST
4607                     && TREE_VALUE (*d) == old))
4608               {
4609                 if (TREE_CODE (*d) == TREE_LIST)
4610                   /* Just replace the old binding with the new.  */
4611                   TREE_VALUE (*d) = new_binding;
4612                 else
4613                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4614                   *d = tree_cons (NULL_TREE, new_binding,
4615                                   TREE_CHAIN (*d));
4616
4617                 /* And update the CPLUS_BINDING node.  */
4618                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4619                   = new_binding;
4620                 return decl;
4621               }
4622
4623           /* We should always find a previous binding in this case.  */
4624           my_friendly_abort (0);
4625         }
4626
4627       /* Install the new binding.  */
4628       push_local_binding (name, new_binding, flags);
4629     }
4630
4631   return decl;
4632 }
4633 \f
4634 /* Generate an implicit declaration for identifier FUNCTIONID
4635    as a function of type int ().  Print a warning if appropriate.  */
4636
4637 tree
4638 implicitly_declare (functionid)
4639      tree functionid;
4640 {
4641   register tree decl;
4642
4643   /* We used to reuse an old implicit decl here,
4644      but this loses with inline functions because it can clobber
4645      the saved decl chains.  */
4646   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4647
4648   DECL_EXTERNAL (decl) = 1;
4649   TREE_PUBLIC (decl) = 1;
4650
4651   /* ISO standard says implicit declarations are in the innermost block.
4652      So we record the decl in the standard fashion.  */
4653   pushdecl (decl);
4654   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4655
4656   if (warn_implicit
4657       /* Only one warning per identifier.  */
4658       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4659     {
4660       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4661     }
4662
4663   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4664
4665   return decl;
4666 }
4667
4668 /* Return zero if the declaration NEWDECL is valid
4669    when the declaration OLDDECL (assumed to be for the same name)
4670    has already been seen.
4671    Otherwise return an error message format string with a %s
4672    where the identifier should go.  */
4673
4674 static const char *
4675 redeclaration_error_message (newdecl, olddecl)
4676      tree newdecl, olddecl;
4677 {
4678   if (TREE_CODE (newdecl) == TYPE_DECL)
4679     {
4680       /* Because C++ can put things into name space for free,
4681          constructs like "typedef struct foo { ... } foo"
4682          would look like an erroneous redeclaration.  */
4683       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4684         return 0;
4685       else
4686         return "redefinition of `%#D'";
4687     }
4688   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4689     {
4690       /* If this is a pure function, its olddecl will actually be
4691          the original initialization to `0' (which we force to call
4692          abort()).  Don't complain about redefinition in this case.  */
4693       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4694         return 0;
4695
4696       /* If both functions come from different namespaces, this is not
4697          a redeclaration - this is a conflict with a used function. */
4698       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4699           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4700         return "`%D' conflicts with used function";
4701
4702       /* We'll complain about linkage mismatches in
4703          warn_extern_redeclared_static.  */
4704
4705       /* Defining the same name twice is no good.  */
4706       if (DECL_INITIAL (olddecl) != NULL_TREE
4707           && DECL_INITIAL (newdecl) != NULL_TREE)
4708         {
4709           if (DECL_NAME (olddecl) == NULL_TREE)
4710             return "`%#D' not declared in class";
4711           else
4712             return "redefinition of `%#D'";
4713         }
4714       return 0;
4715     }
4716   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4717     {
4718       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4719            && (DECL_TEMPLATE_RESULT (newdecl)
4720                != DECL_TEMPLATE_RESULT (olddecl))
4721            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4722            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4723           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4724               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4725               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4726         return "redefinition of `%#D'";
4727       return 0;
4728     }
4729   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4730     {
4731       /* Objects declared at top level:  */
4732       /* If at least one is a reference, it's ok.  */
4733       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4734         return 0;
4735       /* Reject two definitions.  */
4736       return "redefinition of `%#D'";
4737     }
4738   else
4739     {
4740       /* Objects declared with block scope:  */
4741       /* Reject two definitions, and reject a definition
4742          together with an external reference.  */
4743       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4744         return "redeclaration of `%#D'";
4745       return 0;
4746     }
4747 }
4748 \f
4749 /* Create a new label, named ID.  */
4750
4751 static tree
4752 make_label_decl (id, local_p)
4753      tree id;
4754      int local_p;
4755 {
4756   tree decl;
4757
4758   decl = build_decl (LABEL_DECL, id, void_type_node);
4759   if (expanding_p)
4760     /* Make sure every label has an rtx.  */
4761     label_rtx (decl);
4762
4763   DECL_CONTEXT (decl) = current_function_decl;
4764   DECL_MODE (decl) = VOIDmode;
4765   C_DECLARED_LABEL_FLAG (decl) = local_p;
4766
4767   /* Say where one reference is to the label, for the sake of the
4768      error if it is not defined.  */
4769   DECL_SOURCE_LINE (decl) = lineno;
4770   DECL_SOURCE_FILE (decl) = input_filename;
4771
4772   /* Record the fact that this identifier is bound to this label.  */
4773   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4774
4775   return decl;
4776 }
4777
4778 /* Record this label on the list of used labels so that we can check
4779    at the end of the function to see whether or not the label was
4780    actually defined, and so we can check when the label is defined whether
4781    this use is valid.  */
4782
4783 static void
4784 use_label (decl)
4785      tree decl;
4786 {
4787   if (named_label_uses == NULL
4788       || named_label_uses->names_in_scope != current_binding_level->names
4789       || named_label_uses->label_decl != decl)
4790     {
4791       struct named_label_use_list *new_ent;
4792       new_ent = ((struct named_label_use_list *)
4793                  ggc_alloc (sizeof (struct named_label_use_list)));
4794       new_ent->label_decl = decl;
4795       new_ent->names_in_scope = current_binding_level->names;
4796       new_ent->binding_level = current_binding_level;
4797       new_ent->lineno_o_goto = lineno;
4798       new_ent->filename_o_goto = input_filename;
4799       new_ent->next = named_label_uses;
4800       named_label_uses = new_ent;
4801     }
4802 }
4803
4804 /* Look for a label named ID in the current function.  If one cannot
4805    be found, create one.  (We keep track of used, but undefined,
4806    labels, and complain about them at the end of a function.)  */
4807
4808 tree
4809 lookup_label (id)
4810      tree id;
4811 {
4812   tree decl;
4813   struct named_label_list *ent;
4814
4815   /* You can't use labels at global scope.  */
4816   if (current_function_decl == NULL_TREE)
4817     {
4818       error ("label `%s' referenced outside of any function",
4819              IDENTIFIER_POINTER (id));
4820       return NULL_TREE;
4821     }
4822
4823   /* See if we've already got this label.  */
4824   decl = IDENTIFIER_LABEL_VALUE (id);
4825   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4826     return decl;
4827
4828   /* Record this label on the list of labels used in this function.
4829      We do this before calling make_label_decl so that we get the
4830      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4831   ent = ((struct named_label_list *)
4832          ggc_alloc_cleared (sizeof (struct named_label_list)));
4833   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4834   ent->next = named_labels;
4835   named_labels = ent;
4836
4837   /* We need a new label.  */
4838   decl = make_label_decl (id, /*local_p=*/0);
4839
4840   /* Now fill in the information we didn't have before.  */
4841   ent->label_decl = decl;
4842
4843   return decl;
4844 }
4845
4846 /* Declare a local label named ID.  */
4847
4848 tree
4849 declare_local_label (id)
4850      tree id;
4851 {
4852   tree decl;
4853
4854   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4855      this scope we can restore the old value of
4856      IDENTIFIER_TYPE_VALUE.  */
4857   current_binding_level->shadowed_labels
4858     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4859                  current_binding_level->shadowed_labels);
4860   /* Look for the label.  */
4861   decl = make_label_decl (id, /*local_p=*/1);
4862   /* Now fill in the information we didn't have before.  */
4863   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4864
4865   return decl;
4866 }
4867
4868 /* Returns nonzero if it is ill-formed to jump past the declaration of
4869    DECL.  Returns 2 if it's also a real problem.  */
4870
4871 static int
4872 decl_jump_unsafe (decl)
4873      tree decl;
4874 {
4875   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4876     return 0;
4877
4878   if (DECL_INITIAL (decl) == NULL_TREE
4879       && pod_type_p (TREE_TYPE (decl)))
4880     return 0;
4881
4882   /* This is really only important if we're crossing an initialization.
4883      The POD stuff is just pedantry; why should it matter if the class
4884      contains a field of pointer to member type?  */
4885   if (DECL_INITIAL (decl)
4886       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4887     return 2;
4888   return 1;
4889 }
4890
4891 /* Check that a single previously seen jump to a newly defined label
4892    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4893    the jump context; NAMES are the names in scope in LEVEL at the jump
4894    context; FILE and LINE are the source position of the jump or 0.  */
4895
4896 static void
4897 check_previous_goto_1 (decl, level, names, file, line)
4898      tree decl;
4899      struct binding_level *level;
4900      tree names;
4901      const char *file;
4902      int line;
4903 {
4904   int identified = 0;
4905   int saw_eh = 0;
4906   struct binding_level *b = current_binding_level;
4907   for (; b; b = b->level_chain)
4908     {
4909       tree new_decls = b->names;
4910       tree old_decls = (b == level ? names : NULL_TREE);
4911       for (; new_decls != old_decls;
4912            new_decls = TREE_CHAIN (new_decls))
4913         {
4914           int problem = decl_jump_unsafe (new_decls);
4915           if (! problem)
4916             continue;
4917
4918           if (! identified)
4919             {
4920               if (decl)
4921                 cp_pedwarn ("jump to label `%D'", decl);
4922               else
4923                 pedwarn ("jump to case label");
4924
4925               if (file)
4926                 pedwarn_with_file_and_line (file, line, "  from here");
4927               identified = 1;
4928             }
4929
4930           if (problem > 1 && DECL_ARTIFICIAL (new_decls))
4931             /* Can't skip init of __exception_info.  */
4932             cp_error_at ("  enters catch block", new_decls);
4933           else if (problem > 1)
4934             cp_error_at ("  crosses initialization of `%#D'",
4935                          new_decls);
4936           else
4937             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4938                            new_decls);
4939         }
4940
4941       if (b == level)
4942         break;
4943       if (b->eh_region && ! saw_eh)
4944         {
4945           if (! identified)
4946             {
4947               if (decl)
4948                 cp_pedwarn ("jump to label `%D'", decl);
4949               else
4950                 pedwarn ("jump to case label");
4951
4952               if (file)
4953                 pedwarn_with_file_and_line (file, line, "  from here");
4954               identified = 1;
4955             }
4956           error ("  enters try block");
4957           saw_eh = 1;
4958         }
4959     }
4960 }
4961
4962 static void
4963 check_previous_goto (use)
4964      struct named_label_use_list *use;
4965 {
4966   check_previous_goto_1 (use->label_decl, use->binding_level,
4967                          use->names_in_scope, use->filename_o_goto,
4968                          use->lineno_o_goto);
4969 }
4970
4971 static void
4972 check_switch_goto (level)
4973      struct binding_level *level;
4974 {
4975   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
4976 }
4977
4978 /* Check that any previously seen jumps to a newly defined label DECL
4979    are OK.  Called by define_label.  */
4980
4981 static void
4982 check_previous_gotos (decl)
4983      tree decl;
4984 {
4985   struct named_label_use_list **usep;
4986
4987   if (! TREE_USED (decl))
4988     return;
4989
4990   for (usep = &named_label_uses; *usep; )
4991     {
4992       struct named_label_use_list *use = *usep;
4993       if (use->label_decl == decl)
4994         {
4995           check_previous_goto (use);
4996           *usep = use->next;
4997         }
4998       else
4999         usep = &(use->next);
5000     }
5001 }
5002
5003 /* Check that a new jump to a label DECL is OK.  Called by
5004    finish_goto_stmt.  */
5005
5006 void
5007 check_goto (decl)
5008      tree decl;
5009 {
5010   int identified = 0;
5011   tree bad;
5012   struct named_label_list *lab;
5013
5014   /* We can't know where a computed goto is jumping.  So we assume
5015      that it's OK.  */
5016   if (! DECL_P (decl))
5017     return;
5018
5019   /* If the label hasn't been defined yet, defer checking.  */
5020   if (! DECL_INITIAL (decl))
5021     {
5022       use_label (decl);
5023       return;
5024     }
5025
5026   for (lab = named_labels; lab; lab = lab->next)
5027     if (decl == lab->label_decl)
5028       break;
5029
5030   /* If the label is not on named_labels it's a gcc local label, so
5031      it must be in an outer scope, so jumping to it is always OK.  */
5032   if (lab == 0)
5033     return;
5034
5035   if ((lab->eh_region || lab->bad_decls) && !identified)
5036     {
5037       cp_pedwarn_at ("jump to label `%D'", decl);
5038       pedwarn ("  from here");
5039       identified = 1;
5040     }
5041
5042   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5043     {
5044       tree b = TREE_VALUE (bad);
5045       int u = decl_jump_unsafe (b);
5046
5047       if (u > 1 && DECL_ARTIFICIAL (b))
5048         /* Can't skip init of __exception_info.  */
5049         cp_error_at ("  enters catch block", b);
5050       else if (u > 1)
5051         cp_error_at ("  skips initialization of `%#D'", b);
5052       else
5053         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5054     }
5055
5056   if (lab->eh_region)
5057     error ("  enters try block");
5058 }
5059
5060 /* Define a label, specifying the location in the source file.
5061    Return the LABEL_DECL node for the label, if the definition is valid.
5062    Otherwise return 0.  */
5063
5064 tree
5065 define_label (filename, line, name)
5066      const char *filename;
5067      int line;
5068      tree name;
5069 {
5070   tree decl = lookup_label (name);
5071   struct named_label_list *ent;
5072   register struct binding_level *p;
5073
5074   for (ent = named_labels; ent; ent = ent->next)
5075     if (ent->label_decl == decl)
5076       break;
5077
5078   /* After labels, make any new cleanups in the function go into their
5079      own new (temporary) binding contour.  */
5080   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5081     p->more_cleanups_ok = 0;
5082
5083   if (name == get_identifier ("wchar_t"))
5084     cp_pedwarn ("label named wchar_t");
5085
5086   if (DECL_INITIAL (decl) != NULL_TREE)
5087     {
5088       cp_error ("duplicate label `%D'", decl);
5089       return 0;
5090     }
5091   else
5092     {
5093       /* Mark label as having been defined.  */
5094       DECL_INITIAL (decl) = error_mark_node;
5095       /* Say where in the source.  */
5096       DECL_SOURCE_FILE (decl) = filename;
5097       DECL_SOURCE_LINE (decl) = line;
5098       if (ent)
5099         {
5100           ent->names_in_scope = current_binding_level->names;
5101           ent->binding_level = current_binding_level;
5102         }
5103       check_previous_gotos (decl);
5104       current_function_return_value = NULL_TREE;
5105       return decl;
5106     }
5107 }
5108
5109 struct cp_switch
5110 {
5111   struct binding_level *level;
5112   struct cp_switch *next;
5113   /* The SWITCH_STMT being built.  */
5114   tree switch_stmt;
5115   /* A splay-tree mapping the low element of a case range to the high
5116      element, or NULL_TREE if there is no high element.  Used to
5117      determine whether or not a new case label duplicates an old case
5118      label.  We need a tree, rather than simply a hash table, because
5119      of the GNU case range extension.  */
5120   splay_tree cases;
5121 };
5122
5123 /* A stack of the currently active switch statements.  The innermost
5124    switch statement is on the top of the stack.  There is no need to
5125    mark the stack for garbage collection because it is only active
5126    during the processing of the body of a function, and we never
5127    collect at that point.  */
5128
5129 static struct cp_switch *switch_stack;
5130
5131 /* Called right after a switch-statement condition is parsed.
5132    SWITCH_STMT is the switch statement being parsed.  */
5133
5134 void
5135 push_switch (switch_stmt)
5136      tree switch_stmt;
5137 {
5138   struct cp_switch *p
5139     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5140   p->level = current_binding_level;
5141   p->next = switch_stack;
5142   p->switch_stmt = switch_stmt;
5143   p->cases = splay_tree_new (case_compare, NULL, NULL);
5144   switch_stack = p;
5145 }
5146
5147 void
5148 pop_switch ()
5149 {
5150   struct cp_switch *cs;
5151
5152   cs = switch_stack;
5153   splay_tree_delete (cs->cases);
5154   switch_stack = switch_stack->next;
5155   free (cs);
5156 }
5157
5158 /* Note that we've seen a definition of a case label, and complain if this
5159    is a bad place for one.  */
5160
5161 tree
5162 finish_case_label (low_value, high_value)
5163      tree low_value;
5164      tree high_value;
5165 {
5166   tree cond, r;
5167   register struct binding_level *p;
5168
5169   if (! switch_stack)
5170     {
5171       if (high_value)
5172         error ("case label not within a switch statement");
5173       else if (low_value)
5174         cp_error ("case label `%E' not within a switch statement",
5175                   low_value);
5176       else
5177         error ("`default' label not within a switch statement");
5178       return NULL_TREE;
5179     }
5180
5181   if (processing_template_decl)
5182     {
5183       tree label;
5184
5185       /* For templates, just add the case label; we'll do semantic
5186          analysis at instantiation-time.  */
5187       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5188       return add_stmt (build_case_label (low_value, high_value, label));
5189     }
5190
5191   /* Find the condition on which this switch statement depends.  */
5192   cond = SWITCH_COND (switch_stack->switch_stmt);
5193   if (cond && TREE_CODE (cond) == TREE_LIST)
5194     cond = TREE_VALUE (cond);
5195
5196   r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5197   if (r == error_mark_node)
5198     r = NULL_TREE;
5199
5200   check_switch_goto (switch_stack->level);
5201
5202   /* After labels, make any new cleanups in the function go into their
5203      own new (temporary) binding contour.  */
5204   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5205     p->more_cleanups_ok = 0;
5206   current_function_return_value = NULL_TREE;
5207
5208   return r;
5209 }
5210 \f
5211 /* Return the list of declarations of the current level.
5212    Note that this list is in reverse order unless/until
5213    you nreverse it; and when you do nreverse it, you must
5214    store the result back using `storedecls' or you will lose.  */
5215
5216 tree
5217 getdecls ()
5218 {
5219   return current_binding_level->names;
5220 }
5221
5222 /* Return the list of type-tags (for structs, etc) of the current level.  */
5223
5224 tree
5225 gettags ()
5226 {
5227   return current_binding_level->tags;
5228 }
5229
5230 /* Store the list of declarations of the current level.
5231    This is done for the parameter declarations of a function being defined,
5232    after they are modified in the light of any missing parameters.  */
5233
5234 static void
5235 storedecls (decls)
5236      tree decls;
5237 {
5238   current_binding_level->names = decls;
5239 }
5240
5241 /* Similarly, store the list of tags of the current level.  */
5242
5243 void
5244 storetags (tags)
5245      tree tags;
5246 {
5247   current_binding_level->tags = tags;
5248 }
5249 \f
5250 /* Given NAME, an IDENTIFIER_NODE,
5251    return the structure (or union or enum) definition for that name.
5252    Searches binding levels from BINDING_LEVEL up to the global level.
5253    If THISLEVEL_ONLY is nonzero, searches only the specified context
5254    (but skips any tag-transparent contexts to find one that is
5255    meaningful for tags).
5256    FORM says which kind of type the caller wants;
5257    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5258    If the wrong kind of type is found, and it's not a template, an error is
5259    reported.  */
5260
5261 static tree
5262 lookup_tag (form, name, binding_level, thislevel_only)
5263      enum tree_code form;
5264      tree name;
5265      struct binding_level *binding_level;
5266      int thislevel_only;
5267 {
5268   register struct binding_level *level;
5269   /* Non-zero if, we should look past a template parameter level, even
5270      if THISLEVEL_ONLY.  */
5271   int allow_template_parms_p = 1;
5272
5273   for (level = binding_level; level; level = level->level_chain)
5274     {
5275       register tree tail;
5276       if (ANON_AGGRNAME_P (name))
5277         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5278           {
5279             /* There's no need for error checking here, because
5280                anon names are unique throughout the compilation.  */
5281             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5282               return TREE_VALUE (tail);
5283           }
5284       else if (level->namespace_p)
5285         /* Do namespace lookup. */
5286         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5287           {
5288             tree old = binding_for_name (name, tail);
5289
5290             /* If we just skipped past a template parameter level,
5291                even though THISLEVEL_ONLY, and we find a template
5292                class declaration, then we use the _TYPE node for the
5293                template.  See the example below.  */
5294             if (thislevel_only && !allow_template_parms_p
5295                 && old && BINDING_VALUE (old)
5296                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5297               old = TREE_TYPE (BINDING_VALUE (old));
5298             else
5299               old = BINDING_TYPE (old);
5300
5301             /* If it has an original type, it is a typedef, and we
5302                should not return it.  */
5303             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5304               old = NULL_TREE;
5305             if (old && TREE_CODE (old) != form
5306                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5307               {
5308                 cp_error ("`%#D' redeclared as %C", old, form);
5309                 return NULL_TREE;
5310               }
5311             if (old)
5312               return old;
5313             if (thislevel_only || tail == global_namespace)
5314               return NULL_TREE;
5315           }
5316       else
5317         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5318           {
5319             if (TREE_PURPOSE (tail) == name)
5320               {
5321                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5322                 /* Should tighten this up; it'll probably permit
5323                    UNION_TYPE and a struct template, for example.  */
5324                 if (code != form
5325                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5326                   {
5327                     /* Definition isn't the kind we were looking for.  */
5328                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5329                               form);
5330                     return NULL_TREE;
5331                   }
5332                 return TREE_VALUE (tail);
5333               }
5334           }
5335       if (thislevel_only && ! level->tag_transparent)
5336         {
5337           if (level->template_parms_p && allow_template_parms_p)
5338             {
5339               /* We must deal with cases like this:
5340
5341                    template <class T> struct S;
5342                    template <class T> struct S {};
5343
5344                  When looking up `S', for the second declaration, we
5345                  would like to find the first declaration.  But, we
5346                  are in the pseudo-global level created for the
5347                  template parameters, rather than the (surrounding)
5348                  namespace level.  Thus, we keep going one more level,
5349                  even though THISLEVEL_ONLY is non-zero.  */
5350               allow_template_parms_p = 0;
5351               continue;
5352             }
5353           else
5354             return NULL_TREE;
5355         }
5356     }
5357   return NULL_TREE;
5358 }
5359
5360 #if 0
5361 void
5362 set_current_level_tags_transparency (tags_transparent)
5363      int tags_transparent;
5364 {
5365   current_binding_level->tag_transparent = tags_transparent;
5366 }
5367 #endif
5368
5369 /* Given a type, find the tag that was defined for it and return the tag name.
5370    Otherwise return 0.  However, the value can never be 0
5371    in the cases in which this is used.
5372
5373    C++: If NAME is non-zero, this is the new name to install.  This is
5374    done when replacing anonymous tags with real tag names.  */
5375
5376 static tree
5377 lookup_tag_reverse (type, name)
5378      tree type;
5379      tree name;
5380 {
5381   register struct binding_level *level;
5382
5383   for (level = current_binding_level; level; level = level->level_chain)
5384     {
5385       register tree tail;
5386       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5387         {
5388           if (TREE_VALUE (tail) == type)
5389             {
5390               if (name)
5391                 TREE_PURPOSE (tail) = name;
5392               return TREE_PURPOSE (tail);
5393             }
5394         }
5395     }
5396   return NULL_TREE;
5397 }
5398 \f
5399 /* Look up NAME in the NAMESPACE.  */
5400
5401 tree
5402 lookup_namespace_name (namespace, name)
5403      tree namespace, name;
5404 {
5405   tree val;
5406   tree template_id = NULL_TREE;
5407
5408   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5409
5410   if (TREE_CODE (name) == NAMESPACE_DECL)
5411     /* This happens for A::B<int> when B is a namespace. */
5412     return name;
5413   else if (TREE_CODE (name) == TEMPLATE_DECL)
5414     {
5415       /* This happens for A::B where B is a template, and there are no
5416          template arguments.  */
5417       cp_error ("invalid use of `%D'", name);
5418       return error_mark_node;
5419     }
5420
5421   namespace = ORIGINAL_NAMESPACE (namespace);
5422
5423   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5424     {
5425       template_id = name;
5426       name = TREE_OPERAND (name, 0);
5427       if (TREE_CODE (name) == OVERLOAD)
5428         name = DECL_NAME (OVL_CURRENT (name));
5429       else if (DECL_P (name))
5430         name = DECL_NAME (name);
5431     }
5432
5433   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5434
5435   val = make_node (CPLUS_BINDING);
5436   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5437     return error_mark_node;
5438
5439   if (BINDING_VALUE (val))
5440     {
5441       val = BINDING_VALUE (val);
5442
5443       if (template_id)
5444         {
5445           if (DECL_CLASS_TEMPLATE_P (val))
5446             val = lookup_template_class (val,
5447                                          TREE_OPERAND (template_id, 1),
5448                                          /*in_decl=*/NULL_TREE,
5449                                          /*context=*/NULL_TREE,
5450                                          /*entering_scope=*/0,
5451                                          /*complain=*/1);
5452           else if (DECL_FUNCTION_TEMPLATE_P (val)
5453                    || TREE_CODE (val) == OVERLOAD)
5454             val = lookup_template_function (val,
5455                                             TREE_OPERAND (template_id, 1));
5456           else
5457             {
5458               cp_error ("`%D::%D' is not a template",
5459                         namespace, name);
5460               return error_mark_node;
5461             }
5462         }
5463
5464       /* If we have a single function from a using decl, pull it out.  */
5465       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5466         val = OVL_FUNCTION (val);
5467       return val;
5468     }
5469
5470   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5471   return error_mark_node;
5472 }
5473
5474 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5475
5476 static unsigned long
5477 typename_hash (k)
5478      hash_table_key k;
5479 {
5480   unsigned long hash;
5481   tree t;
5482
5483   t = (tree) k;
5484   hash = (((unsigned long) TYPE_CONTEXT (t))
5485           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5486
5487   return hash;
5488 }
5489
5490 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5491
5492 static boolean
5493 typename_compare (k1, k2)
5494      hash_table_key k1;
5495      hash_table_key k2;
5496 {
5497   tree t1;
5498   tree t2;
5499   tree d1;
5500   tree d2;
5501
5502   t1 = (tree) k1;
5503   t2 = (tree) k2;
5504   d1 = TYPE_NAME (t1);
5505   d2 = TYPE_NAME (t2);
5506
5507   return (DECL_NAME (d1) == DECL_NAME (d2)
5508           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5509           && ((TREE_TYPE (t1) != NULL_TREE)
5510               == (TREE_TYPE (t2) != NULL_TREE))
5511           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5512           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5513 }
5514
5515 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5516    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5517    is non-NULL, this type is being created by the implicit typename
5518    extension, and BASE_TYPE is a type named `t' in some base class of
5519    `T' which depends on template parameters.
5520
5521    Returns the new TYPENAME_TYPE.  */
5522
5523 tree
5524 build_typename_type (context, name, fullname, base_type)
5525      tree context;
5526      tree name;
5527      tree fullname;
5528      tree base_type;
5529 {
5530   tree t;
5531   tree d;
5532   struct hash_entry *e;
5533
5534   static struct hash_table ht;
5535
5536   if (!ht.table)
5537     {
5538       static struct hash_table *h = &ht;
5539
5540       hash_table_init (&ht, &hash_newfunc, &typename_hash, &typename_compare);
5541       ggc_add_tree_hash_table_root (&h, 1);
5542     }
5543
5544   /* Build the TYPENAME_TYPE.  */
5545   t = make_aggr_type (TYPENAME_TYPE);
5546   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5547   TYPENAME_TYPE_FULLNAME (t) = fullname;
5548   TREE_TYPE (t) = base_type;
5549
5550   /* Build the corresponding TYPE_DECL.  */
5551   d = build_decl (TYPE_DECL, name, t);
5552   TYPE_NAME (TREE_TYPE (d)) = d;
5553   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5554   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5555   DECL_ARTIFICIAL (d) = 1;
5556
5557   /* See if we already have this type.  */
5558   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5559   if (e)
5560     t = (tree) e->key;
5561   else
5562     /* Insert the type into the table.  */
5563     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5564
5565   return t;
5566 }
5567
5568 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5569    unless an error occurs, in which case error_mark_node is returned.
5570    If COMPLAIN zero, don't complain about any errors that occur.  */
5571
5572 tree
5573 make_typename_type (context, name, complain)
5574      tree context, name;
5575      int complain;
5576 {
5577   tree fullname;
5578
5579   if (TYPE_P (name))
5580     {
5581       if (!(TYPE_LANG_SPECIFIC (name)
5582             && (CLASSTYPE_IS_TEMPLATE (name)
5583                 || CLASSTYPE_USE_TEMPLATE (name))))
5584         name = TYPE_IDENTIFIER (name);
5585       else
5586         /* Create a TEMPLATE_ID_EXPR for the type.  */
5587         name = build_nt (TEMPLATE_ID_EXPR,
5588                          CLASSTYPE_TI_TEMPLATE (name),
5589                          CLASSTYPE_TI_ARGS (name));
5590     }
5591   else if (TREE_CODE (name) == TYPE_DECL)
5592     name = DECL_NAME (name);
5593
5594   fullname = name;
5595
5596   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5597     {
5598       name = TREE_OPERAND (name, 0);
5599       if (TREE_CODE (name) == TEMPLATE_DECL)
5600         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5601     }
5602   if (TREE_CODE (name) != IDENTIFIER_NODE)
5603     my_friendly_abort (2000);
5604
5605   if (TREE_CODE (context) == NAMESPACE_DECL)
5606     {
5607       /* We can get here from typename_sub0 in the explicit_template_type
5608          expansion.  Just fail.  */
5609       if (complain)
5610         cp_error ("no class template named `%#T' in `%#T'",
5611                   name, context);
5612       return error_mark_node;
5613     }
5614
5615   if (! uses_template_parms (context)
5616       || currently_open_class (context))
5617     {
5618       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5619         {
5620           tree tmpl = NULL_TREE;
5621           if (IS_AGGR_TYPE (context))
5622             tmpl = lookup_field (context, name, 0, 0);
5623           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5624             {
5625               if (complain)
5626                 cp_error ("no class template named `%#T' in `%#T'",
5627                           name, context);
5628               return error_mark_node;
5629             }
5630
5631           return lookup_template_class (tmpl,
5632                                         TREE_OPERAND (fullname, 1),
5633                                         NULL_TREE, context,
5634                                         /*entering_scope=*/0,
5635                                         /*complain=*/1);
5636         }
5637       else
5638         {
5639           tree t;
5640
5641           if (!IS_AGGR_TYPE (context))
5642             {
5643               if (complain)
5644                 cp_error ("no type named `%#T' in `%#T'", name, context);
5645               return error_mark_node;
5646             }
5647
5648           t = lookup_field (context, name, 0, 1);
5649           if (t)
5650             return TREE_TYPE (t);
5651         }
5652     }
5653
5654   /* If the CONTEXT is not a template type, then either the field is
5655      there now or its never going to be.  */
5656   if (!uses_template_parms (context))
5657     {
5658       if (complain)
5659         cp_error ("no type named `%#T' in `%#T'", name, context);
5660       return error_mark_node;
5661     }
5662
5663
5664   return build_typename_type (context, name, fullname,  NULL_TREE);
5665 }
5666
5667 /* Select the right _DECL from multiple choices. */
5668
5669 static tree
5670 select_decl (binding, flags)
5671      tree binding;
5672      int flags;
5673 {
5674   tree val;
5675   val = BINDING_VALUE (binding);
5676
5677   /* When we implicitly declare some builtin entity, we mark it
5678      DECL_ANTICIPATED, so that we know to ignore it until it is
5679      really declared.  */
5680   if (val && DECL_P (val)
5681       && DECL_LANG_SPECIFIC (val)
5682       && DECL_ANTICIPATED (val))
5683     return NULL_TREE;
5684
5685   if (LOOKUP_NAMESPACES_ONLY (flags))
5686     {
5687       /* We are not interested in types. */
5688       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5689         return val;
5690       return NULL_TREE;
5691     }
5692
5693   /* If we could have a type and
5694      we have nothing or we need a type and have none.  */
5695   if (BINDING_TYPE (binding)
5696       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5697                    && TREE_CODE (val) != TYPE_DECL)))
5698     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5699   /* Don't return non-types if we really prefer types. */
5700   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5701            && (TREE_CODE (val) != TEMPLATE_DECL
5702                || !DECL_CLASS_TEMPLATE_P (val)))
5703     val = NULL_TREE;
5704
5705   return val;
5706 }
5707
5708 /* Unscoped lookup of a global: iterate over current namespaces,
5709    considering using-directives.  If SPACESP is non-NULL, store a list
5710    of the namespaces we've considered in it.  */
5711
5712 tree
5713 unqualified_namespace_lookup (name, flags, spacesp)
5714      tree name;
5715      int flags;
5716      tree *spacesp;
5717 {
5718   tree b = make_node (CPLUS_BINDING);
5719   tree initial = current_decl_namespace();
5720   tree scope = initial;
5721   tree siter;
5722   struct binding_level *level;
5723   tree val = NULL_TREE;
5724
5725   if (spacesp)
5726     *spacesp = NULL_TREE;
5727
5728   for (; !val; scope = CP_DECL_CONTEXT (scope))
5729     {
5730       if (spacesp)
5731         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5732       val = binding_for_name (name, scope);
5733
5734       /* Initialize binding for this context. */
5735       BINDING_VALUE (b) = BINDING_VALUE (val);
5736       BINDING_TYPE (b) = BINDING_TYPE (val);
5737
5738       /* Add all _DECLs seen through local using-directives. */
5739       for (level = current_binding_level;
5740            !level->namespace_p;
5741            level = level->level_chain)
5742         if (!lookup_using_namespace (name, b, level->using_directives,
5743                                      scope, flags, spacesp))
5744           /* Give up because of error. */
5745           return error_mark_node;
5746
5747       /* Add all _DECLs seen through global using-directives. */
5748       /* XXX local and global using lists should work equally. */
5749       siter = initial;
5750       while (1)
5751         {
5752           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5753                                        scope, flags, spacesp))
5754             /* Give up because of error. */
5755             return error_mark_node;
5756           if (siter == scope) break;
5757           siter = CP_DECL_CONTEXT (siter);
5758         }
5759
5760       val = select_decl (b, flags);
5761       if (scope == global_namespace)
5762         break;
5763     }
5764   return val;
5765 }
5766
5767 /* Combine prefer_type and namespaces_only into flags.  */
5768
5769 static int
5770 lookup_flags (prefer_type, namespaces_only)
5771   int prefer_type, namespaces_only;
5772 {
5773   if (namespaces_only)
5774     return LOOKUP_PREFER_NAMESPACES;
5775   if (prefer_type > 1)
5776     return LOOKUP_PREFER_TYPES;
5777   if (prefer_type > 0)
5778     return LOOKUP_PREFER_BOTH;
5779   return 0;
5780 }
5781
5782 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5783    ignore it or not.  Subroutine of lookup_name_real.  */
5784
5785 static tree
5786 qualify_lookup (val, flags)
5787      tree val;
5788      int flags;
5789 {
5790   if (val == NULL_TREE)
5791     return val;
5792   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5793     return val;
5794   if ((flags & LOOKUP_PREFER_TYPES)
5795       && (TREE_CODE (val) == TYPE_DECL
5796           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5797               && DECL_CLASS_TEMPLATE_P (val))))
5798     return val;
5799   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5800     return NULL_TREE;
5801   return val;
5802 }
5803
5804 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5805    that.  */
5806
5807 static void
5808 warn_about_implicit_typename_lookup (typename, binding)
5809      tree typename;
5810      tree binding;
5811 {
5812   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5813   tree name = DECL_NAME (typename);
5814
5815   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5816          && CLASSTYPE_TEMPLATE_INFO (subtype)
5817          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5818       && ! (TREE_CODE (binding) == TYPE_DECL
5819             && same_type_p (TREE_TYPE (binding), subtype)))
5820     {
5821       cp_warning ("lookup of `%D' finds `%#D'",
5822                   name, binding);
5823       cp_warning ("  instead of `%D' from dependent base class",
5824                   typename);
5825       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5826                   constructor_name (current_class_type), name);
5827     }
5828 }
5829
5830 /* Look up NAME in the current binding level and its superiors in the
5831    namespace of variables, functions and typedefs.  Return a ..._DECL
5832    node of some kind representing its definition if there is only one
5833    such declaration, or return a TREE_LIST with all the overloaded
5834    definitions if there are many, or return 0 if it is undefined.
5835
5836    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5837    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5838    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5839    Otherwise we prefer non-TYPE_DECLs.
5840
5841    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5842    using IDENTIFIER_CLASS_VALUE.  */
5843
5844 static tree
5845 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5846      tree name;
5847      int prefer_type, nonclass, namespaces_only;
5848 {
5849   tree t;
5850   tree val = NULL_TREE;
5851   int yylex = 0;
5852   tree from_obj = NULL_TREE;
5853   int flags;
5854   int val_is_implicit_typename = 0;
5855
5856   /* Hack: copy flag set by parser, if set. */
5857   if (only_namespace_names)
5858     namespaces_only = 1;
5859
5860   if (prefer_type == -2)
5861     {
5862       extern int looking_for_typename;
5863       tree type = NULL_TREE;
5864
5865       yylex = 1;
5866       prefer_type = looking_for_typename;
5867
5868       flags = lookup_flags (prefer_type, namespaces_only);
5869       /* If the next thing is '<', class templates are types. */
5870       if (looking_for_template)
5871         flags |= LOOKUP_TEMPLATES_EXPECTED;
5872
5873       /* std:: becomes :: for now.  */
5874       if (got_scope && got_scope == fake_std_node)
5875         got_scope = void_type_node;
5876
5877       if (got_scope)
5878         type = got_scope;
5879       else if (got_object != error_mark_node)
5880         type = got_object;
5881
5882       if (type)
5883         {
5884           if (type == error_mark_node)
5885             return error_mark_node;
5886           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5887             type = TREE_TYPE (type);
5888
5889           if (TYPE_P (type))
5890             type = complete_type (type);
5891
5892           if (TREE_CODE (type) == VOID_TYPE)
5893             type = global_namespace;
5894           if (TREE_CODE (type) == NAMESPACE_DECL)
5895             {
5896               val = make_node (CPLUS_BINDING);
5897               flags |= LOOKUP_COMPLAIN;
5898               if (!qualified_lookup_using_namespace (name, type, val, flags))
5899                 return NULL_TREE;
5900               val = select_decl (val, flags);
5901             }
5902           else if (! IS_AGGR_TYPE (type)
5903                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5904                    || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
5905                    || TREE_CODE (type) == TYPENAME_TYPE)
5906             /* Someone else will give an error about this if needed.  */
5907             val = NULL_TREE;
5908           else if (type == current_class_type)
5909             val = IDENTIFIER_CLASS_VALUE (name);
5910           else
5911             {
5912               val = lookup_member (type, name, 0, prefer_type);
5913               type_access_control (type, val);
5914
5915               /* Restore the containing TYPENAME_TYPE if we looked
5916                  through it before.  */
5917               if (got_scope && got_scope != type
5918                   && val && TREE_CODE (val) == TYPE_DECL
5919                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
5920                 TYPE_CONTEXT (TREE_TYPE (val)) = got_scope;
5921             }
5922         }
5923       else
5924         val = NULL_TREE;
5925
5926       if (got_scope)
5927         goto done;
5928       else if (got_object && val)
5929         {
5930           from_obj = val;
5931           val = NULL_TREE;
5932         }
5933     }
5934   else
5935     {
5936       flags = lookup_flags (prefer_type, namespaces_only);
5937       /* If we're not parsing, we need to complain. */
5938       flags |= LOOKUP_COMPLAIN;
5939     }
5940
5941   /* First, look in non-namespace scopes.  */
5942
5943   if (current_class_type == NULL_TREE)
5944     nonclass = 1;
5945
5946   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5947     {
5948       tree binding;
5949
5950       if (!LOCAL_BINDING_P (t) && nonclass)
5951         /* We're not looking for class-scoped bindings, so keep going.  */
5952         continue;
5953
5954       /* If this is the kind of thing we're looking for, we're done.  */
5955       if (qualify_lookup (BINDING_VALUE (t), flags))
5956         binding = BINDING_VALUE (t);
5957       else if ((flags & LOOKUP_PREFER_TYPES)
5958                && qualify_lookup (BINDING_TYPE (t), flags))
5959         binding = BINDING_TYPE (t);
5960       else
5961         binding = NULL_TREE;
5962
5963       /* Handle access control on types from enclosing or base classes.  */
5964       if (binding && ! yylex
5965           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5966         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5967
5968       if (binding
5969           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5970         {
5971           if (val_is_implicit_typename && !yylex)
5972             warn_about_implicit_typename_lookup (val, binding);
5973           val = binding;
5974           val_is_implicit_typename
5975             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5976           if (!val_is_implicit_typename)
5977             break;
5978         }
5979     }
5980
5981   /* Now lookup in namespace scopes.  */
5982   if (!val || val_is_implicit_typename)
5983     {
5984       t = unqualified_namespace_lookup (name, flags, 0);
5985       if (t)
5986         {
5987           if (val_is_implicit_typename && !yylex)
5988             warn_about_implicit_typename_lookup (val, t);
5989           val = t;
5990         }
5991     }
5992
5993  done:
5994   if (val)
5995     {
5996       /* This should only warn about types used in qualified-ids.  */
5997       if (from_obj && from_obj != val)
5998         {
5999           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
6000               && TREE_CODE (val) == TYPE_DECL
6001               && ! same_type_p (TREE_TYPE (from_obj), TREE_TYPE (val)))
6002             cp_pedwarn ("\
6003 lookup of `%D' in the scope of `%#T' (`%#D') \
6004 does not match lookup in the current scope (`%#D')",
6005                         name, got_object, from_obj, val);
6006
6007           /* We don't change val to from_obj if got_object depends on
6008              template parms because that breaks implicit typename for
6009              destructor calls.  */
6010           if (! uses_template_parms (got_object))
6011             val = from_obj;
6012         }
6013
6014       /* If we have a single function from a using decl, pull it out.  */
6015       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6016         val = OVL_FUNCTION (val);
6017     }
6018   else if (from_obj)
6019     val = from_obj;
6020
6021   return val;
6022 }
6023
6024 tree
6025 lookup_name_nonclass (name)
6026      tree name;
6027 {
6028   return lookup_name_real (name, 0, 1, 0);
6029 }
6030
6031 tree
6032 lookup_function_nonclass (name, args)
6033      tree name;
6034      tree args;
6035 {
6036   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6037 }
6038
6039 tree
6040 lookup_name_namespace_only (name)
6041      tree name;
6042 {
6043   /* type-or-namespace, nonclass, namespace_only */
6044   return lookup_name_real (name, 1, 1, 1);
6045 }
6046
6047 tree
6048 lookup_name (name, prefer_type)
6049      tree name;
6050      int prefer_type;
6051 {
6052   return lookup_name_real (name, prefer_type, 0, 0);
6053 }
6054
6055 /* Similar to `lookup_name' but look only in the innermost non-class
6056    binding level.  */
6057
6058 tree
6059 lookup_name_current_level (name)
6060      tree name;
6061 {
6062   struct binding_level *b;
6063   tree t = NULL_TREE;
6064
6065   b = current_binding_level;
6066   while (b->parm_flag == 2)
6067     b = b->level_chain;
6068
6069   if (b->namespace_p)
6070     {
6071       t = IDENTIFIER_NAMESPACE_VALUE (name);
6072
6073       /* extern "C" function() */
6074       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6075         t = TREE_VALUE (t);
6076     }
6077   else if (IDENTIFIER_BINDING (name)
6078            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6079     {
6080       while (1)
6081         {
6082           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6083             return IDENTIFIER_VALUE (name);
6084
6085           if (b->keep == 2)
6086             b = b->level_chain;
6087           else
6088             break;
6089         }
6090     }
6091
6092   return t;
6093 }
6094
6095 /* Like lookup_name_current_level, but for types.  */
6096
6097 tree
6098 lookup_type_current_level (name)
6099      tree name;
6100 {
6101   register tree t = NULL_TREE;
6102
6103   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6104
6105   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6106       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6107     {
6108       struct binding_level *b = current_binding_level;
6109       while (1)
6110         {
6111           if (purpose_member (name, b->type_shadowed))
6112             return REAL_IDENTIFIER_TYPE_VALUE (name);
6113           if (b->keep == 2)
6114             b = b->level_chain;
6115           else
6116             break;
6117         }
6118     }
6119
6120   return t;
6121 }
6122
6123 void
6124 begin_only_namespace_names ()
6125 {
6126   only_namespace_names = 1;
6127 }
6128
6129 void
6130 end_only_namespace_names ()
6131 {
6132   only_namespace_names = 0;
6133 }
6134 \f
6135 /* Push the declarations of builtin types into the namespace.
6136    RID_INDEX is the index of the builtin type
6137    in the array RID_POINTERS.  NAME is the name used when looking
6138    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6139
6140 void
6141 record_builtin_type (rid_index, name, type)
6142      enum rid rid_index;
6143      const char *name;
6144      tree type;
6145 {
6146   tree rname = NULL_TREE, tname = NULL_TREE;
6147   tree tdecl = NULL_TREE;
6148
6149   if ((int) rid_index < (int) RID_MAX)
6150     rname = ridpointers[(int) rid_index];
6151   if (name)
6152     tname = get_identifier (name);
6153
6154   TYPE_BUILT_IN (type) = 1;
6155
6156   if (tname)
6157     {
6158       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6159       set_identifier_type_value (tname, NULL_TREE);
6160       if ((int) rid_index < (int) RID_MAX)
6161         /* Built-in types live in the global namespace. */
6162         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6163     }
6164   if (rname != NULL_TREE)
6165     {
6166       if (tname != NULL_TREE)
6167         {
6168           set_identifier_type_value (rname, NULL_TREE);
6169           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6170         }
6171       else
6172         {
6173           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6174           set_identifier_type_value (rname, NULL_TREE);
6175         }
6176     }
6177 }
6178
6179 /* Record one of the standard Java types.
6180  * Declare it as having the given NAME.
6181  * If SIZE > 0, it is the size of one of the integral types;
6182  * otherwise it is the negative of the size of one of the other types.  */
6183
6184 static tree
6185 record_builtin_java_type (name, size)
6186      const char *name;
6187      int size;
6188 {
6189   tree type, decl;
6190   if (size > 0)
6191     type = make_signed_type (size);
6192   else if (size > -32)
6193     { /* "__java_char" or ""__java_boolean". */
6194       type = make_unsigned_type (-size);
6195       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6196     }
6197   else
6198     { /* "__java_float" or ""__java_double". */
6199       type = make_node (REAL_TYPE);
6200       TYPE_PRECISION (type) = - size;
6201       layout_type (type);
6202     }
6203   record_builtin_type (RID_MAX, name, type);
6204   decl = TYPE_NAME (type);
6205
6206   /* Suppress generate debug symbol entries for these types,
6207      since for normal C++ they are just clutter.
6208      However, push_lang_context undoes this if extern "Java" is seen. */
6209   DECL_IGNORED_P (decl) = 1;
6210
6211   TYPE_FOR_JAVA (type) = 1;
6212   return type;
6213 }
6214
6215 /* Push a type into the namespace so that the back-ends ignore it. */
6216
6217 static void
6218 record_unknown_type (type, name)
6219      tree type;
6220      const char *name;
6221 {
6222   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6223   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6224   DECL_IGNORED_P (decl) = 1;
6225   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6226   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6227   TYPE_ALIGN (type) = 1;
6228   TYPE_USER_ALIGN (type) = 0;
6229   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6230 }
6231
6232 /* An string for which we should create an IDENTIFIER_NODE at
6233    startup.  */
6234
6235 typedef struct predefined_identifier
6236 {
6237   /* The name of the identifier.  */
6238   const char *name;
6239   /* The place where the IDENTIFIER_NODE should be stored.  */
6240   tree *node;
6241   /* Non-zero if this is the name of a constructor or destructor.  */
6242   int ctor_or_dtor_p;
6243 } predefined_identifier;
6244
6245 /* Create all the predefined identifiers.  */
6246
6247 static void
6248 initialize_predefined_identifiers ()
6249 {
6250   struct predefined_identifier *pid;
6251
6252   /* A table of identifiers to create at startup.  */
6253   static predefined_identifier predefined_identifiers[] = {
6254     { "C++", &lang_name_cplusplus, 0 },
6255     { "C", &lang_name_c, 0 },
6256     { "Java", &lang_name_java, 0 },
6257     { CTOR_NAME, &ctor_identifier, 1 },
6258     { "__base_ctor", &base_ctor_identifier, 1 },
6259     { "__comp_ctor", &complete_ctor_identifier, 1 },
6260     { DTOR_NAME, &dtor_identifier, 1 },
6261     { "__comp_dtor", &complete_dtor_identifier, 1 },
6262     { "__base_dtor", &base_dtor_identifier, 1 },
6263     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6264     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6265     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6266     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6267     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6268     { "nelts", &nelts_identifier, 0 },
6269     { THIS_NAME, &this_identifier, 0 },
6270     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6271     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6272     { "_vptr", &vptr_identifier, 0 },
6273     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6274     { "__vtt_parm", &vtt_parm_identifier, 0 },
6275     { "std", &std_identifier, 0 },
6276     { NULL, NULL, 0 }
6277   };
6278
6279   for (pid = predefined_identifiers; pid->name; ++pid)
6280     {
6281       *pid->node = get_identifier (pid->name);
6282       if (pid->ctor_or_dtor_p)
6283         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6284     }
6285 }
6286
6287 /* Create the predefined scalar types of C,
6288    and some nodes representing standard constants (0, 1, (void *)0).
6289    Initialize the global binding level.
6290    Make definitions for built-in primitive functions.  */
6291
6292 void
6293 init_decl_processing ()
6294 {
6295   tree fields[20];
6296
6297   /* Check to see that the user did not specify an invalid combination
6298      of command-line options.  */
6299   if (!flag_vtable_thunks)
6300     error ("the ABI requires vtable thunks");
6301
6302   /* Create all the identifiers we need.  */
6303   initialize_predefined_identifiers ();
6304
6305   /* Fill in back-end hooks.  */
6306   init_lang_status = &push_cp_function_context;
6307   free_lang_status = &pop_cp_function_context;
6308   mark_lang_status = &mark_cp_function_context;
6309   lang_safe_from_p = &c_safe_from_p;
6310   lang_dump_tree = &cp_dump_tree;
6311   lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
6312
6313   cp_parse_init ();
6314   init_decl2 ();
6315   init_pt ();
6316
6317   /* Create the global variables.  */
6318   push_to_top_level ();
6319
6320   /* Enter the global namespace. */
6321   my_friendly_assert (global_namespace == NULL_TREE, 375);
6322   push_namespace (get_identifier ("::"));
6323   global_namespace = current_namespace;
6324   current_lang_name = NULL_TREE;
6325
6326   /* Adjust various flags based on command-line settings.  */
6327   if (! flag_permissive && ! pedantic)
6328     flag_pedantic_errors = 1;
6329   if (!flag_no_inline)
6330     flag_inline_trees = 1;
6331
6332   /* Initially, C.  */
6333   current_lang_name = lang_name_c;
6334
6335   current_function_decl = NULL_TREE;
6336   current_binding_level = NULL_BINDING_LEVEL;
6337   free_binding_level = NULL_BINDING_LEVEL;
6338
6339   build_common_tree_nodes (flag_signed_char);
6340
6341   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6342   TREE_TYPE (error_mark_list) = error_mark_node;
6343
6344   /* Make the binding_level structure for global names.  */
6345   pushlevel (0);
6346   global_binding_level = current_binding_level;
6347   /* The global level is the namespace level of ::.  */
6348   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6349   declare_namespace_level ();
6350
6351   /* Create the `std' namespace.  */
6352   if (flag_honor_std)
6353     {
6354       push_namespace (std_identifier);
6355       std_node = current_namespace;
6356       pop_namespace ();
6357       fake_std_node = error_mark_node;
6358     }
6359   else
6360     {
6361       fake_std_node = build_decl (NAMESPACE_DECL,
6362                                   std_identifier,
6363                                   void_type_node);
6364       pushdecl (fake_std_node);
6365     }
6366
6367   c_common_nodes_and_builtins ();
6368
6369   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6370   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6371   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6372   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6373   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6374   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6375   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6376   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6377
6378   integer_two_node = build_int_2 (2, 0);
6379   TREE_TYPE (integer_two_node) = integer_type_node;
6380   integer_three_node = build_int_2 (3, 0);
6381   TREE_TYPE (integer_three_node) = integer_type_node;
6382
6383   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6384   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6385   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6386   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6387   TYPE_PRECISION (boolean_type_node) = 1;
6388   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6389   boolean_false_node = build_int_2 (0, 0);
6390   TREE_TYPE (boolean_false_node) = boolean_type_node;
6391   boolean_true_node = build_int_2 (1, 0);
6392   TREE_TYPE (boolean_true_node) = boolean_type_node;
6393
6394   signed_size_zero_node = build_int_2 (0, 0);
6395   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6396
6397   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6398
6399 #if 0
6400   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6401 #endif
6402
6403   delta_type_node = ptrdiff_type_node;
6404   vtable_index_type = ptrdiff_type_node;
6405
6406   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6407   lang_type_promotes_to = convert_type_from_ellipsis;
6408
6409   void_ftype_ptr
6410     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6411
6412   /* C++ extensions */
6413
6414   unknown_type_node = make_node (UNKNOWN_TYPE);
6415   record_unknown_type (unknown_type_node, "unknown type");
6416
6417   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6418   TREE_TYPE (unknown_type_node) = unknown_type_node;
6419
6420   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6421
6422   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6423      result.  */
6424   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6425   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6426
6427   if (flag_vtable_thunks)
6428     {
6429       /* Make sure we get a unique function type, so we can give
6430          its pointer type a name.  (This wins for gdb.) */
6431       tree vfunc_type = make_node (FUNCTION_TYPE);
6432       TREE_TYPE (vfunc_type) = integer_type_node;
6433       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6434       layout_type (vfunc_type);
6435
6436       vtable_entry_type = build_pointer_type (vfunc_type);
6437     }
6438   else
6439     {
6440       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6441       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6442                               delta_type_node);
6443       fields[1] = build_decl (FIELD_DECL, index_identifier,
6444                               delta_type_node);
6445       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6446                               ptr_type_node);
6447       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6448                            double_type_node);
6449
6450       /* Make this part of an invisible union.  */
6451       fields[3] = copy_node (fields[2]);
6452       TREE_TYPE (fields[3]) = delta_type_node;
6453       DECL_NAME (fields[3]) = delta2_identifier;
6454       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6455       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6456       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6457       TREE_UNSIGNED (fields[3]) = 0;
6458       TREE_CHAIN (fields[2]) = fields[3];
6459       vtable_entry_type = build_qualified_type (vtable_entry_type,
6460                                                 TYPE_QUAL_CONST);
6461     }
6462   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6463
6464   vtbl_type_node
6465     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6466   layout_type (vtbl_type_node);
6467   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6468   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6469   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6470   layout_type (vtbl_ptr_type_node);
6471   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6472
6473   push_namespace (get_identifier ("__cxxabiv1"));
6474   abi_node = current_namespace;
6475   pop_namespace ();
6476
6477   global_type_node = make_node (LANG_TYPE);
6478   record_unknown_type (global_type_node, "global type");
6479
6480   /* Now, C++.  */
6481   current_lang_name = lang_name_cplusplus;
6482
6483   {
6484     tree bad_alloc_type_node, newtype, deltype;
6485     if (flag_honor_std)
6486       push_namespace (std_identifier);
6487     bad_alloc_type_node = xref_tag
6488       (class_type_node, get_identifier ("bad_alloc"), 1);
6489     if (flag_honor_std)
6490       pop_namespace ();
6491     newtype = build_exception_variant
6492       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6493     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6494     push_cp_library_fn (NEW_EXPR, newtype);
6495     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6496     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6497     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6498   }
6499
6500   abort_fndecl
6501     = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
6502
6503   /* Perform other language dependent initializations.  */
6504   init_class_processing ();
6505   init_init_processing ();
6506   init_search_processing ();
6507   init_rtti_processing ();
6508
6509   if (flag_exceptions)
6510     init_exception_processing ();
6511   if (flag_no_inline)
6512     {
6513       flag_inline_functions = 0;
6514     }
6515
6516   if (! supports_one_only ())
6517     flag_weak = 0;
6518
6519   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6520   function_id_node = get_identifier ("__FUNCTION__");
6521   pretty_function_id_node = get_identifier ("__PRETTY_FUNCTION__");
6522   func_id_node = get_identifier ("__func__");
6523
6524   make_fname_decl = cp_make_fname_decl;
6525   declare_function_name ();
6526
6527   /* Prepare to check format strings against argument lists.  */
6528   init_function_format_info ();
6529
6530   /* Show we use EH for cleanups.  */
6531   using_eh_for_cleanups ();
6532
6533   valid_lang_attribute = cp_valid_lang_attribute;
6534
6535   /* Maintain consistency.  Perhaps we should just complain if they
6536      say -fwritable-strings?  */
6537   if (flag_writable_strings)
6538     flag_const_strings = 0;
6539
6540   /* Add GC roots for all of our global variables.  */
6541   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6542   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6543   ggc_add_tree_root (&integer_three_node, 1);
6544   ggc_add_tree_root (&integer_two_node, 1);
6545   ggc_add_tree_root (&signed_size_zero_node, 1);
6546   ggc_add_tree_root (&size_one_node, 1);
6547   ggc_add_tree_root (&size_zero_node, 1);
6548   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6549                 mark_binding_level);
6550   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6551   ggc_add_tree_root (&static_ctors, 1);
6552   ggc_add_tree_root (&static_dtors, 1);
6553   ggc_add_tree_root (&lastiddecl, 1);
6554
6555   ggc_add_tree_root (&last_function_parm_tags, 1);
6556   ggc_add_tree_root (&current_function_return_value, 1);
6557   ggc_add_tree_root (&current_function_parm_tags, 1);
6558   ggc_add_tree_root (&last_function_parms, 1);
6559   ggc_add_tree_root (&error_mark_list, 1);
6560
6561   ggc_add_tree_root (&global_namespace, 1);
6562   ggc_add_tree_root (&global_type_node, 1);
6563   ggc_add_tree_root (&anonymous_namespace_name, 1);
6564
6565   ggc_add_tree_root (&got_object, 1);
6566   ggc_add_tree_root (&got_scope, 1);
6567
6568   ggc_add_tree_root (&current_lang_name, 1);
6569   ggc_add_tree_root (&static_aggregates, 1);
6570   ggc_add_tree_root (&free_bindings, 1);
6571 }
6572
6573 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6574    decl, NAME is the initialization string and TYPE_DEP indicates whether
6575    NAME depended on the type of the function. We make use of that to detect
6576    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6577    the function before emitting any of it, we don't need to treat the
6578    VAR_DECL specially. We can decide whether to emit it later, if it was
6579    used.  */
6580
6581 static tree
6582 cp_make_fname_decl (id, name, type_dep)
6583      tree id;
6584      const char *name;
6585      int type_dep;
6586 {
6587   tree decl, type, init;
6588   size_t length = strlen (name);
6589   tree domain = NULL_TREE;
6590
6591   if (!processing_template_decl)
6592     type_dep = 0;
6593   if (!type_dep)
6594     domain = build_index_type (size_int (length));
6595
6596   type =  build_cplus_array_type
6597           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6598            domain);
6599
6600   decl = build_decl (VAR_DECL, id, type);
6601   TREE_STATIC (decl) = 1;
6602   TREE_READONLY (decl) = 1;
6603   DECL_SOURCE_LINE (decl) = 0;
6604   DECL_ARTIFICIAL (decl) = 1;
6605   DECL_IN_SYSTEM_HEADER (decl) = 1;
6606   pushdecl (decl);
6607   if (processing_template_decl)
6608     decl = push_template_decl (decl);
6609   if (type_dep)
6610     {
6611       init = build (FUNCTION_NAME, type);
6612       DECL_PRETTY_FUNCTION_P (decl) = 1;
6613     }
6614   else
6615     {
6616       init = build_string (length + 1, name);
6617       TREE_TYPE (init) = type;
6618     }
6619   DECL_INITIAL (decl) = init;
6620   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6621
6622   /* We will have to make sure we only emit this, if it is actually used. */
6623   return decl;
6624 }
6625
6626 /* Entry point for the benefit of c_common_nodes_and_builtins.
6627
6628    Make a definition for a builtin function named NAME and whose data type
6629    is TYPE.  TYPE should be a function type with argument types.
6630
6631    CLASS and CODE tell later passes how to compile calls to this function.
6632    See tree.h for possible values.
6633
6634    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6635    the name to be called if we can't opencode the function.  */
6636
6637 tree
6638 builtin_function (name, type, code, class, libname)
6639      const char *name;
6640      tree type;
6641      int code;
6642      enum built_in_class class;
6643      const char *libname;
6644 {
6645   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6646   DECL_BUILT_IN_CLASS (decl) = class;
6647   DECL_FUNCTION_CODE (decl) = code;
6648
6649   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6650
6651   /* All builtins that don't begin with an `_' should go in the `std'
6652      namespace.  */
6653   if (flag_honor_std && name[0] != '_')
6654     {
6655       push_namespace (std_identifier);
6656       DECL_CONTEXT (decl) = std_node;
6657     }
6658   pushdecl (decl);
6659   if (flag_honor_std && name[0] != '_')
6660     pop_namespace ();
6661
6662   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6663      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6664      function in the namespace.  */
6665   if (libname)
6666     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6667   make_decl_rtl (decl, NULL);
6668
6669   /* Warn if a function in the namespace for users
6670      is used without an occasion to consider it declared.  */
6671   if (name[0] != '_' || name[1] != '_')
6672     DECL_ANTICIPATED (decl) = 1;
6673
6674   return decl;
6675 }
6676
6677 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6678    function.  Not called directly.  */
6679
6680 static tree
6681 build_library_fn_1 (name, operator_code, type)
6682      tree name;
6683      enum tree_code operator_code;
6684      tree type;
6685 {
6686   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6687   DECL_EXTERNAL (fn) = 1;
6688   TREE_PUBLIC (fn) = 1;
6689   DECL_ARTIFICIAL (fn) = 1;
6690   TREE_NOTHROW (fn) = 1;
6691   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6692   return fn;
6693 }
6694
6695 /* Returns the _DECL for a library function with C linkage.
6696    We assume that such functions never throw; if this is incorrect,
6697    callers should unset TREE_NOTHROW.  */
6698
6699 tree
6700 build_library_fn (name, type)
6701      tree name;
6702      tree type;
6703 {
6704   tree fn = build_library_fn_1 (name, ERROR_MARK, type);
6705   make_decl_rtl (fn, NULL);
6706   return fn;
6707 }
6708
6709 /* Returns the _DECL for a library function with C++ linkage.  */
6710
6711 static tree
6712 build_cp_library_fn (name, operator_code, type)
6713      tree name;
6714      enum tree_code operator_code;
6715      tree type;
6716 {
6717   tree fn = build_library_fn_1 (name, operator_code, type);
6718   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6719   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6720   set_mangled_name_for_decl (fn);
6721   make_decl_rtl (fn, NULL);
6722   return fn;
6723 }
6724
6725 /* Like build_library_fn, but takes a C string instead of an
6726    IDENTIFIER_NODE.  */
6727
6728 tree
6729 build_library_fn_ptr (name, type)
6730      const char *name;
6731      tree type;
6732 {
6733   return build_library_fn (get_identifier (name), type);
6734 }
6735
6736 /* Like build_cp_library_fn, but takes a C string instead of an
6737    IDENTIFIER_NODE.  */
6738
6739 tree
6740 build_cp_library_fn_ptr (name, type)
6741      const char *name;
6742      tree type;
6743 {
6744   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6745 }
6746
6747 /* Like build_library_fn, but also pushes the function so that we will
6748    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6749
6750 tree
6751 push_library_fn (name, type)
6752      tree name, type;
6753 {
6754   tree fn = build_library_fn (name, type);
6755   pushdecl_top_level (fn);
6756   return fn;
6757 }
6758
6759 /* Like build_cp_library_fn, but also pushes the function so that it
6760    will be found by normal lookup.  */
6761
6762 static tree
6763 push_cp_library_fn (operator_code, type)
6764      enum tree_code operator_code;
6765      tree type;
6766 {
6767   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6768                                  operator_code,
6769                                  type);
6770   pushdecl (fn);
6771   return fn;
6772 }
6773
6774 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6775    a FUNCTION_TYPE.  */
6776
6777 tree
6778 push_void_library_fn (name, parmtypes)
6779      tree name, parmtypes;
6780 {
6781   tree type = build_function_type (void_type_node, parmtypes);
6782   return push_library_fn (name, type);
6783 }
6784
6785 /* Like push_library_fn, but also note that this function throws
6786    and does not return.  Used for __throw_foo and the like.  */
6787
6788 tree
6789 push_throw_library_fn (name, type)
6790      tree name, type;
6791 {
6792   tree fn = push_library_fn (name, type);
6793   TREE_THIS_VOLATILE (fn) = 1;
6794   TREE_NOTHROW (fn) = 0;
6795   return fn;
6796 }
6797 \f
6798 /* When we call finish_struct for an anonymous union, we create
6799    default copy constructors and such.  But, an anonymous union
6800    shouldn't have such things; this function undoes the damage to the
6801    anonymous union type T.
6802
6803    (The reason that we create the synthesized methods is that we don't
6804    distinguish `union { int i; }' from `typedef union { int i; } U'.
6805    The first is an anonymous union; the second is just an ordinary
6806    union type.)  */
6807
6808 void
6809 fixup_anonymous_aggr (t)
6810      tree t;
6811 {
6812   tree *q;
6813
6814   /* Wipe out memory of synthesized methods */
6815   TYPE_HAS_CONSTRUCTOR (t) = 0;
6816   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6817   TYPE_HAS_INIT_REF (t) = 0;
6818   TYPE_HAS_CONST_INIT_REF (t) = 0;
6819   TYPE_HAS_ASSIGN_REF (t) = 0;
6820   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6821
6822   /* Splice the implicitly generated functions out of the TYPE_METHODS
6823      list.  */
6824   q = &TYPE_METHODS (t);
6825   while (*q)
6826     {
6827       if (DECL_ARTIFICIAL (*q))
6828         *q = TREE_CHAIN (*q);
6829       else
6830         q = &TREE_CHAIN (*q);
6831     }
6832
6833   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6834   if (TYPE_METHODS (t))
6835     cp_error_at ("an anonymous union cannot have function members", t);
6836 }
6837
6838 /* Make sure that a declaration with no declarator is well-formed, i.e.
6839    just defines a tagged type or anonymous union.
6840
6841    Returns the type defined, if any.  */
6842
6843 tree
6844 check_tag_decl (declspecs)
6845      tree declspecs;
6846 {
6847   int found_type = 0;
6848   int saw_friend = 0;
6849   tree ob_modifier = NULL_TREE;
6850   register tree link;
6851   register tree t = NULL_TREE;
6852
6853   for (link = declspecs; link; link = TREE_CHAIN (link))
6854     {
6855       register tree value = TREE_VALUE (link);
6856
6857       if (TYPE_P (value)
6858           || TREE_CODE (value) == TYPE_DECL
6859           || (TREE_CODE (value) == IDENTIFIER_NODE
6860               && IDENTIFIER_GLOBAL_VALUE (value)
6861               && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value)) == TYPE_DECL))
6862         {
6863           ++found_type;
6864
6865           if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
6866             {
6867               if (! in_system_header)
6868                 cp_pedwarn ("redeclaration of C++ built-in type `%T'", value);
6869               return NULL_TREE;
6870             }
6871
6872           if (TYPE_P (value)
6873               && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
6874                   || TREE_CODE (value) == ENUMERAL_TYPE))
6875             {
6876               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6877               t = value;
6878             }
6879         }
6880       else if (value == ridpointers[(int) RID_FRIEND])
6881         {
6882           if (current_class_type == NULL_TREE
6883               || current_scope () != current_class_type)
6884             ob_modifier = value;
6885           else
6886             saw_friend = 1;
6887         }
6888       else if (value == ridpointers[(int) RID_STATIC]
6889                || value == ridpointers[(int) RID_EXTERN]
6890                || value == ridpointers[(int) RID_AUTO]
6891                || value == ridpointers[(int) RID_REGISTER]
6892                || value == ridpointers[(int) RID_INLINE]
6893                || value == ridpointers[(int) RID_VIRTUAL]
6894                || value == ridpointers[(int) RID_CONST]
6895                || value == ridpointers[(int) RID_VOLATILE]
6896                || value == ridpointers[(int) RID_EXPLICIT])
6897         ob_modifier = value;
6898     }
6899
6900   if (found_type > 1)
6901     error ("multiple types in one declaration");
6902
6903   if (t == NULL_TREE && ! saw_friend)
6904     pedwarn ("declaration does not declare anything");
6905
6906   /* Check for an anonymous union.  We're careful
6907      accessing TYPE_IDENTIFIER because some built-in types, like
6908      pointer-to-member types, do not have TYPE_NAME.  */
6909   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
6910            && TYPE_NAME (t)
6911            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
6912     {
6913       /* Anonymous unions are objects, so they can have specifiers.  */;
6914       SET_ANON_AGGR_TYPE_P (t);
6915
6916       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
6917         pedwarn ("ISO C++ prohibits anonymous structs");
6918     }
6919
6920   else if (ob_modifier)
6921     {
6922       if (ob_modifier == ridpointers[(int) RID_INLINE]
6923           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6924         cp_error ("`%D' can only be specified for functions", ob_modifier);
6925       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
6926         cp_error ("`%D' can only be specified inside a class", ob_modifier);
6927       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6928         cp_error ("`%D' can only be specified for constructors",
6929                   ob_modifier);
6930       else
6931         cp_error ("`%D' can only be specified for objects and functions",
6932                   ob_modifier);
6933     }
6934
6935   return t;
6936 }
6937
6938 /* Called when a declaration is seen that contains no names to declare.
6939    If its type is a reference to a structure, union or enum inherited
6940    from a containing scope, shadow that tag name for the current scope
6941    with a forward reference.
6942    If its type defines a new named structure or union
6943    or defines an enum, it is valid but we need not do anything here.
6944    Otherwise, it is an error.
6945
6946    C++: may have to grok the declspecs to learn about static,
6947    complain for anonymous unions.  */
6948
6949 void
6950 shadow_tag (declspecs)
6951      tree declspecs;
6952 {
6953   tree t = check_tag_decl (declspecs);
6954
6955   if (t)
6956     maybe_process_partial_specialization (t);
6957
6958   /* This is where the variables in an anonymous union are
6959      declared.  An anonymous union declaration looks like:
6960      union { ... } ;
6961      because there is no declarator after the union, the parser
6962      sends that declaration here.  */
6963   if (t && ANON_AGGR_TYPE_P (t))
6964     {
6965       fixup_anonymous_aggr (t);
6966
6967       if (TYPE_FIELDS (t))
6968         {
6969           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
6970                                       NULL_TREE);
6971           finish_anon_union (decl);
6972         }
6973     }
6974 }
6975 \f
6976 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
6977
6978 tree
6979 groktypename (typename)
6980      tree typename;
6981 {
6982   if (TREE_CODE (typename) != TREE_LIST)
6983     return typename;
6984   return grokdeclarator (TREE_VALUE (typename),
6985                          TREE_PURPOSE (typename),
6986                          TYPENAME, 0, NULL_TREE);
6987 }
6988
6989 /* Decode a declarator in an ordinary declaration or data definition.
6990    This is called as soon as the type information and variable name
6991    have been parsed, before parsing the initializer if any.
6992    Here we create the ..._DECL node, fill in its type,
6993    and put it on the list of decls for the current context.
6994    The ..._DECL node is returned as the value.
6995
6996    Exception: for arrays where the length is not specified,
6997    the type is left null, to be filled in by `cp_finish_decl'.
6998
6999    Function definitions do not come here; they go to start_function
7000    instead.  However, external and forward declarations of functions
7001    do go through here.  Structure field declarations are done by
7002    grokfield and not through here.  */
7003
7004 tree
7005 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7006      tree declarator, declspecs;
7007      int initialized;
7008      tree attributes, prefix_attributes;
7009 {
7010   register tree decl;
7011   register tree type, tem;
7012   tree context;
7013   extern int have_extern_spec;
7014   extern int used_extern_spec;
7015   tree attrlist;
7016
7017 #if 0
7018   /* See code below that used this.  */
7019   int init_written = initialized;
7020 #endif
7021
7022   /* This should only be done once on the top most decl.  */
7023   if (have_extern_spec && !used_extern_spec)
7024     {
7025       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7026                              declspecs);
7027       used_extern_spec = 1;
7028     }
7029
7030   if (attributes || prefix_attributes)
7031     attrlist = build_tree_list (attributes, prefix_attributes);
7032   else
7033     attrlist = NULL_TREE;
7034
7035   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7036                          attrlist);
7037
7038   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7039     return NULL_TREE;
7040
7041   type = TREE_TYPE (decl);
7042
7043   if (type == error_mark_node)
7044     return NULL_TREE;
7045
7046   context = DECL_CONTEXT (decl);
7047
7048   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7049       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7050     {
7051       /* When parsing the initializer, lookup should use the object's
7052          namespace. */
7053       push_decl_namespace (context);
7054     }
7055
7056   /* We are only interested in class contexts, later. */
7057   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7058     context = NULL_TREE;
7059
7060   if (initialized)
7061     /* Is it valid for this decl to have an initializer at all?
7062        If not, set INITIALIZED to zero, which will indirectly
7063        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7064     switch (TREE_CODE (decl))
7065       {
7066       case TYPE_DECL:
7067         /* typedef foo = bar  means give foo the same type as bar.
7068            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7069            Any other case of an initialization in a TYPE_DECL is an error.  */
7070         if (pedantic || list_length (declspecs) > 1)
7071           {
7072             cp_error ("typedef `%D' is initialized", decl);
7073             initialized = 0;
7074           }
7075         break;
7076
7077       case FUNCTION_DECL:
7078         cp_error ("function `%#D' is initialized like a variable", decl);
7079         initialized = 0;
7080         break;
7081
7082       default:
7083         break;
7084       }
7085
7086   if (initialized)
7087     {
7088       if (! toplevel_bindings_p ()
7089           && DECL_EXTERNAL (decl))
7090         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7091                     decl);
7092       DECL_EXTERNAL (decl) = 0;
7093       if (toplevel_bindings_p ())
7094         TREE_STATIC (decl) = 1;
7095
7096       /* Tell `pushdecl' this is an initialized decl
7097          even though we don't yet have the initializer expression.
7098          Also tell `cp_finish_decl' it may store the real initializer.  */
7099       DECL_INITIAL (decl) = error_mark_node;
7100     }
7101
7102 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7103   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7104 #endif
7105
7106   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7107   cplus_decl_attributes (decl, attributes, prefix_attributes);
7108
7109   if (context && COMPLETE_TYPE_P (complete_type (context)))
7110     {
7111       push_nested_class (context, 2);
7112
7113       if (TREE_CODE (decl) == VAR_DECL)
7114         {
7115           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7116           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7117             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7118           else
7119             {
7120               if (DECL_CONTEXT (field) != context)
7121                 {
7122                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7123                               DECL_CONTEXT (field), DECL_NAME (decl),
7124                               context, DECL_NAME (decl));
7125                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7126                 }
7127               /* Static data member are tricky; an in-class initialization
7128                  still doesn't provide a definition, so the in-class
7129                  declaration will have DECL_EXTERNAL set, but will have an
7130                  initialization.  Thus, duplicate_decls won't warn
7131                  about this situation, and so we check here.  */
7132               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7133                 cp_error ("duplicate initialization of %D", decl);
7134               if (duplicate_decls (decl, field))
7135                 decl = field;
7136             }
7137         }
7138       else
7139         {
7140           tree field = check_classfn (context, decl);
7141           if (field && duplicate_decls (decl, field))
7142             decl = field;
7143         }
7144
7145       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7146       DECL_IN_AGGR_P (decl) = 0;
7147       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7148           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7149         {
7150           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7151           /* [temp.expl.spec] An explicit specialization of a static data
7152              member of a template is a definition if the declaration
7153              includes an initializer; otherwise, it is a declaration.
7154
7155              We check for processing_specialization so this only applies
7156              to the new specialization syntax.  */
7157           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7158             DECL_EXTERNAL (decl) = 1;
7159         }
7160
7161       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7162         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7163                     decl);
7164     }
7165
7166   /* Enter this declaration into the symbol table.  */
7167   tem = maybe_push_decl (decl);
7168
7169   if (processing_template_decl)
7170     tem = push_template_decl (tem);
7171
7172 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7173   /* Tell the back-end to use or not use .common as appropriate.  If we say
7174      -fconserve-space, we want this to save .data space, at the expense of
7175      wrong semantics.  If we say -fno-conserve-space, we want this to
7176      produce errors about redefs; to do this we force variables into the
7177      data segment.  */
7178   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7179 #endif
7180
7181   if (! processing_template_decl)
7182     start_decl_1 (tem);
7183
7184   return tem;
7185 }
7186
7187 void
7188 start_decl_1 (decl)
7189      tree decl;
7190 {
7191   tree type = TREE_TYPE (decl);
7192   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7193
7194   if (type == error_mark_node)
7195     return;
7196
7197   maybe_push_cleanup_level (type);
7198
7199   if (initialized)
7200     /* Is it valid for this decl to have an initializer at all?
7201        If not, set INITIALIZED to zero, which will indirectly
7202        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7203     {
7204       /* Don't allow initializations for incomplete types except for
7205          arrays which might be completed by the initialization.  */
7206       if (COMPLETE_TYPE_P (complete_type (type)))
7207         ;                       /* A complete type is ok.  */
7208       else if (TREE_CODE (type) != ARRAY_TYPE)
7209         {
7210           cp_error ("variable `%#D' has initializer but incomplete type",
7211                     decl);
7212           initialized = 0;
7213           type = TREE_TYPE (decl) = error_mark_node;
7214         }
7215       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7216         {
7217           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7218             cp_error ("elements of array `%#D' have incomplete type", decl);
7219           /* else we already gave an error in start_decl.  */
7220           initialized = 0;
7221         }
7222     }
7223
7224   if (!initialized
7225       && TREE_CODE (decl) != TYPE_DECL
7226       && TREE_CODE (decl) != TEMPLATE_DECL
7227       && type != error_mark_node
7228       && IS_AGGR_TYPE (type)
7229       && ! DECL_EXTERNAL (decl))
7230     {
7231       if ((! processing_template_decl || ! uses_template_parms (type))
7232           && !COMPLETE_TYPE_P (complete_type (type)))
7233         {
7234           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7235                  decl);
7236           /* Change the type so that assemble_variable will give
7237              DECL an rtl we can live with: (mem (const_int 0)).  */
7238           type = TREE_TYPE (decl) = error_mark_node;
7239         }
7240       else
7241         {
7242           /* If any base type in the hierarchy of TYPE needs a constructor,
7243              then we set initialized to 1.  This way any nodes which are
7244              created for the purposes of initializing this aggregate
7245              will live as long as it does.  This is necessary for global
7246              aggregates which do not have their initializers processed until
7247              the end of the file.  */
7248           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7249         }
7250     }
7251
7252   if (! initialized)
7253     DECL_INITIAL (decl) = NULL_TREE;
7254 }
7255
7256 /* Handle initialization of references.
7257    These three arguments are from `cp_finish_decl', and have the
7258    same meaning here that they do there.
7259
7260    Quotes on semantics can be found in ARM 8.4.3.  */
7261
7262 static void
7263 grok_reference_init (decl, type, init)
7264      tree decl, type, init;
7265 {
7266   tree tmp;
7267
7268   if (init == NULL_TREE)
7269     {
7270       if ((DECL_LANG_SPECIFIC (decl) == 0
7271            || DECL_IN_AGGR_P (decl) == 0)
7272           && ! DECL_THIS_EXTERN (decl))
7273         cp_error ("`%D' declared as reference but not initialized", decl);
7274       return;
7275     }
7276
7277   if (init == error_mark_node)
7278     return;
7279
7280   if (TREE_CODE (init) == CONSTRUCTOR)
7281     {
7282       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7283       return;
7284     }
7285
7286   if (TREE_CODE (init) == TREE_LIST)
7287     init = build_compound_expr (init);
7288
7289   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7290     init = convert_from_reference (init);
7291
7292   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7293       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7294     {
7295       /* Note: default conversion is only called in very special cases.  */
7296       init = default_conversion (init);
7297     }
7298
7299   /* Convert INIT to the reference type TYPE.  This may involve the
7300      creation of a temporary, whose lifetime must be the same as that
7301      of the reference.  If so, a DECL_STMT for the temporary will be
7302      added just after the DECL_STMT for DECL.  That's why we don't set
7303      DECL_INITIAL for local references (instead assigning to them
7304      explicitly); we need to allow the temporary to be initialized
7305      first.  */
7306   tmp = convert_to_reference
7307     (type, init, CONV_IMPLICIT,
7308      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7309      decl);
7310
7311   if (tmp == error_mark_node)
7312     return;
7313   else if (tmp != NULL_TREE)
7314     {
7315       init = tmp;
7316       tmp = save_expr (tmp);
7317       if (building_stmt_tree ())
7318         {
7319           /* Initialize the declaration.  */
7320           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7321           finish_expr_stmt (tmp);
7322         }
7323       else
7324         DECL_INITIAL (decl) = tmp;
7325     }
7326   else
7327     {
7328       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7329       return;
7330     }
7331
7332   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7333     {
7334       expand_static_init (decl, DECL_INITIAL (decl));
7335       DECL_INITIAL (decl) = NULL_TREE;
7336     }
7337   return;
7338 }
7339
7340 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7341    mucking with forces it does not comprehend (i.e. initialization with a
7342    constructor).  If we are at global scope and won't go into COMMON, fill
7343    it in with a dummy CONSTRUCTOR to force the variable into .data;
7344    otherwise we can use error_mark_node.  */
7345
7346 static tree
7347 obscure_complex_init (decl, init)
7348      tree decl, init;
7349 {
7350   if (! flag_no_inline && TREE_STATIC (decl))
7351     {
7352       if (extract_init (decl, init))
7353         return NULL_TREE;
7354     }
7355
7356 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7357   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7358     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7359                                  NULL_TREE);
7360   else
7361 #endif
7362     DECL_INITIAL (decl) = error_mark_node;
7363
7364   return init;
7365 }
7366
7367 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7368    array until we finish parsing the initializer.  If that's the
7369    situation we're in, update DECL accordingly.  */
7370
7371 static void
7372 maybe_deduce_size_from_array_init (decl, init)
7373      tree decl;
7374      tree init;
7375 {
7376   tree type = TREE_TYPE (decl);
7377
7378   if (TREE_CODE (type) == ARRAY_TYPE
7379       && TYPE_DOMAIN (type) == NULL_TREE
7380       && TREE_CODE (decl) != TYPE_DECL)
7381     {
7382       /* do_default is really a C-ism to deal with tentative definitions.
7383          But let's leave it here to ease the eventual merge.  */
7384       int do_default = !DECL_EXTERNAL (decl);
7385       tree initializer = init ? init : DECL_INITIAL (decl);
7386       int failure = complete_array_type (type, initializer, do_default);
7387
7388       if (failure == 1)
7389         cp_error ("initializer fails to determine size of `%D'", decl);
7390
7391       if (failure == 2)
7392         {
7393           if (do_default)
7394             cp_error ("array size missing in `%D'", decl);
7395           /* If a `static' var's size isn't known, make it extern as
7396              well as static, so it does not get allocated.  If it's not
7397              `static', then don't mark it extern; finish_incomplete_decl
7398              will give it a default size and it will get allocated.  */
7399           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7400             DECL_EXTERNAL (decl) = 1;
7401         }
7402
7403       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7404           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7405                               integer_zero_node))
7406         cp_error ("zero-size array `%D'", decl);
7407
7408       layout_decl (decl, 0);
7409     }
7410 }
7411
7412 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7413    any appropriate error messages regarding the layout.  */
7414
7415 static void
7416 layout_var_decl (decl)
7417      tree decl;
7418 {
7419   tree type = TREE_TYPE (decl);
7420 #if 0
7421   tree ttype = target_type (type);
7422 #endif
7423
7424   /* If we haven't already layed out this declaration, do so now.
7425      Note that we must not call complete type for an external object
7426      because it's type might involve templates that we are not
7427      supposed to isntantiate yet.  (And it's perfectly legal to say
7428      `extern X x' for some incomplete type `X'.)  */
7429   if (!DECL_EXTERNAL (decl))
7430     complete_type (type);
7431   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7432     layout_decl (decl, 0);
7433
7434   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7435     {
7436       /* An automatic variable with an incomplete type: that is an error.
7437          Don't talk about array types here, since we took care of that
7438          message in grokdeclarator.  */
7439       cp_error ("storage size of `%D' isn't known", decl);
7440       TREE_TYPE (decl) = error_mark_node;
7441     }
7442 #if 0
7443   /* Keep this code around in case we later want to control debug info
7444      based on whether a type is "used".  (jason 1999-11-11) */
7445
7446   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7447     /* Let debugger know it should output info for this type.  */
7448     note_debug_info_needed (ttype);
7449
7450   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7451     note_debug_info_needed (DECL_CONTEXT (decl));
7452 #endif
7453
7454   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7455       && DECL_SIZE (decl) != NULL_TREE
7456       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7457     {
7458       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7459         constant_expression_warning (DECL_SIZE (decl));
7460       else
7461         cp_error ("storage size of `%D' isn't constant", decl);
7462     }
7463 }
7464
7465 /* If a local static variable is declared in an inline function, or if
7466    we have a weak definition, we must endeavor to create only one
7467    instance of the variable at link-time.  */
7468
7469 static void
7470 maybe_commonize_var (decl)
7471      tree decl;
7472 {
7473   /* Static data in a function with comdat linkage also has comdat
7474      linkage.  */
7475   if (TREE_STATIC (decl)
7476       /* Don't mess with __FUNCTION__.  */
7477       && ! DECL_ARTIFICIAL (decl)
7478       && current_function_decl
7479       && DECL_CONTEXT (decl) == current_function_decl
7480       && (DECL_THIS_INLINE (current_function_decl)
7481           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7482       && TREE_PUBLIC (current_function_decl))
7483     {
7484       /* Rather than try to get this right with inlining, we suppress
7485          inlining of such functions.  */
7486       current_function_cannot_inline
7487         = "function with static variable cannot be inline";
7488       DECL_UNINLINABLE (current_function_decl) = 1;
7489
7490       /* If flag_weak, we don't need to mess with this, as we can just
7491          make the function weak, and let it refer to its unique local
7492          copy.  This works because we don't allow the function to be
7493          inlined.  */
7494       if (! flag_weak)
7495         {
7496           if (DECL_INTERFACE_KNOWN (current_function_decl))
7497             {
7498               TREE_PUBLIC (decl) = 1;
7499               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7500             }
7501           else if (DECL_INITIAL (decl) == NULL_TREE
7502                    || DECL_INITIAL (decl) == error_mark_node)
7503             {
7504               TREE_PUBLIC (decl) = 1;
7505               DECL_COMMON (decl) = 1;
7506             }
7507           /* else we lose. We can only do this if we can use common,
7508              which we can't if it has been initialized.  */
7509
7510           if (TREE_PUBLIC (decl))
7511             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
7512           else
7513             {
7514               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7515               cp_warning_at ("  you can work around this by removing the initializer", decl);
7516             }
7517         }
7518     }
7519   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7520     /* Set it up again; we might have set DECL_INITIAL since the last
7521        time.  */
7522     comdat_linkage (decl);
7523 }
7524
7525 /* Issue an error message if DECL is an uninitialized const variable.  */
7526
7527 static void
7528 check_for_uninitialized_const_var (decl)
7529      tree decl;
7530 {
7531   tree type = TREE_TYPE (decl);
7532
7533   /* ``Unless explicitly declared extern, a const object does not have
7534      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7535      7.1.6 */
7536   if (TREE_CODE (decl) == VAR_DECL
7537       && TREE_CODE (type) != REFERENCE_TYPE
7538       && CP_TYPE_CONST_P (type)
7539       && !TYPE_NEEDS_CONSTRUCTING (type)
7540       && !DECL_INITIAL (decl))
7541     cp_error ("uninitialized const `%D'", decl);
7542 }
7543
7544 /* Verify INIT (the initializer for DECL), and record the
7545    initialization in DECL_INITIAL, if appropriate.  Returns a new
7546    value for INIT.  */
7547
7548 static tree
7549 check_initializer (decl, init)
7550      tree decl;
7551      tree init;
7552 {
7553   tree type;
7554
7555   if (TREE_CODE (decl) == FIELD_DECL)
7556     return init;
7557
7558   type = TREE_TYPE (decl);
7559
7560   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7561   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7562     init = NULL_TREE;
7563
7564   /* Check the initializer.  */
7565   if (init)
7566     {
7567       /* Things that are going to be initialized need to have complete
7568          type.  */
7569       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7570
7571       if (type == error_mark_node)
7572         /* We will have already complained.  */
7573         init = NULL_TREE;
7574       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7575         {
7576           cp_error ("variable-sized object `%D' may not be initialized", decl);
7577           init = NULL_TREE;
7578         }
7579       else if (TREE_CODE (type) == ARRAY_TYPE
7580                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7581         {
7582           cp_error ("elements of array `%#D' have incomplete type", decl);
7583           init = NULL_TREE;
7584         }
7585       else if (!COMPLETE_TYPE_P (type))
7586         {
7587           cp_error ("`%D' has incomplete type", decl);
7588           TREE_TYPE (decl) = error_mark_node;
7589           init = NULL_TREE;
7590         }
7591     }
7592
7593   if (TREE_CODE (decl) == CONST_DECL)
7594     {
7595       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7596
7597       DECL_INITIAL (decl) = init;
7598
7599       my_friendly_assert (init != NULL_TREE, 149);
7600       init = NULL_TREE;
7601     }
7602   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7603     {
7604       if (TREE_STATIC (decl))
7605         make_decl_rtl (decl, NULL_PTR);
7606       grok_reference_init (decl, type, init);
7607       init = NULL_TREE;
7608     }
7609   else if (init)
7610     {
7611       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7612         {
7613           if (TREE_CODE (type) == ARRAY_TYPE)
7614             init = digest_init (type, init, (tree *) 0);
7615           else if (TREE_CODE (init) == CONSTRUCTOR
7616                    && TREE_HAS_CONSTRUCTOR (init))
7617             {
7618               if (TYPE_NON_AGGREGATE_CLASS (type))
7619                 {
7620                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7621                             decl);
7622                   init = error_mark_node;
7623                 }
7624               else
7625                 goto dont_use_constructor;
7626             }
7627         }
7628       else
7629         {
7630         dont_use_constructor:
7631           if (TREE_CODE (init) != TREE_VEC)
7632             init = store_init_value (decl, init);
7633         }
7634
7635       if (init)
7636         /* We must hide the initializer so that expand_decl
7637            won't try to do something it does not understand.  */
7638         init = obscure_complex_init (decl, init);
7639     }
7640   else if (DECL_EXTERNAL (decl))
7641     ;
7642   else if (TYPE_P (type)
7643            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7644     {
7645       tree core_type = strip_array_types (type);
7646
7647       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7648         {
7649           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7650             cp_error ("structure `%D' with uninitialized const members", decl);
7651           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7652             cp_error ("structure `%D' with uninitialized reference members",
7653                       decl);
7654         }
7655
7656       check_for_uninitialized_const_var (decl);
7657
7658       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7659         init = obscure_complex_init (decl, NULL_TREE);
7660
7661     }
7662   else
7663     check_for_uninitialized_const_var (decl);
7664
7665   return init;
7666 }
7667
7668 /* If DECL is not a local variable, give it RTL.  */
7669
7670 static void
7671 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7672      tree decl;
7673      tree init;
7674      const char *asmspec;
7675 {
7676   int toplev = toplevel_bindings_p ();
7677   int defer_p;
7678
7679   /* Handle non-variables up front.  */
7680   if (TREE_CODE (decl) != VAR_DECL)
7681     {
7682       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7683       return;
7684     }
7685
7686   /* If we see a class member here, it should be a static data
7687      member.  */
7688   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7689     {
7690       my_friendly_assert (TREE_STATIC (decl), 19990828);
7691       /* An in-class declaration of a static data member should be
7692          external; it is only a declaration, and not a definition.  */
7693       if (init == NULL_TREE)
7694         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7695     }
7696
7697   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7698   if (asmspec)
7699     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7700
7701   /* We don't create any RTL for local variables.  */
7702   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7703     return;
7704
7705   /* We defer emission of local statics until the corresponding
7706      DECL_STMT is expanded.  */
7707   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7708
7709   /* We try to defer namespace-scope static constants so that they are
7710      not emitted into the object file unncessarily.  */
7711   if (!DECL_VIRTUAL_P (decl)
7712       && TREE_READONLY (decl)
7713       && DECL_INITIAL (decl) != NULL_TREE
7714       && DECL_INITIAL (decl) != error_mark_node
7715       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7716       && toplev
7717       && !TREE_PUBLIC (decl))
7718     {
7719       /* Fool with the linkage according to #pragma interface.  */
7720       if (!interface_unknown)
7721         {
7722           TREE_PUBLIC (decl) = 1;
7723           DECL_EXTERNAL (decl) = interface_only;
7724         }
7725
7726       defer_p = 1;
7727     }
7728
7729   /* If we're deferring the variable, just make RTL.  Do not actually
7730      emit the variable.  */
7731   if (defer_p)
7732     make_decl_rtl (decl, asmspec);
7733   /* If we're not deferring, go ahead and assemble the variable.  */
7734   else
7735     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7736 }
7737
7738 /* The old ARM scoping rules injected variables declared in the
7739    initialization statement of a for-statement into the surrounding
7740    scope.  We support this usage, in order to be backward-compatible.
7741    DECL is a just-declared VAR_DECL; if necessary inject its
7742    declaration into the surrounding scope.  */
7743
7744 void
7745 maybe_inject_for_scope_var (decl)
7746      tree decl;
7747 {
7748   if (!DECL_NAME (decl))
7749     return;
7750
7751   if (current_binding_level->is_for_scope)
7752     {
7753       struct binding_level *outer
7754         = current_binding_level->level_chain;
7755
7756       /* Check to see if the same name is already bound at the outer
7757          level, either because it was directly declared, or because a
7758          dead for-decl got preserved.  In either case, the code would
7759          not have been valid under the ARM scope rules, so clear
7760          is_for_scope for the current_binding_level.
7761
7762          Otherwise, we need to preserve the temp slot for decl to last
7763          into the outer binding level.  */
7764
7765       tree outer_binding
7766         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7767
7768       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7769           && (TREE_CODE (BINDING_VALUE (outer_binding))
7770               == VAR_DECL)
7771           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7772         {
7773           BINDING_VALUE (outer_binding)
7774             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7775           current_binding_level->is_for_scope = 0;
7776         }
7777       else if (DECL_IN_MEMORY_P (decl))
7778         preserve_temp_slots (DECL_RTL (decl));
7779     }
7780 }
7781
7782 /* Generate code to initialize DECL (a local variable).  */
7783
7784 void
7785 initialize_local_var (decl, init, flags)
7786      tree decl;
7787      tree init;
7788      int flags;
7789 {
7790   tree type = TREE_TYPE (decl);
7791
7792   /* If the type is bogus, don't bother initializing the variable.  */
7793   if (type == error_mark_node)
7794     return;
7795
7796   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7797     {
7798       /* If we used it already as memory, it must stay in memory.  */
7799       DECL_INITIAL (decl) = NULL_TREE;
7800       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7801     }
7802
7803   /* Local statics are handled differently from ordinary automatic
7804      variables.  */
7805   if (TREE_STATIC (decl))
7806     {
7807       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7808           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7809         expand_static_init (decl, init);
7810       return;
7811     }
7812
7813   if (DECL_SIZE (decl) && type != error_mark_node)
7814     {
7815       int already_used;
7816
7817       /* Compute and store the initial value.  */
7818       already_used = TREE_USED (decl) || TREE_USED (type);
7819
7820       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7821         {
7822           int saved_stmts_are_full_exprs_p;
7823
7824           my_friendly_assert (building_stmt_tree (), 20000906);
7825           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7826           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
7827           finish_expr_stmt (build_aggr_init (decl, init, flags));
7828           current_stmt_tree ()->stmts_are_full_exprs_p =
7829             saved_stmts_are_full_exprs_p;
7830         }
7831
7832       /* Set this to 0 so we can tell whether an aggregate which was
7833          initialized was ever used.  Don't do this if it has a
7834          destructor, so we don't complain about the 'resource
7835          allocation is initialization' idiom.  Now set
7836          attribute((unused)) on types so decls of that type will be
7837          marked used. (see TREE_USED, above.)  */
7838       if (TYPE_NEEDS_CONSTRUCTING (type)
7839           && ! already_used
7840           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7841           && DECL_NAME (decl))
7842         TREE_USED (decl) = 0;
7843       else if (already_used)
7844         TREE_USED (decl) = 1;
7845     }
7846 }
7847
7848 /* Generate code to destroy DECL (a local variable).  */
7849
7850 static void
7851 destroy_local_var (decl)
7852      tree decl;
7853 {
7854   tree type = TREE_TYPE (decl);
7855   tree cleanup;
7856
7857   /* Only variables get cleaned up.  */
7858   if (TREE_CODE (decl) != VAR_DECL)
7859     return;
7860
7861   /* And only things with destructors need cleaning up.  */
7862   if (type == error_mark_node
7863       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7864     return;
7865
7866   if (TREE_CODE (decl) == VAR_DECL &&
7867       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7868     /* We don't clean up things that aren't defined in this
7869        translation unit, or that need a static cleanup.  The latter
7870        are handled by finish_file.  */
7871     return;
7872
7873   /* Compute the cleanup.  */
7874   cleanup = maybe_build_cleanup (decl);
7875
7876   /* Record the cleanup required for this declaration.  */
7877   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7878       && cleanup)
7879     finish_decl_cleanup (decl, cleanup);
7880 }
7881
7882 /* Finish processing of a declaration;
7883    install its line number and initial value.
7884    If the length of an array type is not known before,
7885    it must be determined now, from the initial value, or it is an error.
7886
7887    INIT holds the value of an initializer that should be allowed to escape
7888    the normal rules.
7889
7890    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
7891    if the (init) syntax was used.  */
7892
7893 void
7894 cp_finish_decl (decl, init, asmspec_tree, flags)
7895      tree decl, init;
7896      tree asmspec_tree;
7897      int flags;
7898 {
7899   register tree type;
7900   tree ttype = NULL_TREE;
7901   const char *asmspec = NULL;
7902   int was_readonly = 0;
7903
7904   if (! decl)
7905     {
7906       if (init)
7907         error ("assignment (not initialization) in declaration");
7908       return;
7909     }
7910
7911   /* If a name was specified, get the string.  */
7912   if (asmspec_tree)
7913       asmspec = TREE_STRING_POINTER (asmspec_tree);
7914
7915   if (init && TREE_CODE (init) == NAMESPACE_DECL)
7916     {
7917       cp_error ("cannot initialize `%D' to namespace `%D'",
7918                 decl, init);
7919       init = NULL_TREE;
7920     }
7921
7922   if (current_class_type
7923       && CP_DECL_CONTEXT (decl) == current_class_type
7924       && TYPE_BEING_DEFINED (current_class_type)
7925       && (DECL_INITIAL (decl) || init))
7926     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
7927
7928   if (TREE_CODE (decl) == VAR_DECL
7929       && DECL_CONTEXT (decl)
7930       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
7931       && DECL_CONTEXT (decl) != current_namespace
7932       && init)
7933     {
7934       /* Leave the namespace of the object. */
7935       pop_decl_namespace ();
7936     }
7937
7938   type = TREE_TYPE (decl);
7939
7940   if (type == error_mark_node)
7941     return;
7942
7943   /* Add this declaration to the statement-tree.  */
7944   if (building_stmt_tree ()
7945       && at_function_scope_p ()
7946       && TREE_CODE (decl) != RESULT_DECL)
7947     add_decl_stmt (decl);
7948
7949   if (TYPE_HAS_MUTABLE_P (type))
7950     TREE_READONLY (decl) = 0;
7951
7952   if (processing_template_decl)
7953     {
7954       if (init && DECL_INITIAL (decl))
7955         DECL_INITIAL (decl) = init;
7956       goto finish_end0;
7957     }
7958
7959   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
7960   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
7961
7962   /* Take care of TYPE_DECLs up front.  */
7963   if (TREE_CODE (decl) == TYPE_DECL)
7964     {
7965       if (init && DECL_INITIAL (decl))
7966         {
7967           /* typedef foo = bar; store the type of bar as the type of foo.  */
7968           TREE_TYPE (decl) = type = TREE_TYPE (init);
7969           DECL_INITIAL (decl) = init = NULL_TREE;
7970         }
7971       if (type != error_mark_node
7972           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
7973         {
7974           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
7975             cp_warning ("shadowing previous type declaration of `%#D'", decl);
7976           set_identifier_type_value (DECL_NAME (decl), type);
7977           CLASSTYPE_GOT_SEMICOLON (type) = 1;
7978         }
7979       GNU_xref_decl (current_function_decl, decl);
7980
7981       /* If we have installed this as the canonical typedef for this
7982          type, and that type has not been defined yet, delay emitting
7983          the debug information for it, as we will emit it later.  */
7984       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
7985           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
7986         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
7987
7988       rest_of_decl_compilation (decl, NULL_PTR,
7989                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
7990       goto finish_end;
7991     }
7992
7993   if (TREE_CODE (decl) != FUNCTION_DECL)
7994     ttype = target_type (type);
7995
7996   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
7997       && TYPE_NEEDS_CONSTRUCTING (type))
7998     {
7999       /* Currently, GNU C++ puts constants in text space, making them
8000          impossible to initialize.  In the future, one would hope for
8001          an operating system which understood the difference between
8002          initialization and the running of a program.  */
8003       was_readonly = 1;
8004       TREE_READONLY (decl) = 0;
8005     }
8006
8007   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8008     {
8009       /* This must override the asm specifier which was placed by
8010          grokclassfn.  Lay this out fresh.  */
8011       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8012       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8013       make_decl_rtl (decl, asmspec);
8014     }
8015
8016   /* Deduce size of array from initialization, if not already known.  */
8017   maybe_deduce_size_from_array_init (decl, init);
8018   init = check_initializer (decl, init);
8019
8020   GNU_xref_decl (current_function_decl, decl);
8021
8022   if (TREE_CODE (decl) == VAR_DECL)
8023     layout_var_decl (decl);
8024
8025   /* Output the assembler code and/or RTL code for variables and functions,
8026      unless the type is an undefined structure or union.
8027      If not, it will get done when the type is completed.  */
8028   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8029       || TREE_CODE (decl) == RESULT_DECL)
8030     {
8031       if (TREE_CODE (decl) == VAR_DECL)
8032         maybe_commonize_var (decl);
8033
8034       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8035
8036       if (TREE_CODE (type) == FUNCTION_TYPE
8037           || TREE_CODE (type) == METHOD_TYPE)
8038         abstract_virtuals_error (decl,
8039                                  strip_array_types (TREE_TYPE (type)));
8040       else
8041         abstract_virtuals_error (decl, strip_array_types (type));
8042
8043       if (TREE_CODE (decl) == FUNCTION_DECL)
8044         ;
8045       else if (DECL_EXTERNAL (decl)
8046                && ! (DECL_LANG_SPECIFIC (decl)
8047                      && DECL_NOT_REALLY_EXTERN (decl)))
8048         {
8049           if (init)
8050             DECL_INITIAL (decl) = init;
8051         }
8052       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8053         {
8054           /* This is a local declaration.  */
8055           if (doing_semantic_analysis_p ())
8056             maybe_inject_for_scope_var (decl);
8057           /* Initialize the local variable.  But, if we're building a
8058              statement-tree, we'll do the initialization when we
8059              expand the tree.  */
8060           if (processing_template_decl)
8061             {
8062               if (init || DECL_INITIAL (decl) == error_mark_node)
8063                 DECL_INITIAL (decl) = init;
8064             }
8065           else
8066             {
8067               /* If we're not building RTL, then we need to do so
8068                  now.  */
8069               my_friendly_assert (building_stmt_tree (), 20000906);
8070               /* Initialize the variable.  */
8071               initialize_local_var (decl, init, flags);
8072               /* Clean up the variable.  */
8073               destroy_local_var (decl);
8074             }
8075         }
8076       else if (TREE_STATIC (decl) && type != error_mark_node)
8077         {
8078           /* Cleanups for static variables are handled by `finish_file'.  */
8079           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8080               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8081             expand_static_init (decl, init);
8082         }
8083     finish_end0:
8084
8085       /* Undo call to `pushclass' that was done in `start_decl'
8086          due to initialization of qualified member variable.
8087          I.e., Foo::x = 10;  */
8088       {
8089         tree context = CP_DECL_CONTEXT (decl);
8090         if (context
8091             && TYPE_P (context)
8092             && (TREE_CODE (decl) == VAR_DECL
8093                 /* We also have a pushclass done that we need to undo here
8094                    if we're at top level and declare a method.  */
8095                 || TREE_CODE (decl) == FUNCTION_DECL)
8096             /* If size hasn't been set, we're still defining it,
8097                and therefore inside the class body; don't pop
8098                the binding level..  */
8099             && COMPLETE_TYPE_P (context)
8100             && context == current_class_type)
8101           pop_nested_class ();
8102       }
8103     }
8104
8105  finish_end:
8106
8107   if (was_readonly)
8108     TREE_READONLY (decl) = 1;
8109 }
8110
8111 /* This is here for a midend callback from c-common.c */
8112
8113 void
8114 finish_decl (decl, init, asmspec_tree)
8115      tree decl, init;
8116      tree asmspec_tree;
8117 {
8118   cp_finish_decl (decl, init, asmspec_tree, 0);
8119 }
8120
8121 /* Returns a declaration for a VAR_DECL as if:
8122
8123      extern "C" TYPE NAME;
8124
8125    had been seen.  Used to create compiler-generated global
8126    variables.  */
8127
8128 tree
8129 declare_global_var (name, type)
8130      tree name;
8131      tree type;
8132 {
8133   tree decl;
8134
8135   push_to_top_level ();
8136   decl = build_decl (VAR_DECL, name, type);
8137   TREE_PUBLIC (decl) = 1;
8138   DECL_EXTERNAL (decl) = 1;
8139   DECL_ARTIFICIAL (decl) = 1;
8140   pushdecl (decl);
8141   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8142   pop_from_top_level ();
8143
8144   return decl;
8145 }
8146
8147 /* Returns a pointer to the `atexit' function.  Note that if
8148    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8149    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8150
8151 static tree
8152 get_atexit_node ()
8153 {
8154   tree atexit_fndecl;
8155   tree arg_types;
8156   tree fn_type;
8157   tree fn_ptr_type;
8158   const char *name;
8159
8160   if (atexit_node)
8161     return atexit_node;
8162
8163   if (flag_use_cxa_atexit)
8164     {
8165       /* The declaration for `__cxa_atexit' is:
8166
8167            int __cxa_atexit (void (*)(void *), void *, void *)
8168
8169          We build up the argument types and then then function type
8170          itself.  */
8171
8172       /* First, build the pointer-to-function type for the first
8173          argument.  */
8174       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8175       fn_type = build_function_type (void_type_node, arg_types);
8176       fn_ptr_type = build_pointer_type (fn_type);
8177       /* Then, build the rest of the argument types.  */
8178       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8179       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8180       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8181       /* And the final __cxa_atexit type.  */
8182       fn_type = build_function_type (integer_type_node, arg_types);
8183       fn_ptr_type = build_pointer_type (fn_type);
8184       name = "__cxa_atexit";
8185     }
8186   else
8187     {
8188       /* The declaration for `atexit' is:
8189
8190            int atexit (void (*)());
8191
8192          We build up the argument types and then then function type
8193          itself.  */
8194       fn_type = build_function_type (void_type_node, void_list_node);
8195       fn_ptr_type = build_pointer_type (fn_type);
8196       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8197       /* Build the final atexit type.  */
8198       fn_type = build_function_type (integer_type_node, arg_types);
8199       name = "atexit";
8200     }
8201
8202   /* Now, build the function declaration.  */
8203   push_lang_context (lang_name_c);
8204   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8205   mark_used (atexit_fndecl);
8206   pop_lang_context ();
8207   atexit_node = default_conversion (atexit_fndecl);
8208
8209   return atexit_node;
8210 }
8211
8212 /* Returns the __dso_handle VAR_DECL.  */
8213
8214 static tree
8215 get_dso_handle_node ()
8216 {
8217   if (dso_handle_node)
8218     return dso_handle_node;
8219
8220   /* Declare the variable.  */
8221   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8222                                         ptr_type_node);
8223
8224   return dso_handle_node;
8225 }
8226
8227 /* Begin a new function with internal linkage whose job will be simply
8228    to destroy some particular variable.  */
8229
8230 static tree
8231 start_cleanup_fn ()
8232 {
8233   static int counter = 0;
8234   int old_interface_unknown = interface_unknown;
8235   char name[32];
8236   tree parmtypes;
8237   tree fntype;
8238   tree fndecl;
8239
8240   push_to_top_level ();
8241
8242   /* No need to mangle this.  */
8243   push_lang_context (lang_name_c);
8244
8245   interface_unknown = 1;
8246
8247   /* Build the parameter-types.  */
8248   parmtypes = void_list_node;
8249   /* Functions passed to __cxa_atexit take an additional parameter.
8250      We'll just ignore it.  After we implement the new calling
8251      convention for destructors, we can eliminate the use of
8252      additional cleanup functions entirely in the -fnew-abi case.  */
8253   if (flag_use_cxa_atexit)
8254     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8255   /* Build the function type itself.  */
8256   fntype = build_function_type (void_type_node, parmtypes);
8257   /* Build the name of the function.  */
8258   sprintf (name, "__tcf_%d", counter++);
8259   /* Build the function declaration.  */
8260   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8261   /* It's a function with internal linkage, generated by the
8262      compiler.  */
8263   TREE_PUBLIC (fndecl) = 0;
8264   DECL_ARTIFICIAL (fndecl) = 1;
8265   /* Make the function `inline' so that it is only emitted if it is
8266      actually needed.  It is unlikely that it will be inlined, since
8267      it is only called via a function pointer, but we avoid unncessary
8268      emissions this way.  */
8269   DECL_INLINE (fndecl) = 1;
8270   /* Build the parameter.  */
8271   if (flag_use_cxa_atexit)
8272     {
8273       tree parmdecl;
8274
8275       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8276       DECL_CONTEXT (parmdecl) = fndecl;
8277       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8278       TREE_USED (parmdecl) = 1;
8279       DECL_ARGUMENTS (fndecl) = parmdecl;
8280     }
8281
8282   pushdecl (fndecl);
8283   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8284   do_pushlevel ();
8285
8286   interface_unknown = old_interface_unknown;
8287
8288   pop_lang_context ();
8289
8290   return current_function_decl;
8291 }
8292
8293 /* Finish the cleanup function begun by start_cleanup_fn.  */
8294
8295 static void
8296 end_cleanup_fn ()
8297 {
8298   do_poplevel ();
8299
8300   expand_body (finish_function (0));
8301
8302   pop_from_top_level ();
8303 }
8304
8305 /* Generate code to handle the destruction of DECL, an object with
8306    static storage duration.  */
8307
8308 void
8309 register_dtor_fn (decl)
8310      tree decl;
8311 {
8312   tree cleanup;
8313   tree compound_stmt;
8314   tree args;
8315   tree fcall;
8316
8317   int saved_flag_access_control;
8318
8319   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8320     return;
8321
8322   /* Call build_cleanup before we enter the anonymous function so that
8323      any access checks will be done relative to the current scope,
8324      rather than the scope of the anonymous function.  */
8325   build_cleanup (decl);
8326
8327   /* Now start the function.  */
8328   cleanup = start_cleanup_fn ();
8329
8330   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8331      to the original function, rather than the anonymous one.  That
8332      will make the back-end think that nested functions are in use,
8333      which causes confusion.  */
8334   saved_flag_access_control = flag_access_control;
8335   flag_access_control = 0;
8336   fcall = build_cleanup (decl);
8337   flag_access_control = saved_flag_access_control;
8338
8339   /* Create the body of the anonymous function.  */
8340   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8341   finish_expr_stmt (fcall);
8342   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8343   end_cleanup_fn ();
8344
8345   /* Call atexit with the cleanup function.  */
8346   mark_addressable (cleanup);
8347   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8348   if (flag_use_cxa_atexit)
8349     {
8350       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8351       args = tree_cons (NULL_TREE, null_pointer_node, args);
8352       args = tree_cons (NULL_TREE, cleanup, args);
8353     }
8354   else
8355     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8356   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8357 }
8358
8359 void
8360 expand_static_init (decl, init)
8361      tree decl;
8362      tree init;
8363 {
8364   tree oldstatic = value_member (decl, static_aggregates);
8365
8366   if (oldstatic)
8367     {
8368       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8369         cp_error ("multiple initializations given for `%D'", decl);
8370     }
8371   else if (! toplevel_bindings_p ())
8372     {
8373       /* Emit code to perform this initialization but once.  */
8374       tree if_stmt;
8375       tree then_clause;
8376       tree assignment;
8377       tree guard;
8378       tree guard_init;
8379
8380       /* Emit code to perform this initialization but once.  This code
8381          looks like:
8382
8383            static int guard = 0;
8384            if (!guard) {
8385              // Do initialization.
8386              guard = 1;
8387              // Register variable for destruction at end of program.
8388            }
8389
8390          Note that the `temp' variable is only set to 1 *after* the
8391          initialization is complete.  This ensures that an exception,
8392          thrown during the construction, will cause the variable to
8393          reinitialized when we pass through this code again, as per:
8394
8395            [stmt.dcl]
8396
8397            If the initialization exits by throwing an exception, the
8398            initialization is not complete, so it will be tried again
8399            the next time control enters the declaration.
8400
8401          In theory, this process should be thread-safe, too; multiple
8402          threads should not be able to initialize the variable more
8403          than once.  We don't yet attempt to ensure thread-safety.  */
8404
8405       /* Create the guard variable.  */
8406       guard = get_guard (decl);
8407
8408       /* Begin the conditional initialization.  */
8409       if_stmt = begin_if_stmt ();
8410       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8411       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8412
8413       /* Do the initialization itself.  */
8414       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8415           || (init && TREE_CODE (init) == TREE_LIST))
8416         assignment = build_aggr_init (decl, init, 0);
8417       else if (init)
8418         /* The initialization we're doing here is just a bitwise
8419            copy.  */
8420         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8421       else
8422         assignment = NULL_TREE;
8423
8424       /* Once the assignment is complete, set TEMP to 1.  Since the
8425          construction of the static object is complete at this point,
8426          we want to make sure TEMP is set to 1 even if a temporary
8427          constructed during the initialization throws an exception
8428          when it is destroyed.  So, we combine the initialization and
8429          the assignment to TEMP into a single expression, ensuring
8430          that when we call finish_expr_stmt the cleanups will not be
8431          run until after TEMP is set to 1.  */
8432       guard_init = set_guard (guard);
8433       if (assignment)
8434         {
8435           assignment = tree_cons (NULL_TREE, assignment,
8436                                   build_tree_list (NULL_TREE,
8437                                                    guard_init));
8438           assignment = build_compound_expr (assignment);
8439         }
8440       else
8441         assignment = guard_init;
8442       finish_expr_stmt (assignment);
8443
8444       /* Use atexit to register a function for destroying this static
8445          variable.  */
8446       register_dtor_fn (decl);
8447
8448       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8449       finish_then_clause (if_stmt);
8450       finish_if_stmt ();
8451     }
8452   else
8453     static_aggregates = tree_cons (init, decl, static_aggregates);
8454 }
8455
8456 /* Finish the declaration of a catch-parameter.  */
8457
8458 tree
8459 start_handler_parms (declspecs, declarator)
8460      tree declspecs;
8461      tree declarator;
8462 {
8463   tree decl;
8464   if (declspecs)
8465     {
8466       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8467                              1, NULL_TREE);
8468       if (decl == NULL_TREE)
8469         error ("invalid catch parameter");
8470     }
8471   else
8472     decl = NULL_TREE;
8473
8474   return decl;
8475 }
8476
8477 \f
8478 /* Make TYPE a complete type based on INITIAL_VALUE.
8479    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8480    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8481
8482 int
8483 complete_array_type (type, initial_value, do_default)
8484      tree type, initial_value;
8485      int do_default;
8486 {
8487   register tree maxindex = NULL_TREE;
8488   int value = 0;
8489
8490   if (initial_value)
8491     {
8492       /* An array of character type can be initialized from a
8493          brace-enclosed string constant.  */
8494       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8495           && TREE_CODE (initial_value) == CONSTRUCTOR
8496           && CONSTRUCTOR_ELTS (initial_value)
8497           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8498               == STRING_CST)
8499           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8500         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8501
8502       /* Note MAXINDEX is really the maximum index, one less than the
8503          size.  */
8504       if (TREE_CODE (initial_value) == STRING_CST)
8505         {
8506           int eltsize
8507             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8508           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8509                                    / eltsize) - 1, 0);
8510         }
8511       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8512         {
8513           tree elts = CONSTRUCTOR_ELTS (initial_value);
8514
8515           maxindex = ssize_int (-1);
8516           for (; elts; elts = TREE_CHAIN (elts))
8517             {
8518               if (TREE_PURPOSE (elts))
8519                 maxindex = TREE_PURPOSE (elts);
8520               else
8521                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8522             }
8523           maxindex = copy_node (maxindex);
8524         }
8525       else
8526         {
8527           /* Make an error message unless that happened already.  */
8528           if (initial_value != error_mark_node)
8529             value = 1;
8530           else
8531             initial_value = NULL_TREE;
8532
8533           /* Prevent further error messages.  */
8534           maxindex = build_int_2 (0, 0);
8535         }
8536     }
8537
8538   if (!maxindex)
8539     {
8540       if (do_default)
8541         maxindex = build_int_2 (0, 0);
8542       value = 2;
8543     }
8544
8545   if (maxindex)
8546     {
8547       tree itype;
8548       tree domain;
8549
8550       domain = build_index_type (maxindex);
8551       TYPE_DOMAIN (type) = domain;
8552
8553       if (! TREE_TYPE (maxindex))
8554         TREE_TYPE (maxindex) = domain;
8555       if (initial_value)
8556         itype = TREE_TYPE (initial_value);
8557       else
8558         itype = NULL;
8559       if (itype && !TYPE_DOMAIN (itype))
8560         TYPE_DOMAIN (itype) = domain;
8561       /* The type of the main variant should never be used for arrays
8562          of different sizes.  It should only ever be completed with the
8563          size of the array.  */
8564       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8565         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8566     }
8567
8568   /* Lay out the type now that we can get the real answer.  */
8569
8570   layout_type (type);
8571
8572   return value;
8573 }
8574 \f
8575 /* Return zero if something is declared to be a member of type
8576    CTYPE when in the context of CUR_TYPE.  STRING is the error
8577    message to print in that case.  Otherwise, quietly return 1.  */
8578
8579 static int
8580 member_function_or_else (ctype, cur_type, flags)
8581      tree ctype, cur_type;
8582      enum overload_flags flags;
8583 {
8584   if (ctype && ctype != cur_type)
8585     {
8586       if (flags == DTOR_FLAG)
8587         cp_error ("destructor for alien class `%T' cannot be a member",
8588                   ctype);
8589       else
8590         cp_error ("constructor for alien class `%T' cannot be a member",
8591                   ctype);
8592       return 0;
8593     }
8594   return 1;
8595 }
8596 \f
8597 /* Subroutine of `grokdeclarator'.  */
8598
8599 /* Generate errors possibly applicable for a given set of specifiers.
8600    This is for ARM $7.1.2.  */
8601
8602 static void
8603 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8604      tree object;
8605      const char *type;
8606      int virtualp, quals, friendp, raises, inlinep;
8607 {
8608   if (virtualp)
8609     cp_error ("`%D' declared as a `virtual' %s", object, type);
8610   if (inlinep)
8611     cp_error ("`%D' declared as an `inline' %s", object, type);
8612   if (quals)
8613     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8614               object, type);
8615   if (friendp)
8616     cp_error_at ("`%D' declared as a friend", object);
8617   if (raises)
8618     cp_error_at ("`%D' declared with an exception specification", object);
8619 }
8620
8621 /* CTYPE is class type, or null if non-class.
8622    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8623    or METHOD_TYPE.
8624    DECLARATOR is the function's name.
8625    VIRTUALP is truthvalue of whether the function is virtual or not.
8626    FLAGS are to be passed through to `grokclassfn'.
8627    QUALS are qualifiers indicating whether the function is `const'
8628    or `volatile'.
8629    RAISES is a list of exceptions that this function can raise.
8630    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8631    not look, and -1 if we should not call `grokclassfn' at all.
8632
8633    Returns `NULL_TREE' if something goes wrong, after issuing
8634    applicable error messages.  */
8635
8636 static tree
8637 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8638             raises, check, friendp, publicp, inlinep, funcdef_flag,
8639             template_count, in_namespace)
8640      tree ctype, type;
8641      tree declarator;
8642      tree orig_declarator;
8643      int virtualp;
8644      enum overload_flags flags;
8645      tree quals, raises;
8646      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8647      tree in_namespace;
8648 {
8649   tree cname, decl;
8650   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8651   int has_default_arg = 0;
8652   tree t;
8653
8654   if (ctype)
8655     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8656       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8657   else
8658     cname = NULL_TREE;
8659
8660   if (raises)
8661     {
8662       type = build_exception_variant (type, raises);
8663     }
8664
8665   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8666   /* Propagate volatile out from type to decl. */
8667   if (TYPE_VOLATILE (type))
8668     TREE_THIS_VOLATILE (decl) = 1;
8669
8670   /* If this decl has namespace scope, set that up.  */
8671   if (in_namespace)
8672     set_decl_namespace (decl, in_namespace, friendp);
8673   else if (!ctype)
8674     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8675
8676   /* `main' and builtins have implicit 'C' linkage.  */
8677   if ((MAIN_NAME_P (declarator)
8678        || (IDENTIFIER_LENGTH (declarator) > 10
8679            && IDENTIFIER_POINTER (declarator)[0] == '_'
8680            && IDENTIFIER_POINTER (declarator)[1] == '_'
8681            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8682       && current_lang_name == lang_name_cplusplus
8683       && ctype == NULL_TREE
8684       /* NULL_TREE means global namespace.  */
8685       && DECL_CONTEXT (decl) == NULL_TREE)
8686     DECL_LANGUAGE (decl) = lang_c;
8687
8688   /* Should probably propagate const out from type to decl I bet (mrs).  */
8689   if (staticp)
8690     {
8691       DECL_STATIC_FUNCTION_P (decl) = 1;
8692       DECL_CONTEXT (decl) = ctype;
8693     }
8694
8695   if (ctype)
8696     DECL_CONTEXT (decl) = ctype;
8697
8698   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8699     {
8700       if (processing_template_decl)
8701         error ("cannot declare `::main' to be a template");
8702       if (inlinep)
8703         error ("cannot declare `::main' to be inline");
8704       if (!publicp)
8705         error ("cannot declare `::main' to be static");
8706       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8707                         integer_type_node))
8708         error ("`main' must return `int'");
8709       inlinep = 0;
8710       publicp = 1;
8711     }
8712
8713   /* Members of anonymous types and local classes have no linkage; make
8714      them internal.  */
8715   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8716                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8717     publicp = 0;
8718
8719   if (publicp)
8720     {
8721       /* [basic.link]: A name with no linkage (notably, the name of a class
8722          or enumeration declared in a local scope) shall not be used to
8723          declare an entity with linkage.
8724
8725          Only check this for public decls for now.  */
8726       t = no_linkage_check (TREE_TYPE (decl));
8727       if (t)
8728         {
8729           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8730             {
8731               if (DECL_EXTERN_C_P (decl))
8732                 /* Allow this; it's pretty common in C.  */;
8733               else
8734                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8735                             decl);
8736             }
8737           else
8738             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8739                         decl, t);
8740         }
8741     }
8742
8743   TREE_PUBLIC (decl) = publicp;
8744   if (! publicp)
8745     {
8746       DECL_INTERFACE_KNOWN (decl) = 1;
8747       DECL_NOT_REALLY_EXTERN (decl) = 1;
8748     }
8749
8750   if (inlinep)
8751     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8752
8753   DECL_EXTERNAL (decl) = 1;
8754   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8755     {
8756       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8757                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8758       quals = NULL_TREE;
8759     }
8760
8761   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8762     grok_op_properties (decl, virtualp, check < 0);
8763
8764   if (ctype && decl_function_context (decl))
8765     DECL_NO_STATIC_CHAIN (decl) = 1;
8766
8767   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8768     if (TREE_PURPOSE (t)
8769         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8770       {
8771         has_default_arg = 1;
8772         break;
8773       }
8774
8775   if (friendp
8776       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8777     {
8778       if (funcdef_flag)
8779         cp_error
8780           ("defining explicit specialization `%D' in friend declaration",
8781            orig_declarator);
8782       else
8783         {
8784           tree fns = TREE_OPERAND (orig_declarator, 0);
8785           tree args = TREE_OPERAND (orig_declarator, 1);
8786
8787           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8788             {
8789               /* Something like `template <class T> friend void f<T>()'.  */
8790               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8791                         orig_declarator);
8792               return NULL_TREE;
8793             }
8794
8795
8796           /* A friend declaration of the form friend void f<>().  Record
8797              the information in the TEMPLATE_ID_EXPR.  */
8798           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8799
8800           if (TREE_CODE (fns) == COMPONENT_REF)
8801             {
8802               /* Due to bison parser ickiness, we will have already looked
8803                  up an operator_name or PFUNCNAME within the current class
8804                  (see template_id in parse.y). If the current class contains
8805                  such a name, we'll get a COMPONENT_REF here. Undo that. */
8806
8807               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
8808                                   == current_class_type, 20001120);
8809               fns = TREE_OPERAND (fns, 1);
8810             }
8811           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
8812                               || TREE_CODE (fns) == LOOKUP_EXPR
8813                               || TREE_CODE (fns) == OVERLOAD, 20001120);
8814           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
8815
8816           if (has_default_arg)
8817             {
8818               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8819                         decl);
8820               return NULL_TREE;
8821             }
8822
8823           if (inlinep)
8824             {
8825               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8826                         decl);
8827               return NULL_TREE;
8828             }
8829         }
8830     }
8831
8832   if (has_default_arg)
8833     add_defarg_fn (decl);
8834
8835   /* Plain overloading: will not be grok'd by grokclassfn.  */
8836   if (! ctype && ! processing_template_decl
8837       && (! DECL_EXTERN_C_P (decl) || DECL_OVERLOADED_OPERATOR_P (decl))
8838       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8839     set_mangled_name_for_decl (decl);
8840
8841   if (funcdef_flag)
8842     /* Make the init_value nonzero so pushdecl knows this is not
8843        tentative.  error_mark_node is replaced later with the BLOCK.  */
8844     DECL_INITIAL (decl) = error_mark_node;
8845
8846   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8847     TREE_NOTHROW (decl) = 1;
8848
8849   /* Caller will do the rest of this.  */
8850   if (check < 0)
8851     return decl;
8852
8853   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8854     DECL_CONSTRUCTOR_P (decl) = 1;
8855
8856   /* Function gets the ugly name, field gets the nice one.  This call
8857      may change the type of the function (because of default
8858      parameters)!  */
8859   if (ctype != NULL_TREE)
8860     grokclassfn (ctype, decl, flags, quals);
8861
8862   decl = check_explicit_specialization (orig_declarator, decl,
8863                                         template_count,
8864                                         2 * (funcdef_flag != 0) +
8865                                         4 * (friendp != 0));
8866   if (decl == error_mark_node)
8867     return NULL_TREE;
8868
8869   if (ctype != NULL_TREE
8870       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8871       && check)
8872     {
8873       tree old_decl;
8874
8875       old_decl = check_classfn (ctype, decl);
8876
8877       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
8878         /* Because grokfndecl is always supposed to return a
8879            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8880            here.  We depend on our callers to figure out that its
8881            really a template that's being returned.  */
8882         old_decl = DECL_TEMPLATE_RESULT (old_decl);
8883
8884       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
8885           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8886         {
8887           /* Remove the `this' parm added by grokclassfn.
8888              XXX Isn't this done in start_function, too?  */
8889           revert_static_member_fn (decl);
8890           last_function_parms = TREE_CHAIN (last_function_parms);
8891         }
8892       if (old_decl && DECL_ARTIFICIAL (old_decl))
8893         cp_error ("definition of implicitly-declared `%D'", old_decl);
8894
8895       if (old_decl)
8896         {
8897           /* Since we've smashed OLD_DECL to its
8898              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
8899           if (TREE_CODE (decl) == TEMPLATE_DECL)
8900             decl = DECL_TEMPLATE_RESULT (decl);
8901
8902           /* Attempt to merge the declarations.  This can fail, in
8903              the case of some illegal specialization declarations.  */
8904           if (!duplicate_decls (decl, old_decl))
8905             cp_error ("no `%#D' member function declared in class `%T'",
8906                       decl, ctype);
8907           return old_decl;
8908         }
8909     }
8910
8911   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
8912     return NULL_TREE;
8913
8914   if (ctype == NULL_TREE || check)
8915     return decl;
8916
8917   if (virtualp)
8918     DECL_VIRTUAL_P (decl) = 1;
8919
8920   return decl;
8921 }
8922
8923 static tree
8924 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
8925      tree type;
8926      tree declarator;
8927      RID_BIT_TYPE *specbits_in;
8928      int initialized;
8929      int constp;
8930      tree in_namespace;
8931 {
8932   tree decl;
8933   RID_BIT_TYPE specbits;
8934
8935   specbits = *specbits_in;
8936
8937   if (TREE_CODE (type) == OFFSET_TYPE)
8938     {
8939       /* If you declare a static member so that it
8940          can be initialized, the code will reach here.  */
8941       tree basetype = TYPE_OFFSET_BASETYPE (type);
8942       type = TREE_TYPE (type);
8943       decl = build_lang_decl (VAR_DECL, declarator, type);
8944       DECL_CONTEXT (decl) = basetype;
8945       /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
8946          templates.  */
8947       if (!uses_template_parms (decl))
8948         DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
8949     }
8950   else
8951     {
8952       tree context;
8953
8954       if (in_namespace)
8955         context = in_namespace;
8956       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
8957         context = current_namespace;
8958       else
8959         context = NULL_TREE;
8960
8961       if (processing_template_decl && context)
8962         /* For global variables, declared in a template, we need the
8963            full lang_decl.  */
8964         decl = build_lang_decl (VAR_DECL, declarator, type);
8965       else
8966         decl = build_decl (VAR_DECL, declarator, type);
8967
8968       if (context)
8969         set_decl_namespace (decl, context, 0);
8970
8971       context = DECL_CONTEXT (decl);
8972       if (declarator && context && current_lang_name != lang_name_c)
8973         DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
8974     }
8975
8976   if (in_namespace)
8977     set_decl_namespace (decl, in_namespace, 0);
8978
8979   if (RIDBIT_SETP (RID_EXTERN, specbits))
8980     {
8981       DECL_THIS_EXTERN (decl) = 1;
8982       DECL_EXTERNAL (decl) = !initialized;
8983     }
8984
8985   /* In class context, static means one per class,
8986      public access, and static storage.  */
8987   if (DECL_CLASS_SCOPE_P (decl))
8988     {
8989       TREE_PUBLIC (decl) = 1;
8990       TREE_STATIC (decl) = 1;
8991       DECL_EXTERNAL (decl) = 0;
8992     }
8993   /* At top level, either `static' or no s.c. makes a definition
8994      (perhaps tentative), and absence of `static' makes it public.  */
8995   else if (toplevel_bindings_p ())
8996     {
8997       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
8998                             && (DECL_THIS_EXTERN (decl) || ! constp));
8999       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9000     }
9001   /* Not at top level, only `static' makes a static definition.  */
9002   else
9003     {
9004       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9005       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9006     }
9007
9008   if (TREE_PUBLIC (decl))
9009     {
9010       /* [basic.link]: A name with no linkage (notably, the name of a class
9011          or enumeration declared in a local scope) shall not be used to
9012          declare an entity with linkage.
9013
9014          Only check this for public decls for now.  */
9015       tree t = no_linkage_check (TREE_TYPE (decl));
9016       if (t)
9017         {
9018           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9019             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9020           else
9021             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9022                         decl, t);
9023         }
9024     }
9025
9026   return decl;
9027 }
9028
9029 /* Create and return a canonical pointer to member function type, for
9030    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9031
9032 tree
9033 build_ptrmemfunc_type (type)
9034      tree type;
9035 {
9036   tree fields[4];
9037   tree t;
9038   tree unqualified_variant = NULL_TREE;
9039
9040   if (type == error_mark_node)
9041     return type;
9042
9043   /* If a canonical type already exists for this type, use it.  We use
9044      this method instead of type_hash_canon, because it only does a
9045      simple equality check on the list of field members.  */
9046
9047   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9048     return t;
9049
9050   /* Make sure that we always have the unqualified pointer-to-member
9051      type first.  */
9052   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9053     unqualified_variant
9054       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9055
9056   t = make_aggr_type (RECORD_TYPE);
9057   /* Let the front-end know this is a pointer to member function...  */
9058   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9059   /* ... and not really an aggregate.  */
9060   SET_IS_AGGR_TYPE (t, 0);
9061
9062   fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9063   fields[1] = build_decl (FIELD_DECL, delta_identifier,
9064                           delta_type_node);
9065   finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9066
9067   /* Zap out the name so that the back-end will give us the debugging
9068      information for this anonymous RECORD_TYPE.  */
9069   TYPE_NAME (t) = NULL_TREE;
9070
9071   /* If this is not the unqualified form of this pointer-to-member
9072      type, set the TYPE_MAIN_VARIANT for this type to be the
9073      unqualified type.  Since they are actually RECORD_TYPEs that are
9074      not variants of each other, we must do this manually.  */
9075   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9076     {
9077       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9078       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9079       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9080       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9081     }
9082
9083   /* Cache this pointer-to-member type so that we can find it again
9084      later.  */
9085   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9086
9087   /* Seems to be wanted.  */
9088   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9089
9090   return t;
9091 }
9092
9093 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9094    Check to see that the definition is valid.  Issue appropriate error
9095    messages.  Return 1 if the definition is particularly bad, or 0
9096    otherwise.  */
9097
9098 int
9099 check_static_variable_definition (decl, type)
9100      tree decl;
9101      tree type;
9102 {
9103   /* Motion 10 at San Diego: If a static const integral data member is
9104      initialized with an integral constant expression, the initializer
9105      may appear either in the declaration (within the class), or in
9106      the definition, but not both.  If it appears in the class, the
9107      member is a member constant.  The file-scope definition is always
9108      required.  */
9109   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9110     {
9111       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9112                 type);
9113       /* If we just return the declaration, crashes will sometimes
9114          occur.  We therefore return void_type_node, as if this was a
9115          friend declaration, to cause callers to completely ignore
9116          this declaration.  */
9117       return 1;
9118     }
9119   else if (!CP_TYPE_CONST_P (type))
9120     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9121               decl);
9122   else if (pedantic && !INTEGRAL_TYPE_P (type))
9123     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9124
9125   return 0;
9126 }
9127
9128 /* Given the SIZE (i.e., number of elements) in an array, compute an
9129    appropriate index type for the array.  If non-NULL, NAME is the
9130    name of the thing being declared.  */
9131
9132 tree
9133 compute_array_index_type (name, size)
9134      tree name;
9135      tree size;
9136 {
9137   tree itype;
9138
9139   /* The size might be the result of a cast. */
9140   STRIP_TYPE_NOPS (size);
9141
9142   /* It might be a const variable or enumeration constant.  */
9143   size = decl_constant_value (size);
9144
9145   /* If this involves a template parameter, it will be a constant at
9146      instantiation time, but we don't know what the value is yet.
9147      Even if no template parameters are involved, we may an expression
9148      that is not a constant; we don't even simplify `1 + 2' when
9149      processing a template.  */
9150   if (processing_template_decl)
9151     {
9152       /* Resolve a qualified reference to an enumerator or static
9153          const data member of ours.  */
9154       if (TREE_CODE (size) == SCOPE_REF
9155           && TREE_OPERAND (size, 0) == current_class_type)
9156         {
9157           tree t = lookup_field (current_class_type,
9158                                  TREE_OPERAND (size, 1), 0, 0);
9159           if (t)
9160             size = t;
9161         }
9162
9163       return build_index_type (build_min (MINUS_EXPR, sizetype,
9164                                           size, integer_one_node));
9165     }
9166
9167   /* The array bound must be an integer type.  */
9168   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9169       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9170       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9171     {
9172       if (name)
9173         cp_error ("size of array `%D' has non-integer type", name);
9174       else
9175         cp_error ("size of array has non-integer type");
9176       size = integer_one_node;
9177     }
9178
9179   /* Normally, the array-bound will be a constant.  */
9180   if (TREE_CODE (size) == INTEGER_CST)
9181     {
9182       /* Check to see if the array bound overflowed.  Make that an
9183          error, no matter how generous we're being.  */
9184       int old_flag_pedantic_errors = flag_pedantic_errors;
9185       int old_pedantic = pedantic;
9186       pedantic = flag_pedantic_errors = 1;
9187       constant_expression_warning (size);
9188       pedantic = old_pedantic;
9189       flag_pedantic_errors = old_flag_pedantic_errors;
9190
9191       /* An array must have a positive number of elements.  */
9192       if (INT_CST_LT (size, integer_zero_node))
9193         {
9194           if (name)
9195             cp_error ("size of array `%D' is negative", name);
9196           else
9197             cp_error ("size of array is negative");
9198           size = integer_one_node;
9199         }
9200       /* Except that an extension we allow zero-sized arrays.  We
9201          always allow them in system headers because glibc uses
9202          them.  */
9203       else if (integer_zerop (size) && pedantic && !in_system_header)
9204         {
9205           if (name)
9206             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9207           else
9208             cp_pedwarn ("ISO C++ forbids zero-size array");
9209         }
9210     }
9211   else if (TREE_CONSTANT (size))
9212     {
9213       /* `(int) &fn' is not a valid array bound.  */
9214       if (name)
9215         cp_error ("size of array `%D' is not an integral constant-expression",
9216                   name);
9217       else
9218         cp_error ("size of array is not an integral constant-expression");
9219     }
9220
9221   /* Compute the index of the largest element in the array.  It is
9222      one less than the number of elements in the array.  */
9223   itype
9224     = fold (cp_build_binary_op (MINUS_EXPR,
9225                                 cp_convert (ssizetype, size),
9226                                 cp_convert (ssizetype,
9227                                             integer_one_node)));
9228
9229   /* Check for variable-sized arrays.  We allow such things as an
9230      extension, even though they are not allowed in ANSI/ISO C++.  */
9231   if (!TREE_CONSTANT (itype))
9232     {
9233       if (pedantic)
9234         {
9235           if (name)
9236             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9237                         name);
9238           else
9239             cp_pedwarn ("ISO C++ forbids variable-size array");
9240         }
9241
9242       /* Create a variable-sized array index type.  */
9243       itype = variable_size (itype);
9244     }
9245   /* Make sure that there was no overflow when creating to a signed
9246      index type.  (For example, on a 32-bit machine, an array with
9247      size 2^32 - 1 is too big.)  */
9248   else if (TREE_OVERFLOW (itype))
9249     {
9250       error ("overflow in array dimension");
9251       TREE_OVERFLOW (itype) = 0;
9252     }
9253
9254   /* Create and return the appropriate index type.  */
9255   return build_index_type (itype);
9256 }
9257
9258 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9259    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9260    with this type.  */
9261
9262 static tree
9263 create_array_type_for_decl (name, type, size)
9264      tree name;
9265      tree type;
9266      tree size;
9267 {
9268   tree itype = NULL_TREE;
9269   const char* error_msg;
9270
9271   /* If things have already gone awry, bail now.  */
9272   if (type == error_mark_node || size == error_mark_node)
9273     return error_mark_node;
9274
9275   /* Assume that everything will go OK.  */
9276   error_msg = NULL;
9277
9278   /* There are some types which cannot be array elements.  */
9279   switch (TREE_CODE (type))
9280     {
9281     case VOID_TYPE:
9282       error_msg = "array of void";
9283       break;
9284
9285     case FUNCTION_TYPE:
9286       error_msg = "array of functions";
9287       break;
9288
9289     case REFERENCE_TYPE:
9290       error_msg = "array of references";
9291       break;
9292
9293     case OFFSET_TYPE:
9294       error_msg = "array of data members";
9295       break;
9296
9297     case METHOD_TYPE:
9298       error_msg = "array of function members";
9299       break;
9300
9301     default:
9302       break;
9303     }
9304
9305   /* If something went wrong, issue an error-message and return.  */
9306   if (error_msg)
9307     {
9308       if (name)
9309         cp_error ("declaration of `%D' as %s", name, error_msg);
9310       else
9311         cp_error ("creating %s", error_msg);
9312
9313       return error_mark_node;
9314     }
9315
9316   /* [dcl.array]
9317
9318      The constant expressions that specify the bounds of the arrays
9319      can be omitted only for the first member of the sequence.  */
9320   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9321     {
9322       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9323                 name);
9324
9325       return error_mark_node;
9326     }
9327
9328   /* Figure out the index type for the array.  */
9329   if (size)
9330     itype = compute_array_index_type (name, size);
9331
9332   return build_cplus_array_type (type, itype);
9333 }
9334
9335 /* Check that it's OK to declare a function with the indicated TYPE.
9336    SFK indicates the kind of special function (if any) that this
9337    function is.  OPTYPE is the type given in a conversion operator
9338    declaration.  Returns the actual return type of the function; that
9339    may be different than TYPE if an error occurs, or for certain
9340    special functions.  */
9341
9342 static tree
9343 check_special_function_return_type (sfk, type, optype)
9344      special_function_kind sfk;
9345      tree type;
9346      tree optype;
9347 {
9348   switch (sfk)
9349     {
9350     case sfk_constructor:
9351       if (type)
9352         cp_error ("return type specification for constructor invalid");
9353
9354       /* In the new ABI constructors do not return a value.  */
9355       type = void_type_node;
9356       break;
9357
9358     case sfk_destructor:
9359       if (type)
9360         cp_error ("return type specification for destructor invalid");
9361       type = void_type_node;
9362       break;
9363
9364     case sfk_conversion:
9365       if (type && !same_type_p (type, optype))
9366         cp_error ("operator `%T' declared to return `%T'", optype, type);
9367       else if (type)
9368         cp_pedwarn ("return type specified for `operator %T'",  optype);
9369       type = optype;
9370       break;
9371
9372     default:
9373       my_friendly_abort (20000408);
9374       break;
9375     }
9376
9377   return type;
9378 }
9379
9380 /* Given declspecs and a declarator,
9381    determine the name and type of the object declared
9382    and construct a ..._DECL node for it.
9383    (In one case we can return a ..._TYPE node instead.
9384     For invalid input we sometimes return 0.)
9385
9386    DECLSPECS is a chain of tree_list nodes whose value fields
9387     are the storage classes and type specifiers.
9388
9389    DECL_CONTEXT says which syntactic context this declaration is in:
9390      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9391      FUNCDEF for a function definition.  Like NORMAL but a few different
9392       error messages in each case.  Return value may be zero meaning
9393       this definition is too screwy to try to parse.
9394      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9395       handle member functions (which have FIELD context).
9396       Return value may be zero meaning this definition is too screwy to
9397       try to parse.
9398      PARM for a parameter declaration (either within a function prototype
9399       or before a function body).  Make a PARM_DECL, or return void_type_node.
9400      CATCHPARM for a parameter declaration before a catch clause.
9401      TYPENAME if for a typename (in a cast or sizeof).
9402       Don't make a DECL node; just return the ..._TYPE node.
9403      FIELD for a struct or union field; make a FIELD_DECL.
9404      BITFIELD for a field with specified width.
9405    INITIALIZED is 1 if the decl has an initializer.
9406
9407    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9408    normal attributes in TREE_PURPOSE, or NULL_TREE.
9409
9410    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9411    It may also be so in the PARM case, for a prototype where the
9412    argument type is specified but not the name.
9413
9414    This function is where the complicated C meanings of `static'
9415    and `extern' are interpreted.
9416
9417    For C++, if there is any monkey business to do, the function which
9418    calls this one must do it, i.e., prepending instance variables,
9419    renaming overloaded function names, etc.
9420
9421    Note that for this C++, it is an error to define a method within a class
9422    which does not belong to that class.
9423
9424    Except in the case where SCOPE_REFs are implicitly known (such as
9425    methods within a class being redundantly qualified),
9426    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9427    (class_name::decl_name).  The caller must also deal with this.
9428
9429    If a constructor or destructor is seen, and the context is FIELD,
9430    then the type gains the attribute TREE_HAS_x.  If such a declaration
9431    is erroneous, NULL_TREE is returned.
9432
9433    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9434    function, these are the qualifiers to give to the `this' pointer. We
9435    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9436
9437    May return void_type_node if the declarator turned out to be a friend.
9438    See grokfield for details.  */
9439
9440 tree
9441 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9442      tree declspecs;
9443      tree declarator;
9444      enum decl_context decl_context;
9445      int initialized;
9446      tree attrlist;
9447 {
9448   RID_BIT_TYPE specbits;
9449   int nclasses = 0;
9450   tree spec;
9451   tree type = NULL_TREE;
9452   int longlong = 0;
9453   int constp;
9454   int restrictp;
9455   int volatilep;
9456   int type_quals;
9457   int virtualp, explicitp, friendp, inlinep, staticp;
9458   int explicit_int = 0;
9459   int explicit_char = 0;
9460   int defaulted_int = 0;
9461   tree typedef_decl = NULL_TREE;
9462   const char *name;
9463   tree typedef_type = NULL_TREE;
9464   int funcdef_flag = 0;
9465   enum tree_code innermost_code = ERROR_MARK;
9466   int bitfield = 0;
9467 #if 0
9468   /* See the code below that used this.  */
9469   tree decl_machine_attr = NULL_TREE;
9470 #endif
9471   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9472      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9473   tree init = NULL_TREE;
9474
9475   /* Keep track of what sort of function is being processed
9476      so that we can warn about default return values, or explicit
9477      return values which do not match prescribed defaults.  */
9478   special_function_kind sfk = sfk_none;
9479
9480   tree dname = NULL_TREE;
9481   tree ctype = current_class_type;
9482   tree ctor_return_type = NULL_TREE;
9483   enum overload_flags flags = NO_SPECIAL;
9484   tree quals = NULL_TREE;
9485   tree raises = NULL_TREE;
9486   int template_count = 0;
9487   tree in_namespace = NULL_TREE;
9488   tree inner_attrs;
9489   int ignore_attrs;
9490
9491   RIDBIT_RESET_ALL (specbits);
9492   if (decl_context == FUNCDEF)
9493     funcdef_flag = 1, decl_context = NORMAL;
9494   else if (decl_context == MEMFUNCDEF)
9495     funcdef_flag = -1, decl_context = FIELD;
9496   else if (decl_context == BITFIELD)
9497     bitfield = 1, decl_context = FIELD;
9498
9499   /* Look inside a declarator for the name being declared
9500      and get it as a string, for an error message.  */
9501   {
9502     tree *next = &declarator;
9503     register tree decl;
9504     name = NULL;
9505
9506     while (next && *next)
9507       {
9508         decl = *next;
9509         switch (TREE_CODE (decl))
9510           {
9511           case TREE_LIST:
9512             /* For attributes.  */
9513             next = &TREE_VALUE (decl);
9514             break;
9515
9516           case COND_EXPR:
9517             ctype = NULL_TREE;
9518             next = &TREE_OPERAND (decl, 0);
9519             break;
9520
9521           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9522             {
9523               tree name = TREE_OPERAND (decl, 0);
9524               tree rename = NULL_TREE;
9525
9526               my_friendly_assert (flags == NO_SPECIAL, 152);
9527               flags = DTOR_FLAG;
9528               sfk = sfk_destructor;
9529               if (TREE_CODE (name) == TYPE_DECL)
9530                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9531               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9532               if (ctype == NULL_TREE)
9533                 {
9534                   if (current_class_type == NULL_TREE)
9535                     {
9536                       error ("destructors must be member functions");
9537                       flags = NO_SPECIAL;
9538                     }
9539                   else
9540                     {
9541                       tree t = constructor_name (current_class_name);
9542                       if (t != name)
9543                         rename = t;
9544                     }
9545                 }
9546               else
9547                 {
9548                   tree t = constructor_name (ctype);
9549                   if (t != name)
9550                     rename = t;
9551                 }
9552
9553               if (rename)
9554                 {
9555                   cp_error ("destructor `%T' must match class name `%T'",
9556                             name, rename);
9557                   TREE_OPERAND (decl, 0) = rename;
9558                 }
9559               next = &name;
9560             }
9561             break;
9562
9563           case ADDR_EXPR:       /* C++ reference declaration */
9564             /* Fall through. */
9565           case ARRAY_REF:
9566           case INDIRECT_REF:
9567             ctype = NULL_TREE;
9568             innermost_code = TREE_CODE (decl);
9569             next = &TREE_OPERAND (decl, 0);
9570             break;
9571
9572           case CALL_EXPR:
9573             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9574               {
9575                 /* This is actually a variable declaration using
9576                    constructor syntax.  We need to call start_decl and
9577                    cp_finish_decl so we can get the variable
9578                    initialized...  */
9579
9580                 tree attributes, prefix_attributes;
9581
9582                 *next = TREE_OPERAND (decl, 0);
9583                 init = CALL_DECLARATOR_PARMS (decl);
9584
9585                 if (attrlist)
9586                   {
9587                     attributes = TREE_PURPOSE (attrlist);
9588                     prefix_attributes = TREE_VALUE (attrlist);
9589                   }
9590                 else
9591                   {
9592                     attributes = NULL_TREE;
9593                     prefix_attributes = NULL_TREE;
9594                   }
9595
9596                 decl = start_decl (declarator, declspecs, 1,
9597                                    attributes, prefix_attributes);
9598                 decl_type_access_control (decl);
9599                 if (decl)
9600                   {
9601                     /* Look for __unused__ attribute */
9602                     if (TREE_USED (TREE_TYPE (decl)))
9603                       TREE_USED (decl) = 1;
9604                     finish_decl (decl, init, NULL_TREE);
9605                   }
9606                 else
9607                   cp_error ("invalid declarator");
9608                 return 0;
9609               }
9610             innermost_code = TREE_CODE (decl);
9611             if (decl_context == FIELD && ctype == NULL_TREE)
9612               ctype = current_class_type;
9613             if (ctype
9614                 && TREE_OPERAND (decl, 0)
9615                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9616                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9617                          == constructor_name_full (ctype))
9618                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9619                             == constructor_name (ctype)))))
9620               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9621             next = &TREE_OPERAND (decl, 0);
9622             decl = *next;
9623             if (ctype != NULL_TREE
9624                 && decl != NULL_TREE && flags != DTOR_FLAG
9625                 && decl == constructor_name (ctype))
9626               {
9627                 sfk = sfk_constructor;
9628                 ctor_return_type = ctype;
9629               }
9630             ctype = NULL_TREE;
9631             break;
9632
9633           case TEMPLATE_ID_EXPR:
9634               {
9635                 tree fns = TREE_OPERAND (decl, 0);
9636
9637                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9638                   fns = TREE_OPERAND (fns, 0);
9639
9640                 dname = fns;
9641                 if (TREE_CODE (dname) == COMPONENT_REF)
9642                   dname = TREE_OPERAND (dname, 1);
9643                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9644                   {
9645                     my_friendly_assert (is_overloaded_fn (dname),
9646                                         19990331);
9647                     dname = DECL_NAME (get_first_fn (dname));
9648                   }
9649               }
9650           /* Fall through. */
9651
9652           case IDENTIFIER_NODE:
9653             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9654               dname = decl;
9655
9656             next = 0;
9657
9658             if (C_IS_RESERVED_WORD (dname))
9659               {
9660                 cp_error ("declarator-id missing; using reserved word `%D'",
9661                           dname);
9662                 name = IDENTIFIER_POINTER (dname);
9663               }
9664             else if (!IDENTIFIER_TYPENAME_P (dname))
9665               name = IDENTIFIER_POINTER (dname);
9666             else
9667               {
9668                 my_friendly_assert (flags == NO_SPECIAL, 154);
9669                 flags = TYPENAME_FLAG;
9670                 ctor_return_type = TREE_TYPE (dname);
9671                 sfk = sfk_conversion;
9672                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9673                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9674                         == TYPE_DECL))
9675                   name = IDENTIFIER_POINTER (dname);
9676                 else
9677                   name = "<invalid operator>";
9678               }
9679             break;
9680
9681             /* C++ extension */
9682           case SCOPE_REF:
9683             {
9684               /* Perform error checking, and decide on a ctype.  */
9685               tree cname = TREE_OPERAND (decl, 0);
9686               if (cname == NULL_TREE)
9687                 ctype = NULL_TREE;
9688               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9689                 {
9690                   ctype = NULL_TREE;
9691                   in_namespace = TREE_OPERAND (decl, 0);
9692                   TREE_OPERAND (decl, 0) = NULL_TREE;
9693                 }
9694               else if (! is_aggr_type (cname, 1))
9695                 TREE_OPERAND (decl, 0) = NULL_TREE;
9696               /* Must test TREE_OPERAND (decl, 1), in case user gives
9697                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9698               else if (TREE_OPERAND (decl, 1)
9699                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9700                 ctype = cname;
9701               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9702                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9703                 {
9704                   cp_error ("`%T::%D' is not a valid declarator", cname,
9705                             TREE_OPERAND (decl, 1));
9706                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9707                             cname, TREE_OPERAND (decl, 1));
9708                   return void_type_node;
9709                 }
9710               else if (ctype == NULL_TREE)
9711                 ctype = cname;
9712               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9713                 TREE_OPERAND (decl, 0) = ctype;
9714               else
9715                 {
9716                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9717                     {
9718                       cp_error ("type `%T' is not derived from type `%T'",
9719                                 cname, ctype);
9720                       TREE_OPERAND (decl, 0) = NULL_TREE;
9721                     }
9722                   else
9723                     ctype = cname;
9724                 }
9725
9726               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9727                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9728                        == constructor_name_full (ctype))
9729                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9730                           == constructor_name (ctype))))
9731                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9732               next = &TREE_OPERAND (decl, 1);
9733               decl = *next;
9734               if (ctype)
9735                 {
9736                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9737                       && constructor_name (ctype) == decl)
9738                     {
9739                       sfk = sfk_constructor;
9740                       ctor_return_type = ctype;
9741                     }
9742                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9743                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9744                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9745                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9746                     {
9747                       sfk = sfk_destructor;
9748                       ctor_return_type = ctype;
9749                       flags = DTOR_FLAG;
9750                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9751                       next = &TREE_OPERAND (decl, 0);
9752                     }
9753                 }
9754             }
9755             break;
9756
9757           case ERROR_MARK:
9758             next = 0;
9759             break;
9760
9761           case TYPE_DECL:
9762             /* Parse error puts this typespec where
9763                a declarator should go.  */
9764             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9765             if (TREE_TYPE (decl) == current_class_type)
9766               cp_error ("  perhaps you want `%T' for a constructor",
9767                         current_class_name);
9768             dname = DECL_NAME (decl);
9769             name = IDENTIFIER_POINTER (dname);
9770
9771             /* Avoid giving two errors for this.  */
9772             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9773
9774             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9775             *next = dname;
9776             next = 0;
9777             break;
9778
9779           default:
9780             cp_compiler_error ("`%D' as declarator", decl);
9781             return 0; /* We used to do a 155 abort here.  */
9782           }
9783       }
9784   }
9785
9786   /* A function definition's declarator must have the form of
9787      a function declarator.  */
9788
9789   if (funcdef_flag && innermost_code != CALL_EXPR)
9790     return 0;
9791
9792   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9793       && innermost_code != CALL_EXPR
9794       && ! (ctype && declspecs == NULL_TREE))
9795     {
9796       cp_error ("declaration of `%D' as non-function", dname);
9797       return void_type_node;
9798     }
9799
9800   /* Anything declared one level down from the top level
9801      must be one of the parameters of a function
9802      (because the body is at least two levels down).  */
9803
9804   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9805      by not allowing C++ class definitions to specify their parameters
9806      with xdecls (must be spec.d in the parmlist).
9807
9808      Since we now wait to push a class scope until we are sure that
9809      we are in a legitimate method context, we must set oldcname
9810      explicitly (since current_class_name is not yet alive).
9811
9812      We also want to avoid calling this a PARM if it is in a namespace.  */
9813
9814   if (decl_context == NORMAL && !toplevel_bindings_p ())
9815     {
9816       struct binding_level *b = current_binding_level;
9817       current_binding_level = b->level_chain;
9818       if (current_binding_level != 0 && toplevel_bindings_p ())
9819         decl_context = PARM;
9820       current_binding_level = b;
9821     }
9822
9823   if (name == NULL)
9824     name = decl_context == PARM ? "parameter" : "type name";
9825
9826   /* Look through the decl specs and record which ones appear.
9827      Some typespecs are defined as built-in typenames.
9828      Others, the ones that are modifiers of other types,
9829      are represented by bits in SPECBITS: set the bits for
9830      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9831
9832      If there is a typedef name or a type, store the type in TYPE.
9833      This includes builtin typedefs such as `int'.
9834
9835      Set EXPLICIT_INT if the type is `int' or `char' and did not
9836      come from a user typedef.
9837
9838      Set LONGLONG if `long' is mentioned twice.
9839
9840      For C++, constructors and destructors have their own fast treatment.  */
9841
9842   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9843     {
9844       register int i;
9845       register tree id;
9846
9847       /* Certain parse errors slip through.  For example,
9848          `int class;' is not caught by the parser. Try
9849          weakly to recover here.  */
9850       if (TREE_CODE (spec) != TREE_LIST)
9851         return 0;
9852
9853       id = TREE_VALUE (spec);
9854
9855       if (TREE_CODE (id) == IDENTIFIER_NODE)
9856         {
9857           if (id == ridpointers[(int) RID_INT]
9858               || id == ridpointers[(int) RID_CHAR]
9859               || id == ridpointers[(int) RID_BOOL]
9860               || id == ridpointers[(int) RID_WCHAR])
9861             {
9862               if (type)
9863                 {
9864                   if (id == ridpointers[(int) RID_BOOL])
9865                     error ("`bool' is now a keyword");
9866                   else
9867                     cp_error ("extraneous `%T' ignored", id);
9868                 }
9869               else
9870                 {
9871                   if (id == ridpointers[(int) RID_INT])
9872                     explicit_int = 1;
9873                   else if (id == ridpointers[(int) RID_CHAR])
9874                     explicit_char = 1;
9875                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9876                 }
9877               goto found;
9878             }
9879           /* C++ aggregate types.  */
9880           if (IDENTIFIER_HAS_TYPE_VALUE (id))
9881             {
9882               if (type)
9883                 cp_error ("multiple declarations `%T' and `%T'", type, id);
9884               else
9885                 type = IDENTIFIER_TYPE_VALUE (id);
9886               goto found;
9887             }
9888
9889           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
9890             {
9891               if (ridpointers[i] == id)
9892                 {
9893                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
9894                     {
9895                       if (pedantic && ! in_system_header && warn_long_long)
9896                         pedwarn ("ISO C++ does not support `long long'");
9897                       if (longlong)
9898                         error ("`long long long' is too long for GCC");
9899                       else
9900                         longlong = 1;
9901                     }
9902                   else if (RIDBIT_SETP (i, specbits))
9903                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
9904                   RIDBIT_SET (i, specbits);
9905                   goto found;
9906                 }
9907             }
9908         }
9909       /* C++ aggregate types.  */
9910       else if (TREE_CODE (id) == TYPE_DECL)
9911         {
9912           if (type)
9913             cp_error ("multiple declarations `%T' and `%T'", type,
9914                       TREE_TYPE (id));
9915           else
9916             {
9917               type = TREE_TYPE (id);
9918               TREE_VALUE (spec) = type;
9919             }
9920           goto found;
9921         }
9922       if (type)
9923         error ("two or more data types in declaration of `%s'", name);
9924       else if (TREE_CODE (id) == IDENTIFIER_NODE)
9925         {
9926           register tree t = lookup_name (id, 1);
9927           if (!t || TREE_CODE (t) != TYPE_DECL)
9928             error ("`%s' fails to be a typedef or built in type",
9929                    IDENTIFIER_POINTER (id));
9930           else
9931             {
9932               type = TREE_TYPE (t);
9933 #if 0
9934               /* See the code below that used this.  */
9935               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
9936 #endif
9937               typedef_decl = t;
9938             }
9939         }
9940       else if (id != error_mark_node)
9941         /* Can't change CLASS nodes into RECORD nodes here!  */
9942         type = id;
9943
9944     found: ;
9945     }
9946
9947   typedef_type = type;
9948
9949   /* No type at all: default to `int', and set DEFAULTED_INT
9950      because it was not a user-defined typedef.  */
9951
9952   if (type == NULL_TREE
9953       && (RIDBIT_SETP (RID_SIGNED, specbits)
9954           || RIDBIT_SETP (RID_UNSIGNED, specbits)
9955           || RIDBIT_SETP (RID_LONG, specbits)
9956           || RIDBIT_SETP (RID_SHORT, specbits)))
9957     {
9958       /* These imply 'int'.  */
9959       type = integer_type_node;
9960       defaulted_int = 1;
9961     }
9962
9963   if (sfk != sfk_none)
9964     type = check_special_function_return_type (sfk, type,
9965                                                ctor_return_type);
9966   else if (type == NULL_TREE)
9967     {
9968       int is_main;
9969
9970       explicit_int = -1;
9971
9972           /* We handle `main' specially here, because 'main () { }' is so
9973              common.  With no options, it is allowed.  With -Wreturn-type,
9974              it is a warning.  It is only an error with -pedantic-errors.  */
9975       is_main = (funcdef_flag
9976                  && MAIN_NAME_P (dname)
9977                  && ctype == NULL_TREE
9978                  && in_namespace == NULL_TREE
9979                  && current_namespace == global_namespace);
9980
9981       if (in_system_header || flag_ms_extensions)
9982         /* Allow it, sigh.  */;
9983       else if (pedantic || ! is_main)
9984         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
9985                     name);
9986       else if (warn_return_type)
9987         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
9988                     name);
9989
9990       type = integer_type_node;
9991     }
9992
9993   ctype = NULL_TREE;
9994
9995   /* Now process the modifiers that were specified
9996      and check for invalid combinations.  */
9997
9998   /* Long double is a special combination.  */
9999
10000   if (RIDBIT_SETP (RID_LONG, specbits)
10001       && TYPE_MAIN_VARIANT (type) == double_type_node)
10002     {
10003       RIDBIT_RESET (RID_LONG, specbits);
10004       type = build_qualified_type (long_double_type_node,
10005                                    CP_TYPE_QUALS (type));
10006     }
10007
10008   /* Check all other uses of type modifiers.  */
10009
10010   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10011       || RIDBIT_SETP (RID_SIGNED, specbits)
10012       || RIDBIT_SETP (RID_LONG, specbits)
10013       || RIDBIT_SETP (RID_SHORT, specbits))
10014     {
10015       int ok = 0;
10016
10017       if (TREE_CODE (type) == REAL_TYPE)
10018         error ("short, signed or unsigned invalid for `%s'", name);
10019       else if (TREE_CODE (type) != INTEGER_TYPE)
10020         error ("long, short, signed or unsigned invalid for `%s'", name);
10021       else if (RIDBIT_SETP (RID_LONG, specbits)
10022                && RIDBIT_SETP (RID_SHORT, specbits))
10023         error ("long and short specified together for `%s'", name);
10024       else if ((RIDBIT_SETP (RID_LONG, specbits)
10025                 || RIDBIT_SETP (RID_SHORT, specbits))
10026                && explicit_char)
10027         error ("long or short specified with char for `%s'", name);
10028       else if ((RIDBIT_SETP (RID_LONG, specbits)
10029                 || RIDBIT_SETP (RID_SHORT, specbits))
10030                && TREE_CODE (type) == REAL_TYPE)
10031         error ("long or short specified with floating type for `%s'", name);
10032       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10033                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10034         error ("signed and unsigned given together for `%s'", name);
10035       else
10036         {
10037           ok = 1;
10038           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10039             {
10040               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10041                        name);
10042               if (flag_pedantic_errors)
10043                 ok = 0;
10044             }
10045         }
10046
10047       /* Discard the type modifiers if they are invalid.  */
10048       if (! ok)
10049         {
10050           RIDBIT_RESET (RID_UNSIGNED, specbits);
10051           RIDBIT_RESET (RID_SIGNED, specbits);
10052           RIDBIT_RESET (RID_LONG, specbits);
10053           RIDBIT_RESET (RID_SHORT, specbits);
10054           longlong = 0;
10055         }
10056     }
10057
10058   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10059       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10060     {
10061       error ("complex invalid for `%s'", name);
10062       RIDBIT_RESET (RID_COMPLEX, specbits);
10063     }
10064
10065   /* Decide whether an integer type is signed or not.
10066      Optionally treat bitfields as signed by default.  */
10067   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10068       /* [class.bit]
10069
10070          It is implementation-defined whether a plain (neither
10071          explicitly signed or unsigned) char, short, int, or long
10072          bit-field is signed or unsigned.
10073
10074          Naturally, we extend this to long long as well.  Note that
10075          this does not include wchar_t.  */
10076       || (bitfield && !flag_signed_bitfields
10077           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10078           /* A typedef for plain `int' without `signed' can be
10079              controlled just like plain `int', but a typedef for
10080              `signed int' cannot be so controlled.  */
10081           && !(typedef_decl
10082                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10083           && (TREE_CODE (type) == INTEGER_TYPE
10084               || TREE_CODE (type) == CHAR_TYPE)
10085           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10086     {
10087       if (longlong)
10088         type = long_long_unsigned_type_node;
10089       else if (RIDBIT_SETP (RID_LONG, specbits))
10090         type = long_unsigned_type_node;
10091       else if (RIDBIT_SETP (RID_SHORT, specbits))
10092         type = short_unsigned_type_node;
10093       else if (type == char_type_node)
10094         type = unsigned_char_type_node;
10095       else if (typedef_decl)
10096         type = unsigned_type (type);
10097       else
10098         type = unsigned_type_node;
10099     }
10100   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10101            && type == char_type_node)
10102     type = signed_char_type_node;
10103   else if (longlong)
10104     type = long_long_integer_type_node;
10105   else if (RIDBIT_SETP (RID_LONG, specbits))
10106     type = long_integer_type_node;
10107   else if (RIDBIT_SETP (RID_SHORT, specbits))
10108     type = short_integer_type_node;
10109
10110   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10111     {
10112       /* If we just have "complex", it is equivalent to
10113          "complex double", but if any modifiers at all are specified it is
10114          the complex form of TYPE.  E.g, "complex short" is
10115          "complex short int".  */
10116
10117       if (defaulted_int && ! longlong
10118           && ! (RIDBIT_SETP (RID_LONG, specbits)
10119                 || RIDBIT_SETP (RID_SHORT, specbits)
10120                 || RIDBIT_SETP (RID_SIGNED, specbits)
10121                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10122         type = complex_double_type_node;
10123       else if (type == integer_type_node)
10124         type = complex_integer_type_node;
10125       else if (type == float_type_node)
10126         type = complex_float_type_node;
10127       else if (type == double_type_node)
10128         type = complex_double_type_node;
10129       else if (type == long_double_type_node)
10130         type = complex_long_double_type_node;
10131       else
10132         type = build_complex_type (type);
10133     }
10134
10135   if (sfk == sfk_conversion
10136       && (RIDBIT_SETP (RID_CONST, specbits)
10137           || RIDBIT_SETP (RID_VOLATILE, specbits)
10138           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10139     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10140               ctor_return_type);
10141
10142   /* Set CONSTP if this declaration is `const', whether by
10143      explicit specification or via a typedef.
10144      Likewise for VOLATILEP.  */
10145
10146   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10147   restrictp =
10148     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10149   volatilep =
10150     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10151   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10152                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10153                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10154   type = cp_build_qualified_type (type, type_quals);
10155   staticp = 0;
10156   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10157   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10158   RIDBIT_RESET (RID_VIRTUAL, specbits);
10159   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10160   RIDBIT_RESET (RID_EXPLICIT, specbits);
10161
10162   if (RIDBIT_SETP (RID_STATIC, specbits))
10163     staticp = 1 + (decl_context == FIELD);
10164
10165   if (virtualp && staticp == 2)
10166     {
10167       cp_error ("member `%D' cannot be declared both virtual and static",
10168                 dname);
10169       staticp = 0;
10170     }
10171   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10172   RIDBIT_RESET (RID_FRIEND, specbits);
10173
10174   /* Warn if two storage classes are given. Default to `auto'.  */
10175
10176   if (RIDBIT_ANY_SET (specbits))
10177     {
10178       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10179       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10180       if (decl_context == PARM && nclasses > 0)
10181         error ("storage class specifiers invalid in parameter declarations");
10182       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10183         {
10184           if (decl_context == PARM)
10185             error ("typedef declaration invalid in parameter declaration");
10186           nclasses++;
10187         }
10188       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10189       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10190     }
10191
10192   /* Give error if `virtual' is used outside of class declaration.  */
10193   if (virtualp
10194       && (current_class_name == NULL_TREE || decl_context != FIELD))
10195     {
10196       error ("virtual outside class declaration");
10197       virtualp = 0;
10198     }
10199
10200   /* Static anonymous unions are dealt with here.  */
10201   if (staticp && decl_context == TYPENAME
10202       && TREE_CODE (declspecs) == TREE_LIST
10203       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10204     decl_context = FIELD;
10205
10206   /* Warn about storage classes that are invalid for certain
10207      kinds of declarations (parameters, typenames, etc.).  */
10208
10209   if (nclasses > 1)
10210     error ("multiple storage classes in declaration of `%s'", name);
10211   else if (decl_context != NORMAL && nclasses > 0)
10212     {
10213       if ((decl_context == PARM || decl_context == CATCHPARM)
10214           && (RIDBIT_SETP (RID_REGISTER, specbits)
10215               || RIDBIT_SETP (RID_AUTO, specbits)))
10216         ;
10217       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10218         ;
10219       else if (decl_context == FIELD
10220                /* C++ allows static class elements  */
10221                && RIDBIT_SETP (RID_STATIC, specbits))
10222         /* C++ also allows inlines and signed and unsigned elements,
10223            but in those cases we don't come in here.  */
10224         ;
10225       else
10226         {
10227           if (decl_context == FIELD)
10228             {
10229               tree tmp = NULL_TREE;
10230               register int op = 0;
10231
10232               if (declarator)
10233                 {
10234                   /* Avoid trying to get an operand off an identifier node.  */
10235                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10236                     tmp = declarator;
10237                   else
10238                     tmp = TREE_OPERAND (declarator, 0);
10239                   op = IDENTIFIER_OPNAME_P (tmp);
10240                   if (IDENTIFIER_TYPENAME_P (tmp))
10241                     {
10242                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10243                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10244                               == TYPE_DECL))
10245                         name = IDENTIFIER_POINTER (tmp);
10246                       else
10247                         name = "<invalid operator>";
10248                     }
10249                 }
10250               error ("storage class specified for %s `%s'",
10251                      op ? "member operator" : "field",
10252                      name);
10253             }
10254           else
10255             {
10256               if (decl_context == PARM || decl_context == CATCHPARM)
10257                 error ("storage class specified for parameter `%s'", name);
10258               else
10259                 error ("storage class specified for typename");
10260             }
10261           RIDBIT_RESET (RID_REGISTER, specbits);
10262           RIDBIT_RESET (RID_AUTO, specbits);
10263           RIDBIT_RESET (RID_EXTERN, specbits);
10264         }
10265     }
10266   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10267     {
10268       if (toplevel_bindings_p ())
10269         {
10270           /* It's common practice (and completely valid) to have a const
10271              be initialized and declared extern.  */
10272           if (!(type_quals & TYPE_QUAL_CONST))
10273             warning ("`%s' initialized and declared `extern'", name);
10274         }
10275       else
10276         error ("`%s' has both `extern' and initializer", name);
10277     }
10278   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10279            && ! toplevel_bindings_p ())
10280     error ("nested function `%s' declared `extern'", name);
10281   else if (toplevel_bindings_p ())
10282     {
10283       if (RIDBIT_SETP (RID_AUTO, specbits))
10284         error ("top-level declaration of `%s' specifies `auto'", name);
10285     }
10286
10287   if (nclasses > 0 && friendp)
10288     error ("storage class specifiers invalid in friend function declarations");
10289
10290   /* Now figure out the structure of the declarator proper.
10291      Descend through it, creating more complex types, until we reach
10292      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10293
10294   inner_attrs = NULL_TREE;
10295   ignore_attrs = 0;
10296
10297   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10298          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10299     {
10300       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10301          an INDIRECT_REF (for *...),
10302          a CALL_EXPR (for ...(...)),
10303          an identifier (for the name being declared)
10304          or a null pointer (for the place in an absolute declarator
10305          where the name was omitted).
10306          For the last two cases, we have just exited the loop.
10307
10308          For C++ it could also be
10309          a SCOPE_REF (for class :: ...).  In this case, we have converted
10310          sensible names to types, and those are the values we use to
10311          qualify the member name.
10312          an ADDR_EXPR (for &...),
10313          a BIT_NOT_EXPR (for destructors)
10314
10315          At this point, TYPE is the type of elements of an array,
10316          or for a function to return, or for a pointer to point to.
10317          After this sequence of ifs, TYPE is the type of the
10318          array or function or pointer, and DECLARATOR has had its
10319          outermost layer removed.  */
10320
10321       if (type == error_mark_node)
10322         {
10323           if (TREE_CODE (declarator) == SCOPE_REF)
10324             declarator = TREE_OPERAND (declarator, 1);
10325           else
10326             declarator = TREE_OPERAND (declarator, 0);
10327           continue;
10328         }
10329       if (quals != NULL_TREE
10330           && (declarator == NULL_TREE
10331               || TREE_CODE (declarator) != SCOPE_REF))
10332         {
10333           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10334             ctype = TYPE_METHOD_BASETYPE (type);
10335           if (ctype != NULL_TREE)
10336             {
10337               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10338               grok_method_quals (ctype, dummy, quals);
10339               type = TREE_TYPE (dummy);
10340               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10341               quals = NULL_TREE;
10342             }
10343         }
10344
10345       /* See the comment for the TREE_LIST case, below.  */
10346       if (ignore_attrs)
10347         ignore_attrs = 0;
10348       else if (inner_attrs)
10349         {
10350           decl_attributes (type, inner_attrs, NULL_TREE);
10351           inner_attrs = NULL_TREE;
10352         }
10353
10354       switch (TREE_CODE (declarator))
10355         {
10356         case TREE_LIST:
10357           {
10358             /* We encode a declarator with embedded attributes using
10359                a TREE_LIST.  The attributes apply to the declarator
10360                directly inside them, so we have to skip an iteration
10361                before applying them to the type.  If the declarator just
10362                inside is the declarator-id, we apply the attrs to the
10363                decl itself.  */
10364             inner_attrs = TREE_PURPOSE (declarator);
10365             ignore_attrs = 1;
10366             declarator = TREE_VALUE (declarator);
10367           }
10368           break;
10369
10370         case ARRAY_REF:
10371           {
10372             register tree size;
10373
10374             size = TREE_OPERAND (declarator, 1);
10375
10376             /* VC++ spells a zero-sized array with [].  */
10377             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10378                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10379               size = integer_zero_node;
10380
10381             declarator = TREE_OPERAND (declarator, 0);
10382
10383             type = create_array_type_for_decl (dname, type, size);
10384
10385             /* VLAs never work as fields. */
10386             if (decl_context == FIELD && !processing_template_decl
10387                 && TREE_CODE (type) == ARRAY_TYPE
10388                 && TYPE_DOMAIN (type) != NULL_TREE
10389                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10390               {
10391                 cp_error ("size of member `%D' is not constant", dname);
10392                 /* Proceed with arbitrary constant size, so that offset
10393                    computations don't get confused. */
10394                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10395                                                    integer_one_node);
10396               }
10397
10398             ctype = NULL_TREE;
10399           }
10400           break;
10401
10402         case CALL_EXPR:
10403           {
10404             tree arg_types;
10405             int funcdecl_p;
10406             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10407             tree inner_decl = TREE_OPERAND (declarator, 0);
10408
10409             /* Declaring a function type.
10410                Make sure we have a valid type for the function to return.  */
10411
10412             /* We now know that the TYPE_QUALS don't apply to the
10413                decl, but to its return type.  */
10414             type_quals = TYPE_UNQUALIFIED;
10415
10416             /* Warn about some types functions can't return.  */
10417
10418             if (TREE_CODE (type) == FUNCTION_TYPE)
10419               {
10420                 error ("`%s' declared as function returning a function", name);
10421                 type = integer_type_node;
10422               }
10423             if (TREE_CODE (type) == ARRAY_TYPE)
10424               {
10425                 error ("`%s' declared as function returning an array", name);
10426                 type = integer_type_node;
10427               }
10428
10429             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10430               inner_decl = TREE_OPERAND (inner_decl, 1);
10431
10432             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10433               inner_decl = dname;
10434
10435             /* Pick up type qualifiers which should be applied to `this'.  */
10436             quals = CALL_DECLARATOR_QUALS (declarator);
10437
10438             /* Pick up the exception specifications.  */
10439             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10440
10441             /* Say it's a definition only for the CALL_EXPR
10442                closest to the identifier.  */
10443             funcdecl_p
10444               = inner_decl
10445               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10446                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10447                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10448
10449             if (ctype == NULL_TREE
10450                 && decl_context == FIELD
10451                 && funcdecl_p
10452                 && (friendp == 0 || dname == current_class_name))
10453               ctype = current_class_type;
10454
10455             if (ctype && sfk == sfk_conversion)
10456               TYPE_HAS_CONVERSION (ctype) = 1;
10457             if (ctype && constructor_name (ctype) == dname)
10458               {
10459                 /* We are within a class's scope. If our declarator name
10460                    is the same as the class name, and we are defining
10461                    a function, then it is a constructor/destructor, and
10462                    therefore returns a void type.  */
10463
10464                 if (flags == DTOR_FLAG)
10465                   {
10466                     /* ISO C++ 12.4/2.  A destructor may not be
10467                        declared const or volatile.  A destructor may
10468                        not be static.  */
10469                     if (staticp == 2)
10470                       error ("destructor cannot be static member function");
10471                     if (quals)
10472                       {
10473                         cp_error ("destructors may not be `%s'",
10474                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10475                         quals = NULL_TREE;
10476                       }
10477                     if (decl_context == FIELD)
10478                       {
10479                         if (! member_function_or_else (ctype,
10480                                                        current_class_type,
10481                                                        flags))
10482                           return void_type_node;
10483                       }
10484                   }
10485                 else            /* It's a constructor.  */
10486                   {
10487                     if (explicitp == 1)
10488                       explicitp = 2;
10489                     /* ISO C++ 12.1.  A constructor may not be
10490                        declared const or volatile.  A constructor may
10491                        not be virtual.  A constructor may not be
10492                        static.  */
10493                     if (staticp == 2)
10494                       error ("constructor cannot be static member function");
10495                     if (virtualp)
10496                       {
10497                         pedwarn ("constructors cannot be declared virtual");
10498                         virtualp = 0;
10499                       }
10500                     if (quals)
10501                       {
10502                         cp_error ("constructors may not be `%s'",
10503                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10504                         quals = NULL_TREE;
10505                       }
10506                     {
10507                       RID_BIT_TYPE tmp_bits;
10508                       memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
10509                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10510                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10511                       if (RIDBIT_ANY_SET (tmp_bits))
10512                         error ("return value type specifier for constructor ignored");
10513                     }
10514                     if (decl_context == FIELD)
10515                       {
10516                         if (! member_function_or_else (ctype,
10517                                                        current_class_type,
10518                                                        flags))
10519                           return void_type_node;
10520                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10521                         if (sfk != sfk_constructor)
10522                           return NULL_TREE;
10523                       }
10524                   }
10525                 if (decl_context == FIELD)
10526                   staticp = 0;
10527               }
10528             else if (friendp)
10529               {
10530                 if (initialized)
10531                   error ("can't initialize friend function `%s'", name);
10532                 if (virtualp)
10533                   {
10534                     /* Cannot be both friend and virtual.  */
10535                     error ("virtual functions cannot be friends");
10536                     RIDBIT_RESET (RID_FRIEND, specbits);
10537                     friendp = 0;
10538                   }
10539                 if (decl_context == NORMAL)
10540                   error ("friend declaration not in class definition");
10541                 if (current_function_decl && funcdef_flag)
10542                   cp_error ("can't define friend function `%s' in a local class definition",
10543                             name);
10544               }
10545
10546             /* Construct the function type and go to the next
10547                inner layer of declarator.  */
10548
10549             declarator = TREE_OPERAND (declarator, 0);
10550
10551             /* FIXME: This is where default args should be fully
10552                processed.  */
10553
10554             arg_types = grokparms (inner_parms);
10555
10556             if (declarator && flags == DTOR_FLAG)
10557               {
10558                 /* A destructor declared in the body of a class will
10559                    be represented as a BIT_NOT_EXPR.  But, we just
10560                    want the underlying IDENTIFIER.  */
10561                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10562                   declarator = TREE_OPERAND (declarator, 0);
10563
10564                 if (arg_types != void_list_node)
10565                   {
10566                     cp_error ("destructors may not have parameters");
10567                     arg_types = void_list_node;
10568                     last_function_parms = NULL_TREE;
10569                   }
10570               }
10571
10572             /* ANSI says that `const int foo ();'
10573                does not make the function foo const.  */
10574             type = build_function_type (type, arg_types);
10575
10576             {
10577               tree t;
10578               for (t = arg_types; t; t = TREE_CHAIN (t))
10579                 if (TREE_PURPOSE (t)
10580                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10581                   {
10582                     add_defarg_fn (type);
10583                     break;
10584                   }
10585             }
10586           }
10587           break;
10588
10589         case ADDR_EXPR:
10590         case INDIRECT_REF:
10591           /* Filter out pointers-to-references and references-to-references.
10592              We can get these if a TYPE_DECL is used.  */
10593
10594           if (TREE_CODE (type) == REFERENCE_TYPE)
10595             {
10596               error ("cannot declare %s to references",
10597                      TREE_CODE (declarator) == ADDR_EXPR
10598                      ? "references" : "pointers");
10599               declarator = TREE_OPERAND (declarator, 0);
10600               continue;
10601             }
10602
10603           if (TREE_CODE (type) == OFFSET_TYPE
10604               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10605                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10606             {
10607               cp_error ("cannot declare pointer to `%#T' member",
10608                         TREE_TYPE (type));
10609               type = TREE_TYPE (type);
10610             }
10611
10612           /* Merge any constancy or volatility into the target type
10613              for the pointer.  */
10614
10615           /* We now know that the TYPE_QUALS don't apply to the decl,
10616              but to the target of the pointer.  */
10617           type_quals = TYPE_UNQUALIFIED;
10618
10619           if (TREE_CODE (declarator) == ADDR_EXPR)
10620             {
10621               if (TREE_CODE (type) == VOID_TYPE)
10622                 error ("invalid type: `void &'");
10623               else
10624                 type = build_reference_type (type);
10625             }
10626           else if (TREE_CODE (type) == METHOD_TYPE)
10627             type = build_ptrmemfunc_type (build_pointer_type (type));
10628           else
10629             type = build_pointer_type (type);
10630
10631           /* Process a list of type modifier keywords (such as
10632              const or volatile) that were given inside the `*' or `&'.  */
10633
10634           if (TREE_TYPE (declarator))
10635             {
10636               register tree typemodlist;
10637               int erred = 0;
10638
10639               constp = 0;
10640               volatilep = 0;
10641               restrictp = 0;
10642               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10643                    typemodlist = TREE_CHAIN (typemodlist))
10644                 {
10645                   tree qualifier = TREE_VALUE (typemodlist);
10646
10647                   if (qualifier == ridpointers[(int) RID_CONST])
10648                     constp++;
10649                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10650                     volatilep++;
10651                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10652                     restrictp++;
10653                   else if (!erred)
10654                     {
10655                       erred = 1;
10656                       error ("invalid type modifier within pointer declarator");
10657                     }
10658                 }
10659               if (constp > 1)
10660                 pedwarn ("duplicate `const'");
10661               if (volatilep > 1)
10662                 pedwarn ("duplicate `volatile'");
10663               if (restrictp > 1)
10664                 pedwarn ("duplicate `restrict'");
10665
10666               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10667                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10668                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10669               if (TREE_CODE (declarator) == ADDR_EXPR
10670                   && (constp || volatilep))
10671                 {
10672                   if (constp)
10673                     pedwarn ("discarding `const' applied to a reference");
10674                   if (volatilep)
10675                     pedwarn ("discarding `volatile' applied to a reference");
10676                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10677                 }
10678               type = cp_build_qualified_type (type, type_quals);
10679             }
10680           declarator = TREE_OPERAND (declarator, 0);
10681           ctype = NULL_TREE;
10682           break;
10683
10684         case SCOPE_REF:
10685           {
10686             /* We have converted type names to NULL_TREE if the
10687                name was bogus, or to a _TYPE node, if not.
10688
10689                The variable CTYPE holds the type we will ultimately
10690                resolve to.  The code here just needs to build
10691                up appropriate member types.  */
10692             tree sname = TREE_OPERAND (declarator, 1);
10693             tree t;
10694
10695             /* Destructors can have their visibilities changed as well.  */
10696             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10697               sname = TREE_OPERAND (sname, 0);
10698
10699             if (TREE_COMPLEXITY (declarator) == 0)
10700               /* This needs to be here, in case we are called
10701                  multiple times.  */ ;
10702             else if (TREE_COMPLEXITY (declarator) == -1)
10703               /* Namespace member. */
10704               pop_decl_namespace ();
10705             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10706               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10707             else if (! IS_AGGR_TYPE_CODE
10708                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10709               ;
10710             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10711               {
10712                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10713                    that refer to ctype.  They couldn't be resolved earlier
10714                    because we hadn't pushed into the class yet.
10715                    Example: resolve 'B<T>::type' in
10716                    'B<typename B<T>::type> B<T>::f () { }'.  */
10717                 if (current_template_parms
10718                     && uses_template_parms (type)
10719                     && uses_template_parms (current_class_type))
10720                   {
10721                     tree args = current_template_args ();
10722                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10723                   }
10724
10725                 /* This pop_nested_class corresponds to the
10726                    push_nested_class used to push into class scope for
10727                    parsing the argument list of a function decl, in
10728                    qualified_id.  */
10729                 pop_nested_class ();
10730                 TREE_COMPLEXITY (declarator) = current_class_depth;
10731               }
10732             else
10733               my_friendly_abort (16);
10734
10735             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10736               {
10737                 /* We had a reference to a global decl, or
10738                    perhaps we were given a non-aggregate typedef,
10739                    in which case we cleared this out, and should just
10740                    keep going as though it wasn't there.  */
10741                 declarator = sname;
10742                 continue;
10743               }
10744             ctype = TREE_OPERAND (declarator, 0);
10745
10746             t = ctype;
10747             while (t != NULL_TREE && CLASS_TYPE_P (t))
10748               {
10749                 /* You're supposed to have one `template <...>'
10750                    for every template class, but you don't need one
10751                    for a full specialization.  For example:
10752
10753                      template <class T> struct S{};
10754                      template <> struct S<int> { void f(); };
10755                      void S<int>::f () {}
10756
10757                    is correct; there shouldn't be a `template <>' for
10758                    the definition of `S<int>::f'.  */
10759                 if (CLASSTYPE_TEMPLATE_INFO (t)
10760                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10761                         || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
10762                     && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
10763                   template_count += 1;
10764
10765                 t = TYPE_MAIN_DECL (t);
10766                 t = DECL_CONTEXT (t);
10767               }
10768
10769             if (sname == NULL_TREE)
10770               goto done_scoping;
10771
10772             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10773               {
10774                 /* This is the `standard' use of the scoping operator:
10775                    basetype :: member .  */
10776
10777                 if (ctype == current_class_type)
10778                   {
10779                     /* class A {
10780                          void A::f ();
10781                        };
10782
10783                        Is this ill-formed?  */
10784
10785                     if (pedantic)
10786                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10787                                   ctype, name);
10788                   }
10789                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10790                   {
10791                     if (current_class_type == NULL_TREE || friendp)
10792                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10793                                                       TYPE_ARG_TYPES (type));
10794                     else
10795                       {
10796                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10797                                   ctype, name, current_class_type);
10798                         return void_type_node;
10799                       }
10800                   }
10801                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10802                          || COMPLETE_TYPE_P (complete_type (ctype)))
10803                   {
10804                     /* Have to move this code elsewhere in this function.
10805                        this code is used for i.e., typedef int A::M; M *pm;
10806
10807                        It is?  How? jason 10/2/94 */
10808
10809                     if (current_class_type)
10810                       {
10811                         cp_error ("cannot declare member `%T::%s' within `%T'",
10812                                   ctype, name, current_class_type);
10813                         return void_type_node;
10814                       }
10815                     type = build_offset_type (ctype, type);
10816                   }
10817                 else
10818                   {
10819                     incomplete_type_error (NULL_TREE, ctype);
10820                     return error_mark_node;
10821                   }
10822
10823                 declarator = sname;
10824               }
10825             else if (TREE_CODE (sname) == SCOPE_REF)
10826               my_friendly_abort (17);
10827             else
10828               {
10829               done_scoping:
10830                 declarator = TREE_OPERAND (declarator, 1);
10831                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10832                   /* In this case, we will deal with it later.  */
10833                   ;
10834                 else
10835                   {
10836                     if (TREE_CODE (type) == FUNCTION_TYPE)
10837                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10838                                                       TYPE_ARG_TYPES (type));
10839                     else
10840                       type = build_offset_type (ctype, type);
10841                   }
10842               }
10843           }
10844           break;
10845
10846         case BIT_NOT_EXPR:
10847           declarator = TREE_OPERAND (declarator, 0);
10848           break;
10849
10850         case RECORD_TYPE:
10851         case UNION_TYPE:
10852         case ENUMERAL_TYPE:
10853           declarator = NULL_TREE;
10854           break;
10855
10856         case ERROR_MARK:
10857           declarator = NULL_TREE;
10858           break;
10859
10860         default:
10861           my_friendly_abort (158);
10862         }
10863     }
10864
10865   /* See the comment for the TREE_LIST case, above.  */
10866   if (inner_attrs)
10867     {
10868       if (! ignore_attrs)
10869         decl_attributes (type, inner_attrs, NULL_TREE);
10870       else if (attrlist)
10871         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10872       else
10873         attrlist = build_tree_list (NULL_TREE, inner_attrs);
10874     }
10875
10876   /* Now TYPE has the actual type.  */
10877
10878   if (explicitp == 1 || (explicitp && friendp))
10879     {
10880       /* [dcl.fct.spec] The explicit specifier shall only be used in
10881          declarations of constructors within a class definition.  */
10882       error ("only declarations of constructors can be `explicit'");
10883       explicitp = 0;
10884     }
10885
10886   if (RIDBIT_SETP (RID_MUTABLE, specbits))
10887     {
10888       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
10889         {
10890           error ("non-member `%s' cannot be declared `mutable'", name);
10891           RIDBIT_RESET (RID_MUTABLE, specbits);
10892         }
10893       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
10894         {
10895           error ("non-object member `%s' cannot be declared `mutable'", name);
10896           RIDBIT_RESET (RID_MUTABLE, specbits);
10897         }
10898       else if (TREE_CODE (type) == FUNCTION_TYPE
10899                || TREE_CODE (type) == METHOD_TYPE)
10900         {
10901           error ("function `%s' cannot be declared `mutable'", name);
10902           RIDBIT_RESET (RID_MUTABLE, specbits);
10903         }
10904       else if (staticp)
10905         {
10906           error ("static `%s' cannot be declared `mutable'", name);
10907           RIDBIT_RESET (RID_MUTABLE, specbits);
10908         }
10909       else if (type_quals & TYPE_QUAL_CONST)
10910         {
10911           error ("const `%s' cannot be declared `mutable'", name);
10912           RIDBIT_RESET (RID_MUTABLE, specbits);
10913         }
10914     }
10915
10916   if (declarator == NULL_TREE
10917       || TREE_CODE (declarator) == IDENTIFIER_NODE
10918       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
10919           && (TREE_CODE (type) == FUNCTION_TYPE
10920               || TREE_CODE (type) == METHOD_TYPE)))
10921     /* OK */;
10922   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10923     {
10924       cp_error ("template-id `%D' used as a declarator", declarator);
10925       declarator = dname;
10926     }
10927   else
10928     /* Unexpected declarator format.  */
10929     my_friendly_abort (990210);
10930
10931   /* If this is declaring a typedef name, return a TYPE_DECL.  */
10932
10933   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
10934     {
10935       tree decl;
10936
10937       /* Note that the grammar rejects storage classes
10938          in typenames, fields or parameters.  */
10939       if (current_lang_name == lang_name_java)
10940         TYPE_FOR_JAVA (type) = 1;
10941
10942       if (decl_context == FIELD)
10943         {
10944           if (declarator == constructor_name (current_class_type))
10945             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
10946                         declarator);
10947           decl = build_lang_decl (TYPE_DECL, declarator, type);
10948         }
10949       else
10950         decl = build_decl (TYPE_DECL, declarator, type);
10951
10952       /* If the user declares "typedef struct {...} foo" then the
10953          struct will have an anonymous name.  Fill that name in now.
10954          Nothing can refer to it, so nothing needs know about the name
10955          change.  */
10956       if (type != error_mark_node
10957           && declarator
10958           && TYPE_NAME (type)
10959           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10960           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
10961           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
10962         {
10963           tree oldname = TYPE_NAME (type);
10964           tree t;
10965
10966           /* Replace the anonymous name with the real name everywhere.  */
10967           lookup_tag_reverse (type, declarator);
10968           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10969             if (TYPE_NAME (t) == oldname)
10970               TYPE_NAME (t) = decl;
10971
10972           if (TYPE_LANG_SPECIFIC (type))
10973             TYPE_WAS_ANONYMOUS (type) = 1;
10974
10975           /* If this is a typedef within a template class, the nested
10976              type is a (non-primary) template.  The name for the
10977              template needs updating as well.  */
10978           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
10979             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
10980               = TYPE_IDENTIFIER (type);
10981
10982           DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
10983
10984           /* FIXME remangle member functions; member functions of a
10985              type with external linkage have external linkage.  */
10986         }
10987
10988       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
10989         {
10990           cp_error_at ("typedef name may not be class-qualified", decl);
10991           return NULL_TREE;
10992         }
10993       else if (quals)
10994         {
10995           if (ctype == NULL_TREE)
10996             {
10997               if (TREE_CODE (type) != METHOD_TYPE)
10998                 cp_error_at ("invalid type qualifier for non-member function type", decl);
10999               else
11000                 ctype = TYPE_METHOD_BASETYPE (type);
11001             }
11002           if (ctype != NULL_TREE)
11003             grok_method_quals (ctype, decl, quals);
11004         }
11005
11006       if (RIDBIT_SETP (RID_SIGNED, specbits)
11007           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11008         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11009
11010       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11011                       inlinep, friendp, raises != NULL_TREE);
11012
11013       if (initialized)
11014         error ("typedef declaration includes an initializer");
11015
11016       return decl;
11017     }
11018
11019   /* Detect the case of an array type of unspecified size
11020      which came, as such, direct from a typedef name.
11021      We must copy the type, so that each identifier gets
11022      a distinct type, so that each identifier's size can be
11023      controlled separately by its own initializer.  */
11024
11025   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11026       && TYPE_DOMAIN (type) == NULL_TREE)
11027     {
11028       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11029     }
11030
11031   /* If this is a type name (such as, in a cast or sizeof),
11032      compute the type and return it now.  */
11033
11034   if (decl_context == TYPENAME)
11035     {
11036       /* Note that the grammar rejects storage classes
11037          in typenames, fields or parameters.  */
11038       if (type_quals != TYPE_UNQUALIFIED)
11039         type_quals = TYPE_UNQUALIFIED;
11040
11041       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11042       if (friendp)
11043         {
11044           if (type_quals != TYPE_UNQUALIFIED)
11045             {
11046               cp_error ("type qualifiers specified for friend class declaration");
11047               type_quals = TYPE_UNQUALIFIED;
11048             }
11049           if (inlinep)
11050             {
11051               cp_error ("`inline' specified for friend class declaration");
11052               inlinep = 0;
11053             }
11054
11055           /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11056              But don't allow implicit typenames except with a class-key.  */
11057           if (!current_aggr && (TREE_CODE (type) != TYPENAME_TYPE
11058                                 || IMPLICIT_TYPENAME_P (type)))
11059             {
11060               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11061                 cp_pedwarn ("template parameters cannot be friends");
11062               else if (TREE_CODE (type) == TYPENAME_TYPE)
11063                 cp_pedwarn ("\
11064 friend declaration requires class-key, i.e. `friend class %T::%T'",
11065                             constructor_name (current_class_type),
11066                             TYPE_IDENTIFIER (type));
11067               else
11068                 cp_pedwarn ("\
11069 friend declaration requires class-key, i.e. `friend %#T'",
11070                             type);
11071             }
11072
11073           /* Only try to do this stuff if we didn't already give up.  */
11074           if (type != integer_type_node)
11075             {
11076               decl_type_access_control (TYPE_NAME (type));
11077
11078               /* A friendly class?  */
11079               if (current_class_type)
11080                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11081               else
11082                 cp_error ("trying to make class `%T' a friend of global scope",
11083                           type);
11084
11085               type = void_type_node;
11086             }
11087         }
11088       else if (quals)
11089         {
11090           if (ctype == NULL_TREE)
11091             {
11092               if (TREE_CODE (type) != METHOD_TYPE)
11093                 cp_error ("invalid qualifiers on non-member function type");
11094               else
11095                 ctype = TYPE_METHOD_BASETYPE (type);
11096             }
11097           if (ctype)
11098             {
11099               tree dummy = build_decl (TYPE_DECL, declarator, type);
11100               grok_method_quals (ctype, dummy, quals);
11101               type = TREE_TYPE (dummy);
11102             }
11103         }
11104
11105       return type;
11106     }
11107   else if (declarator == NULL_TREE && decl_context != PARM
11108            && decl_context != CATCHPARM
11109            && TREE_CODE (type) != UNION_TYPE
11110            && ! bitfield)
11111     {
11112       cp_error ("abstract declarator `%T' used as declaration", type);
11113       declarator = make_anon_name ();
11114     }
11115
11116   /* `void' at top level (not within pointer)
11117      is allowed only in typedefs or type names.
11118      We don't complain about parms either, but that is because
11119      a better error message can be made later.  */
11120
11121   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11122     {
11123       if (! declarator)
11124         error ("unnamed variable or field declared void");
11125       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11126         {
11127           if (IDENTIFIER_OPNAME_P (declarator))
11128             my_friendly_abort (356);
11129           else
11130             error ("variable or field `%s' declared void", name);
11131         }
11132       else
11133         error ("variable or field declared void");
11134       type = integer_type_node;
11135     }
11136
11137   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11138      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11139
11140   if (decl_context == PARM || decl_context == CATCHPARM)
11141     {
11142       if (ctype || in_namespace)
11143         error ("cannot use `::' in parameter declaration");
11144
11145       /* A parameter declared as an array of T is really a pointer to T.
11146          One declared as a function is really a pointer to a function.
11147          One declared as a member is really a pointer to member.  */
11148
11149       if (TREE_CODE (type) == ARRAY_TYPE)
11150         {
11151           /* Transfer const-ness of array into that of type pointed to.  */
11152           type = build_pointer_type (TREE_TYPE (type));
11153           type_quals = TYPE_UNQUALIFIED;
11154         }
11155       else if (TREE_CODE (type) == FUNCTION_TYPE)
11156         type = build_pointer_type (type);
11157       else if (TREE_CODE (type) == OFFSET_TYPE)
11158         type = build_pointer_type (type);
11159     }
11160
11161   {
11162     register tree decl;
11163
11164     if (decl_context == PARM)
11165       {
11166         decl = build_decl (PARM_DECL, declarator, type);
11167
11168         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11169                         inlinep, friendp, raises != NULL_TREE);
11170
11171         /* Compute the type actually passed in the parmlist,
11172            for the case where there is no prototype.
11173            (For example, shorts and chars are passed as ints.)
11174            When there is a prototype, this is overridden later.  */
11175
11176         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11177       }
11178     else if (decl_context == FIELD)
11179       {
11180         if (type == error_mark_node)
11181           {
11182             /* Happens when declaring arrays of sizes which
11183                are error_mark_node, for example.  */
11184             decl = NULL_TREE;
11185           }
11186         else if (in_namespace && !friendp)
11187           {
11188             /* Something like struct S { int N::j; };  */
11189             cp_error ("invalid use of `::'");
11190             decl = NULL_TREE;
11191           }
11192         else if (TREE_CODE (type) == FUNCTION_TYPE)
11193           {
11194             int publicp = 0;
11195             tree function_context;
11196
11197             /* We catch the others as conflicts with the builtin
11198                typedefs.  */
11199             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11200               {
11201                 cp_error ("function `%D' cannot be declared friend",
11202                           declarator);
11203                 friendp = 0;
11204               }
11205
11206             if (friendp == 0)
11207               {
11208                 if (ctype == NULL_TREE)
11209                   ctype = current_class_type;
11210
11211                 if (ctype == NULL_TREE)
11212                   {
11213                     cp_error ("can't make `%D' into a method -- not in a class",
11214                               declarator);
11215                     return void_type_node;
11216                   }
11217
11218                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11219                    ARM 9.5 */
11220                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11221                   {
11222                     cp_error ("function `%D' declared virtual inside a union",
11223                               declarator);
11224                     return void_type_node;
11225                   }
11226
11227                 if (declarator == ansi_opname (NEW_EXPR)
11228                     || declarator == ansi_opname (VEC_NEW_EXPR)
11229                     || declarator == ansi_opname (DELETE_EXPR)
11230                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11231                   {
11232                     if (virtualp)
11233                       {
11234                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11235                                   declarator);
11236                         virtualp = 0;
11237                       }
11238                   }
11239                 else if (staticp < 2)
11240                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11241                                                   TYPE_ARG_TYPES (type));
11242               }
11243
11244             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11245             function_context = (ctype != NULL_TREE) ?
11246               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11247             publicp = (! friendp || ! staticp)
11248               && function_context == NULL_TREE;
11249             decl = grokfndecl (ctype, type,
11250                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11251                                ? declarator : dname,
11252                                declarator,
11253                                virtualp, flags, quals, raises,
11254                                friendp ? -1 : 0, friendp, publicp, inlinep,
11255                                funcdef_flag, template_count, in_namespace);
11256             if (decl == NULL_TREE)
11257               return decl;
11258 #if 0
11259             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11260             /* The decl and setting of decl_machine_attr is also turned off.  */
11261             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11262 #endif
11263
11264             /* [class.conv.ctor]
11265
11266                A constructor declared without the function-specifier
11267                explicit that can be called with a single parameter
11268                specifies a conversion from the type of its first
11269                parameter to the type of its class.  Such a constructor
11270                is called a converting constructor.  */
11271             if (explicitp == 2)
11272               DECL_NONCONVERTING_P (decl) = 1;
11273             else if (DECL_CONSTRUCTOR_P (decl))
11274               {
11275                 /* The constructor can be called with exactly one
11276                    parameter if there is at least one parameter, and
11277                    any subsequent parameters have default arguments.
11278                    We don't look at the first parameter, which is
11279                    really just the `this' parameter for the new
11280                    object.  */
11281                 tree arg_types =
11282                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11283
11284                 /* Skip the `in_chrg' argument too, if present.  */
11285                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11286                   arg_types = TREE_CHAIN (arg_types);
11287
11288                 if (arg_types == void_list_node
11289                     || (arg_types
11290                         && TREE_CHAIN (arg_types)
11291                         && TREE_CHAIN (arg_types) != void_list_node
11292                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11293                   DECL_NONCONVERTING_P (decl) = 1;
11294               }
11295           }
11296         else if (TREE_CODE (type) == METHOD_TYPE)
11297           {
11298             /* We only get here for friend declarations of
11299                members of other classes.  */
11300             /* All method decls are public, so tell grokfndecl to set
11301                TREE_PUBLIC, also.  */
11302             decl = grokfndecl (ctype, type, declarator, declarator,
11303                                virtualp, flags, quals, raises,
11304                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11305                                template_count, in_namespace);
11306             if (decl == NULL_TREE)
11307               return NULL_TREE;
11308           }
11309         else if (!staticp && ! processing_template_decl
11310                  && !COMPLETE_TYPE_P (complete_type (type))
11311                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11312           {
11313             if (declarator)
11314               cp_error ("field `%D' has incomplete type", declarator);
11315             else
11316               cp_error ("name `%T' has incomplete type", type);
11317
11318             /* If we're instantiating a template, tell them which
11319                instantiation made the field's type be incomplete.  */
11320             if (current_class_type
11321                 && TYPE_NAME (current_class_type)
11322                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11323                 && declspecs && TREE_VALUE (declspecs)
11324                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11325               cp_error ("  in instantiation of template `%T'",
11326                         current_class_type);
11327
11328             type = error_mark_node;
11329             decl = NULL_TREE;
11330           }
11331         else
11332           {
11333             if (friendp)
11334               {
11335                 error ("`%s' is neither function nor member function; cannot be declared friend",
11336                        IDENTIFIER_POINTER (declarator));
11337                 friendp = 0;
11338               }
11339             decl = NULL_TREE;
11340           }
11341
11342         if (friendp)
11343           {
11344             /* Friends are treated specially.  */
11345             if (ctype == current_class_type)
11346               warning ("member functions are implicitly friends of their class");
11347             else
11348               {
11349                 tree t = NULL_TREE;
11350                 if (decl && DECL_NAME (decl))
11351                   {
11352                     if (template_class_depth (current_class_type) == 0)
11353                       {
11354                         decl
11355                           = check_explicit_specialization
11356                           (declarator, decl,
11357                            template_count, 2 * (funcdef_flag != 0) + 4);
11358                         if (decl == error_mark_node)
11359                           return error_mark_node;
11360                       }
11361
11362                     t = do_friend (ctype, declarator, decl,
11363                                    last_function_parms, attrlist, flags, quals,
11364                                    funcdef_flag);
11365                   }
11366                 if (t && funcdef_flag)
11367                   return t;
11368
11369                 return void_type_node;
11370               }
11371           }
11372
11373         /* Structure field.  It may not be a function, except for C++ */
11374
11375         if (decl == NULL_TREE)
11376           {
11377             if (initialized)
11378               {
11379                 if (!staticp)
11380                   {
11381                     /* An attempt is being made to initialize a non-static
11382                        member.  But, from [class.mem]:
11383
11384                        4 A member-declarator can contain a
11385                        constant-initializer only if it declares a static
11386                        member (_class.static_) of integral or enumeration
11387                        type, see _class.static.data_.
11388
11389                        This used to be relatively common practice, but
11390                        the rest of the compiler does not correctly
11391                        handle the initialization unless the member is
11392                        static so we make it static below.  */
11393                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11394                                 declarator);
11395                     cp_pedwarn ("making `%D' static", declarator);
11396                     staticp = 1;
11397                   }
11398
11399                 if (uses_template_parms (type))
11400                   /* We'll check at instantiation time.  */
11401                   ;
11402                 else if (check_static_variable_definition (declarator,
11403                                                            type))
11404                   /* If we just return the declaration, crashes
11405                      will sometimes occur.  We therefore return
11406                      void_type_node, as if this was a friend
11407                      declaration, to cause callers to completely
11408                      ignore this declaration.  */
11409                   return void_type_node;
11410               }
11411
11412             /* 9.2p13 [class.mem] */
11413             if (declarator == constructor_name (current_class_type)
11414                 /* The standard does not allow non-static data members
11415                    here either, but we agreed at the 10/99 meeting
11416                    to change that in TC 1 so that they are allowed in
11417                    classes with no user-defined constructors.  */
11418                 && staticp)
11419               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11420                           declarator);
11421
11422             if (staticp)
11423               {
11424                 /* C++ allows static class members.  All other work
11425                    for this is done by grokfield.  */
11426                 decl = build_lang_decl (VAR_DECL, declarator, type);
11427                 TREE_STATIC (decl) = 1;
11428                 /* In class context, 'static' means public access.  */
11429                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11430               }
11431             else
11432               {
11433                 decl = build_decl (FIELD_DECL, declarator, type);
11434                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11435                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11436                   {
11437                     DECL_MUTABLE_P (decl) = 1;
11438                     RIDBIT_RESET (RID_MUTABLE, specbits);
11439                   }
11440               }
11441
11442             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11443                             inlinep, friendp, raises != NULL_TREE);
11444           }
11445       }
11446     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11447       {
11448         tree original_name;
11449         int publicp = 0;
11450
11451         if (! declarator)
11452           return NULL_TREE;
11453
11454         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11455           original_name = dname;
11456         else
11457           original_name = declarator;
11458
11459         if (RIDBIT_SETP (RID_AUTO, specbits))
11460           error ("storage class `auto' invalid for function `%s'", name);
11461         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11462           error ("storage class `register' invalid for function `%s'", name);
11463
11464         /* Function declaration not at top level.
11465            Storage classes other than `extern' are not allowed
11466            and `extern' makes no difference.  */
11467         if (! toplevel_bindings_p ()
11468             && (RIDBIT_SETP (RID_STATIC, specbits)
11469                 || RIDBIT_SETP (RID_INLINE, specbits))
11470             && pedantic)
11471           {
11472             if (RIDBIT_SETP (RID_STATIC, specbits))
11473               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11474             else
11475               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11476           }
11477
11478         if (ctype == NULL_TREE)
11479           {
11480             if (virtualp)
11481               {
11482                 error ("virtual non-class function `%s'", name);
11483                 virtualp = 0;
11484               }
11485           }
11486         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11487           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11488                                           TYPE_ARG_TYPES (type));
11489
11490         /* Record presence of `static'.  */
11491         publicp = (ctype != NULL_TREE
11492                    || RIDBIT_SETP (RID_EXTERN, specbits)
11493                    || !RIDBIT_SETP (RID_STATIC, specbits));
11494
11495         decl = grokfndecl (ctype, type, original_name, declarator,
11496                            virtualp, flags, quals, raises,
11497                            1, friendp,
11498                            publicp, inlinep, funcdef_flag,
11499                            template_count, in_namespace);
11500         if (decl == NULL_TREE)
11501           return NULL_TREE;
11502
11503         if (staticp == 1)
11504           {
11505             int illegal_static = 0;
11506
11507             /* Don't allow a static member function in a class, and forbid
11508                declaring main to be static.  */
11509             if (TREE_CODE (type) == METHOD_TYPE)
11510               {
11511                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11512                 illegal_static = 1;
11513               }
11514             else if (current_function_decl)
11515               {
11516                 /* FIXME need arm citation */
11517                 error ("cannot declare static function inside another function");
11518                 illegal_static = 1;
11519               }
11520
11521             if (illegal_static)
11522               {
11523                 staticp = 0;
11524                 RIDBIT_RESET (RID_STATIC, specbits);
11525               }
11526           }
11527       }
11528     else
11529       {
11530         /* It's a variable.  */
11531
11532         /* An uninitialized decl with `extern' is a reference.  */
11533         decl = grokvardecl (type, declarator, &specbits,
11534                             initialized,
11535                             (type_quals & TYPE_QUAL_CONST) != 0,
11536                             in_namespace);
11537         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11538                         inlinep, friendp, raises != NULL_TREE);
11539
11540         if (ctype)
11541           {
11542             DECL_CONTEXT (decl) = ctype;
11543             if (staticp == 1)
11544               {
11545                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11546                 staticp = 0;
11547                 RIDBIT_RESET (RID_STATIC, specbits);
11548               }
11549             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11550               {
11551                 cp_error ("static member `%D' declared `register'", decl);
11552                 RIDBIT_RESET (RID_REGISTER, specbits);
11553               }
11554             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11555               {
11556                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11557                             decl);
11558                 RIDBIT_RESET (RID_EXTERN, specbits);
11559               }
11560           }
11561       }
11562
11563     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11564
11565     /* Record `register' declaration for warnings on &
11566        and in case doing stupid register allocation.  */
11567
11568     if (RIDBIT_SETP (RID_REGISTER, specbits))
11569       DECL_REGISTER (decl) = 1;
11570
11571     if (RIDBIT_SETP (RID_EXTERN, specbits))
11572       DECL_THIS_EXTERN (decl) = 1;
11573
11574     if (RIDBIT_SETP (RID_STATIC, specbits))
11575       DECL_THIS_STATIC (decl) = 1;
11576
11577     /* Record constancy and volatility.  There's no need to do this
11578        when processing a template; we'll do this for the instantiated
11579        declaration based on the type of DECL.  */
11580     if (!processing_template_decl)
11581       c_apply_type_quals_to_decl (type_quals, decl);
11582
11583     return decl;
11584   }
11585 }
11586 \f
11587 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11588    An empty exprlist is a parmlist.  An exprlist which
11589    contains only identifiers at the global level
11590    is a parmlist.  Otherwise, it is an exprlist.  */
11591
11592 int
11593 parmlist_is_exprlist (exprs)
11594      tree exprs;
11595 {
11596   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11597     return 0;
11598
11599   if (toplevel_bindings_p ())
11600     {
11601       /* At the global level, if these are all identifiers,
11602          then it is a parmlist.  */
11603       while (exprs)
11604         {
11605           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11606             return 1;
11607           exprs = TREE_CHAIN (exprs);
11608         }
11609       return 0;
11610     }
11611   return 1;
11612 }
11613
11614 /* Subroutine of start_function.  Ensure that each of the parameter
11615    types (as listed in PARMS) is complete, as is required for a
11616    function definition.  */
11617
11618 static void
11619 require_complete_types_for_parms (parms)
11620      tree parms;
11621 {
11622   for (; parms; parms = TREE_CHAIN (parms))
11623     {
11624       if (VOID_TYPE_P (TREE_TYPE (parms)))
11625         /* grokparms will have already issued an error */
11626         TREE_TYPE (parms) = error_mark_node;
11627       else if (complete_type_or_else (TREE_TYPE (parms), parms))
11628         layout_decl (parms, 0);
11629       else
11630         TREE_TYPE (parms) = error_mark_node;
11631     }
11632 }
11633
11634 /* Returns non-zero if T is a local variable.  */
11635
11636 int
11637 local_variable_p (t)
11638      tree t;
11639 {
11640   if ((TREE_CODE (t) == VAR_DECL
11641        /* A VAR_DECL with a context that is a _TYPE is a static data
11642           member.  */
11643        && !TYPE_P (CP_DECL_CONTEXT (t))
11644        /* Any other non-local variable must be at namespace scope.  */
11645        && !DECL_NAMESPACE_SCOPE_P (t))
11646       || (TREE_CODE (t) == PARM_DECL))
11647     return 1;
11648
11649   return 0;
11650 }
11651
11652 /* Returns non-zero if T is an automatic local variable or a label.
11653    (These are the declarations that need to be remapped when the code
11654    containing them is duplicated.)  */
11655
11656 int
11657 nonstatic_local_decl_p (t)
11658      tree t;
11659 {
11660   return ((local_variable_p (t) && !TREE_STATIC (t))
11661           || TREE_CODE (t) == LABEL_DECL
11662           || TREE_CODE (t) == RESULT_DECL);
11663 }
11664
11665 /* Like local_variable_p, but suitable for use as a tree-walking
11666    function.  */
11667
11668 static tree
11669 local_variable_p_walkfn (tp, walk_subtrees, data)
11670      tree *tp;
11671      int *walk_subtrees ATTRIBUTE_UNUSED;
11672      void *data ATTRIBUTE_UNUSED;
11673 {
11674   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11675           ? *tp : NULL_TREE);
11676 }
11677
11678 /* Check that ARG, which is a default-argument expression for a
11679    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11680    something goes wrong.  DECL may also be a _TYPE node, rather than a
11681    DECL, if there is no DECL available.  */
11682
11683 tree
11684 check_default_argument (decl, arg)
11685      tree decl;
11686      tree arg;
11687 {
11688   tree var;
11689   tree decl_type;
11690
11691   if (TREE_CODE (arg) == DEFAULT_ARG)
11692     /* We get a DEFAULT_ARG when looking at an in-class declaration
11693        with a default argument.  Ignore the argument for now; we'll
11694        deal with it after the class is complete.  */
11695     return arg;
11696
11697   if (processing_template_decl || uses_template_parms (arg))
11698     /* We don't do anything checking until instantiation-time.  Note
11699        that there may be uninstantiated arguments even for an
11700        instantiated function, since default arguments are not
11701        instantiated until they are needed.  */
11702     return arg;
11703
11704   if (TYPE_P (decl))
11705     {
11706       decl_type = decl;
11707       decl = NULL_TREE;
11708     }
11709   else
11710     decl_type = TREE_TYPE (decl);
11711
11712   if (arg == error_mark_node
11713       || decl == error_mark_node
11714       || TREE_TYPE (arg) == error_mark_node
11715       || decl_type == error_mark_node)
11716     /* Something already went wrong.  There's no need to check
11717        further.  */
11718     return error_mark_node;
11719
11720   /* [dcl.fct.default]
11721
11722      A default argument expression is implicitly converted to the
11723      parameter type.  */
11724   if (!TREE_TYPE (arg)
11725       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11726     {
11727       if (decl)
11728         cp_error ("default argument for `%#D' has type `%T'",
11729                   decl, TREE_TYPE (arg));
11730       else
11731         cp_error ("default argument for parameter of type `%T' has type `%T'",
11732                   decl_type, TREE_TYPE (arg));
11733
11734       return error_mark_node;
11735     }
11736
11737   /* [dcl.fct.default]
11738
11739      Local variables shall not be used in default argument
11740      expressions.
11741
11742      The keyword `this' shall not be used in a default argument of a
11743      member function.  */
11744   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
11745                                       NULL);
11746   if (var)
11747     {
11748       cp_error ("default argument `%E' uses local variable `%D'",
11749                 arg, var);
11750       return error_mark_node;
11751     }
11752
11753   /* All is well.  */
11754   return arg;
11755 }
11756
11757 /* Decode the list of parameter types for a function type.
11758    Given the list of things declared inside the parens,
11759    return a list of types.
11760
11761    We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
11762    flag. If unset, we append void_list_node. A parmlist declared
11763    as `(void)' is accepted as the empty parmlist.
11764
11765    Also set last_function_parms to the chain of PARM_DECLs.  */
11766
11767 static tree
11768 grokparms (first_parm)
11769      tree first_parm;
11770 {
11771   tree result = NULL_TREE;
11772   tree decls = NULL_TREE;
11773   int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
11774   tree parm, chain;
11775   int any_error = 0;
11776
11777   my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
11778
11779   for (parm = first_parm; parm != NULL_TREE; parm = chain)
11780     {
11781       tree type = NULL_TREE;
11782       register tree decl = TREE_VALUE (parm);
11783       tree init = TREE_PURPOSE (parm);
11784
11785       chain = TREE_CHAIN (parm);
11786       /* @@ weak defense against parse errors.  */
11787       if (TREE_CODE (decl) != VOID_TYPE
11788           && TREE_CODE (decl) != TREE_LIST)
11789         {
11790           /* Give various messages as the need arises.  */
11791           if (TREE_CODE (decl) == STRING_CST)
11792             cp_error ("invalid string constant `%E'", decl);
11793           else if (TREE_CODE (decl) == INTEGER_CST)
11794             error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11795           continue;
11796         }
11797
11798       if (parm == void_list_node)
11799         break;
11800
11801       decl = grokdeclarator (TREE_VALUE (decl), TREE_PURPOSE (decl),
11802                      PARM, init != NULL_TREE, NULL_TREE);
11803       if (! decl || TREE_TYPE (decl) == error_mark_node)
11804         continue;
11805
11806       type = TREE_TYPE (decl);
11807       if (VOID_TYPE_P (type))
11808         {
11809           if (same_type_p (type, void_type_node)
11810               && !DECL_NAME (decl) && !result && !chain && !ellipsis)
11811             /* this is a parmlist of `(void)', which is ok.  */
11812             break;
11813           incomplete_type_error (decl, type);
11814           /* It's not a good idea to actually create parameters of
11815              type `void'; other parts of the compiler assume that a
11816              void type terminates the parameter list.  */
11817           type = error_mark_node;
11818           TREE_TYPE (decl) = error_mark_node;
11819         }
11820
11821       if (type != error_mark_node)
11822         {
11823           /* Top-level qualifiers on the parameters are
11824              ignored for function types.  */
11825           type = TYPE_MAIN_VARIANT (type);
11826           if (TREE_CODE (type) == METHOD_TYPE)
11827             {
11828               cp_error ("parameter `%D' invalidly declared method type", decl);
11829               type = build_pointer_type (type);
11830               TREE_TYPE (decl) = type;
11831             }
11832           else if (TREE_CODE (type) == OFFSET_TYPE)
11833             {
11834               cp_error ("parameter `%D' invalidly declared offset type", decl);
11835               type = build_pointer_type (type);
11836               TREE_TYPE (decl) = type;
11837             }
11838           else if (abstract_virtuals_error (decl, type))
11839             any_error = 1;  /* Seems like a good idea. */
11840           else if (POINTER_TYPE_P (type))
11841             {
11842               /* [dcl.fct]/6, parameter types cannot contain pointers
11843                  (references) to arrays of unknown bound.  */
11844               tree t = TREE_TYPE (type);
11845               int ptr = TYPE_PTR_P (type);
11846
11847               while (1)
11848                 {
11849                   if (TYPE_PTR_P (t))
11850                     ptr = 1;
11851                   else if (TREE_CODE (t) != ARRAY_TYPE)
11852                     break;
11853                   else if (!TYPE_DOMAIN (t))
11854                     break;
11855                   t = TREE_TYPE (t);
11856                 }
11857               if (TREE_CODE (t) == ARRAY_TYPE)
11858                 cp_error ("parameter `%D' includes %s to array of unknown bound `%T'",
11859                           decl, ptr ? "pointer" : "reference", t);
11860             }
11861
11862           DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11863           if (PROMOTE_PROTOTYPES
11864               && (TREE_CODE (type) == INTEGER_TYPE
11865                   || TREE_CODE (type) == ENUMERAL_TYPE)
11866               && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11867             DECL_ARG_TYPE (decl) = integer_type_node;
11868           if (!any_error && init)
11869             init = check_default_argument (decl, init);
11870           else
11871             init = NULL_TREE;
11872         }
11873
11874       TREE_CHAIN (decl) = decls;
11875       decls = decl;
11876       result = tree_cons (init, type, result);
11877     }
11878   decls = nreverse (decls);
11879   result = nreverse (result);
11880   if (!ellipsis)
11881     result = chainon (result, void_list_node);
11882   last_function_parms = decls;
11883
11884   return result;
11885 }
11886
11887 \f
11888 /* D is a constructor or overloaded `operator='.  Returns non-zero if
11889    D's arguments allow it to be a copy constructor, or copy assignment
11890    operator.  */
11891
11892 int
11893 copy_args_p (d)
11894      tree d;
11895 {
11896   tree t;
11897
11898   if (!DECL_FUNCTION_MEMBER_P (d))
11899     return 0;
11900
11901   t = FUNCTION_ARG_CHAIN (d);
11902   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
11903     t = TREE_CHAIN (t);
11904   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
11905       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
11906           == DECL_CONTEXT (d))
11907       && (TREE_CHAIN (t) == NULL_TREE
11908           || TREE_CHAIN (t) == void_list_node
11909           || TREE_PURPOSE (TREE_CHAIN (t))))
11910     return 1;
11911   return 0;
11912 }
11913
11914 /* These memoizing functions keep track of special properties which
11915    a class may have.  `grok_ctor_properties' notices whether a class
11916    has a constructor of the form X(X&), and also complains
11917    if the class has a constructor of the form X(X).
11918    `grok_op_properties' takes notice of the various forms of
11919    operator= which are defined, as well as what sorts of type conversion
11920    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
11921
11922 int
11923 grok_ctor_properties (ctype, decl)
11924      tree ctype, decl;
11925 {
11926   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
11927   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
11928
11929   /* When a type has virtual baseclasses, a magical first int argument is
11930      added to any ctor so we can tell if the class has been initialized
11931      yet.  This could screw things up in this function, so we deliberately
11932      ignore the leading int if we're in that situation.  */
11933   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11934     {
11935       my_friendly_assert (parmtypes
11936                           && TREE_VALUE (parmtypes) == integer_type_node,
11937                           980529);
11938       parmtypes = TREE_CHAIN (parmtypes);
11939       parmtype = TREE_VALUE (parmtypes);
11940     }
11941
11942   /* [class.copy]
11943
11944      A non-template constructor for class X is a copy constructor if
11945      its first parameter is of type X&, const X&, volatile X& or const
11946      volatile X&, and either there are no other parameters or else all
11947      other parameters have default arguments.  */
11948   if (TREE_CODE (parmtype) == REFERENCE_TYPE
11949       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
11950       && sufficient_parms_p (TREE_CHAIN (parmtypes))
11951       && !(DECL_TEMPLATE_INSTANTIATION (decl)
11952            && is_member_template (DECL_TI_TEMPLATE (decl))))
11953     {
11954       TYPE_HAS_INIT_REF (ctype) = 1;
11955       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
11956         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
11957     }
11958   /* [class.copy]
11959
11960      A declaration of a constructor for a class X is ill-formed if its
11961      first parameter is of type (optionally cv-qualified) X and either
11962      there are no other parameters or else all other parameters have
11963      default arguments.
11964
11965      We *don't* complain about member template instantiations that
11966      have this form, though; they can occur as we try to decide what
11967      constructor to use during overload resolution.  Since overload
11968      resolution will never prefer such a constructor to the
11969      non-template copy constructor (which is either explicitly or
11970      implicitly defined), there's no need to worry about their
11971      existence.  Theoretically, they should never even be
11972      instantiated, but that's hard to forestall.  */
11973   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
11974            && sufficient_parms_p (TREE_CHAIN (parmtypes))
11975            && !(DECL_TEMPLATE_INSTANTIATION (decl)
11976                 && is_member_template (DECL_TI_TEMPLATE (decl))))
11977     {
11978       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
11979                 ctype, ctype);
11980       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
11981       return 0;
11982     }
11983   else if (TREE_CODE (parmtype) == VOID_TYPE
11984            || TREE_PURPOSE (parmtypes) != NULL_TREE)
11985     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
11986
11987   return 1;
11988 }
11989
11990 /* An operator with this code is unary, but can also be binary.  */
11991
11992 static int
11993 ambi_op_p (code)
11994      enum tree_code code;
11995 {
11996   return (code == INDIRECT_REF
11997           || code == ADDR_EXPR
11998           || code == CONVERT_EXPR
11999           || code == NEGATE_EXPR
12000           || code == PREINCREMENT_EXPR
12001           || code == PREDECREMENT_EXPR);
12002 }
12003
12004 /* An operator with this name can only be unary.  */
12005
12006 static int
12007 unary_op_p (code)
12008      enum tree_code code;
12009 {
12010   return (code == TRUTH_NOT_EXPR
12011           || code == BIT_NOT_EXPR
12012           || code == COMPONENT_REF
12013           || code == TYPE_EXPR);
12014 }
12015
12016 /* Do a little sanity-checking on how they declared their operator.  */
12017
12018 void
12019 grok_op_properties (decl, virtualp, friendp)
12020      tree decl;
12021      int virtualp, friendp;
12022 {
12023   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12024   tree argtype;
12025   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12026   tree name = DECL_NAME (decl);
12027   enum tree_code operator_code;
12028   int arity;
12029
12030   /* Count the number of arguments.  */
12031   for (argtype = argtypes, arity = 0;
12032        argtype && argtype != void_list_node;
12033        argtype = TREE_CHAIN (argtype))
12034     ++arity;
12035
12036   if (current_class_type == NULL_TREE)
12037     friendp = 1;
12038
12039   if (DECL_CONV_FN_P (decl))
12040     operator_code = TYPE_EXPR;
12041   else
12042     do
12043       {
12044 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P)  \
12045         if (ansi_opname (CODE) == name)                                     \
12046           {                                                                 \
12047             operator_code = CODE;                                           \
12048             break;                                                          \
12049           }                                                                 \
12050         else if (ansi_assopname (CODE) == name)                             \
12051           {                                                                 \
12052             operator_code = CODE;                                           \
12053             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;                          \
12054             break;                                                          \
12055           }
12056
12057 #include "operators.def"
12058 #undef DEF_OPERATOR
12059
12060         my_friendly_abort (20000527);
12061       }
12062     while (0);
12063   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12064   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12065
12066   if (! friendp)
12067     {
12068       switch (operator_code)
12069         {
12070         case CALL_EXPR:
12071           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12072           break;
12073
12074         case ARRAY_REF:
12075           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12076           break;
12077
12078         case COMPONENT_REF:
12079         case MEMBER_REF:
12080           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12081           break;
12082
12083         case NEW_EXPR:
12084           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12085           break;
12086
12087         case DELETE_EXPR:
12088           TYPE_GETS_DELETE (current_class_type) |= 1;
12089           break;
12090
12091         case VEC_NEW_EXPR:
12092           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12093           break;
12094
12095         case VEC_DELETE_EXPR:
12096           TYPE_GETS_DELETE (current_class_type) |= 2;
12097           break;
12098
12099         default:
12100           break;
12101         }
12102     }
12103
12104   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12105     {
12106       /* When the compiler encounters the definition of A::operator new, it
12107          doesn't look at the class declaration to find out if it's static.  */
12108       if (methodp)
12109         revert_static_member_fn (decl);
12110
12111       TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12112     }
12113   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12114     {
12115       if (methodp)
12116         revert_static_member_fn (decl);
12117
12118       TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12119     }
12120   else
12121     {
12122       /* An operator function must either be a non-static member function
12123          or have at least one parameter of a class, a reference to a class,
12124          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12125       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12126         {
12127           if (operator_code == TYPE_EXPR
12128               || operator_code == CALL_EXPR
12129               || operator_code == COMPONENT_REF
12130               || operator_code == ARRAY_REF
12131               || operator_code == NOP_EXPR)
12132             cp_error ("`%D' must be a nonstatic member function", decl);
12133           else
12134             {
12135               tree p = argtypes;
12136
12137               if (DECL_STATIC_FUNCTION_P (decl))
12138                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12139
12140               if (p)
12141                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12142                   {
12143                     tree arg = TREE_VALUE (p);
12144                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12145                       arg = TREE_TYPE (arg);
12146
12147                     /* This lets bad template code slip through.  */
12148                     if (IS_AGGR_TYPE (arg)
12149                         || TREE_CODE (arg) == ENUMERAL_TYPE
12150                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12151                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12152                       goto foundaggr;
12153                   }
12154               cp_error
12155                 ("`%D' must have an argument of class or enumerated type",
12156                  decl);
12157             foundaggr:
12158               ;
12159             }
12160         }
12161
12162       if (operator_code == CALL_EXPR)
12163         return;                 /* No restrictions on args. */
12164
12165       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12166         {
12167           tree t = TREE_TYPE (name);
12168           if (! friendp)
12169             {
12170               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12171               const char *what = 0;
12172
12173               if (ref)
12174                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12175
12176               if (TREE_CODE (t) == VOID_TYPE)
12177                 what = "void";
12178               else if (t == current_class_type)
12179                 what = "the same type";
12180               /* Don't force t to be complete here.  */
12181               else if (IS_AGGR_TYPE (t)
12182                        && COMPLETE_TYPE_P (t)
12183                        && DERIVED_FROM_P (t, current_class_type))
12184                 what = "a base class";
12185
12186               if (what)
12187                 warning ("conversion to %s%s will never use a type conversion operator",
12188                          ref ? "a reference to " : "", what);
12189             }
12190         }
12191
12192       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12193           && operator_code == NOP_EXPR)
12194         {
12195           tree parmtype;
12196
12197           if (arity != 2 && methodp)
12198             {
12199               cp_error ("`%D' must take exactly one argument", decl);
12200               return;
12201             }
12202           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12203
12204           /* [class.copy]
12205
12206              A user-declared copy assignment operator X::operator= is
12207              a non-static non-template member function of class X with
12208              exactly one parameter of type X, X&, const X&, volatile
12209              X& or const volatile X&.  */
12210           if (copy_assignment_arg_p (parmtype, virtualp)
12211               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12212                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12213               && ! friendp)
12214             {
12215               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12216               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12217                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12218                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12219             }
12220         }
12221       else if (operator_code == COND_EXPR)
12222         {
12223           /* 13.4.0.3 */
12224           cp_error ("ISO C++ prohibits overloading operator ?:");
12225         }
12226       else if (ambi_op_p (operator_code))
12227         {
12228           if (arity == 1)
12229             /* We pick the one-argument operator codes by default, so
12230                we don't have to change anything.  */
12231             ;
12232           else if (arity == 2)
12233             {
12234               /* If we thought this was a unary operator, we now know
12235                  it to be a binary operator.  */
12236               switch (operator_code)
12237                 {
12238                 case INDIRECT_REF:
12239                   operator_code = MULT_EXPR;
12240                   break;
12241
12242                 case ADDR_EXPR:
12243                   operator_code = BIT_AND_EXPR;
12244                   break;
12245
12246                 case CONVERT_EXPR:
12247                   operator_code = PLUS_EXPR;
12248                   break;
12249
12250                 case NEGATE_EXPR:
12251                   operator_code = MINUS_EXPR;
12252                   break;
12253
12254                 case PREINCREMENT_EXPR:
12255                   operator_code = POSTINCREMENT_EXPR;
12256                   break;
12257
12258                 case PREDECREMENT_EXPR:
12259                   operator_code = POSTDECREMENT_EXPR;
12260                   break;
12261
12262                 default:
12263                   my_friendly_abort (20000527);
12264                 }
12265
12266               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12267
12268               if ((operator_code == POSTINCREMENT_EXPR
12269                    || operator_code == POSTDECREMENT_EXPR)
12270                   && ! processing_template_decl
12271                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12272                 {
12273                   if (methodp)
12274                     cp_error ("postfix `%D' must take `int' as its argument",
12275                               decl);
12276                   else
12277                     cp_error
12278                       ("postfix `%D' must take `int' as its second argument",
12279                        decl);
12280                 }
12281             }
12282           else
12283             {
12284               if (methodp)
12285                 cp_error ("`%D' must take either zero or one argument", decl);
12286               else
12287                 cp_error ("`%D' must take either one or two arguments", decl);
12288             }
12289
12290           /* More Effective C++ rule 6.  */
12291           if (warn_ecpp
12292               && (operator_code == POSTINCREMENT_EXPR
12293                   || operator_code == POSTDECREMENT_EXPR
12294                   || operator_code == PREINCREMENT_EXPR
12295                   || operator_code == PREDECREMENT_EXPR))
12296             {
12297               tree arg = TREE_VALUE (argtypes);
12298               tree ret = TREE_TYPE (TREE_TYPE (decl));
12299               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12300                 arg = TREE_TYPE (arg);
12301               arg = TYPE_MAIN_VARIANT (arg);
12302               if (operator_code == PREINCREMENT_EXPR
12303                   || operator_code == PREDECREMENT_EXPR)
12304                 {
12305                   if (TREE_CODE (ret) != REFERENCE_TYPE
12306                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12307                                        arg))
12308                     cp_warning ("prefix `%D' should return `%T'", decl,
12309                                 build_reference_type (arg));
12310                 }
12311               else
12312                 {
12313                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12314                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12315                 }
12316             }
12317         }
12318       else if (unary_op_p (operator_code))
12319         {
12320           if (arity != 1)
12321             {
12322               if (methodp)
12323                 cp_error ("`%D' must take `void'", decl);
12324               else
12325                 cp_error ("`%D' must take exactly one argument", decl);
12326             }
12327         }
12328       else /* if (binary_op_p (operator_code)) */
12329         {
12330           if (arity != 2)
12331             {
12332               if (methodp)
12333                 cp_error ("`%D' must take exactly one argument", decl);
12334               else
12335                 cp_error ("`%D' must take exactly two arguments", decl);
12336             }
12337
12338           /* More Effective C++ rule 7.  */
12339           if (warn_ecpp
12340               && (operator_code == TRUTH_ANDIF_EXPR
12341                   || operator_code == TRUTH_ORIF_EXPR
12342                   || operator_code == COMPOUND_EXPR))
12343             cp_warning ("user-defined `%D' always evaluates both arguments",
12344                         decl);
12345         }
12346
12347       /* Effective C++ rule 23.  */
12348       if (warn_ecpp
12349           && arity == 2
12350           && (operator_code == PLUS_EXPR
12351               || operator_code == MINUS_EXPR
12352               || operator_code == TRUNC_DIV_EXPR
12353               || operator_code == MULT_EXPR)
12354           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12355         cp_warning ("`%D' should return by value", decl);
12356
12357       /* 13.4.0.8 */
12358       for (; argtypes && argtypes != void_list_node;
12359           argtypes = TREE_CHAIN (argtypes))
12360         if (TREE_PURPOSE (argtypes))
12361           {
12362             TREE_PURPOSE (argtypes) = NULL_TREE;
12363             if (operator_code == POSTINCREMENT_EXPR
12364                 || operator_code == POSTDECREMENT_EXPR)
12365               {
12366                 if (pedantic)
12367                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12368               }
12369             else
12370               cp_error ("`%D' cannot have default arguments", decl);
12371           }
12372
12373     }
12374 }
12375 \f
12376 static const char *
12377 tag_name (code)
12378      enum tag_types code;
12379 {
12380   switch (code)
12381     {
12382     case record_type:
12383       return "struct";
12384     case class_type:
12385       return "class";
12386     case union_type:
12387       return "union ";
12388     case enum_type:
12389       return "enum";
12390     default:
12391       my_friendly_abort (981122);
12392     }
12393 }
12394
12395 /* Get the struct, enum or union (CODE says which) with tag NAME.
12396    Define the tag as a forward-reference if it is not defined.
12397
12398    C++: If a class derivation is given, process it here, and report
12399    an error if multiple derivation declarations are not identical.
12400
12401    If this is a definition, come in through xref_tag and only look in
12402    the current frame for the name (since C++ allows new names in any
12403    scope.)  */
12404
12405 tree
12406 xref_tag (code_type_node, name, globalize)
12407      tree code_type_node;
12408      tree name;
12409      int globalize;
12410 {
12411   enum tag_types tag_code;
12412   enum tree_code code;
12413   register tree ref, t;
12414   struct binding_level *b = current_binding_level;
12415   int got_type = 0;
12416   tree attributes = NULL_TREE;
12417   tree context = NULL_TREE;
12418
12419   /* If we are called from the parser, code_type_node will sometimes be a
12420      TREE_LIST.  This indicates that the user wrote
12421      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12422      use them later.  */
12423   if (TREE_CODE (code_type_node) == TREE_LIST)
12424     {
12425       attributes = TREE_PURPOSE (code_type_node);
12426       code_type_node = TREE_VALUE (code_type_node);
12427     }
12428
12429   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12430   switch (tag_code)
12431     {
12432     case record_type:
12433     case class_type:
12434       code = RECORD_TYPE;
12435       break;
12436     case union_type:
12437       code = UNION_TYPE;
12438       break;
12439     case enum_type:
12440       code = ENUMERAL_TYPE;
12441       break;
12442     default:
12443       my_friendly_abort (18);
12444     }
12445
12446   /* If a cross reference is requested, look up the type
12447      already defined for this tag and return it.  */
12448   if (TYPE_P (name))
12449     {
12450       t = name;
12451       name = TYPE_IDENTIFIER (t);
12452       got_type = 1;
12453     }
12454   else
12455     t = IDENTIFIER_TYPE_VALUE (name);
12456
12457   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12458   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12459     {
12460       static int explained;
12461
12462       cp_warning ("`%s %T' declares a new type at namespace scope;\n\
12463 to refer to the inherited type, say `%s %T::%T'%s",
12464                   tag_name (tag_code), name, tag_name (tag_code),
12465                   constructor_name (current_class_type), TYPE_IDENTIFIER (t),
12466                   (!explained ? "\n\
12467 (names from dependent base classes are not visible to unqualified name lookup)"
12468                    : ""));
12469
12470       explained = 1;
12471     }
12472
12473   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12474       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12475     t = NULL_TREE;
12476
12477   if (! globalize)
12478     {
12479       /* If we know we are defining this tag, only look it up in
12480          this scope and don't try to find it as a type.  */
12481       ref = lookup_tag (code, name, b, 1);
12482     }
12483   else
12484     {
12485       if (t)
12486         {
12487           /* [dcl.type.elab] If the identifier resolves to a
12488              typedef-name or a template type-parameter, the
12489              elaborated-type-specifier is ill-formed.  */
12490           if (t != TYPE_MAIN_VARIANT (t)
12491               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12492             cp_pedwarn ("using typedef-name `%D' after `%s'",
12493                         TYPE_NAME (t), tag_name (tag_code));
12494           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12495             cp_error ("using template type parameter `%T' after `%s'",
12496                       t, tag_name (tag_code));
12497
12498           ref = t;
12499         }
12500       else
12501         ref = lookup_tag (code, name, b, 0);
12502
12503       if (! ref)
12504         {
12505           /* Try finding it as a type declaration.  If that wins,
12506              use it.  */
12507           ref = lookup_name (name, 1);
12508
12509           if (ref != NULL_TREE
12510               && processing_template_decl
12511               && DECL_CLASS_TEMPLATE_P (ref)
12512               && template_class_depth (current_class_type) == 0)
12513             /* Since GLOBALIZE is true, we're declaring a global
12514                template, so we want this type.  */
12515             ref = DECL_TEMPLATE_RESULT (ref);
12516
12517           if (ref && TREE_CODE (ref) == TYPE_DECL
12518               && TREE_CODE (TREE_TYPE (ref)) == code)
12519             ref = TREE_TYPE (ref);
12520           else
12521             ref = NULL_TREE;
12522         }
12523
12524       if (ref && current_class_type
12525           && template_class_depth (current_class_type)
12526           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12527         {
12528           /* Since GLOBALIZE is non-zero, we are not looking at a
12529              definition of this tag.  Since, in addition, we are currently
12530              processing a (member) template declaration of a template
12531              class, we must be very careful; consider:
12532
12533                template <class X>
12534                struct S1
12535
12536                template <class U>
12537                struct S2
12538                { template <class V>
12539                friend struct S1; };
12540
12541              Here, the S2::S1 declaration should not be confused with the
12542              outer declaration.  In particular, the inner version should
12543              have a template parameter of level 2, not level 1.  This
12544              would be particularly important if the member declaration
12545              were instead:
12546
12547                template <class V = U> friend struct S1;
12548
12549              say, when we should tsubst into `U' when instantiating
12550              S2.  On the other hand, when presented with:
12551
12552                  template <class T>
12553                  struct S1 {
12554                    template <class U>
12555                    struct S2 {};
12556                    template <class U>
12557                    friend struct S2;
12558                  };
12559
12560               we must find the inner binding eventually.  We
12561               accomplish this by making sure that the new type we
12562               create to represent this declaration has the right
12563               TYPE_CONTEXT.  */
12564           context = TYPE_CONTEXT (ref);
12565           ref = NULL_TREE;
12566         }
12567     }
12568
12569   if (! ref)
12570     {
12571       /* If no such tag is yet defined, create a forward-reference node
12572          and record it as the "definition".
12573          When a real declaration of this type is found,
12574          the forward-reference will be altered into a real type.  */
12575       if (code == ENUMERAL_TYPE)
12576         {
12577           cp_error ("use of enum `%#D' without previous declaration", name);
12578
12579           ref = make_node (ENUMERAL_TYPE);
12580
12581           /* Give the type a default layout like unsigned int
12582              to avoid crashing if it does not get defined.  */
12583           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12584           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12585           TYPE_USER_ALIGN (ref) = 0;
12586           TREE_UNSIGNED (ref) = 1;
12587           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12588           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12589           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12590
12591           /* Enable us to recognize when a type is created in class context.
12592              To do nested classes correctly, this should probably be cleared
12593              out when we leave this classes scope.  Currently this in only
12594              done in `start_enum'.  */
12595
12596           pushtag (name, ref, globalize);
12597         }
12598       else
12599         {
12600           struct binding_level *old_b = class_binding_level;
12601
12602           ref = make_aggr_type (code);
12603           TYPE_CONTEXT (ref) = context;
12604
12605 #ifdef NONNESTED_CLASSES
12606           /* Class types don't nest the way enums do.  */
12607           class_binding_level = (struct binding_level *)0;
12608 #endif
12609           pushtag (name, ref, globalize);
12610           class_binding_level = old_b;
12611         }
12612     }
12613   else
12614     {
12615       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12616         redeclare_class_template (ref, current_template_parms);
12617     }
12618
12619   /* Until the type is defined, tentatively accept whatever
12620      structure tag the user hands us.  */
12621   if (!COMPLETE_TYPE_P (ref)
12622       && ref != current_class_type
12623       /* Have to check this, in case we have contradictory tag info.  */
12624       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12625     {
12626       if (tag_code == class_type)
12627         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12628       else if (tag_code == record_type)
12629         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12630     }
12631
12632   TREE_TYPE (ref) = attributes;
12633
12634   return ref;
12635 }
12636
12637 tree
12638 xref_tag_from_type (old, id, globalize)
12639      tree old, id;
12640      int globalize;
12641 {
12642   tree code_type_node;
12643
12644   if (TREE_CODE (old) == RECORD_TYPE)
12645     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12646                       ? class_type_node : record_type_node);
12647   else
12648     code_type_node = union_type_node;
12649
12650   if (id == NULL_TREE)
12651     id = TYPE_IDENTIFIER (old);
12652
12653   return xref_tag (code_type_node, id, globalize);
12654 }
12655
12656 /* REF is a type (named NAME), for which we have just seen some
12657    baseclasses.  BINFO is a list of those baseclasses; the
12658    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12659    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12660    struct, or union.  */
12661
12662 void
12663 xref_basetypes (code_type_node, name, ref, binfo)
12664      tree code_type_node;
12665      tree name, ref;
12666      tree binfo;
12667 {
12668   /* In the declaration `A : X, Y, ... Z' we mark all the types
12669      (A, X, Y, ..., Z) so we can check for duplicates.  */
12670   tree binfos;
12671   tree base;
12672
12673   int i, len;
12674   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12675
12676   if (tag_code == union_type)
12677     {
12678       cp_error ("derived union `%T' invalid", ref);
12679       return;
12680     }
12681
12682   len = list_length (binfo);
12683
12684   /* First, make sure that any templates in base-classes are
12685      instantiated.  This ensures that if we call ourselves recursively
12686      we do not get confused about which classes are marked and which
12687      are not.  */
12688   for (base = binfo; base; base = TREE_CHAIN (base))
12689     complete_type (TREE_VALUE (base));
12690
12691   SET_CLASSTYPE_MARKED (ref);
12692   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12693
12694   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12695     {
12696       /* The base of a derived struct is public by default.  */
12697       int via_public
12698         = (TREE_PURPOSE (binfo) == access_public_node
12699            || TREE_PURPOSE (binfo) == access_public_virtual_node
12700            || (tag_code != class_type
12701                && (TREE_PURPOSE (binfo) == access_default_node
12702                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12703       int via_protected
12704         = (TREE_PURPOSE (binfo) == access_protected_node
12705            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12706       int via_virtual
12707         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12708            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12709            || TREE_PURPOSE (binfo) == access_public_virtual_node
12710            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12711       tree basetype = TREE_VALUE (binfo);
12712       tree base_binfo;
12713
12714       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12715         basetype = TREE_TYPE (basetype);
12716       if (!basetype
12717           || (TREE_CODE (basetype) != RECORD_TYPE
12718               && TREE_CODE (basetype) != TYPENAME_TYPE
12719               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12720               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
12721         {
12722           cp_error ("base type `%T' fails to be a struct or class type",
12723                     TREE_VALUE (binfo));
12724           continue;
12725         }
12726
12727       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12728
12729       /* This code replaces similar code in layout_basetypes.
12730          We put the complete_type first for implicit `typename'.  */
12731       if (!COMPLETE_TYPE_P (basetype)
12732           && ! (current_template_parms && uses_template_parms (basetype)))
12733         {
12734           cp_error ("base class `%T' has incomplete type", basetype);
12735           continue;
12736         }
12737       else
12738         {
12739           if (CLASSTYPE_MARKED (basetype))
12740             {
12741               if (basetype == ref)
12742                 cp_error ("recursive type `%T' undefined", basetype);
12743               else
12744                 cp_error ("duplicate base type `%T' invalid", basetype);
12745               continue;
12746             }
12747
12748           if (TYPE_FOR_JAVA (basetype)
12749               && (current_lang_stack
12750                   == &VARRAY_TREE (current_lang_base, 0)))
12751             TYPE_FOR_JAVA (ref) = 1;
12752
12753           /* Note that the BINFO records which describe individual
12754              inheritances are *not* shared in the lattice!  They
12755              cannot be shared because a given baseclass may be
12756              inherited with different `accessibility' by different
12757              derived classes.  (Each BINFO record describing an
12758              individual inheritance contains flags which say what
12759              the `accessibility' of that particular inheritance is.)  */
12760
12761           base_binfo
12762             = make_binfo (size_zero_node, basetype,
12763                           CLASS_TYPE_P (basetype)
12764                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12765                           CLASS_TYPE_P (basetype)
12766                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12767
12768           TREE_VEC_ELT (binfos, i) = base_binfo;
12769           TREE_VIA_PUBLIC (base_binfo) = via_public;
12770           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12771           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12772           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12773
12774           /* We need to unshare the binfos now so that lookups during class
12775              definition work.  */
12776           unshare_base_binfos (base_binfo);
12777
12778           SET_CLASSTYPE_MARKED (basetype);
12779
12780           /* We are free to modify these bits because they are meaningless
12781              at top level, and BASETYPE is a top-level type.  */
12782           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12783             {
12784               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12785               /* Converting to a virtual base class requires looking
12786                  up the offset of the virtual base.  */
12787               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12788             }
12789
12790           if (CLASS_TYPE_P (basetype))
12791             {
12792               TYPE_HAS_NEW_OPERATOR (ref)
12793                 |= TYPE_HAS_NEW_OPERATOR (basetype);
12794               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12795                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12796               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12797               /* If the base-class uses multiple inheritance, so do we.  */
12798               TYPE_USES_MULTIPLE_INHERITANCE (ref)
12799                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12800               /* Likewise, if converting to a base of the base may require
12801                  code, then we may need to generate code to convert to a
12802                  base as well.  */
12803               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12804                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12805             }
12806
12807           i += 1;
12808         }
12809     }
12810   if (i)
12811     TREE_VEC_LENGTH (binfos) = i;
12812   else
12813     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12814
12815   if (i > 1)
12816     {
12817       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12818       /* If there is more than one non-empty they cannot be at the same
12819          address.  */
12820       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12821     }
12822
12823   /* Unmark all the types.  */
12824   while (--i >= 0)
12825     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12826   CLEAR_CLASSTYPE_MARKED (ref);
12827
12828   /* Now that we know all the base-classes, set up the list of virtual
12829      bases.  */
12830   get_vbase_types (ref);
12831 }
12832
12833 \f
12834 /* Begin compiling the definition of an enumeration type.
12835    NAME is its name (or null if anonymous).
12836    Returns the type object, as yet incomplete.
12837    Also records info about it so that build_enumerator
12838    may be used to declare the individual values as they are read.  */
12839
12840 tree
12841 start_enum (name)
12842      tree name;
12843 {
12844   register tree enumtype = NULL_TREE;
12845   struct binding_level *b = current_binding_level;
12846
12847   /* If this is the real definition for a previous forward reference,
12848      fill in the contents in the same object that used to be the
12849      forward reference.  */
12850
12851   if (name != NULL_TREE)
12852     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12853
12854   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12855     {
12856       cp_error ("multiple definition of `%#T'", enumtype);
12857       cp_error_at ("previous definition here", enumtype);
12858       /* Clear out TYPE_VALUES, and start again.  */
12859       TYPE_VALUES (enumtype) = NULL_TREE;
12860     }
12861   else
12862     {
12863       enumtype = make_node (ENUMERAL_TYPE);
12864       pushtag (name, enumtype, 0);
12865     }
12866
12867   if (current_class_type)
12868     TREE_ADDRESSABLE (b->tags) = 1;
12869
12870   GNU_xref_decl (current_function_decl, enumtype);
12871   return enumtype;
12872 }
12873
12874 /* After processing and defining all the values of an enumeration type,
12875    install their decls in the enumeration type and finish it off.
12876    ENUMTYPE is the type object and VALUES a list of name-value pairs.
12877    Returns ENUMTYPE.  */
12878
12879 tree
12880 finish_enum (enumtype)
12881      tree enumtype;
12882 {
12883   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
12884   /* Calculate the maximum value of any enumerator in this type.  */
12885
12886   tree values = TYPE_VALUES (enumtype);
12887   if (values)
12888     {
12889       tree pair;
12890
12891       for (pair = values; pair; pair = TREE_CHAIN (pair))
12892         {
12893           tree decl;
12894           tree value;
12895
12896           /* The TREE_VALUE is a CONST_DECL for this enumeration
12897              constant.  */
12898           decl = TREE_VALUE (pair);
12899
12900           /* [dcl.enum]
12901
12902              Following the closing brace of an enum-specifier, each
12903              enumerator has the type of its enumeration.  Prior to the
12904              closing brace, the type of each enumerator is the type of
12905              its initializing value.  */
12906           TREE_TYPE (decl) = enumtype;
12907
12908           /* The DECL_INITIAL will be NULL if we are processing a
12909              template declaration and this enumeration constant had no
12910              explicit initializer.  */
12911           value = DECL_INITIAL (decl);
12912           if (value && !processing_template_decl)
12913             {
12914               /* Set the TREE_TYPE for the VALUE as well.  That's so
12915                  that when we call decl_constant_value we get an
12916                  entity of the right type (but with the constant
12917                  value).  Since we shouldn't ever call
12918                  decl_constant_value on a template type, there's no
12919                  reason to do that when processing_template_decl.
12920                  And, if the expression is something like a
12921                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12922                  wreak havoc on the intended type of the expression.
12923
12924                  Of course, there's also no point in trying to compute
12925                  minimum or maximum values if we're in a template.  */
12926               TREE_TYPE (value) = enumtype;
12927
12928               if (!minnode)
12929                 minnode = maxnode = value;
12930               else if (tree_int_cst_lt (maxnode, value))
12931                 maxnode = value;
12932               else if (tree_int_cst_lt (value, minnode))
12933                 minnode = value;
12934             }
12935
12936           if (processing_template_decl)
12937             /* If this is just a template, leave the CONST_DECL
12938                alone.  That way tsubst_copy will find CONST_DECLs for
12939                CONST_DECLs, and not INTEGER_CSTs.  */
12940             ;
12941           else
12942             /* In the list we're building up, we want the enumeration
12943                values, not the CONST_DECLs.  */
12944             TREE_VALUE (pair) = value;
12945         }
12946     }
12947   else
12948     maxnode = minnode = integer_zero_node;
12949
12950   TYPE_VALUES (enumtype) = nreverse (values);
12951
12952   if (processing_template_decl)
12953     {
12954       tree scope = current_scope ();
12955       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12956         add_stmt (build_min (TAG_DEFN, enumtype));
12957     }
12958   else
12959     {
12960       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
12961       int lowprec = min_precision (minnode, unsignedp);
12962       int highprec = min_precision (maxnode, unsignedp);
12963       int precision = MAX (lowprec, highprec);
12964       tree tem;
12965
12966       TYPE_SIZE (enumtype) = NULL_TREE;
12967
12968       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
12969
12970       TYPE_PRECISION (enumtype) = precision;
12971       if (unsignedp)
12972         fixup_unsigned_type (enumtype);
12973       else
12974         fixup_signed_type (enumtype);
12975
12976       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
12977         /* Use the width of the narrowest normal C type which is wide
12978            enough.  */
12979         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
12980                                                     (precision, 1));
12981       else
12982         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
12983
12984       TYPE_SIZE (enumtype) = 0;
12985       layout_type (enumtype);
12986
12987       /* Fix up all variant types of this enum type.  */
12988       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
12989            tem = TYPE_NEXT_VARIANT (tem))
12990         {
12991           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
12992           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
12993           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
12994           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
12995           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
12996           TYPE_MODE (tem) = TYPE_MODE (enumtype);
12997           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
12998           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
12999           TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
13000           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
13001         }
13002
13003       /* Finish debugging output for this type.  */
13004       rest_of_type_compilation (enumtype, namespace_bindings_p ());
13005     }
13006
13007   return enumtype;
13008 }
13009
13010 /* Build and install a CONST_DECL for an enumeration constant of the
13011    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13012    Assignment of sequential values by default is handled here.  */
13013
13014 void
13015 build_enumerator (name, value, enumtype)
13016      tree name;
13017      tree value;
13018      tree enumtype;
13019 {
13020   tree decl;
13021   tree context;
13022   tree type;
13023   tree values;
13024
13025   /* Remove no-op casts from the value.  */
13026   if (value)
13027     STRIP_TYPE_NOPS (value);
13028
13029   if (! processing_template_decl)
13030     {
13031       /* Validate and default VALUE.  */
13032       if (value != NULL_TREE)
13033         {
13034           value = decl_constant_value (value);
13035
13036           if (TREE_CODE (value) == INTEGER_CST)
13037             {
13038               value = default_conversion (value);
13039               constant_expression_warning (value);
13040             }
13041           else
13042             {
13043               cp_error ("enumerator value for `%D' not integer constant", name);
13044               value = NULL_TREE;
13045             }
13046         }
13047
13048       /* Default based on previous value.  */
13049       if (value == NULL_TREE && ! processing_template_decl)
13050         {
13051           tree prev_value;
13052
13053           if (TYPE_VALUES (enumtype))
13054             {
13055               /* The next value is the previous value ... */
13056               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13057               /* ... plus one.  */
13058               value = cp_build_binary_op (PLUS_EXPR,
13059                                           prev_value,
13060                                           integer_one_node);
13061
13062               if (tree_int_cst_lt (value, prev_value))
13063                 cp_error ("overflow in enumeration values at `%D'", name);
13064             }
13065           else
13066             value = integer_zero_node;
13067         }
13068
13069       /* Remove no-op casts from the value.  */
13070       if (value)
13071         STRIP_TYPE_NOPS (value);
13072 #if 0
13073       /* To fix MAX_VAL enum consts. (bkoz)  */
13074       TREE_TYPE (value) = integer_type_node;
13075 #endif
13076     }
13077
13078   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13079      Even in other cases, we will later (in finish_enum) be setting
13080      the type of VALUE.  But, we don't need to make a copy if this
13081      VALUE is one of the enumeration constants for this same
13082      enumeration type.  */
13083   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13084     if (TREE_VALUE (values) == value)
13085       break;
13086   /* If we didn't break out of the loop, then we do need a copy.  */
13087   if (!values && value)
13088     value = copy_node (value);
13089
13090   /* C++ associates enums with global, function, or class declarations.  */
13091   context = current_scope ();
13092
13093   /* Build the actual enumeration constant.  Note that the enumeration
13094     constants have the type of their initializers until the
13095     enumeration is complete:
13096
13097       [ dcl.enum ]
13098
13099       Following the closing brace of an enum-specifier, each enumer-
13100       ator has the type of its enumeration.  Prior to the closing
13101       brace, the type of each enumerator is the type of its
13102       initializing value.
13103
13104     In finish_enum we will reset the type.  Of course, if we're
13105     processing a template, there may be no value.   */
13106   type = value ? TREE_TYPE (value) : NULL_TREE;
13107
13108   if (context && context == current_class_type)
13109     /* This enum declaration is local to the class.  We need the full
13110        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13111     decl = build_lang_decl (CONST_DECL, name, type);
13112   else
13113     /* It's a global enum, or it's local to a function.  (Note local to
13114       a function could mean local to a class method.  */
13115     decl = build_decl (CONST_DECL, name, type);
13116
13117   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13118   DECL_INITIAL (decl) = value;
13119   TREE_READONLY (decl) = 1;
13120
13121   if (context && context == current_class_type)
13122     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13123       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13124       things like `S::i' later.)  */
13125     finish_member_declaration (decl);
13126   else
13127     {
13128       pushdecl (decl);
13129       GNU_xref_decl (current_function_decl, decl);
13130     }
13131
13132   /* Add this enumeration constant to the list for this type.  */
13133   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13134 }
13135
13136 \f
13137 /* We're defining DECL.  Make sure that it's type is OK.  */
13138
13139 static void
13140 check_function_type (decl, current_function_parms)
13141      tree decl;
13142      tree current_function_parms;
13143 {
13144   tree fntype = TREE_TYPE (decl);
13145   tree return_type = complete_type (TREE_TYPE (fntype));
13146
13147   /* In a function definition, arg types must be complete.  */
13148   require_complete_types_for_parms (current_function_parms);
13149
13150   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13151     {
13152       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13153
13154       /* Make it return void instead, but don't change the
13155          type of the DECL_RESULT, in case we have a named return value.  */
13156       if (TREE_CODE (fntype) == METHOD_TYPE)
13157         {
13158           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13159           TREE_TYPE (decl)
13160             = build_cplus_method_type (ctype,
13161                                        void_type_node,
13162                                        FUNCTION_ARG_CHAIN (decl));
13163         }
13164       else
13165         TREE_TYPE (decl)
13166           = build_function_type (void_type_node,
13167                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13168       TREE_TYPE (decl)
13169         = build_exception_variant (fntype,
13170                                    TYPE_RAISES_EXCEPTIONS (fntype));
13171     }
13172   else
13173     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13174 }
13175
13176 /* Create the FUNCTION_DECL for a function definition.
13177    DECLSPECS and DECLARATOR are the parts of the declaration;
13178    they describe the function's name and the type it returns,
13179    but twisted together in a fashion that parallels the syntax of C.
13180
13181    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13182    DECLARATOR is really the DECL for the function we are about to
13183    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13184    indicating that the function is an inline defined in-class.
13185
13186    This function creates a binding context for the function body
13187    as well as setting up the FUNCTION_DECL in current_function_decl.
13188
13189    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13190    (it defines a datum instead), we return 0, which tells
13191    yyparse to report a parse error.
13192
13193    For C++, we must first check whether that datum makes any sense.
13194    For example, "class A local_a(1,2);" means that variable local_a
13195    is an aggregate of type A, which should have a constructor
13196    applied to it with the argument list [1, 2].  */
13197
13198 int
13199 start_function (declspecs, declarator, attrs, flags)
13200      tree declspecs, declarator, attrs;
13201      int flags;
13202 {
13203   tree decl1;
13204   tree ctype = NULL_TREE;
13205   tree fntype;
13206   tree restype;
13207   extern int have_extern_spec;
13208   extern int used_extern_spec;
13209   int doing_friend = 0;
13210   struct binding_level *bl;
13211   tree current_function_parms;
13212
13213   /* Sanity check.  */
13214   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13215   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13216
13217   /* This should only be done once on the top most decl.  */
13218   if (have_extern_spec && !used_extern_spec)
13219     {
13220       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13221       used_extern_spec = 1;
13222     }
13223
13224   if (flags & SF_PRE_PARSED)
13225     {
13226       decl1 = declarator;
13227
13228       fntype = TREE_TYPE (decl1);
13229       if (TREE_CODE (fntype) == METHOD_TYPE)
13230         ctype = TYPE_METHOD_BASETYPE (fntype);
13231
13232       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13233          the (lexical) scope of the class in which it is defined.  */
13234       if (!ctype && DECL_FRIEND_P (decl1))
13235         {
13236           ctype = DECL_FRIEND_CONTEXT (decl1);
13237
13238           /* CTYPE could be null here if we're dealing with a template;
13239              for example, `inline friend float foo()' inside a template
13240              will have no CTYPE set.  */
13241           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13242             ctype = NULL_TREE;
13243           else
13244             doing_friend = 1;
13245         }
13246
13247       last_function_parms = DECL_ARGUMENTS (decl1);
13248       last_function_parm_tags = NULL_TREE;
13249     }
13250   else
13251     {
13252       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13253       /* If the declarator is not suitable for a function definition,
13254          cause a syntax error.  */
13255       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13256
13257       fntype = TREE_TYPE (decl1);
13258
13259       restype = TREE_TYPE (fntype);
13260       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13261         {
13262           cp_error ("semicolon missing after declaration of `%#T'", restype);
13263           shadow_tag (build_tree_list (NULL_TREE, restype));
13264           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13265           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13266             fntype = build_function_type (integer_type_node,
13267                                           TYPE_ARG_TYPES (fntype));
13268           else
13269             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13270                                               integer_type_node,
13271                                               TYPE_ARG_TYPES (fntype));
13272           TREE_TYPE (decl1) = fntype;
13273         }
13274
13275       if (TREE_CODE (fntype) == METHOD_TYPE)
13276         ctype = TYPE_METHOD_BASETYPE (fntype);
13277       else if (DECL_MAIN_P (decl1))
13278         {
13279           /* If this doesn't return integer_type, complain.  */
13280           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13281             {
13282               if (pedantic || warn_return_type)
13283                 pedwarn ("return type for `main' changed to `int'");
13284               TREE_TYPE (decl1) = fntype = default_function_type;
13285             }
13286         }
13287     }
13288
13289   /* Sometimes we don't notice that a function is a static member, and
13290      build a METHOD_TYPE for it.  Fix that up now.  */
13291   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13292       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13293     {
13294       revert_static_member_fn (decl1);
13295       last_function_parms = TREE_CHAIN (last_function_parms);
13296       ctype = NULL_TREE;
13297     }
13298
13299   /* Warn if function was previously implicitly declared
13300      (but not if we warned then).  */
13301   if (! warn_implicit
13302       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13303     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13304
13305   /* Set up current_class_type, and enter the scope of the class, if
13306      appropriate.  */
13307   if (ctype)
13308     push_nested_class (ctype, 1);
13309   else if (DECL_STATIC_FUNCTION_P (decl1))
13310     push_nested_class (DECL_CONTEXT (decl1), 2);
13311
13312   /* Now that we have entered the scope of the class, we must restore
13313      the bindings for any template parameters surrounding DECL1, if it
13314      is an inline member template.  (Order is important; consider the
13315      case where a template parameter has the same name as a field of
13316      the class.)  It is not until after this point that
13317      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13318   if (flags & SF_INCLASS_INLINE)
13319     maybe_begin_member_template_processing (decl1);
13320
13321   /* Effective C++ rule 15.  */
13322   if (warn_ecpp
13323       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13324       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13325     cp_warning ("`operator=' should return a reference to `*this'");
13326
13327   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13328      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13329   if (!DECL_INITIAL (decl1))
13330     DECL_INITIAL (decl1) = error_mark_node;
13331
13332 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13333   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13334 #endif
13335
13336   /* This function exists in static storage.
13337      (This does not mean `static' in the C sense!)  */
13338   TREE_STATIC (decl1) = 1;
13339
13340   /* We must call push_template_decl after current_class_type is set
13341      up.  (If we are processing inline definitions after exiting a
13342      class scope, current_class_type will be NULL_TREE until set above
13343      by push_nested_class.)  */
13344   if (processing_template_decl)
13345     decl1 = push_template_decl (decl1);
13346
13347   /* We are now in the scope of the function being defined.  */
13348   current_function_decl = decl1;
13349
13350   /* Save the parm names or decls from this function's declarator
13351      where store_parm_decls will find them.  */
13352   current_function_parms = last_function_parms;
13353   current_function_parm_tags = last_function_parm_tags;
13354
13355   /* Make sure the parameter and return types are reasonable.  When
13356      you declare a function, these types can be incomplete, but they
13357      must be complete when you define the function.  */
13358   if (! processing_template_decl)
13359     check_function_type (decl1, current_function_parms);
13360
13361   /* Build the return declaration for the function.  */
13362   restype = TREE_TYPE (fntype);
13363   if (!processing_template_decl)
13364     {
13365       if (!DECL_RESULT (decl1))
13366         {
13367           DECL_RESULT (decl1)
13368             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13369           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13370                                       DECL_RESULT (decl1));
13371         }
13372     }
13373   else
13374     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13375     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13376
13377   /* Initialize RTL machinery.  We cannot do this until
13378      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13379      even when processing a template; this is how we get
13380      CFUN set up, and our per-function variables initialized.
13381      FIXME factor out the non-RTL stuff.  */
13382   bl = current_binding_level;
13383   init_function_start (decl1, input_filename, lineno);
13384   current_binding_level = bl;
13385
13386   /* Even though we're inside a function body, we still don't want to
13387      call expand_expr to calculate the size of a variable-sized array.
13388      We haven't necessarily assigned RTL to all variables yet, so it's
13389      not safe to try to expand expressions involving them.  */
13390   immediate_size_expand = 0;
13391   cfun->x_dont_save_pending_sizes_p = 1;
13392
13393   /* Start the statement-tree, start the tree now.  */
13394   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13395
13396   /* Let the user know we're compiling this function.  */
13397   announce_function (decl1);
13398
13399   /* Record the decl so that the function name is defined.
13400      If we already have a decl for this name, and it is a FUNCTION_DECL,
13401      use the old decl.  */
13402   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13403     {
13404       /* A specialization is not used to guide overload resolution.  */
13405       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13406           && ! DECL_FUNCTION_MEMBER_P (decl1))
13407         decl1 = pushdecl (decl1);
13408       else
13409         {
13410           /* We need to set the DECL_CONTEXT. */
13411           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13412             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13413           /* And make sure we have enough default args.  */
13414           check_default_args (decl1);
13415         }
13416       fntype = TREE_TYPE (decl1);
13417     }
13418
13419   /* Reset these in case the call to pushdecl changed them.  */
13420   current_function_decl = decl1;
13421   cfun->decl = decl1;
13422
13423   /* If we are (erroneously) defining a function that we have already
13424      defined before, wipe out what we knew before.  */
13425   if (!DECL_PENDING_INLINE_P (decl1)
13426       && DECL_SAVED_FUNCTION_DATA (decl1))
13427     {
13428       free (DECL_SAVED_FUNCTION_DATA (decl1));
13429       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13430     }
13431
13432   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13433     {
13434       /* We know that this was set up by `grokclassfn'.  We do not
13435          wait until `store_parm_decls', since evil parse errors may
13436          never get us to that point.  Here we keep the consistency
13437          between `current_class_type' and `current_class_ptr'.  */
13438       tree t = DECL_ARGUMENTS (decl1);
13439
13440       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13441                           162);
13442       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13443                           19990811);
13444
13445       cp_function_chain->x_current_class_ref
13446         = build_indirect_ref (t, NULL_PTR);
13447       cp_function_chain->x_current_class_ptr = t;
13448
13449       /* Constructors and destructors need to know whether they're "in
13450          charge" of initializing virtual base classes.  */
13451       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13452         current_in_charge_parm = TREE_CHAIN (t);
13453     }
13454
13455   if (DECL_INTERFACE_KNOWN (decl1))
13456     {
13457       tree ctx = decl_function_context (decl1);
13458
13459       if (DECL_NOT_REALLY_EXTERN (decl1))
13460         DECL_EXTERNAL (decl1) = 0;
13461
13462       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13463           && TREE_PUBLIC (ctx))
13464         /* This is a function in a local class in an extern inline
13465            function.  */
13466         comdat_linkage (decl1);
13467     }
13468   /* If this function belongs to an interface, it is public.
13469      If it belongs to someone else's interface, it is also external.
13470      This only affects inlines and template instantiations.  */
13471   else if (interface_unknown == 0
13472            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13473                || flag_alt_external_templates))
13474     {
13475       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13476           || processing_template_decl)
13477         {
13478           DECL_EXTERNAL (decl1)
13479             = (interface_only
13480                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13481                    && !DECL_VINDEX (decl1)));
13482
13483           /* For WIN32 we also want to put these in linkonce sections.  */
13484           maybe_make_one_only (decl1);
13485         }
13486       else
13487         DECL_EXTERNAL (decl1) = 0;
13488       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13489       DECL_INTERFACE_KNOWN (decl1) = 1;
13490     }
13491   else if (interface_unknown && interface_only
13492            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13493                || flag_alt_external_templates))
13494     {
13495       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13496          interface, we will have interface_only set but not
13497          interface_known.  In that case, we don't want to use the normal
13498          heuristics because someone will supply a #pragma implementation
13499          elsewhere, and deducing it here would produce a conflict.  */
13500       comdat_linkage (decl1);
13501       DECL_EXTERNAL (decl1) = 0;
13502       DECL_INTERFACE_KNOWN (decl1) = 1;
13503       DECL_DEFER_OUTPUT (decl1) = 1;
13504     }
13505   else
13506     {
13507       /* This is a definition, not a reference.
13508          So clear DECL_EXTERNAL.  */
13509       DECL_EXTERNAL (decl1) = 0;
13510
13511       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13512           && ! DECL_INTERFACE_KNOWN (decl1)
13513           /* Don't try to defer nested functions for now.  */
13514           && ! decl_function_context (decl1))
13515         DECL_DEFER_OUTPUT (decl1) = 1;
13516       else
13517         DECL_INTERFACE_KNOWN (decl1) = 1;
13518     }
13519
13520   pushlevel (0);
13521   current_binding_level->parm_flag = 1;
13522
13523   if (attrs)
13524     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13525
13526   /* We need to do this even if we aren't expanding yet so that
13527      assemble_external works.  */
13528   make_decl_rtl (decl1, NULL);
13529
13530   /* Promote the value to int before returning it.  */
13531   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13532     restype = type_promotes_to (restype);
13533
13534   /* If this fcn was already referenced via a block-scope `extern' decl
13535      (or an implicit decl), propagate certain information about the usage.  */
13536   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13537     TREE_ADDRESSABLE (decl1) = 1;
13538
13539   if (DECL_RESULT (decl1) == NULL_TREE)
13540     {
13541       DECL_RESULT (decl1)
13542         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13543       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13544       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13545     }
13546
13547   ++function_depth;
13548
13549   if (DECL_DESTRUCTOR_P (decl1))
13550     {
13551       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13552       DECL_CONTEXT (dtor_label) = current_function_decl;
13553     }
13554
13555   store_parm_decls (current_function_parms);
13556
13557   return 1;
13558 }
13559 \f
13560 /* Store the parameter declarations into the current function declaration.
13561    This is called after parsing the parameter declarations, before
13562    digesting the body of the function.
13563
13564    Also install to binding contour return value identifier, if any.  */
13565
13566 static void
13567 store_parm_decls (current_function_parms)
13568      tree current_function_parms;
13569 {
13570   register tree fndecl = current_function_decl;
13571   register tree parm;
13572   int parms_have_cleanups = 0;
13573   tree cleanups = NULL_TREE;
13574
13575   /* This is a list of types declared among parms in a prototype.  */
13576   tree parmtags = current_function_parm_tags;
13577
13578   /* This is a chain of any other decls that came in among the parm
13579      declarations.  If a parm is declared with  enum {foo, bar} x;
13580      then CONST_DECLs for foo and bar are put here.  */
13581   tree nonparms = NULL_TREE;
13582
13583   if (current_function_parms)
13584     {
13585       /* This case is when the function was defined with an ANSI prototype.
13586          The parms already have decls, so we need not do anything here
13587          except record them as in effect
13588          and complain if any redundant old-style parm decls were written.  */
13589
13590       tree specparms = current_function_parms;
13591       tree next;
13592
13593       /* Must clear this because it might contain TYPE_DECLs declared
13594              at class level.  */
13595       storedecls (NULL_TREE);
13596
13597       /* If we're doing semantic analysis, then we'll call pushdecl
13598              for each of these.  We must do them in reverse order so that
13599              they end in the correct forward order.  */
13600       specparms = nreverse (specparms);
13601
13602       for (parm = specparms; parm; parm = next)
13603         {
13604           next = TREE_CHAIN (parm);
13605           if (TREE_CODE (parm) == PARM_DECL)
13606             {
13607               tree cleanup;
13608
13609               if (DECL_NAME (parm) == NULL_TREE
13610                   || TREE_CODE (parm) != VOID_TYPE)
13611                 pushdecl (parm);
13612               else
13613                 cp_error ("parameter `%D' declared void", parm);
13614
13615               cleanup = (processing_template_decl
13616                          ? NULL_TREE
13617                          : maybe_build_cleanup (parm));
13618
13619               if (cleanup)
13620                 cleanups = tree_cons (parm, cleanup, cleanups);
13621             }
13622           else
13623             {
13624               /* If we find an enum constant or a type tag,
13625                  put it aside for the moment.  */
13626               TREE_CHAIN (parm) = NULL_TREE;
13627               nonparms = chainon (nonparms, parm);
13628             }
13629         }
13630
13631       /* Get the decls in their original chain order and record in the
13632          function.  This is all and only the PARM_DECLs that were
13633          pushed into scope by the loop above.  */
13634       DECL_ARGUMENTS (fndecl) = getdecls ();
13635       storetags (chainon (parmtags, gettags ()));
13636     }
13637   else
13638     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13639
13640   /* Now store the final chain of decls for the arguments
13641      as the decl-chain of the current lexical scope.
13642      Put the enumerators in as well, at the front so that
13643      DECL_ARGUMENTS is not modified.  */
13644   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13645
13646   /* Now that we have initialized the parms, we can start their
13647      cleanups.  We cannot do this before, since expand_decl_cleanup
13648      should not be called before the parm can be used.  */
13649   while (cleanups)
13650     {
13651       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13652                            TREE_VALUE (cleanups));
13653       cleanups = TREE_CHAIN (cleanups);
13654     }
13655
13656   /* Create a binding contour which can be used to catch
13657      cleanup-generated temporaries.  */
13658   if (parms_have_cleanups)
13659     pushlevel (0);
13660
13661   /* Do the starting of the exception specifications, if we have any.  */
13662   if (flag_exceptions && !processing_template_decl
13663       && flag_enforce_eh_specs
13664       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13665     current_eh_spec_try_block = expand_start_eh_spec ();
13666 }
13667
13668 \f
13669 /* We have finished doing semantic analysis on DECL, but have not yet
13670    generated RTL for its body.  Save away our current state, so that
13671    when we want to generate RTL later we know what to do.  */
13672
13673 static void
13674 save_function_data (decl)
13675      tree decl;
13676 {
13677   struct cp_language_function *f;
13678
13679   /* Save the language-specific per-function data so that we can
13680      get it back when we really expand this function.  */
13681   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13682                       19990908);
13683
13684   /* Make a copy.  */
13685   f = ((struct cp_language_function *)
13686        xmalloc (sizeof (struct cp_language_function)));
13687   memcpy (f, cp_function_chain, sizeof (struct cp_language_function));
13688   DECL_SAVED_FUNCTION_DATA (decl) = f;
13689
13690   /* Clear out the bits we don't need.  */
13691   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
13692   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
13693   f->x_named_label_uses = NULL;
13694   f->bindings = NULL;
13695
13696   /* When we get back here again, we will be expanding.  */
13697   f->x_expanding_p = 1;
13698
13699   /* If we've already decided that we cannot inline this function, we
13700      must remember that fact when we actually go to expand the
13701      function.  */
13702   f->cannot_inline = current_function_cannot_inline;
13703 }
13704
13705 /* At the end of every constructor we generate to code to return
13706    `this'.  Do that now.  */
13707
13708 static void
13709 finish_constructor_body ()
13710 {
13711   /* Any return from a constructor will end up here.  */
13712   if (ctor_label)
13713     add_stmt (build_stmt (LABEL_STMT, ctor_label));
13714
13715   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13716      generate the return, rather than a goto to CTOR_LABEL.  */
13717   ctor_label = NULL_TREE;
13718   /* In check_return_expr we translate an empty return from a
13719      constructor to a return of `this'.  */
13720   finish_return_stmt (NULL_TREE);
13721   /* Mark the end of the constructor.  */
13722   add_stmt (build_stmt (CTOR_STMT));
13723 }
13724
13725 /* At the end of every destructor we generate code to restore virtual
13726    function tables to the values desired by base classes and to call
13727    to base class destructors.  Do that now.  */
13728
13729 static void
13730 finish_destructor_body ()
13731 {
13732   tree compound_stmt;
13733   tree virtual_size;
13734   tree exprstmt;
13735   tree if_stmt;
13736
13737   /* Create a block to contain all the extra code.  */
13738   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13739
13740   /* Any return from a destructor will end up here.  */
13741   add_stmt (build_stmt (LABEL_STMT, dtor_label));
13742
13743   /* Generate the code to call destructor on base class.  If this
13744      destructor belongs to a class with virtual functions, then set
13745      the virtual function table pointer to represent the type of our
13746      base class.  */
13747
13748   /* This side-effect makes call to `build_delete' generate the code
13749      we have to have at the end of this destructor.  `build_delete'
13750      will set the flag again.  */
13751   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13752
13753   exprstmt = build_delete (current_class_type,
13754                            current_class_ref,
13755                            sfk_base_destructor,
13756                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13757                            0);
13758
13759   if (exprstmt != error_mark_node
13760       && (TREE_CODE (exprstmt) != NOP_EXPR
13761           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13762           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13763     {
13764       if (exprstmt != void_zero_node)
13765         /* Don't call `expand_expr_stmt' if we're not going to do
13766            anything, since -Wall will give a diagnostic.  */
13767         finish_expr_stmt (exprstmt);
13768
13769       /* Run destructors for all virtual baseclasses.  */
13770       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13771         {
13772           tree vbases;
13773           tree if_stmt;
13774
13775           if_stmt = begin_if_stmt ();
13776           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13777                                       current_in_charge_parm,
13778                                       integer_two_node),
13779                                if_stmt);
13780
13781           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
13782           /* The CLASSTYPE_VBASECLASSES list is in initialization
13783              order, so we have to march through it in reverse order.  */
13784           for (vbases = nreverse (copy_list (vbases));
13785                vbases;
13786                vbases = TREE_CHAIN (vbases))
13787             {
13788               tree vbase = TREE_VALUE (vbases);
13789               tree base_type = BINFO_TYPE (vbase);
13790
13791               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (base_type))
13792                 {
13793                   tree base_ptr_type = build_pointer_type (base_type);
13794                   tree expr = current_class_ptr;
13795
13796                   /* Convert to the basetype here, as we know the layout is
13797                      fixed. What is more, if we let build_method_call do it,
13798                      it will use the vtable, which may have been clobbered
13799                      by the deletion of our primary base.  */
13800
13801                   expr = build1 (NOP_EXPR, base_ptr_type, expr);
13802                   expr = build (PLUS_EXPR, base_ptr_type, expr,
13803                                 BINFO_OFFSET (vbase));
13804                   expr = build_indirect_ref (expr, NULL);
13805                   expr = build_method_call (expr, base_dtor_identifier,
13806                                             NULL_TREE, vbase,
13807                                             LOOKUP_NORMAL);
13808                   finish_expr_stmt (expr);
13809                 }
13810             }
13811
13812           finish_then_clause (if_stmt);
13813           finish_if_stmt ();
13814         }
13815     }
13816
13817   virtual_size = c_sizeof (current_class_type);
13818
13819   /* At the end, call delete if that's what's requested.  */
13820
13821   /* FDIS sez: At the point of definition of a virtual destructor
13822      (including an implicit definition), non-placement operator delete
13823      shall be looked up in the scope of the destructor's class and if
13824      found shall be accessible and unambiguous.
13825
13826      This is somewhat unclear, but I take it to mean that if the class
13827      only defines placement deletes we don't do anything here.  So we
13828      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
13829      they ever try to delete one of these.  */
13830   exprstmt = build_op_delete_call
13831     (DELETE_EXPR, current_class_ptr, virtual_size,
13832      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13833
13834   if_stmt = begin_if_stmt ();
13835   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13836                               current_in_charge_parm,
13837                               integer_one_node),
13838                        if_stmt);
13839   finish_expr_stmt (exprstmt);
13840   finish_then_clause (if_stmt);
13841   finish_if_stmt ();
13842
13843   /* Close the block we started above.  */
13844   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13845 }
13846
13847 /* Finish up a function declaration and compile that function
13848    all the way to assembler language output.  The free the storage
13849    for the function definition.
13850
13851    FLAGS is a bitwise or of the following values:
13852      1 - CALL_POPLEVEL
13853        An extra call to poplevel (and expand_end_bindings) must be
13854        made to take care of the binding contour for the base
13855        initializers.  This is only relevant for constructors.
13856      2 - INCLASS_INLINE
13857        We just finished processing the body of an in-class inline
13858        function definition.  (This processing will have taken place
13859        after the class definition is complete.)  */
13860
13861 tree
13862 finish_function (flags)
13863      int flags;
13864 {
13865   register tree fndecl = current_function_decl;
13866   tree fntype, ctype = NULL_TREE;
13867   int call_poplevel = (flags & 1) != 0;
13868   int inclass_inline = (flags & 2) != 0;
13869   int nested;
13870
13871   /* When we get some parse errors, we can end up without a
13872      current_function_decl, so cope.  */
13873   if (fndecl == NULL_TREE)
13874     return error_mark_node;
13875
13876   nested = function_depth > 1;
13877   fntype = TREE_TYPE (fndecl);
13878
13879   /*  TREE_READONLY (fndecl) = 1;
13880       This caused &foo to be of type ptr-to-const-function
13881       which then got a warning when stored in a ptr-to-function variable.  */
13882
13883   my_friendly_assert (building_stmt_tree (), 20000911);
13884
13885   /* For a cloned function, we've already got all the code we need;
13886      there's no need to add any extra bits.  */
13887   if (!DECL_CLONED_FUNCTION_P (fndecl))
13888     {
13889       if (DECL_CONSTRUCTOR_P (fndecl))
13890         {
13891           finish_constructor_body ();
13892           if (call_poplevel)
13893             do_poplevel ();
13894         }
13895       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
13896         finish_destructor_body ();
13897       else if (DECL_MAIN_P (fndecl))
13898         {
13899           /* Make it so that `main' always returns 0 by default.  */
13900 #ifdef VMS
13901           finish_return_stmt (integer_one_node);
13902 #else
13903           finish_return_stmt (integer_zero_node);
13904 #endif
13905         }
13906
13907       /* Finish dealing with exception specifiers.  */
13908       if (flag_exceptions && !processing_template_decl
13909           && flag_enforce_eh_specs
13910           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13911         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
13912                             (TREE_TYPE (current_function_decl)),
13913                             current_eh_spec_try_block);
13914     }
13915
13916   /* If we're saving up tree structure, tie off the function now.  */
13917   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
13918
13919   /* This must come after expand_function_end because cleanups might
13920      have declarations (from inline functions) that need to go into
13921      this function's blocks.  */
13922   if (current_binding_level->parm_flag != 1)
13923     my_friendly_abort (122);
13924   poplevel (1, 0, 1);
13925
13926   /* Remember that we were in class scope.  */
13927   if (current_class_name)
13928     ctype = current_class_type;
13929
13930   /* Must mark the RESULT_DECL as being in this function.  */
13931   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
13932
13933   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13934      to the FUNCTION_DECL node itself.  */
13935   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
13936
13937   /* Save away current state, if appropriate.  */
13938   if (!processing_template_decl)
13939     save_function_data (fndecl);
13940
13941   /* If this function calls `setjmp' it cannot be inlined.  When
13942      `longjmp' is called it is not guaranteed to restore the value of
13943      local variables that have been modified since the call to
13944      `setjmp'.  So, if were to inline this function into some caller
13945      `c', then when we `longjmp', we might not restore all variables
13946      in `c'.  (It might seem, at first blush, that there's no way for
13947      this function to modify local variables in `c', but their
13948      addresses may have been stored somewhere accessible to this
13949      function.)  */
13950   if (!processing_template_decl && calls_setjmp_p (fndecl))
13951     DECL_UNINLINABLE (fndecl) = 1;
13952
13953   /* Clear out memory we no longer need.  */
13954   free_after_parsing (cfun);
13955   /* Since we never call rest_of_compilation, we never clear
13956      CFUN.  Do so explicitly.  */
13957   free_after_compilation (cfun);
13958   cfun = NULL;
13959
13960   /* If this is a in-class inline definition, we may have to pop the
13961      bindings for the template parameters that we added in
13962      maybe_begin_member_template_processing when start_function was
13963      called.  */
13964   if (inclass_inline)
13965     maybe_end_member_template_processing ();
13966
13967   /* Leave the scope of the class.  */
13968   if (ctype)
13969     pop_nested_class ();
13970
13971   --function_depth;
13972
13973   /* Clean up.  */
13974   if (! nested)
13975     /* Let the error reporting routines know that we're outside a
13976        function.  For a nested function, this value is used in
13977        pop_cp_function_context and then reset via pop_function_context.  */
13978     current_function_decl = NULL_TREE;
13979
13980   return fndecl;
13981 }
13982 \f
13983 /* Create the FUNCTION_DECL for a function definition.
13984    DECLSPECS and DECLARATOR are the parts of the declaration;
13985    they describe the return type and the name of the function,
13986    but twisted together in a fashion that parallels the syntax of C.
13987
13988    This function creates a binding context for the function body
13989    as well as setting up the FUNCTION_DECL in current_function_decl.
13990
13991    Returns a FUNCTION_DECL on success.
13992
13993    If the DECLARATOR is not suitable for a function (it defines a datum
13994    instead), we return 0, which tells yyparse to report a parse error.
13995
13996    May return void_type_node indicating that this method is actually
13997    a friend.  See grokfield for more details.
13998
13999    Came here with a `.pushlevel' .
14000
14001    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14002    CHANGES TO CODE IN `grokfield'.  */
14003
14004 tree
14005 start_method (declspecs, declarator, attrlist)
14006      tree declarator, declspecs, attrlist;
14007 {
14008   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14009                                 attrlist);
14010
14011   /* Something too ugly to handle.  */
14012   if (fndecl == NULL_TREE)
14013     return NULL_TREE;
14014
14015   /* Pass friends other than inline friend functions back.  */
14016   if (fndecl == void_type_node)
14017     return fndecl;
14018
14019   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14020     /* Not a function, tell parser to report parse error.  */
14021     return NULL_TREE;
14022
14023   if (DECL_IN_AGGR_P (fndecl))
14024     {
14025       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14026         {
14027           if (DECL_CONTEXT (fndecl)
14028               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14029             cp_error ("`%D' is already defined in class `%T'", fndecl,
14030                       DECL_CONTEXT (fndecl));
14031         }
14032       return void_type_node;
14033     }
14034
14035   check_template_shadow (fndecl);
14036
14037   DECL_THIS_INLINE (fndecl) = 1;
14038
14039   if (flag_default_inline)
14040     DECL_INLINE (fndecl) = 1;
14041
14042   /* We process method specializations in finish_struct_1.  */
14043   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14044     fndecl = push_template_decl (fndecl);
14045
14046   if (! DECL_FRIEND_P (fndecl))
14047     {
14048       if (TREE_CHAIN (fndecl))
14049         {
14050           fndecl = copy_node (fndecl);
14051           TREE_CHAIN (fndecl) = NULL_TREE;
14052         }
14053
14054       if (DECL_CONSTRUCTOR_P (fndecl))
14055         {
14056           if (! grok_ctor_properties (current_class_type, fndecl))
14057             return void_type_node;
14058         }
14059       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14060         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14061     }
14062
14063   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14064
14065   /* Make a place for the parms */
14066   pushlevel (0);
14067   current_binding_level->parm_flag = 1;
14068
14069   DECL_IN_AGGR_P (fndecl) = 1;
14070   return fndecl;
14071 }
14072
14073 /* Go through the motions of finishing a function definition.
14074    We don't compile this method until after the whole class has
14075    been processed.
14076
14077    FINISH_METHOD must return something that looks as though it
14078    came from GROKFIELD (since we are defining a method, after all).
14079
14080    This is called after parsing the body of the function definition.
14081    STMTS is the chain of statements that makes up the function body.
14082
14083    DECL is the ..._DECL that `start_method' provided.  */
14084
14085 tree
14086 finish_method (decl)
14087      tree decl;
14088 {
14089   register tree fndecl = decl;
14090   tree old_initial;
14091
14092   register tree link;
14093
14094   if (decl == void_type_node)
14095     return decl;
14096
14097   old_initial = DECL_INITIAL (fndecl);
14098
14099   /* Undo the level for the parms (from start_method).
14100      This is like poplevel, but it causes nothing to be
14101      saved.  Saving information here confuses symbol-table
14102      output routines.  Besides, this information will
14103      be correctly output when this method is actually
14104      compiled.  */
14105
14106   /* Clear out the meanings of the local variables of this level;
14107      also record in each decl which block it belongs to.  */
14108
14109   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14110     {
14111       if (DECL_NAME (link) != NULL_TREE)
14112         pop_binding (DECL_NAME (link), link);
14113       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14114       DECL_CONTEXT (link) = NULL_TREE;
14115     }
14116
14117   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14118                       (HOST_WIDE_INT) current_binding_level->level_chain,
14119                       current_binding_level->parm_flag,
14120                       current_binding_level->keep);
14121
14122   poplevel (0, 0, 0);
14123
14124   DECL_INITIAL (fndecl) = old_initial;
14125
14126   /* We used to check if the context of FNDECL was different from
14127      current_class_type as another way to get inside here.  This didn't work
14128      for String.cc in libg++.  */
14129   if (DECL_FRIEND_P (fndecl))
14130     {
14131       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14132         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14133       decl = void_type_node;
14134     }
14135
14136   return decl;
14137 }
14138 \f
14139 /* Called when a new struct TYPE is defined.
14140    If this structure or union completes the type of any previous
14141    variable declaration, lay it out and output its rtl.  */
14142
14143 void
14144 hack_incomplete_structures (type)
14145      tree type;
14146 {
14147   tree *list;
14148   struct binding_level *level;
14149
14150   if (!type) /* Don't do this for class templates.  */
14151     return;
14152
14153   if (namespace_bindings_p ())
14154     {
14155       level = 0;
14156       list = &namespace_scope_incomplete;
14157     }
14158   else
14159     {
14160       level = innermost_nonclass_level ();
14161       list = &level->incomplete;
14162     }
14163
14164   while (1)
14165     {
14166       while (*list)
14167         {
14168           tree decl = TREE_VALUE (*list);
14169           if ((decl && TREE_TYPE (decl) == type)
14170               || (TREE_TYPE (decl)
14171                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14172                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14173             {
14174               int toplevel = toplevel_bindings_p ();
14175               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14176                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14177                 layout_type (TREE_TYPE (decl));
14178               layout_decl (decl, 0);
14179               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14180               if (! toplevel)
14181                 {
14182                   tree cleanup;
14183                   expand_decl (decl);
14184                   cleanup = maybe_build_cleanup (decl);
14185                   expand_decl_init (decl);
14186                   if (! expand_decl_cleanup (decl, cleanup))
14187                     cp_error ("parser lost in parsing declaration of `%D'",
14188                               decl);
14189                 }
14190               *list = TREE_CHAIN (*list);
14191             }
14192           else
14193             list = &TREE_CHAIN (*list);
14194         }
14195
14196       /* Keep looking through artificial binding levels generated
14197          for local variables.  */
14198       if (level && level->keep == 2)
14199         {
14200           level = level->level_chain;
14201           list = &level->incomplete;
14202         }
14203       else
14204         break;
14205     }
14206 }
14207
14208 /* If DECL is of a type which needs a cleanup, build that cleanup
14209    here.  */
14210
14211 tree
14212 maybe_build_cleanup (decl)
14213      tree decl;
14214 {
14215   tree type = TREE_TYPE (decl);
14216
14217   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14218     {
14219       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14220       tree rval;
14221
14222       if (TREE_CODE (type) == ARRAY_TYPE)
14223         rval = decl;
14224       else
14225         {
14226           mark_addressable (decl);
14227           rval = build_unary_op (ADDR_EXPR, decl, 0);
14228         }
14229
14230       /* Optimize for space over speed here.  */
14231       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14232           || flag_expensive_optimizations)
14233         flags |= LOOKUP_NONVIRTUAL;
14234
14235       rval = build_delete (TREE_TYPE (rval), rval,
14236                            sfk_complete_destructor, flags, 0);
14237
14238       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14239           && ! TYPE_HAS_DESTRUCTOR (type))
14240         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14241                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14242
14243       return rval;
14244     }
14245   return 0;
14246 }
14247 \f
14248 /* When a stmt has been parsed, this function is called.  */
14249
14250 void
14251 finish_stmt ()
14252 {
14253   /* Always assume this statement was not an expression statement.  If
14254      it actually was an expression statement, its our callers
14255      responsibility to fix this up.  */
14256   last_expr_type = NULL_TREE;
14257 }
14258
14259 /* DECL was originally constructed as a non-static member function,
14260    but turned out to be static.  Update it accordingly.  */
14261
14262 void
14263 revert_static_member_fn (decl)
14264      tree decl;
14265 {
14266   tree tmp;
14267   tree function = TREE_TYPE (decl);
14268   tree args = TYPE_ARG_TYPES (function);
14269
14270   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14271       != TYPE_UNQUALIFIED)
14272     cp_error ("static member function `%#D' declared with type qualifiers",
14273               decl);
14274
14275   args = TREE_CHAIN (args);
14276   tmp = build_function_type (TREE_TYPE (function), args);
14277   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14278   tmp = build_exception_variant (tmp,
14279                                  TYPE_RAISES_EXCEPTIONS (function));
14280   TREE_TYPE (decl) = tmp;
14281   if (DECL_ARGUMENTS (decl))
14282     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14283   DECL_STATIC_FUNCTION_P (decl) = 1;
14284 }
14285
14286 /* Initialize the variables used during compilation of a C++
14287    function.  */
14288
14289 static void
14290 push_cp_function_context (f)
14291      struct function *f;
14292 {
14293   struct cp_language_function *p
14294     = ((struct cp_language_function *)
14295        xcalloc (1, sizeof (struct cp_language_function)));
14296   f->language = (struct language_function *) p;
14297
14298   /* It takes an explicit call to expand_body to generate RTL for a
14299      function.  */
14300   expanding_p = 0;
14301
14302   /* Whenever we start a new function, we destroy temporaries in the
14303      usual way.  */
14304   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14305 }
14306
14307 /* Free the language-specific parts of F, now that we've finished
14308    compiling the function.  */
14309
14310 static void
14311 pop_cp_function_context (f)
14312      struct function *f;
14313 {
14314   if (f->language)
14315     free (f->language);
14316   f->language = 0;
14317 }
14318
14319 /* Mark P for GC.  */
14320
14321 static void
14322 mark_lang_function (p)
14323      struct cp_language_function *p;
14324 {
14325   if (!p)
14326     return;
14327
14328   mark_c_language_function (&p->base);
14329
14330   ggc_mark_tree (p->x_ctor_label);
14331   ggc_mark_tree (p->x_dtor_label);
14332   ggc_mark_tree (p->x_current_class_ptr);
14333   ggc_mark_tree (p->x_current_class_ref);
14334   ggc_mark_tree (p->x_eh_spec_try_block);
14335
14336   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14337   mark_binding_level (&p->bindings);
14338 }
14339
14340 /* Mark the language-specific data in F for GC.  */
14341
14342 static void
14343 mark_cp_function_context (f)
14344      struct function *f;
14345 {
14346   mark_lang_function ((struct cp_language_function *) f->language);
14347 }
14348
14349 void
14350 lang_mark_tree (t)
14351      tree t;
14352 {
14353   enum tree_code code = TREE_CODE (t);
14354   if (code == IDENTIFIER_NODE)
14355     {
14356       struct lang_identifier *li = (struct lang_identifier *) t;
14357       struct lang_id2 *li2 = li->x;
14358       ggc_mark_tree (li->namespace_bindings);
14359       ggc_mark_tree (li->bindings);
14360       ggc_mark_tree (li->class_value);
14361       ggc_mark_tree (li->class_template_info);
14362
14363       if (li2)
14364         {
14365           ggc_mark_tree (li2->label_value);
14366           ggc_mark_tree (li2->implicit_decl);
14367           ggc_mark_tree (li2->error_locus);
14368         }
14369     }
14370   else if (code == CPLUS_BINDING)
14371     {
14372       if (BINDING_HAS_LEVEL_P (t))
14373         mark_binding_level (&BINDING_LEVEL (t));
14374       else
14375         ggc_mark_tree (BINDING_SCOPE (t));
14376       ggc_mark_tree (BINDING_VALUE (t));
14377     }
14378   else if (code == OVERLOAD)
14379     ggc_mark_tree (OVL_FUNCTION (t));
14380   else if (code == TEMPLATE_PARM_INDEX)
14381     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14382   else if (TREE_CODE_CLASS (code) == 'd')
14383     {
14384       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14385
14386       if (ld)
14387         {
14388           ggc_mark (ld);
14389           c_mark_lang_decl (&ld->decl_flags.base);
14390           if (!DECL_GLOBAL_CTOR_P (t)
14391               && !DECL_GLOBAL_DTOR_P (t)
14392               && !DECL_THUNK_P (t))
14393             ggc_mark_tree (ld->decl_flags.u2.access);
14394           else if (DECL_THUNK_P (t))
14395             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14396           if (TREE_CODE (t) != NAMESPACE_DECL)
14397             ggc_mark_tree (ld->decl_flags.u.template_info);
14398           else
14399             mark_binding_level (&NAMESPACE_LEVEL (t));
14400           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14401             {
14402               ggc_mark_tree (ld->befriending_classes);
14403               ggc_mark_tree (ld->context);
14404               ggc_mark_tree (ld->cloned_function);
14405               if (!DECL_OVERLOADED_OPERATOR_P (t))
14406                 ggc_mark_tree (ld->u2.vtt_parm);
14407               if (TREE_CODE (t) == TYPE_DECL)
14408                 ggc_mark_tree (ld->u.sorted_fields);
14409               else if (TREE_CODE (t) == FUNCTION_DECL
14410                        && !DECL_PENDING_INLINE_P (t))
14411                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14412             }
14413         }
14414     }
14415   else if (TREE_CODE_CLASS (code) == 't')
14416     {
14417       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14418
14419       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14420                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14421         {
14422           ggc_mark (lt);
14423           ggc_mark_tree (lt->primary_base);
14424           ggc_mark_tree (lt->vfields);
14425           ggc_mark_tree (lt->vbases);
14426           ggc_mark_tree (lt->tags);
14427           ggc_mark_tree (lt->size);
14428           ggc_mark_tree (lt->pure_virtuals);
14429           ggc_mark_tree (lt->friend_classes);
14430           ggc_mark_tree (lt->rtti);
14431           ggc_mark_tree (lt->methods);
14432           ggc_mark_tree (lt->template_info);
14433           ggc_mark_tree (lt->befriending_classes);
14434         }
14435       else if (lt)
14436         /* In the case of pointer-to-member function types, the
14437            TYPE_LANG_SPECIFIC is really just a tree.  */
14438         ggc_mark_tree ((tree) lt);
14439     }
14440 }
14441
14442 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14443    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
14444
14445 tree
14446 identifier_global_value (t)
14447      tree t;
14448 {
14449   return IDENTIFIER_GLOBAL_VALUE (t);
14450 }
14451
14452 /* Build the void_list_node (void_type_node having been created).  */
14453 tree
14454 build_void_list_node ()
14455 {
14456   tree t = build_tree_list (NULL_TREE, void_type_node);
14457   TREE_PARMLIST (t) = 1;
14458   return t;
14459 }
14460
14461 static int
14462 cp_missing_noreturn_ok_p (decl)
14463      tree decl;
14464 {
14465   /* A missing noreturn is ok for the `main' function.  */
14466   return MAIN_NAME_P (DECL_ASSEMBLER_NAME (decl));
14467 }