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    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 "defaults.h"
  41 #include "output.h"
  42 #include "except.h"
  43 #include "toplev.h"
  44 #include "../hash.h"
  45 #include "ggc.h"
  46 #include "tm_p.h"
  47
  48 extern int current_class_depth;
  49
  50 extern tree global_namespace;
  51
  52 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  53
  54 #ifndef BOOL_TYPE_SIZE
  55 #ifdef SLOW_BYTE_ACCESS
  56 /* In the new ABI, `bool' has size and alignment `1', on all
  57    platforms.  */
  58 #define BOOL_TYPE_SIZE \
  59   ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
  60 #else
  61 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  62 #endif
  63 #endif
  64
  65 /* We let tm.h override the types used here, to handle trivial differences
  66    such as the choice of unsigned int or long unsigned int for size_t.
  67    When machines start needing nontrivial differences in the size type,
  68    it would be best to do something here to figure out automatically
  69    from other information what type to use.  */
  70
  71 #ifndef SIZE_TYPE
  72 #define SIZE_TYPE "long unsigned int"
  73 #endif
  74
  75 #ifndef PTRDIFF_TYPE
  76 #define PTRDIFF_TYPE "long int"
  77 #endif
  78
  79 #ifndef WCHAR_TYPE
  80 #define WCHAR_TYPE "int"
  81 #endif
  82
  83 static tree grokparms                           PARAMS ((tree));
  84 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  85
  86 static void push_binding_level PARAMS ((struct binding_level *, int,
  87                                       int));
  88 static void pop_binding_level PARAMS ((void));
  89 static void suspend_binding_level PARAMS ((void));
  90 static void resume_binding_level PARAMS ((struct binding_level *));
  91 static struct binding_level *make_binding_level PARAMS ((void));
  92 static void declare_namespace_level PARAMS ((void));
  93 static int decl_jump_unsafe PARAMS ((tree));
  94 static void storedecls PARAMS ((tree));
  95 static void require_complete_types_for_parms PARAMS ((tree));
  96 static int ambi_op_p PARAMS ((enum tree_code));
  97 static int unary_op_p PARAMS ((enum tree_code));
  98 static tree store_bindings PARAMS ((tree, tree));
  99 static tree lookup_tag_reverse PARAMS ((tree, tree));
 100 static tree obscure_complex_init PARAMS ((tree, tree));
 101 static tree lookup_name_real PARAMS ((tree, int, int, int));
 102 static void warn_extern_redeclared_static PARAMS ((tree, tree));
 103 static void grok_reference_init PARAMS ((tree, tree, tree));
 104 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
 105                               enum overload_flags, tree,
 106                               tree, int, int, int, int, int, int, tree));
 107 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
 108 static tree lookup_tag PARAMS ((enum tree_code, tree,
 109                               struct binding_level *, int));
 110 static void set_identifier_type_value_with_scope
 111         PARAMS ((tree, tree, struct binding_level *));
 112 static void record_builtin_type PARAMS ((enum rid, const char *, tree));
 113 static void record_unknown_type PARAMS ((tree, const char *));
 114 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
 115 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
 116 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
 117                                   int));
 118 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
 119 static void check_for_uninitialized_const_var PARAMS ((tree));
 120 static unsigned long typename_hash PARAMS ((hash_table_key));
 121 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
 122 static void push_binding PARAMS ((tree, tree, struct binding_level*));
 123 static int add_binding PARAMS ((tree, tree));
 124 static void pop_binding PARAMS ((tree, tree));
 125 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 126 static tree find_binding PARAMS ((tree, tree));
 127 static tree select_decl PARAMS ((tree, int));
 128 static int lookup_flags PARAMS ((int, int));
 129 static tree qualify_lookup PARAMS ((tree, int));
 130 static tree record_builtin_java_type PARAMS ((const char *, int));
 131 static const char *tag_name PARAMS ((enum tag_types code));
 132 static void find_class_binding_level PARAMS ((void));
 133 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 134 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 135 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 136 static int walk_globals_r PARAMS ((tree, void *));
 137 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 138 static tree make_label_decl PARAMS ((tree, int));
 139 static void use_label PARAMS ((tree));
 140 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 141                                            const char *, int));
 142 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 143 static void check_switch_goto PARAMS ((struct binding_level *));
 144 static void check_previous_gotos PARAMS ((tree));
 145 static void pop_label PARAMS ((tree, tree));
 146 static void pop_labels PARAMS ((tree));
 147 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 148 static void layout_var_decl PARAMS ((tree));
 149 static void maybe_commonize_var PARAMS ((tree));
 150 static tree check_initializer PARAMS ((tree, tree));
 151 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 152 static void push_cp_function_context PARAMS ((struct function *));
 153 static void pop_cp_function_context PARAMS ((struct function *));
 154 static void mark_binding_level PARAMS ((void *));
 155 static void mark_named_label_lists PARAMS ((void *, void *));
 156 static void mark_cp_function_context PARAMS ((struct function *));
 157 static void mark_saved_scope PARAMS ((void *));
 158 static void mark_lang_function PARAMS ((struct cp_language_function *));
 159 static void save_function_data PARAMS ((tree));
 160 static void check_function_type PARAMS ((tree, tree));
 161 static void destroy_local_var PARAMS ((tree));
 162 static void finish_constructor_body PARAMS ((void));
 163 static void finish_destructor_body PARAMS ((void));
 164 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 165 static tree get_atexit_node PARAMS ((void));
 166 static tree get_dso_handle_node PARAMS ((void));
 167 static tree start_cleanup_fn PARAMS ((void));
 168 static void end_cleanup_fn PARAMS ((void));
 169 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
 170 static void initialize_predefined_identifiers PARAMS ((void));
 171 static tree check_special_function_return_type
 172   PARAMS ((special_function_kind, tree, tree, tree));
 173 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 174 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 175 static void store_parm_decls PARAMS ((tree));
 176
 177 #if defined (DEBUG_CP_BINDING_LEVELS)
 178 static void indent PARAMS ((void));
 179 #endif
 180
 181 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 182 tree error_mark_list;
 183
 184 /* The following symbols are subsumed in the cp_global_trees array, and
 185    listed here individually for documentation purposes.
 186
 187    C++ extensions
 188         tree wchar_decl_node;
 189
 190         tree vtable_entry_type;
 191         tree delta_type_node;
 192 #if 0
 193    Old rtti stuff.
 194         tree __baselist_desc_type_node;
 195         tree __i_desc_type_node, __m_desc_type_node;
 196         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 197 #endif
 198         tree __t_desc_type_node;
 199 #if 0
 200         tree __tp_desc_type_node;
 201 #endif
 202         tree ti_desc_type_node;
 203         tree bltn_desc_type_node, ptr_desc_type_node;
 204         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 205         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 206         tree ptm_desc_type_node;
 207         tree base_desc_type_node;
 208 #if 0
 209    Not needed yet?  May be needed one day?
 210         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 211         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 212         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 213 #endif
 214
 215         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 216         tree unknown_type_node;
 217
 218    Array type `vtable_entry_type[]'
 219
 220         tree vtbl_type_node;
 221         tree vtbl_ptr_type_node;
 222
 223    Namespaces,
 224
 225         tree std_node;
 226         tree abi_node;
 227
 228    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 229    one that the user will declare, but sufficient to be called
 230    by routines that want to abort the program.
 231
 232         tree abort_fndecl;
 233
 234    The FUNCTION_DECL for the default `::operator delete'.
 235
 236         tree global_delete_fndecl;
 237
 238    Used by RTTI
 239         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 240         tree tinfo_var_id;
 241
 242 */
 243
 244 tree cp_global_trees[CPTI_MAX];
 245
 246 /* Indicates that there is a type value in some namespace, although
 247    that is not necessarily in scope at the moment.  */
 248
 249 static tree global_type_node;
 250
 251 /* If non-zero, this is the number of times we have entered the `std'
 252    namespace when we are treating that namespace as an alias for the
 253    global namespace.  */
 254 static int in_fake_std;
 255
 256 /* Expect only namespace names now. */
 257 static int only_namespace_names;
 258
 259 /* Used only for jumps to as-yet undefined labels, since jumps to
 260    defined labels can have their validity checked immediately.  */
 261
 262 struct named_label_use_list
 263 {
 264   struct binding_level *binding_level;
 265   tree names_in_scope;
 266   tree label_decl;
 267   const char *filename_o_goto;
 268   int lineno_o_goto;
 269   struct named_label_use_list *next;
 270 };
 271
 272 #define named_label_uses cp_function_chain->x_named_label_uses
 273
 274 /* A list of objects which have constructors or destructors
 275    which reside in the global scope.  The decl is stored in
 276    the TREE_VALUE slot and the initializer is stored
 277    in the TREE_PURPOSE slot.  */
 278 tree static_aggregates;
 279
 280 /* -- end of C++ */
 281
 282 /* A node for the integer constants 2, and 3.  */
 283
 284 tree integer_two_node, integer_three_node;
 285
 286 /* Parsing a function declarator leaves here a chain of structure
 287    and enum types declared in the parmlist.  */
 288
 289 static tree last_function_parm_tags;
 290
 291 /* Similar, for last_function_parm_tags.  */
 292 tree last_function_parms;
 293 static tree current_function_parm_tags;
 294
 295 /* A list of all LABEL_DECLs in the function that have names.  Here so
 296    we can clear out their names' definitions at the end of the
 297    function, and so we can check the validity of jumps to these labels.  */
 298
 299 struct named_label_list
 300 {
 301   struct binding_level *binding_level;
 302   tree names_in_scope;
 303   tree old_value;
 304   tree label_decl;
 305   tree bad_decls;
 306   int eh_region;
 307   struct named_label_list *next;
 308 };
 309
 310 #define named_labels cp_function_chain->x_named_labels
 311
 312 /* Set to 0 at beginning of a function definition, and whenever
 313    a label (case or named) is defined.  Set to value of expression
 314    returned from function when that value can be transformed into
 315    a named return value.  */
 316
 317 tree current_function_return_value;
 318
 319 /* Nonzero means use the ISO C94 dialect of C.  */
 320
 321 int flag_isoc94;
 322
 323 /* Nonzero means use the ISO C99 dialect of C.  */
 324
 325 int flag_isoc99;
 326
 327 /* Nonzero means we are a hosted implementation for code shared with C.  */
 328
 329 int flag_hosted = 1;
 330
 331 /* Nonzero means add default format_arg attributes for functions not
 332    in ISO C.  */
 333
 334 int flag_noniso_default_format_attributes = 1;
 335
 336 /* Nonzero means give `double' the same size as `float'.  */
 337
 338 extern int flag_short_double;
 339
 340 /* Nonzero if we want to conserve space in the .o files.  We do this
 341    by putting uninitialized data and runtime initialized data into
 342    .common instead of .data at the expense of not flagging multiple
 343    definitions.  */
 344 extern int flag_conserve_space;
 345 \f
 346 /* C and C++ flags are in decl2.c.  */
 347
 348 /* Flag used when debugging spew.c */
 349
 350 extern int spew_debug;
 351
 352 /* A expression of value 0 with the same precision as a sizetype
 353    node, but signed.  */
 354 tree signed_size_zero_node;
 355
 356 /* The name of the anonymous namespace, throughout this translation
 357    unit.  */
 358 tree anonymous_namespace_name;
 359
 360 /* The number of function bodies which we are currently processing.
 361    (Zero if we are at namespace scope, one inside the body of a
 362    function, two inside the body of a function in a local class, etc.)  */
 363 int function_depth;
 364 \f
 365 /* For each binding contour we allocate a binding_level structure
 366    which records the names defined in that contour.
 367    Contours include:
 368     0) the global one
 369     1) one for each function definition,
 370        where internal declarations of the parameters appear.
 371     2) one for each compound statement,
 372        to record its declarations.
 373
 374    The current meaning of a name can be found by searching the levels
 375    from the current one out to the global one.
 376
 377    Off to the side, may be the class_binding_level.  This exists only
 378    to catch class-local declarations.  It is otherwise nonexistent.
 379
 380    Also there may be binding levels that catch cleanups that must be
 381    run when exceptions occur.  Thus, to see whether a name is bound in
 382    the current scope, it is not enough to look in the
 383    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 384    instead.  */
 385
 386 /* Note that the information in the `names' component of the global contour
 387    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 388
 389 struct binding_level
 390   {
 391     /* A chain of _DECL nodes for all variables, constants, functions,
 392        and typedef types.  These are in the reverse of the order
 393        supplied.  There may be OVERLOADs on this list, too, but they
 394        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 395     tree names;
 396
 397     /* A list of structure, union and enum definitions, for looking up
 398        tag names.
 399        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 400        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 401        or ENUMERAL_TYPE node.
 402
 403        C++: the TREE_VALUE nodes can be simple types for
 404        component_bindings.  */
 405     tree tags;
 406
 407     /* A list of USING_DECL nodes. */
 408     tree usings;
 409
 410     /* A list of used namespaces. PURPOSE is the namespace,
 411        VALUE the common ancestor with this binding_level's namespace. */
 412     tree using_directives;
 413
 414     /* If this binding level is the binding level for a class, then
 415        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 416        is the name of an entity bound in the class; the TREE_VALUE is
 417        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 418        when leaving class scope, we can restore the
 419        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 420        the DECL bound by this name in the class.  */
 421     tree class_shadowed;
 422
 423     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 424        is used for all binding levels.  */
 425     tree type_shadowed;
 426
 427     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 428        label in this scope.  The TREE_PURPOSE is the previous value of
 429        the IDENTIFIER_LABEL VALUE.  */
 430     tree shadowed_labels;
 431
 432     /* For each level (except not the global one),
 433        a chain of BLOCK nodes for all the levels
 434        that were entered and exited one level down.  */
 435     tree blocks;
 436
 437     /* The _TYPE node for this level, if parm_flag == 2.  */
 438     tree this_class;
 439
 440     /* The binding level which this one is contained in (inherits from).  */
 441     struct binding_level *level_chain;
 442
 443     /* List of decls in `names' that have incomplete
 444        structure or union types.  */
 445     tree incomplete;
 446
 447     /* List of VAR_DECLS saved from a previous for statement.
 448        These would be dead in ISO-conforming code, but might
 449        be referenced in ARM-era code.  These are stored in a
 450        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 451     tree dead_vars_from_for;
 452
 453     /* 1 for the level that holds the parameters of a function.
 454        2 for the level that holds a class declaration.  */
 455     unsigned parm_flag : 2;
 456
 457     /* 1 means make a BLOCK for this level regardless of all else.
 458        2 for temporary binding contours created by the compiler.  */
 459     unsigned keep : 2;
 460
 461     /* Nonzero if this level "doesn't exist" for tags.  */
 462     unsigned tag_transparent : 1;
 463
 464     /* Nonzero if this level can safely have additional
 465        cleanup-needing variables added to it.  */
 466     unsigned more_cleanups_ok : 1;
 467     unsigned have_cleanups : 1;
 468
 469     /* Nonzero if this scope is for storing the decls for template
 470        parameters and generic decls; these decls will be discarded and
 471        replaced with a TEMPLATE_DECL.  */
 472     unsigned template_parms_p : 1;
 473
 474     /* Nonzero if this scope corresponds to the `<>' in a
 475        `template <>' clause.  Whenever this flag is set,
 476        TEMPLATE_PARMS_P will be set as well.  */
 477     unsigned template_spec_p : 1;
 478
 479     /* This is set for a namespace binding level.  */
 480     unsigned namespace_p : 1;
 481
 482     /* True if this level is that of a for-statement where we need to
 483        worry about ambiguous (ARM or ISO) scope rules.  */
 484     unsigned is_for_scope : 1;
 485
 486     /* True if this level corresponds to an EH region, as for a try block.
 487        Currently this information is only available while building the
 488        tree structure.  */
 489     unsigned eh_region : 1;
 490
 491     /* Four bits left for this word.  */
 492
 493 #if defined(DEBUG_CP_BINDING_LEVELS)
 494     /* Binding depth at which this level began.  */
 495     unsigned binding_depth;
 496 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 497   };
 498
 499 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 500
 501 /* The binding level currently in effect.  */
 502
 503 #define current_binding_level                   \
 504   (cfun                                         \
 505    ? cp_function_chain->bindings                \
 506    : scope_chain->bindings)
 507
 508 /* The binding level of the current class, if any.  */
 509
 510 #define class_binding_level scope_chain->class_bindings
 511
 512 /* A chain of binding_level structures awaiting reuse.  */
 513
 514 static struct binding_level *free_binding_level;
 515
 516 /* The outermost binding level, for names of file scope.
 517    This is created when the compiler is started and exists
 518    through the entire run.  */
 519
 520 static struct binding_level *global_binding_level;
 521
 522 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 523
 524 static int keep_next_level_flag;
 525
 526 #if defined(DEBUG_CP_BINDING_LEVELS)
 527 static int binding_depth = 0;
 528 static int is_class_level = 0;
 529
 530 static void
 531 indent ()
 532 {
 533   register unsigned i;
 534
 535   for (i = 0; i < binding_depth*2; i++)
 536     putc (' ', stderr);
 537 }
 538 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 539
 540 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 541
 542 static void
 543 push_binding_level (newlevel, tag_transparent, keep)
 544      struct binding_level *newlevel;
 545      int tag_transparent, keep;
 546 {
 547   /* Add this level to the front of the chain (stack) of levels that
 548      are active.  */
 549   memset ((char*) newlevel, 0, sizeof (struct binding_level));
 550   newlevel->level_chain = current_binding_level;
 551   current_binding_level = newlevel;
 552   newlevel->tag_transparent = tag_transparent;
 553   newlevel->more_cleanups_ok = 1;
 554
 555   newlevel->keep = keep;
 556 #if defined(DEBUG_CP_BINDING_LEVELS)
 557   newlevel->binding_depth = binding_depth;
 558   indent ();
 559   fprintf (stderr, "push %s level 0x%08x line %d\n",
 560            (is_class_level) ? "class" : "block", newlevel, lineno);
 561   is_class_level = 0;
 562   binding_depth++;
 563 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 564 }
 565
 566 /* Find the innermost enclosing class scope, and reset
 567    CLASS_BINDING_LEVEL appropriately.  */
 568
 569 static void
 570 find_class_binding_level ()
 571 {
 572   struct binding_level *level = current_binding_level;
 573
 574   while (level && level->parm_flag != 2)
 575     level = level->level_chain;
 576   if (level && level->parm_flag == 2)
 577     class_binding_level = level;
 578   else
 579     class_binding_level = 0;
 580 }
 581
 582 static void
 583 pop_binding_level ()
 584 {
 585   if (global_binding_level)
 586     {
 587       /* Cannot pop a level, if there are none left to pop.  */
 588       if (current_binding_level == global_binding_level)
 589         my_friendly_abort (123);
 590     }
 591   /* Pop the current level, and free the structure for reuse.  */
 592 #if defined(DEBUG_CP_BINDING_LEVELS)
 593   binding_depth--;
 594   indent ();
 595   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 596           (is_class_level) ? "class" : "block",
 597           current_binding_level, lineno);
 598   if (is_class_level != (current_binding_level == class_binding_level))
 599     {
 600       indent ();
 601       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 602     }
 603   is_class_level = 0;
 604 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 605   {
 606     register struct binding_level *level = current_binding_level;
 607     current_binding_level = current_binding_level->level_chain;
 608     level->level_chain = free_binding_level;
 609 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 610     if (level->binding_depth != binding_depth)
 611       abort ();
 612 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 613     free_binding_level = level;
 614     find_class_binding_level ();
 615   }
 616 }
 617
 618 static void
 619 suspend_binding_level ()
 620 {
 621   if (class_binding_level)
 622     current_binding_level = class_binding_level;
 623
 624   if (global_binding_level)
 625     {
 626       /* Cannot suspend a level, if there are none left to suspend.  */
 627       if (current_binding_level == global_binding_level)
 628         my_friendly_abort (123);
 629     }
 630   /* Suspend the current level.  */
 631 #if defined(DEBUG_CP_BINDING_LEVELS)
 632   binding_depth--;
 633   indent ();
 634   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 635           (is_class_level) ? "class" : "block",
 636           current_binding_level, lineno);
 637   if (is_class_level != (current_binding_level == class_binding_level))
 638     {
 639       indent ();
 640       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 641     }
 642   is_class_level = 0;
 643 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 644   current_binding_level = current_binding_level->level_chain;
 645   find_class_binding_level ();
 646 }
 647
 648 static void
 649 resume_binding_level (b)
 650      struct binding_level *b;
 651 {
 652   /* Resuming binding levels is meant only for namespaces,
 653      and those cannot nest into classes. */
 654   my_friendly_assert(!class_binding_level, 386);
 655   /* Also, resuming a non-directly nested namespace is a no-no.  */
 656   my_friendly_assert(b->level_chain == current_binding_level, 386);
 657   current_binding_level = b;
 658 #if defined(DEBUG_CP_BINDING_LEVELS)
 659   b->binding_depth = binding_depth;
 660   indent ();
 661   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 662            (is_class_level) ? "class" : "block", b, lineno);
 663   is_class_level = 0;
 664   binding_depth++;
 665 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 666 }
 667 \f
 668 /* Create a new `struct binding_level'.  */
 669
 670 static
 671 struct binding_level *
 672 make_binding_level ()
 673 {
 674   /* NOSTRICT */
 675   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 676 }
 677
 678 /* Nonzero if we are currently in the global binding level.  */
 679
 680 int
 681 global_bindings_p ()
 682 {
 683   return current_binding_level == global_binding_level;
 684 }
 685
 686 /* Return the innermost binding level that is not for a class scope.  */
 687
 688 static struct binding_level *
 689 innermost_nonclass_level ()
 690 {
 691   struct binding_level *b;
 692
 693   b = current_binding_level;
 694   while (b->parm_flag == 2)
 695     b = b->level_chain;
 696
 697   return b;
 698 }
 699
 700 /* Nonzero if we are currently in a toplevel binding level.  This
 701    means either the global binding level or a namespace in a toplevel
 702    binding level.  Since there are no non-toplevel namespace levels,
 703    this really means any namespace or template parameter level.  We
 704    also include a class whose context is toplevel.  */
 705
 706 int
 707 toplevel_bindings_p ()
 708 {
 709   struct binding_level *b = innermost_nonclass_level ();
 710
 711   return b->namespace_p || b->template_parms_p;
 712 }
 713
 714 /* Nonzero if this is a namespace scope, or if we are defining a class
 715    which is itself at namespace scope, or whose enclosing class is
 716    such a class, etc.  */
 717
 718 int
 719 namespace_bindings_p ()
 720 {
 721   struct binding_level *b = innermost_nonclass_level ();
 722
 723   return b->namespace_p;
 724 }
 725
 726 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 727    unconditionally.  Otherwise, use the normal logic to decide whether
 728    or not to create a BLOCK.  */
 729
 730 void
 731 keep_next_level (keep)
 732      int keep;
 733 {
 734   keep_next_level_flag = keep;
 735 }
 736
 737 /* Nonzero if the current level needs to have a BLOCK made.  */
 738
 739 int
 740 kept_level_p ()
 741 {
 742   return (current_binding_level->blocks != NULL_TREE
 743           || current_binding_level->keep
 744           || current_binding_level->names != NULL_TREE
 745           || (current_binding_level->tags != NULL_TREE
 746               && !current_binding_level->tag_transparent));
 747 }
 748
 749 static void
 750 declare_namespace_level ()
 751 {
 752   current_binding_level->namespace_p = 1;
 753 }
 754
 755 /* Returns non-zero if this scope was created to store template
 756    parameters.  */
 757
 758 int
 759 template_parm_scope_p ()
 760 {
 761   return current_binding_level->template_parms_p;
 762 }
 763
 764 /* Returns the kind of template specialization we are currently
 765    processing, given that it's declaration contained N_CLASS_SCOPES
 766    explicit scope qualifications.  */
 767
 768 tmpl_spec_kind
 769 current_tmpl_spec_kind (n_class_scopes)
 770      int n_class_scopes;
 771 {
 772   int n_template_parm_scopes = 0;
 773   int seen_specialization_p = 0;
 774   int innermost_specialization_p = 0;
 775   struct binding_level *b;
 776
 777   /* Scan through the template parameter scopes.  */
 778   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 779     {
 780       /* If we see a specialization scope inside a parameter scope,
 781          then something is wrong.  That corresponds to a declaration
 782          like:
 783
 784             template <class T> template <> ...
 785
 786          which is always illegal since [temp.expl.spec] forbids the
 787          specialization of a class member template if the enclosing
 788          class templates are not explicitly specialized as well.  */
 789       if (b->template_spec_p)
 790         {
 791           if (n_template_parm_scopes == 0)
 792             innermost_specialization_p = 1;
 793           else
 794             seen_specialization_p = 1;
 795         }
 796       else if (seen_specialization_p == 1)
 797         return tsk_invalid_member_spec;
 798
 799       ++n_template_parm_scopes;
 800     }
 801
 802   /* Handle explicit instantiations.  */
 803   if (processing_explicit_instantiation)
 804     {
 805       if (n_template_parm_scopes != 0)
 806         /* We've seen a template parameter list during an explicit
 807            instantiation.  For example:
 808
 809              template <class T> template void f(int);
 810
 811            This is erroneous.  */
 812         return tsk_invalid_expl_inst;
 813       else
 814         return tsk_expl_inst;
 815     }
 816
 817   if (n_template_parm_scopes < n_class_scopes)
 818     /* We've not seen enough template headers to match all the
 819        specialized classes present.  For example:
 820
 821          template <class T> void R<T>::S<T>::f(int);
 822
 823        This is illegal; there needs to be one set of template
 824        parameters for each class.  */
 825     return tsk_insufficient_parms;
 826   else if (n_template_parm_scopes == n_class_scopes)
 827     /* We're processing a non-template declaration (even though it may
 828        be a member of a template class.)  For example:
 829
 830          template <class T> void S<T>::f(int);
 831
 832        The `class T' maches the `S<T>', leaving no template headers
 833        corresponding to the `f'.  */
 834     return tsk_none;
 835   else if (n_template_parm_scopes > n_class_scopes + 1)
 836     /* We've got too many template headers.  For example:
 837
 838          template <> template <class T> void f (T);
 839
 840        There need to be more enclosing classes.  */
 841     return tsk_excessive_parms;
 842   else
 843     /* This must be a template.  It's of the form:
 844
 845          template <class T> template <class U> void S<T>::f(U);
 846
 847        This is a specialization if the innermost level was a
 848        specialization; otherwise it's just a definition of the
 849        template.  */
 850     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 851 }
 852
 853 void
 854 set_class_shadows (shadows)
 855      tree shadows;
 856 {
 857   class_binding_level->class_shadowed = shadows;
 858 }
 859
 860 /* Enter a new binding level.
 861    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 862    not for that of tags.  */
 863
 864 void
 865 pushlevel (tag_transparent)
 866      int tag_transparent;
 867 {
 868   struct binding_level *newlevel;
 869
 870   if (cfun && !doing_semantic_analysis_p ())
 871     return;
 872
 873   /* Reuse or create a struct for this binding level.  */
 874 #if defined(DEBUG_CP_BINDING_LEVELS)
 875   if (0)
 876 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 877   if (free_binding_level)
 878 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 879     {
 880       newlevel = free_binding_level;
 881       free_binding_level = free_binding_level->level_chain;
 882     }
 883   else
 884     newlevel = make_binding_level ();
 885
 886   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 887   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 888   keep_next_level_flag = 0;
 889 }
 890
 891 /* Enter a new scope.  The KIND indicates what kind of scope is being
 892    created.  */
 893
 894 void
 895 begin_scope (sk)
 896      scope_kind sk;
 897 {
 898   pushlevel (0);
 899
 900   switch (sk)
 901     {
 902     case sk_template_spec:
 903       current_binding_level->template_spec_p = 1;
 904       /* Fall through.  */
 905
 906     case sk_template_parms:
 907       current_binding_level->template_parms_p = 1;
 908       break;
 909
 910     default:
 911       my_friendly_abort (20000309);
 912     }
 913 }
 914
 915 /* Exit the current scope.  */
 916
 917 void
 918 finish_scope ()
 919 {
 920   poplevel (0, 0, 0);
 921 }
 922
 923 void
 924 note_level_for_for ()
 925 {
 926   current_binding_level->is_for_scope = 1;
 927 }
 928
 929 /* Record that the current binding level represents a try block.  */
 930
 931 void
 932 note_level_for_eh ()
 933 {
 934   current_binding_level->eh_region = 1;
 935 }
 936
 937 /* For a binding between a name and an entity at a block scope,
 938    this is the `struct binding_level' for the block.  */
 939 #define BINDING_LEVEL(NODE) \
 940    (((struct tree_binding*)NODE)->scope.level)
 941
 942 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 943    level at which this declaration is being bound.  */
 944
 945 static void
 946 push_binding (id, decl, level)
 947      tree id;
 948      tree decl;
 949      struct binding_level* level;
 950 {
 951   tree binding;
 952
 953   binding = make_node (CPLUS_BINDING);
 954
 955   /* Now, fill in the binding information.  */
 956   BINDING_VALUE (binding) = decl;
 957   BINDING_TYPE (binding) = NULL_TREE;
 958   BINDING_LEVEL (binding) = level;
 959   INHERITED_VALUE_BINDING_P (binding) = 0;
 960   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 961   BINDING_HAS_LEVEL_P (binding) = 1;
 962
 963   /* And put it on the front of the list of bindings for ID.  */
 964   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 965   IDENTIFIER_BINDING (id) = binding;
 966 }
 967
 968 /* ID is already bound in the current scope.  But, DECL is an
 969    additional binding for ID in the same scope.  This is the `struct
 970    stat' hack whereby a non-typedef class-name or enum-name can be
 971    bound at the same level as some other kind of entity.  It's the
 972    responsibility of the caller to check that inserting this name is
 973    legal here.  Returns nonzero if the new binding was successful.  */
 974 static int
 975 add_binding (id, decl)
 976      tree id;
 977      tree decl;
 978 {
 979   tree binding = IDENTIFIER_BINDING (id);
 980   int ok = 1;
 981
 982   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
 983     /* The new name is the type name.  */
 984     BINDING_TYPE (binding) = decl;
 985   else if (!BINDING_VALUE (binding))
 986     /* This situation arises when push_class_level_binding moves an
 987        inherited type-binding out of the way to make room for a new
 988        value binding.  */
 989     BINDING_VALUE (binding) = decl;
 990   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
 991            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
 992     {
 993       /* The old binding was a type name.  It was placed in
 994          BINDING_VALUE because it was thought, at the point it was
 995          declared, to be the only entity with such a name.  Move the
 996          type name into the type slot; it is now hidden by the new
 997          binding.  */
 998       BINDING_TYPE (binding) = BINDING_VALUE (binding);
 999       BINDING_VALUE (binding) = decl;
1000       INHERITED_VALUE_BINDING_P (binding) = 0;
1001     }
1002   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1003            && TREE_CODE (decl) == TYPE_DECL
1004            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1005            && same_type_p (TREE_TYPE (decl),
1006                            TREE_TYPE (BINDING_VALUE (binding))))
1007     /* We have two typedef-names, both naming the same type to have
1008        the same name.  This is OK because of:
1009
1010          [dcl.typedef]
1011
1012          In a given scope, a typedef specifier can be used to redefine
1013          the name of any type declared in that scope to refer to the
1014          type to which it already refers.  */
1015     ok = 0;
1016   /* There can be two block-scope declarations of the same variable,
1017      so long as they are `extern' declarations.  */
1018   else if (TREE_CODE (decl) == VAR_DECL
1019            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1020            && DECL_EXTERNAL (decl)
1021            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1022     {
1023       duplicate_decls (decl, BINDING_VALUE (binding));
1024       ok = 0;
1025     }
1026   else
1027     {
1028       cp_error ("declaration of `%#D'", decl);
1029       cp_error_at ("conflicts with previous declaration `%#D'",
1030                    BINDING_VALUE (binding));
1031       ok = 0;
1032     }
1033
1034   return ok;
1035 }
1036
1037 /* Add DECL to the list of things declared in B.  */
1038
1039 static void
1040 add_decl_to_level (decl, b)
1041      tree decl;
1042      struct binding_level *b;
1043 {
1044   /* We build up the list in reverse order, and reverse it later if
1045      necessary.  */
1046   TREE_CHAIN (decl) = b->names;
1047   b->names = decl;
1048 }
1049
1050 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1051    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1052    doesn't really belong to this binding level, that it got here
1053    through a using-declaration.  */
1054
1055 void
1056 push_local_binding (id, decl, flags)
1057      tree id;
1058      tree decl;
1059      int flags;
1060 {
1061   struct binding_level *b;
1062
1063   /* Skip over any local classes.  This makes sense if we call
1064      push_local_binding with a friend decl of a local class.  */
1065   b = current_binding_level;
1066   while (b->parm_flag == 2)
1067     b = b->level_chain;
1068
1069   if (lookup_name_current_level (id))
1070     {
1071       /* Supplement the existing binding.  */
1072       if (!add_binding (id, decl))
1073         /* It didn't work.  Something else must be bound at this
1074            level.  Do not add DECL to the list of things to pop
1075            later.  */
1076         return;
1077     }
1078   else
1079     /* Create a new binding.  */
1080     push_binding (id, decl, b);
1081
1082   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1083     /* We must put the OVERLOAD into a TREE_LIST since the
1084        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1085        decls that got here through a using-declaration.  */
1086     decl = build_tree_list (NULL_TREE, decl);
1087
1088   /* And put DECL on the list of things declared by the current
1089      binding level.  */
1090   add_decl_to_level (decl, b);
1091 }
1092
1093 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1094    binding was successful.  */
1095
1096 int
1097 push_class_binding (id, decl)
1098      tree id;
1099      tree decl;
1100 {
1101   int result = 1;
1102   tree binding = IDENTIFIER_BINDING (id);
1103   tree context;
1104
1105   /* Note that we declared this value so that we can issue an error if
1106      this an illegal redeclaration of a name already used for some
1107      other purpose.  */
1108   note_name_declared_in_class (id, decl);
1109
1110   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1111     /* Supplement the existing binding.  */
1112     result = add_binding (id, decl);
1113   else
1114     /* Create a new binding.  */
1115     push_binding (id, decl, class_binding_level);
1116
1117   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1118      class-level declaration.  Note that we do not use DECL here
1119      because of the possibility of the `struct stat' hack; if DECL is
1120      a class-name or enum-name we might prefer a field-name, or some
1121      such.  */
1122   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1123
1124   /* If this is a binding from a base class, mark it as such.  */
1125   binding = IDENTIFIER_BINDING (id);
1126   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1127     {
1128       /* Any implicit typename must be from a base-class.  The
1129          context for an implicit typename declaration is always
1130          the derived class in which the lookup was done, so the checks
1131          based on the context of DECL below will not trigger.  */
1132       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1133         INHERITED_VALUE_BINDING_P (binding) = 1;
1134       else
1135         {
1136           if (TREE_CODE (decl) == OVERLOAD)
1137             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1138           else
1139             {
1140               my_friendly_assert (DECL_P (decl), 0);
1141               context = CP_DECL_CONTEXT (decl);
1142             }
1143
1144           if (is_properly_derived_from (current_class_type, context))
1145             INHERITED_VALUE_BINDING_P (binding) = 1;
1146           else
1147             INHERITED_VALUE_BINDING_P (binding) = 0;
1148         }
1149     }
1150   else if (BINDING_VALUE (binding) == decl)
1151     /* We only encounter a TREE_LIST when push_class_decls detects an
1152        ambiguity.  Such an ambiguity can be overridden by a definition
1153        in this class.  */
1154     INHERITED_VALUE_BINDING_P (binding) = 1;
1155
1156   return result;
1157 }
1158
1159 /* Remove the binding for DECL which should be the innermost binding
1160    for ID.  */
1161
1162 static void
1163 pop_binding (id, decl)
1164      tree id;
1165      tree decl;
1166 {
1167   tree binding;
1168
1169   if (id == NULL_TREE)
1170     /* It's easiest to write the loops that call this function without
1171        checking whether or not the entities involved have names.  We
1172        get here for such an entity.  */
1173     return;
1174
1175   /* Get the innermost binding for ID.  */
1176   binding = IDENTIFIER_BINDING (id);
1177
1178   /* The name should be bound.  */
1179   my_friendly_assert (binding != NULL_TREE, 0);
1180
1181   /* The DECL will be either the ordinary binding or the type
1182      binding for this identifier.  Remove that binding.  */
1183   if (BINDING_VALUE (binding) == decl)
1184     BINDING_VALUE (binding) = NULL_TREE;
1185   else if (BINDING_TYPE (binding) == decl)
1186     BINDING_TYPE (binding) = NULL_TREE;
1187   else
1188     my_friendly_abort (0);
1189
1190   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
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
1196 /* When a label goes out of scope, check to see if that label was used
1197    in a valid manner, and issue any appropriate warnings or errors.  */
1198
1199 static void
1200 pop_label (label, old_value)
1201      tree label;
1202      tree old_value;
1203 {
1204   if (!processing_template_decl && doing_semantic_analysis_p ())
1205     {
1206       if (DECL_INITIAL (label) == NULL_TREE)
1207         {
1208           cp_error_at ("label `%D' used but not defined", label);
1209           /* Avoid crashing later.  */
1210           define_label (input_filename, 1, DECL_NAME (label));
1211         }
1212       else if (warn_unused_label && !TREE_USED (label))
1213         cp_warning_at ("label `%D' defined but not used", label);
1214     }
1215
1216   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1217 }
1218
1219 /* At the end of a function, all labels declared within the function
1220    go out of scope.  BLOCK is the top-level block for the
1221    function.  */
1222
1223 static void
1224 pop_labels (block)
1225      tree block;
1226 {
1227   struct named_label_list *link;
1228
1229   /* Clear out the definitions of all label names, since their scopes
1230      end here.  */
1231   for (link = named_labels; link; link = link->next)
1232     {
1233       pop_label (link->label_decl, link->old_value);
1234       /* Put the labels into the "variables" of the top-level block,
1235          so debugger can see them.  */
1236       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1237       BLOCK_VARS (block) = link->label_decl;
1238     }
1239
1240   named_labels = NULL;
1241 }
1242
1243 /* Exit a binding level.
1244    Pop the level off, and restore the state of the identifier-decl mappings
1245    that were in effect when this level was entered.
1246
1247    If KEEP == 1, this level had explicit declarations, so
1248    and create a "block" (a BLOCK node) for the level
1249    to record its declarations and subblocks for symbol table output.
1250
1251    If FUNCTIONBODY is nonzero, this level is the body of a function,
1252    so create a block as if KEEP were set and also clear out all
1253    label names.
1254
1255    If REVERSE is nonzero, reverse the order of decls before putting
1256    them into the BLOCK.  */
1257
1258 tree
1259 poplevel (keep, reverse, functionbody)
1260      int keep;
1261      int reverse;
1262      int functionbody;
1263 {
1264   register tree link;
1265   /* The chain of decls was accumulated in reverse order.
1266      Put it into forward order, just for cleanliness.  */
1267   tree decls;
1268   int tmp = functionbody;
1269   int real_functionbody;
1270   tree tags;
1271   tree subblocks;
1272   tree block = NULL_TREE;
1273   tree decl;
1274   int leaving_for_scope;
1275
1276   if (cfun && !doing_semantic_analysis_p ())
1277     return NULL_TREE;
1278
1279   my_friendly_assert (current_binding_level->parm_flag != 2,
1280                       19990916);
1281
1282   real_functionbody = (current_binding_level->keep == 2
1283                        ? ((functionbody = 0), tmp) : functionbody);
1284   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1285   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1286
1287   my_friendly_assert (!current_binding_level->class_shadowed,
1288                       19990414);
1289
1290   /* We used to use KEEP == 2 to indicate that the new block should go
1291      at the beginning of the list of blocks at this binding level,
1292      rather than the end.  This hack is no longer used.  */
1293   my_friendly_assert (keep == 0 || keep == 1, 0);
1294
1295   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1296                       (HOST_WIDE_INT) current_binding_level->level_chain,
1297                       current_binding_level->parm_flag,
1298                       current_binding_level->keep);
1299
1300   if (current_binding_level->keep == 1)
1301     keep = 1;
1302
1303   /* Any uses of undefined labels, and any defined labels, now operate
1304      under constraints of next binding contour.  */
1305   if (cfun && !functionbody)
1306     {
1307       struct binding_level *level_chain;
1308       level_chain = current_binding_level->level_chain;
1309       if (level_chain)
1310         {
1311           struct named_label_use_list *uses;
1312           struct named_label_list *labels;
1313           for (labels = named_labels; labels; labels = labels->next)
1314             if (labels->binding_level == current_binding_level)
1315               {
1316                 tree decl;
1317                 if (current_binding_level->eh_region)
1318                   labels->eh_region = 1;
1319                 for (decl = labels->names_in_scope; decl;
1320                      decl = TREE_CHAIN (decl))
1321                   if (decl_jump_unsafe (decl))
1322                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1323                                                    labels->bad_decls);
1324                 labels->binding_level = level_chain;
1325                 labels->names_in_scope = level_chain->names;
1326               }
1327
1328           for (uses = named_label_uses; uses; uses = uses->next)
1329             if (uses->binding_level == current_binding_level)
1330               {
1331                 uses->binding_level = level_chain;
1332                 uses->names_in_scope = level_chain->names;
1333               }
1334         }
1335     }
1336
1337   /* Get the decls in the order they were written.
1338      Usually current_binding_level->names is in reverse order.
1339      But parameter decls were previously put in forward order.  */
1340
1341   if (reverse)
1342     current_binding_level->names
1343       = decls = nreverse (current_binding_level->names);
1344   else
1345     decls = current_binding_level->names;
1346
1347   /* Output any nested inline functions within this block
1348      if they weren't already output.  */
1349   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1350     if (TREE_CODE (decl) == FUNCTION_DECL
1351         && ! TREE_ASM_WRITTEN (decl)
1352         && DECL_INITIAL (decl) != NULL_TREE
1353         && TREE_ADDRESSABLE (decl)
1354         && decl_function_context (decl) == current_function_decl)
1355       {
1356         /* If this decl was copied from a file-scope decl
1357            on account of a block-scope extern decl,
1358            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1359         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1360           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1361         else
1362           {
1363             push_function_context ();
1364             output_inline_function (decl);
1365             pop_function_context ();
1366           }
1367       }
1368
1369   /* When not in function-at-a-time mode, expand_end_bindings will
1370      warn about unused variables.  But, in function-at-a-time mode
1371      expand_end_bindings is not passed the list of variables in the
1372      current scope, and therefore no warning is emitted.  So, we
1373      explicitly warn here.  */
1374   if (!processing_template_decl)
1375     warn_about_unused_variables (getdecls ());
1376
1377   /* If there were any declarations or structure tags in that level,
1378      or if this level is a function body,
1379      create a BLOCK to record them for the life of this function.  */
1380   block = NULL_TREE;
1381   if (keep == 1 || functionbody)
1382     block = make_node (BLOCK);
1383   if (block != NULL_TREE)
1384     {
1385       BLOCK_VARS (block) = decls;
1386       BLOCK_SUBBLOCKS (block) = subblocks;
1387     }
1388
1389   /* In each subblock, record that this is its superior.  */
1390   if (keep >= 0)
1391     for (link = subblocks; link; link = TREE_CHAIN (link))
1392       BLOCK_SUPERCONTEXT (link) = block;
1393
1394   /* We still support the old for-scope rules, whereby the variables
1395      in a for-init statement were in scope after the for-statement
1396      ended.  We only use the new rules in flag_new_for_scope is
1397      nonzero.  */
1398   leaving_for_scope
1399     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1400
1401   /* Remove declarations for all the DECLs in this level.  */
1402   for (link = decls; link; link = TREE_CHAIN (link))
1403     {
1404       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1405           && DECL_NAME (link))
1406         {
1407           tree outer_binding
1408             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1409           tree ns_binding;
1410
1411           if (!outer_binding)
1412             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1413           else
1414             ns_binding = NULL_TREE;
1415
1416           if (outer_binding
1417               && (BINDING_LEVEL (outer_binding)
1418                   == current_binding_level->level_chain))
1419             /* We have something like:
1420
1421                  int i;
1422                  for (int i; ;);
1423
1424                and we are leaving the `for' scope.  There's no reason to
1425                keep the binding of the inner `i' in this case.  */
1426             pop_binding (DECL_NAME (link), link);
1427           else if ((outer_binding
1428                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1429                         == TYPE_DECL))
1430                    || (ns_binding
1431                        && TREE_CODE (ns_binding) == TYPE_DECL))
1432             /* Here, we have something like:
1433
1434                  typedef int I;
1435
1436                  void f () {
1437                    for (int I; ;);
1438                  }
1439
1440                We must pop the for-scope binding so we know what's a
1441                type and what isn't.  */
1442             pop_binding (DECL_NAME (link), link);
1443           else
1444             {
1445               /* Mark this VAR_DECL as dead so that we can tell we left it
1446                  there only for backward compatibility.  */
1447               DECL_DEAD_FOR_LOCAL (link) = 1;
1448
1449               /* Keep track of what should of have happenned when we
1450                  popped the binding.  */
1451               if (outer_binding && BINDING_VALUE (outer_binding))
1452                 DECL_SHADOWED_FOR_VAR (link)
1453                   = BINDING_VALUE (outer_binding);
1454
1455               /* Add it to the list of dead variables in the next
1456                  outermost binding to that we can remove these when we
1457                  leave that binding.  */
1458               current_binding_level->level_chain->dead_vars_from_for
1459                 = tree_cons (NULL_TREE, link,
1460                              current_binding_level->level_chain->
1461                              dead_vars_from_for);
1462
1463               /* Although we don't pop the CPLUS_BINDING, we do clear
1464                  its BINDING_LEVEL since the level is going away now.  */
1465               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1466                 = 0;
1467             }
1468         }
1469       else
1470         {
1471           /* Remove the binding.  */
1472           decl = link;
1473           if (TREE_CODE (decl) == TREE_LIST)
1474             decl = TREE_VALUE (decl);
1475           if (DECL_P (decl))
1476             pop_binding (DECL_NAME (decl), decl);
1477           else if (TREE_CODE (decl) == OVERLOAD)
1478             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1479           else
1480             my_friendly_abort (0);
1481         }
1482     }
1483
1484   /* Remove declarations for any `for' variables from inner scopes
1485      that we kept around.  */
1486   for (link = current_binding_level->dead_vars_from_for;
1487        link; link = TREE_CHAIN (link))
1488     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1489
1490   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1491   for (link = current_binding_level->type_shadowed;
1492        link; link = TREE_CHAIN (link))
1493     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1494
1495   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1496   for (link = current_binding_level->shadowed_labels;
1497        link;
1498        link = TREE_CHAIN (link))
1499     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1500
1501   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1502      list if a `using' declaration put them there.  The debugging
1503      back-ends won't understand OVERLOAD, so we remove them here.
1504      Because the BLOCK_VARS are (temporarily) shared with
1505      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1506      popped all the bindings.  */
1507   if (block)
1508     {
1509       tree* d;
1510
1511       for (d = &BLOCK_VARS (block); *d; )
1512         {
1513           if (TREE_CODE (*d) == TREE_LIST)
1514             *d = TREE_CHAIN (*d);
1515           else
1516             d = &TREE_CHAIN (*d);
1517         }
1518     }
1519
1520   /* If the level being exited is the top level of a function,
1521      check over all the labels.  */
1522   if (functionbody)
1523     {
1524       /* Since this is the top level block of a function, the vars are
1525          the function's parameters.  Don't leave them in the BLOCK
1526          because they are found in the FUNCTION_DECL instead.  */
1527       BLOCK_VARS (block) = 0;
1528       pop_labels (block);
1529     }
1530
1531   tmp = current_binding_level->keep;
1532
1533   pop_binding_level ();
1534   if (functionbody)
1535     DECL_INITIAL (current_function_decl) = block;
1536   else if (block)
1537     current_binding_level->blocks
1538       = chainon (current_binding_level->blocks, block);
1539
1540   /* If we did not make a block for the level just exited,
1541      any blocks made for inner levels
1542      (since they cannot be recorded as subblocks in that level)
1543      must be carried forward so they will later become subblocks
1544      of something else.  */
1545   else if (subblocks)
1546     current_binding_level->blocks
1547       = chainon (current_binding_level->blocks, subblocks);
1548
1549   /* Each and every BLOCK node created here in `poplevel' is important
1550      (e.g. for proper debugging information) so if we created one
1551      earlier, mark it as "used".  */
1552   if (block)
1553     TREE_USED (block) = 1;
1554
1555   /* Take care of compiler's internal binding structures.  */
1556   if (tmp == 2)
1557     {
1558       tree scope_stmts;
1559
1560       scope_stmts
1561         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1562       if (block)
1563         {
1564           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1565           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1566         }
1567
1568       block = poplevel (keep, reverse, functionbody);
1569     }
1570
1571   return block;
1572 }
1573
1574 /* Delete the node BLOCK from the current binding level.
1575    This is used for the block inside a stmt expr ({...})
1576    so that the block can be reinserted where appropriate.  */
1577
1578 void
1579 delete_block (block)
1580      tree block;
1581 {
1582   tree t;
1583   if (current_binding_level->blocks == block)
1584     current_binding_level->blocks = TREE_CHAIN (block);
1585   for (t = current_binding_level->blocks; t;)
1586     {
1587       if (TREE_CHAIN (t) == block)
1588         TREE_CHAIN (t) = TREE_CHAIN (block);
1589       else
1590         t = TREE_CHAIN (t);
1591     }
1592   TREE_CHAIN (block) = NULL_TREE;
1593   /* Clear TREE_USED which is always set by poplevel.
1594      The flag is set again if insert_block is called.  */
1595   TREE_USED (block) = 0;
1596 }
1597
1598 /* Insert BLOCK at the end of the list of subblocks of the
1599    current binding level.  This is used when a BIND_EXPR is expanded,
1600    to handle the BLOCK node inside the BIND_EXPR.  */
1601
1602 void
1603 insert_block (block)
1604      tree block;
1605 {
1606   TREE_USED (block) = 1;
1607   current_binding_level->blocks
1608     = chainon (current_binding_level->blocks, block);
1609 }
1610
1611 /* Set the BLOCK node for the innermost scope
1612    (the one we are currently in).  */
1613
1614 void
1615 set_block (block)
1616     tree block ATTRIBUTE_UNUSED;
1617 {
1618   /* The RTL expansion machinery requires us to provide this callback,
1619      but it is not applicable in function-at-a-time mode.  */
1620   my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1621 }
1622
1623 /* Do a pushlevel for class declarations.  */
1624
1625 void
1626 pushlevel_class ()
1627 {
1628   register struct binding_level *newlevel;
1629
1630   /* Reuse or create a struct for this binding level.  */
1631 #if defined(DEBUG_CP_BINDING_LEVELS)
1632   if (0)
1633 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1634   if (free_binding_level)
1635 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1636     {
1637       newlevel = free_binding_level;
1638       free_binding_level = free_binding_level->level_chain;
1639     }
1640   else
1641     newlevel = make_binding_level ();
1642
1643 #if defined(DEBUG_CP_BINDING_LEVELS)
1644   is_class_level = 1;
1645 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1646
1647   push_binding_level (newlevel, 0, 0);
1648
1649   class_binding_level = current_binding_level;
1650   class_binding_level->parm_flag = 2;
1651   class_binding_level->this_class = current_class_type;
1652 }
1653
1654 /* ...and a poplevel for class declarations.  */
1655
1656 void
1657 poplevel_class ()
1658 {
1659   register struct binding_level *level = class_binding_level;
1660   tree shadowed;
1661
1662   my_friendly_assert (level != 0, 354);
1663
1664   /* If we're leaving a toplevel class, don't bother to do the setting
1665      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1666      shouldn't even be used when current_class_type isn't set, and second,
1667      if we don't touch it here, we're able to use the cache effect if the
1668      next time we're entering a class scope, it is the same class.  */
1669   if (current_class_depth != 1)
1670     {
1671       struct binding_level* b;
1672
1673       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1674       for (shadowed = level->class_shadowed;
1675            shadowed;
1676            shadowed = TREE_CHAIN (shadowed))
1677         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1678
1679       /* Find the next enclosing class, and recreate
1680          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1681       b = level->level_chain;
1682       while (b && b->parm_flag != 2)
1683         b = b->level_chain;
1684
1685       if (b)
1686         for (shadowed = b->class_shadowed;
1687              shadowed;
1688              shadowed = TREE_CHAIN (shadowed))
1689           {
1690             tree t;
1691
1692             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1693             while (t && BINDING_LEVEL (t) != b)
1694               t = TREE_CHAIN (t);
1695
1696             if (t)
1697               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1698                 = BINDING_VALUE (t);
1699           }
1700     }
1701   else
1702     /* Remember to save what IDENTIFIER's were bound in this scope so we
1703        can recover from cache misses.  */
1704     {
1705       previous_class_type = current_class_type;
1706       previous_class_values = class_binding_level->class_shadowed;
1707     }
1708   for (shadowed = level->type_shadowed;
1709        shadowed;
1710        shadowed = TREE_CHAIN (shadowed))
1711     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1712
1713   /* Remove the bindings for all of the class-level declarations.  */
1714   for (shadowed = level->class_shadowed;
1715        shadowed;
1716        shadowed = TREE_CHAIN (shadowed))
1717     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1718
1719   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1720                       (HOST_WIDE_INT) class_binding_level->level_chain,
1721                       class_binding_level->parm_flag,
1722                       class_binding_level->keep);
1723
1724   /* Now, pop out of the binding level which we created up in the
1725      `pushlevel_class' routine.  */
1726 #if defined(DEBUG_CP_BINDING_LEVELS)
1727   is_class_level = 1;
1728 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1729
1730   pop_binding_level ();
1731 }
1732
1733 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1734    for any names in enclosing classes.  */
1735
1736 void
1737 clear_identifier_class_values ()
1738 {
1739   tree t;
1740
1741   if (!class_binding_level)
1742     return;
1743
1744   for (t = class_binding_level->class_shadowed;
1745        t;
1746        t = TREE_CHAIN (t))
1747     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1748 }
1749
1750 /* Returns non-zero if T is a virtual function table.  */
1751
1752 int
1753 vtable_decl_p (t, data)
1754      tree t;
1755      void *data ATTRIBUTE_UNUSED;
1756 {
1757   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1758 }
1759
1760 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1761    functions.  */
1762
1763 int
1764 vtype_decl_p (t, data)
1765      tree t;
1766      void *data ATTRIBUTE_UNUSED;
1767 {
1768   return (TREE_CODE (t) == TYPE_DECL
1769           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1770           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1771 }
1772
1773 /* Return the declarations that are members of the namespace NS.  */
1774
1775 tree
1776 cp_namespace_decls (ns)
1777      tree ns;
1778 {
1779   return NAMESPACE_LEVEL (ns)->names;
1780 }
1781
1782 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1783    itself, calling F for each.  The DATA is passed to F as well.  */
1784
1785 static int
1786 walk_namespaces_r (namespace, f, data)
1787      tree namespace;
1788      walk_namespaces_fn f;
1789      void *data;
1790 {
1791   tree current;
1792   int result = 0;
1793
1794   result |= (*f) (namespace, data);
1795
1796   for (current = cp_namespace_decls (namespace);
1797        current;
1798        current = TREE_CHAIN (current))
1799     {
1800       if (TREE_CODE (current) != NAMESPACE_DECL
1801           || DECL_NAMESPACE_ALIAS (current))
1802         continue;
1803       if (!DECL_LANG_SPECIFIC (current))
1804         {
1805           /* Hmm. std. */
1806           my_friendly_assert (current == fake_std_node, 393);
1807           continue;
1808         }
1809
1810       /* We found a namespace.  */
1811       result |= walk_namespaces_r (current, f, data);
1812     }
1813
1814   return result;
1815 }
1816
1817 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1818    F as well.  */
1819
1820 int
1821 walk_namespaces (f, data)
1822      walk_namespaces_fn f;
1823      void *data;
1824 {
1825   return walk_namespaces_r (global_namespace, f, data);
1826 }
1827
1828 struct walk_globals_data {
1829   walk_globals_pred p;
1830   walk_globals_fn f;
1831   void *data;
1832 };
1833
1834 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1835    for which P returns non-zero, call F with its address.  If any call
1836    to F returns a non-zero value, return a non-zero value.  */
1837
1838 static int
1839 walk_globals_r (namespace, data)
1840      tree namespace;
1841      void *data;
1842 {
1843   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1844   walk_globals_pred p = wgd->p;
1845   walk_globals_fn f = wgd->f;
1846   void *d = wgd->data;
1847   tree *t;
1848   int result = 0;
1849
1850   t = &NAMESPACE_LEVEL (namespace)->names;
1851
1852   while (*t)
1853     {
1854       tree glbl = *t;
1855
1856       if ((*p) (glbl, d))
1857         result |= (*f) (t, d);
1858
1859       /* If F changed *T, then *T still points at the next item to
1860          examine.  */
1861       if (*t == glbl)
1862         t = &TREE_CHAIN (*t);
1863     }
1864
1865   return result;
1866 }
1867
1868 /* Walk the global declarations.  Whenever one is found for which P
1869    returns non-zero, call F with its address.  If any call to F
1870    returns a non-zero value, return a non-zero value.  */
1871
1872 int
1873 walk_globals (p, f, data)
1874      walk_globals_pred p;
1875      walk_globals_fn f;
1876      void *data;
1877 {
1878   struct walk_globals_data wgd;
1879   wgd.p = p;
1880   wgd.f = f;
1881   wgd.data = data;
1882
1883   return walk_namespaces (walk_globals_r, &wgd);
1884 }
1885
1886 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1887    DATA is non-NULL, this is the last time we will call
1888    wrapup_global_declarations for this NAMESPACE.  */
1889
1890 int
1891 wrapup_globals_for_namespace (namespace, data)
1892      tree namespace;
1893      void *data;
1894 {
1895   tree globals = cp_namespace_decls (namespace);
1896   int len = list_length (globals);
1897   tree *vec = (tree *) alloca (sizeof (tree) * len);
1898   int i;
1899   int result;
1900   tree decl;
1901   int last_time = (data != 0);
1902
1903   if (last_time && namespace == global_namespace)
1904     /* Let compile_file handle the global namespace.  */
1905     return 0;
1906
1907   /* Process the decls in reverse order--earliest first.
1908      Put them into VEC from back to front, then take out from front.  */
1909   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1910     vec[len - i - 1] = decl;
1911
1912   if (last_time)
1913     {
1914       check_global_declarations (vec, len);
1915       return 0;
1916     }
1917
1918   /* Temporarily mark vtables as external.  That prevents
1919      wrapup_global_declarations from writing them out; we must process
1920      them ourselves in finish_vtable_vardecl.  */
1921   for (i = 0; i < len; ++i)
1922     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1923       {
1924         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1925         DECL_EXTERNAL (vec[i]) = 1;
1926       }
1927
1928   /* Write out any globals that need to be output.  */
1929   result = wrapup_global_declarations (vec, len);
1930
1931   /* Undo the hack to DECL_EXTERNAL above.  */
1932   for (i = 0; i < len; ++i)
1933     if (vtable_decl_p (vec[i], /*data=*/0)
1934         && DECL_NOT_REALLY_EXTERN (vec[i]))
1935       {
1936         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1937         DECL_EXTERNAL (vec[i]) = 0;
1938       }
1939
1940   return result;
1941 }
1942
1943 \f
1944 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1945
1946 static void
1947 mark_binding_level (arg)
1948      void *arg;
1949 {
1950   struct binding_level *lvl = *(struct binding_level **)arg;
1951
1952   for (; lvl; lvl = lvl->level_chain)
1953     {
1954       ggc_mark_tree (lvl->names);
1955       ggc_mark_tree (lvl->tags);
1956       ggc_mark_tree (lvl->usings);
1957       ggc_mark_tree (lvl->using_directives);
1958       ggc_mark_tree (lvl->class_shadowed);
1959       ggc_mark_tree (lvl->type_shadowed);
1960       ggc_mark_tree (lvl->shadowed_labels);
1961       ggc_mark_tree (lvl->blocks);
1962       ggc_mark_tree (lvl->this_class);
1963       ggc_mark_tree (lvl->incomplete);
1964       ggc_mark_tree (lvl->dead_vars_from_for);
1965     }
1966 }
1967
1968 static void
1969 mark_named_label_lists (labs, uses)
1970      void *labs;
1971      void *uses;
1972 {
1973   struct named_label_list *l = *(struct named_label_list **)labs;
1974   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
1975
1976   for (; l; l = l->next)
1977     {
1978       ggc_mark (l);
1979       mark_binding_level (l->binding_level);
1980       ggc_mark_tree (l->old_value);
1981       ggc_mark_tree (l->label_decl);
1982       ggc_mark_tree (l->bad_decls);
1983     }
1984
1985   for (; u; u = u->next)
1986     ggc_mark (u);
1987 }
1988 \f
1989 /* For debugging.  */
1990 static int no_print_functions = 0;
1991 static int no_print_builtins = 0;
1992
1993 void
1994 print_binding_level (lvl)
1995      struct binding_level *lvl;
1996 {
1997   tree t;
1998   int i = 0, len;
1999   fprintf (stderr, " blocks=");
2000   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2001   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2002            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2003   if (lvl->tag_transparent)
2004     fprintf (stderr, " tag-transparent");
2005   if (lvl->more_cleanups_ok)
2006     fprintf (stderr, " more-cleanups-ok");
2007   if (lvl->have_cleanups)
2008     fprintf (stderr, " have-cleanups");
2009   fprintf (stderr, "\n");
2010   if (lvl->names)
2011     {
2012       fprintf (stderr, " names:\t");
2013       /* We can probably fit 3 names to a line?  */
2014       for (t = lvl->names; t; t = TREE_CHAIN (t))
2015         {
2016           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2017             continue;
2018           if (no_print_builtins
2019               && (TREE_CODE (t) == TYPE_DECL)
2020               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2021             continue;
2022
2023           /* Function decls tend to have longer names.  */
2024           if (TREE_CODE (t) == FUNCTION_DECL)
2025             len = 3;
2026           else
2027             len = 2;
2028           i += len;
2029           if (i > 6)
2030             {
2031               fprintf (stderr, "\n\t");
2032               i = len;
2033             }
2034           print_node_brief (stderr, "", t, 0);
2035           if (t == error_mark_node)
2036             break;
2037         }
2038       if (i)
2039         fprintf (stderr, "\n");
2040     }
2041   if (lvl->tags)
2042     {
2043       fprintf (stderr, " tags:\t");
2044       i = 0;
2045       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2046         {
2047           if (TREE_PURPOSE (t) == NULL_TREE)
2048             len = 3;
2049           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2050             len = 2;
2051           else
2052             len = 4;
2053           i += len;
2054           if (i > 5)
2055             {
2056               fprintf (stderr, "\n\t");
2057               i = len;
2058             }
2059           if (TREE_PURPOSE (t) == NULL_TREE)
2060             {
2061               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2062               fprintf (stderr, ">");
2063             }
2064           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2065             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2066           else
2067             {
2068               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2069               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2070               fprintf (stderr, ">");
2071             }
2072         }
2073       if (i)
2074         fprintf (stderr, "\n");
2075     }
2076   if (lvl->class_shadowed)
2077     {
2078       fprintf (stderr, " class-shadowed:");
2079       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2080         {
2081           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2082         }
2083       fprintf (stderr, "\n");
2084     }
2085   if (lvl->type_shadowed)
2086     {
2087       fprintf (stderr, " type-shadowed:");
2088       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2089         {
2090           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2091         }
2092       fprintf (stderr, "\n");
2093     }
2094 }
2095
2096 void
2097 print_other_binding_stack (stack)
2098      struct binding_level *stack;
2099 {
2100   struct binding_level *level;
2101   for (level = stack; level != global_binding_level; level = level->level_chain)
2102     {
2103       fprintf (stderr, "binding level ");
2104       fprintf (stderr, HOST_PTR_PRINTF, level);
2105       fprintf (stderr, "\n");
2106       print_binding_level (level);
2107     }
2108 }
2109
2110 void
2111 print_binding_stack ()
2112 {
2113   struct binding_level *b;
2114   fprintf (stderr, "current_binding_level=");
2115   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2116   fprintf (stderr, "\nclass_binding_level=");
2117   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2118   fprintf (stderr, "\nglobal_binding_level=");
2119   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2120   fprintf (stderr, "\n");
2121   if (class_binding_level)
2122     {
2123       for (b = class_binding_level; b; b = b->level_chain)
2124         if (b == current_binding_level)
2125           break;
2126       if (b)
2127         b = class_binding_level;
2128       else
2129         b = current_binding_level;
2130     }
2131   else
2132     b = current_binding_level;
2133   print_other_binding_stack (b);
2134   fprintf (stderr, "global:\n");
2135   print_binding_level (global_binding_level);
2136 }
2137
2138 /* Namespace binding access routines: The namespace_bindings field of
2139    the identifier is polymorphic, with three possible values:
2140    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2141    indicating the BINDING_VALUE of global_namespace. */
2142
2143 /* Check whether the a binding for the name to scope is known.
2144    Assumes that the bindings of the name are already a list
2145    of bindings. Returns the binding found, or NULL_TREE. */
2146
2147 static tree
2148 find_binding (name, scope)
2149      tree name;
2150      tree scope;
2151 {
2152   tree iter, prev = NULL_TREE;
2153
2154   scope = ORIGINAL_NAMESPACE (scope);
2155
2156   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2157        iter = TREE_CHAIN (iter))
2158     {
2159       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2160       if (BINDING_SCOPE (iter) == scope)
2161         {
2162           /* Move binding found to the front of the list, so
2163              subsequent lookups will find it faster. */
2164           if (prev)
2165             {
2166               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2167               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2168               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2169             }
2170           return iter;
2171         }
2172       prev = iter;
2173     }
2174   return NULL_TREE;
2175 }
2176
2177 /* Always returns a binding for name in scope. If the
2178    namespace_bindings is not a list, convert it to one first.
2179    If no binding is found, make a new one. */
2180
2181 tree
2182 binding_for_name (name, scope)
2183      tree name;
2184      tree scope;
2185 {
2186   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2187   tree result;
2188
2189   scope = ORIGINAL_NAMESPACE (scope);
2190
2191   if (b && TREE_CODE (b) != CPLUS_BINDING)
2192     {
2193       /* Get rid of optimization for global scope. */
2194       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2195       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2196       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2197     }
2198   if (b && (result = find_binding (name, scope)))
2199     return result;
2200   /* Not found, make a new one. */
2201   result = make_node (CPLUS_BINDING);
2202   TREE_CHAIN (result) = b;
2203   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2204   BINDING_SCOPE (result) = scope;
2205   BINDING_TYPE (result) = NULL_TREE;
2206   BINDING_VALUE (result) = NULL_TREE;
2207   return result;
2208 }
2209
2210 /* Return the binding value for name in scope, considering that
2211    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2212
2213 tree
2214 namespace_binding (name, scope)
2215      tree name;
2216      tree scope;
2217 {
2218   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2219   if (b == NULL_TREE)
2220     return NULL_TREE;
2221   if (scope == NULL_TREE)
2222     scope = global_namespace;
2223   if (TREE_CODE (b) != CPLUS_BINDING)
2224     return (scope == global_namespace) ? b : NULL_TREE;
2225   name = find_binding (name,scope);
2226   if (name == NULL_TREE)
2227     return name;
2228   return BINDING_VALUE (name);
2229 }
2230
2231 /* Set the binding value for name in scope. If modifying the binding
2232    of global_namespace is attempted, try to optimize it. */
2233
2234 void
2235 set_namespace_binding (name, scope, val)
2236      tree name;
2237      tree scope;
2238      tree val;
2239 {
2240   tree b;
2241
2242   if (scope == NULL_TREE)
2243     scope = global_namespace;
2244
2245   if (scope == global_namespace)
2246     {
2247       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2248       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2249         {
2250           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2251           return;
2252         }
2253     }
2254   b = binding_for_name (name, scope);
2255   BINDING_VALUE (b) = val;
2256 }
2257
2258 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2259    select a name that is unique to this compilation unit.  */
2260
2261 void
2262 push_namespace (name)
2263      tree name;
2264 {
2265   tree d = NULL_TREE;
2266   int need_new = 1;
2267   int implicit_use = 0;
2268   int global = 0;
2269   if (!global_namespace)
2270     {
2271       /* This must be ::. */
2272       my_friendly_assert (name == get_identifier ("::"), 377);
2273       global = 1;
2274     }
2275   else if (!name)
2276     {
2277       /* The name of anonymous namespace is unique for the translation
2278          unit.  */
2279       if (!anonymous_namespace_name)
2280         anonymous_namespace_name = get_file_function_name ('N');
2281       name = anonymous_namespace_name;
2282       d = IDENTIFIER_NAMESPACE_VALUE (name);
2283       if (d)
2284         /* Reopening anonymous namespace.  */
2285         need_new = 0;
2286       implicit_use = 1;
2287     }
2288   else if (current_namespace == global_namespace
2289            && !flag_honor_std
2290            && name == std_identifier)
2291     {
2292       in_fake_std++;
2293       return;
2294     }
2295   else
2296     {
2297       /* Check whether this is an extended namespace definition. */
2298       d = IDENTIFIER_NAMESPACE_VALUE (name);
2299       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2300         {
2301           need_new = 0;
2302           if (DECL_NAMESPACE_ALIAS (d))
2303             {
2304               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2305                         d, DECL_NAMESPACE_ALIAS (d));
2306               d = DECL_NAMESPACE_ALIAS (d);
2307             }
2308         }
2309     }
2310
2311   if (need_new)
2312     {
2313       /* Make a new namespace, binding the name to it. */
2314       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2315       /* The global namespace is not pushed, and the global binding
2316          level is set elsewhere.  */
2317       if (!global)
2318         {
2319           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2320           d = pushdecl (d);
2321           pushlevel (0);
2322           declare_namespace_level ();
2323           NAMESPACE_LEVEL (d) = current_binding_level;
2324         }
2325     }
2326   else
2327     resume_binding_level (NAMESPACE_LEVEL (d));
2328
2329   if (implicit_use)
2330     do_using_directive (d);
2331   /* Enter the name space. */
2332   current_namespace = d;
2333 }
2334
2335 /* Pop from the scope of the current namespace.  */
2336
2337 void
2338 pop_namespace ()
2339 {
2340   if (current_namespace == global_namespace)
2341     {
2342       my_friendly_assert (in_fake_std > 0, 980421);
2343       in_fake_std--;
2344       return;
2345     }
2346   current_namespace = CP_DECL_CONTEXT (current_namespace);
2347   /* The binding level is not popped, as it might be re-opened later.  */
2348   suspend_binding_level ();
2349 }
2350
2351 /* Push into the scope of the namespace NS, even if it is deeply
2352    nested within another namespace.  */
2353
2354 void
2355 push_nested_namespace (ns)
2356      tree ns;
2357 {
2358   if (ns == global_namespace)
2359     push_to_top_level ();
2360   else
2361     {
2362       push_nested_namespace (CP_DECL_CONTEXT (ns));
2363       push_namespace (DECL_NAME (ns));
2364     }
2365 }
2366
2367 /* Pop back from the scope of the namespace NS, which was previously
2368    entered with push_nested_namespace.  */
2369
2370 void
2371 pop_nested_namespace (ns)
2372      tree ns;
2373 {
2374   while (ns != global_namespace)
2375     {
2376       pop_namespace ();
2377       ns = CP_DECL_CONTEXT (ns);
2378     }
2379
2380   pop_from_top_level ();
2381 }
2382
2383 \f
2384 /* Subroutines for reverting temporarily to top-level for instantiation
2385    of templates and such.  We actually need to clear out the class- and
2386    local-value slots of all identifiers, so that only the global values
2387    are at all visible.  Simply setting current_binding_level to the global
2388    scope isn't enough, because more binding levels may be pushed.  */
2389 struct saved_scope *scope_chain;
2390
2391 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2392
2393 static void
2394 mark_saved_scope (arg)
2395      void *arg;
2396 {
2397   struct saved_scope *t = *(struct saved_scope **)arg;
2398   while (t)
2399     {
2400       mark_binding_level (&t->class_bindings);
2401       ggc_mark_tree (t->old_bindings);
2402       ggc_mark_tree (t->old_namespace);
2403       ggc_mark_tree (t->class_name);
2404       ggc_mark_tree (t->class_type);
2405       ggc_mark_tree (t->access_specifier);
2406       ggc_mark_tree (t->function_decl);
2407       if (t->lang_base)
2408         ggc_mark_tree_varray (t->lang_base);
2409       ggc_mark_tree (t->lang_name);
2410       ggc_mark_tree (t->template_parms);
2411       ggc_mark_tree (t->x_previous_class_type);
2412       ggc_mark_tree (t->x_previous_class_values);
2413       ggc_mark_tree (t->x_saved_tree);
2414       ggc_mark_tree (t->incomplete);
2415       ggc_mark_tree (t->lookups);
2416
2417       mark_stmt_tree (&t->x_stmt_tree);
2418       mark_binding_level (&t->bindings);
2419       t = t->prev;
2420     }
2421 }
2422
2423 static tree
2424 store_bindings (names, old_bindings)
2425      tree names, old_bindings;
2426 {
2427   tree t;
2428   tree search_bindings = old_bindings;
2429
2430   for (t = names; t; t = TREE_CHAIN (t))
2431     {
2432       tree binding, t1, id;
2433
2434       if (TREE_CODE (t) == TREE_LIST)
2435         id = TREE_PURPOSE (t);
2436       else
2437         id = DECL_NAME (t);
2438
2439       if (!id
2440           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2441              we have no IDENTIFIER_BINDING if we have left the class
2442              scope, but cached the class-level declarations.  */
2443           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2444         continue;
2445
2446       for (t1 = search_bindings; t1; t1 = TREE_CHAIN (t1))
2447         if (TREE_VEC_ELT (t1, 0) == id)
2448           goto skip_it;
2449
2450       binding = make_tree_vec (4);
2451
2452       if (id)
2453         {
2454           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2455           TREE_VEC_ELT (binding, 0) = id;
2456           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2457           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2458           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2459           IDENTIFIER_BINDING (id) = NULL_TREE;
2460           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2461         }
2462       TREE_CHAIN (binding) = old_bindings;
2463       old_bindings = binding;
2464     skip_it:
2465       ;
2466     }
2467   return old_bindings;
2468 }
2469
2470 void
2471 maybe_push_to_top_level (pseudo)
2472      int pseudo;
2473 {
2474   struct saved_scope *s;
2475   struct binding_level *b;
2476   tree old_bindings;
2477   int need_pop;
2478
2479   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2480
2481   b = scope_chain ? current_binding_level : 0;
2482
2483   /* If we're in the middle of some function, save our state.  */
2484   if (cfun)
2485     {
2486       need_pop = 1;
2487       push_function_context_to (NULL_TREE);
2488     }
2489   else
2490     need_pop = 0;
2491
2492   old_bindings = NULL_TREE;
2493   if (scope_chain && previous_class_type)
2494     old_bindings = store_bindings (previous_class_values, old_bindings);
2495
2496   /* Have to include global_binding_level, because class-level decls
2497      aren't listed anywhere useful.  */
2498   for (; b; b = b->level_chain)
2499     {
2500       tree t;
2501
2502       /* Template IDs are inserted into the global level. If they were
2503          inserted into namespace level, finish_file wouldn't find them
2504          when doing pending instantiations. Therefore, don't stop at
2505          namespace level, but continue until :: .  */
2506       if (b == global_binding_level || (pseudo && b->template_parms_p))
2507         break;
2508
2509       old_bindings = store_bindings (b->names, old_bindings);
2510       /* We also need to check class_shadowed to save class-level type
2511          bindings, since pushclass doesn't fill in b->names.  */
2512       if (b->parm_flag == 2)
2513         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2514
2515       /* Unwind type-value slots back to top level.  */
2516       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2517         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2518     }
2519   s->prev = scope_chain;
2520   s->old_bindings = old_bindings;
2521   s->bindings = b;
2522   s->need_pop_function_context = need_pop;
2523   s->function_decl = current_function_decl;
2524
2525   scope_chain = s;
2526   current_function_decl = NULL_TREE;
2527   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2528   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2529   current_lang_name = lang_name_cplusplus;
2530   current_namespace = global_namespace;
2531 }
2532
2533 void
2534 push_to_top_level ()
2535 {
2536   maybe_push_to_top_level (0);
2537 }
2538
2539 void
2540 pop_from_top_level ()
2541 {
2542   struct saved_scope *s = scope_chain;
2543   tree t;
2544
2545   /* Clear out class-level bindings cache.  */
2546   if (previous_class_type)
2547     invalidate_class_lookup_cache ();
2548
2549   VARRAY_FREE (current_lang_base);
2550
2551   scope_chain = s->prev;
2552   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2553     {
2554       tree id = TREE_VEC_ELT (t, 0);
2555       if (id)
2556         {
2557           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2558           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2559           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2560         }
2561     }
2562
2563   /* If we were in the middle of compiling a function, restore our
2564      state.  */
2565   if (s->need_pop_function_context)
2566     pop_function_context_from (NULL_TREE);
2567   current_function_decl = s->function_decl;
2568
2569   free (s);
2570 }
2571 \f
2572 /* Push a definition of struct, union or enum tag "name".
2573    into binding_level "b".   "type" should be the type node,
2574    We assume that the tag "name" is not already defined.
2575
2576    Note that the definition may really be just a forward reference.
2577    In that case, the TYPE_SIZE will be a NULL_TREE.
2578
2579    C++ gratuitously puts all these tags in the name space.  */
2580
2581 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2582    record the shadowed value for this binding contour.  TYPE is
2583    the type that ID maps to.  */
2584
2585 static void
2586 set_identifier_type_value_with_scope (id, type, b)
2587      tree id;
2588      tree type;
2589      struct binding_level *b;
2590 {
2591   if (!b->namespace_p)
2592     {
2593       /* Shadow the marker, not the real thing, so that the marker
2594          gets restored later. */
2595       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2596       b->type_shadowed
2597         = tree_cons (id, old_type_value, b->type_shadowed);
2598     }
2599   else
2600     {
2601       tree binding = binding_for_name (id, current_namespace);
2602       BINDING_TYPE (binding) = type;
2603       /* Store marker instead of real type. */
2604       type = global_type_node;
2605     }
2606   SET_IDENTIFIER_TYPE_VALUE (id, type);
2607 }
2608
2609 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2610
2611 void
2612 set_identifier_type_value (id, type)
2613      tree id;
2614      tree type;
2615 {
2616   set_identifier_type_value_with_scope (id, type, current_binding_level);
2617 }
2618
2619 /* Return the type associated with id. */
2620
2621 tree
2622 identifier_type_value (id)
2623      tree id;
2624 {
2625   /* There is no type with that name, anywhere. */
2626   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2627     return NULL_TREE;
2628   /* This is not the type marker, but the real thing. */
2629   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2630     return REAL_IDENTIFIER_TYPE_VALUE (id);
2631   /* Have to search for it. It must be on the global level, now.
2632      Ask lookup_name not to return non-types. */
2633   id = lookup_name_real (id, 2, 1, 0);
2634   if (id)
2635     return TREE_TYPE (id);
2636   return NULL_TREE;
2637 }
2638
2639 /* Pop off extraneous binding levels left over due to syntax errors.
2640
2641    We don't pop past namespaces, as they might be valid.  */
2642
2643 void
2644 pop_everything ()
2645 {
2646 #ifdef DEBUG_CP_BINDING_LEVELS
2647   fprintf (stderr, "XXX entering pop_everything ()\n");
2648 #endif
2649   while (!toplevel_bindings_p ())
2650     {
2651       if (current_binding_level->parm_flag == 2)
2652         pop_nested_class ();
2653       else
2654         poplevel (0, 0, 0);
2655     }
2656 #ifdef DEBUG_CP_BINDING_LEVELS
2657   fprintf (stderr, "XXX leaving pop_everything ()\n");
2658 #endif
2659 }
2660
2661 /* The type TYPE is being declared.  If it is a class template, or a
2662    specialization of a class template, do any processing required and
2663    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2664    being declared a friend.  B is the binding level at which this TYPE
2665    should be bound.
2666
2667    Returns the TYPE_DECL for TYPE, which may have been altered by this
2668    processing.  */
2669
2670 static tree
2671 maybe_process_template_type_declaration (type, globalize, b)
2672      tree type;
2673      int globalize;
2674      struct binding_level* b;
2675 {
2676   tree decl = TYPE_NAME (type);
2677
2678   if (processing_template_parmlist)
2679     /* You can't declare a new template type in a template parameter
2680        list.  But, you can declare a non-template type:
2681
2682          template <class A*> struct S;
2683
2684        is a forward-declaration of `A'.  */
2685     ;
2686   else
2687     {
2688       maybe_check_template_type (type);
2689
2690       my_friendly_assert (IS_AGGR_TYPE (type)
2691                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2692
2693
2694       if (processing_template_decl)
2695         {
2696           /* This may change after the call to
2697              push_template_decl_real, but we want the original value.  */
2698           tree name = DECL_NAME (decl);
2699
2700           decl = push_template_decl_real (decl, globalize);
2701           /* If the current binding level is the binding level for the
2702              template parameters (see the comment in
2703              begin_template_parm_list) and the enclosing level is a class
2704              scope, and we're not looking at a friend, push the
2705              declaration of the member class into the class scope.  In the
2706              friend case, push_template_decl will already have put the
2707              friend into global scope, if appropriate.  */
2708           if (TREE_CODE (type) != ENUMERAL_TYPE
2709               && !globalize && b->template_parms_p
2710               && b->level_chain->parm_flag == 2)
2711             {
2712               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2713               /* Put this tag on the list of tags for the class, since
2714                  that won't happen below because B is not the class
2715                  binding level, but is instead the pseudo-global level.  */
2716               b->level_chain->tags =
2717                 tree_cons (name, type, b->level_chain->tags);
2718               if (!COMPLETE_TYPE_P (current_class_type))
2719                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2720             }
2721         }
2722     }
2723
2724   return decl;
2725 }
2726
2727 /* In C++, you don't have to write `struct S' to refer to `S'; you
2728    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2729    if the user had written `typedef struct S S'.  Create and return
2730    the TYPE_DECL for TYPE.  */
2731
2732 tree
2733 create_implicit_typedef (name, type)
2734      tree name;
2735      tree type;
2736 {
2737   tree decl;
2738
2739   decl = build_decl (TYPE_DECL, name, type);
2740   DECL_ARTIFICIAL (decl) = 1;
2741   /* There are other implicit type declarations, like the one *within*
2742      a class that allows you to write `S::S'.  We must distinguish
2743      amongst these.  */
2744   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2745   TYPE_NAME (type) = decl;
2746
2747   return decl;
2748 }
2749
2750 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2751    Normally put it into the inner-most non-tag-transparent scope,
2752    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2753    The latter is needed for implicit declarations.  */
2754
2755 void
2756 pushtag (name, type, globalize)
2757      tree name, type;
2758      int globalize;
2759 {
2760   register struct binding_level *b;
2761
2762   b = current_binding_level;
2763   while (b->tag_transparent
2764          || (globalize && b->parm_flag == 2))
2765     b = b->level_chain;
2766
2767   b->tags = tree_cons (name, type, b->tags);
2768
2769   if (name)
2770     {
2771       /* Do C++ gratuitous typedefing.  */
2772       if (IDENTIFIER_TYPE_VALUE (name) != type)
2773         {
2774           register tree d = NULL_TREE;
2775           int in_class = 0;
2776           tree context = TYPE_CONTEXT (type);
2777
2778           if (! context)
2779             {
2780               tree cs = current_scope ();
2781
2782               if (! globalize)
2783                 context = cs;
2784               else if (cs != NULL_TREE && TYPE_P (cs))
2785                 /* When declaring a friend class of a local class, we want
2786                    to inject the newly named class into the scope
2787                    containing the local class, not the namespace scope.  */
2788                 context = decl_function_context (get_type_decl (cs));
2789             }
2790           if (!context)
2791             context = current_namespace;
2792
2793           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2794               || b->parm_flag == 2)
2795             in_class = 1;
2796
2797           if (current_lang_name == lang_name_java)
2798             TYPE_FOR_JAVA (type) = 1;
2799
2800           d = create_implicit_typedef (name, type);
2801           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2802           if (! in_class)
2803             set_identifier_type_value_with_scope (name, type, b);
2804
2805           d = maybe_process_template_type_declaration (type,
2806                                                        globalize, b);
2807
2808           if (b->parm_flag == 2)
2809             {
2810               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2811                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2812                    class.  But if it's a member template class, we
2813                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2814                    is done later.  */
2815                 finish_member_declaration (d);
2816               else
2817                 pushdecl_class_level (d);
2818             }
2819           else
2820             d = pushdecl_with_scope (d, b);
2821
2822           if (ANON_AGGRNAME_P (name))
2823             DECL_IGNORED_P (d) = 1;
2824
2825           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2826           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2827
2828           /* If this is a local class, keep track of it.  We need this
2829              information for name-mangling, and so that it is possible to find
2830              all function definitions in a translation unit in a convenient
2831              way.  (It's otherwise tricky to find a member function definition
2832              it's only pointed to from within a local class.)  */
2833           if (TYPE_CONTEXT (type)
2834               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2835               && !processing_template_decl)
2836             VARRAY_PUSH_TREE (local_classes, type);
2837
2838           if (!uses_template_parms (type))
2839             {
2840               if (flag_new_abi)
2841                 DECL_ASSEMBLER_NAME (d) = mangle_type (type);
2842               else
2843                 DECL_ASSEMBLER_NAME (d)
2844                   = get_identifier (build_overload_name (type, 1, 1));
2845             }
2846         }
2847       if (b->parm_flag == 2)
2848         {
2849           if (!COMPLETE_TYPE_P (current_class_type))
2850             CLASSTYPE_TAGS (current_class_type) = b->tags;
2851         }
2852     }
2853
2854   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2855     /* Use the canonical TYPE_DECL for this node.  */
2856     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2857   else
2858     {
2859       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2860          will be the tagged type we just added to the current
2861          binding level.  This fake NULL-named TYPE_DECL node helps
2862          dwarfout.c to know when it needs to output a
2863          representation of a tagged type, and it also gives us a
2864          convenient place to record the "scope start" address for
2865          the tagged type.  */
2866
2867       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2868       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2869     }
2870 }
2871
2872 /* Counter used to create anonymous type names.  */
2873
2874 static int anon_cnt = 0;
2875
2876 /* Return an IDENTIFIER which can be used as a name for
2877    anonymous structs and unions.  */
2878
2879 tree
2880 make_anon_name ()
2881 {
2882   char buf[32];
2883
2884   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2885   return get_identifier (buf);
2886 }
2887
2888 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2889    This keeps dbxout from getting confused.  */
2890
2891 void
2892 clear_anon_tags ()
2893 {
2894   register struct binding_level *b;
2895   register tree tags;
2896   static int last_cnt = 0;
2897
2898   /* Fast out if no new anon names were declared.  */
2899   if (last_cnt == anon_cnt)
2900     return;
2901
2902   b = current_binding_level;
2903   while (b->tag_transparent)
2904     b = b->level_chain;
2905   tags = b->tags;
2906   while (tags)
2907     {
2908       /* A NULL purpose means we have already processed all tags
2909          from here to the end of the list.  */
2910       if (TREE_PURPOSE (tags) == NULL_TREE)
2911         break;
2912       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2913         TREE_PURPOSE (tags) = NULL_TREE;
2914       tags = TREE_CHAIN (tags);
2915     }
2916   last_cnt = anon_cnt;
2917 }
2918 \f
2919 /* Subroutine of duplicate_decls: return truthvalue of whether
2920    or not types of these decls match.
2921
2922    For C++, we must compare the parameter list so that `int' can match
2923    `int&' in a parameter position, but `int&' is not confused with
2924    `const int&'.  */
2925
2926 int
2927 decls_match (newdecl, olddecl)
2928      tree newdecl, olddecl;
2929 {
2930   int types_match;
2931
2932   if (newdecl == olddecl)
2933     return 1;
2934
2935   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2936     /* If the two DECLs are not even the same kind of thing, we're not
2937        interested in their types.  */
2938     return 0;
2939
2940   if (TREE_CODE (newdecl) == FUNCTION_DECL)
2941     {
2942       tree f1 = TREE_TYPE (newdecl);
2943       tree f2 = TREE_TYPE (olddecl);
2944       tree p1 = TYPE_ARG_TYPES (f1);
2945       tree p2 = TYPE_ARG_TYPES (f2);
2946
2947       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2948           && ! (DECL_EXTERN_C_P (newdecl)
2949                 && DECL_EXTERN_C_P (olddecl)))
2950         return 0;
2951
2952       if (TREE_CODE (f1) != TREE_CODE (f2))
2953         return 0;
2954
2955       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2956         {
2957           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
2958               && (DECL_BUILT_IN (olddecl)
2959 #ifndef NO_IMPLICIT_EXTERN_C
2960                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
2961                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
2962 #endif
2963               ))
2964             {
2965               types_match = self_promoting_args_p (p1);
2966               if (p1 == void_list_node)
2967                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2968             }
2969 #ifndef NO_IMPLICIT_EXTERN_C
2970           else if (p1 == NULL_TREE
2971                    && (DECL_EXTERN_C_P (olddecl)
2972                        && DECL_IN_SYSTEM_HEADER (olddecl)
2973                        && !DECL_CLASS_SCOPE_P (olddecl))
2974                    && (DECL_EXTERN_C_P (newdecl)
2975                        && DECL_IN_SYSTEM_HEADER (newdecl)
2976                        && !DECL_CLASS_SCOPE_P (newdecl)))
2977             {
2978               types_match = self_promoting_args_p (p2);
2979               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2980             }
2981 #endif
2982           else
2983             types_match = compparms (p1, p2);
2984         }
2985       else
2986         types_match = 0;
2987     }
2988   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2989     {
2990       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2991                                 DECL_TEMPLATE_PARMS (olddecl)))
2992         return 0;
2993
2994       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
2995           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
2996         return 0;
2997
2998       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2999         types_match = 1;
3000       else
3001         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3002                                    DECL_TEMPLATE_RESULT (newdecl));
3003     }
3004   else
3005     {
3006       if (TREE_TYPE (newdecl) == error_mark_node)
3007         types_match = TREE_TYPE (olddecl) == error_mark_node;
3008       else if (TREE_TYPE (olddecl) == NULL_TREE)
3009         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3010       else if (TREE_TYPE (newdecl) == NULL_TREE)
3011         types_match = 0;
3012       else
3013         types_match = comptypes (TREE_TYPE (newdecl),
3014                                  TREE_TYPE (olddecl),
3015                                  COMPARE_REDECLARATION);
3016     }
3017
3018   return types_match;
3019 }
3020
3021 /* If NEWDECL is `static' and an `extern' was seen previously,
3022    warn about it.  OLDDECL is the previous declaration.
3023
3024    Note that this does not apply to the C++ case of declaring
3025    a variable `extern const' and then later `const'.
3026
3027    Don't complain about built-in functions, since they are beyond
3028    the user's control.  */
3029
3030 static void
3031 warn_extern_redeclared_static (newdecl, olddecl)
3032      tree newdecl, olddecl;
3033 {
3034   static const char *explicit_extern_static_warning
3035     = "`%D' was declared `extern' and later `static'";
3036   static const char *implicit_extern_static_warning
3037     = "`%D' was declared implicitly `extern' and later `static'";
3038
3039   tree name;
3040
3041   if (TREE_CODE (newdecl) == TYPE_DECL
3042       || TREE_CODE (newdecl) == TEMPLATE_DECL
3043       || TREE_CODE (newdecl) == CONST_DECL)
3044     return;
3045
3046   /* Don't get confused by static member functions; that's a different
3047      use of `static'.  */
3048   if (TREE_CODE (newdecl) == FUNCTION_DECL
3049       && DECL_STATIC_FUNCTION_P (newdecl))
3050     return;
3051
3052   /* If the old declaration was `static', or the new one isn't, then
3053      then everything is OK.  */
3054   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3055     return;
3056
3057   /* It's OK to declare a builtin function as `static'.  */
3058   if (TREE_CODE (olddecl) == FUNCTION_DECL
3059       && DECL_ARTIFICIAL (olddecl))
3060     return;
3061
3062   name = DECL_ASSEMBLER_NAME (newdecl);
3063   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3064               ? implicit_extern_static_warning
3065               : explicit_extern_static_warning, newdecl);
3066   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3067 }
3068
3069 /* Handle when a new declaration NEWDECL has the same name as an old
3070    one OLDDECL in the same binding contour.  Prints an error message
3071    if appropriate.
3072
3073    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3074    Otherwise, return 0.  */
3075
3076 int
3077 duplicate_decls (newdecl, olddecl)
3078      tree newdecl, olddecl;
3079 {
3080   unsigned olddecl_uid = DECL_UID (olddecl);
3081   int olddecl_friend = 0, types_match = 0;
3082   int new_defines_function = 0;
3083
3084   if (newdecl == olddecl)
3085     return 1;
3086
3087   types_match = decls_match (newdecl, olddecl);
3088
3089   /* If either the type of the new decl or the type of the old decl is an
3090      error_mark_node, then that implies that we have already issued an
3091      error (earlier) for some bogus type specification, and in that case,
3092      it is rather pointless to harass the user with yet more error message
3093      about the same declaration, so just pretend the types match here.  */
3094   if (TREE_TYPE (newdecl) == error_mark_node
3095       || TREE_TYPE (olddecl) == error_mark_node)
3096     types_match = 1;
3097
3098   /* Check for redeclaration and other discrepancies. */
3099   if (TREE_CODE (olddecl) == FUNCTION_DECL
3100       && DECL_ARTIFICIAL (olddecl))
3101     {
3102       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3103         {
3104           /* If you declare a built-in or predefined function name as static,
3105              the old definition is overridden, but optionally warn this was a
3106              bad choice of name.  */
3107           if (! TREE_PUBLIC (newdecl))
3108             {
3109               if (warn_shadow)
3110                 cp_warning ("shadowing %s function `%#D'",
3111                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3112                             olddecl);
3113               /* Discard the old built-in function.  */
3114               return 0;
3115             }
3116           /* If the built-in is not ansi, then programs can override
3117              it even globally without an error.  */
3118           else if (! DECL_BUILT_IN (olddecl))
3119             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3120                         olddecl, newdecl);
3121           else
3122             {
3123               cp_error ("declaration of `%#D'", newdecl);
3124               cp_error ("conflicts with built-in declaration `%#D'",
3125                         olddecl);
3126             }
3127           return 0;
3128         }
3129       else if (!types_match)
3130         {
3131           if ((DECL_EXTERN_C_P (newdecl)
3132                && DECL_EXTERN_C_P (olddecl))
3133               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3134                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3135             {
3136               /* A near match; override the builtin.  */
3137
3138               if (TREE_PUBLIC (newdecl))
3139                 {
3140                   cp_warning ("new declaration `%#D'", newdecl);
3141                   cp_warning ("ambiguates built-in declaration `%#D'",
3142                               olddecl);
3143                 }
3144               else if (warn_shadow)
3145                 cp_warning ("shadowing %s function `%#D'",
3146                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3147                             olddecl);
3148             }
3149           else
3150             /* Discard the old built-in function.  */
3151             return 0;
3152         }
3153
3154       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3155         {
3156           /* If a builtin function is redeclared as `static', merge
3157              the declarations, but make the original one static.  */
3158           DECL_THIS_STATIC (olddecl) = 1;
3159           TREE_PUBLIC (olddecl) = 0;
3160
3161           /* Make the old declaration consistent with the new one so
3162              that all remnants of the builtin-ness of this function
3163              will be banished.  */
3164           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3165           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3166           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3167           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3168                                        newdecl);
3169         }
3170     }
3171   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3172     {
3173       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3174            && TREE_CODE (newdecl) != TYPE_DECL
3175            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3176                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3177           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3178               && TREE_CODE (olddecl) != TYPE_DECL
3179               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3180                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3181                         == TYPE_DECL))))
3182         {
3183           /* We do nothing special here, because C++ does such nasty
3184              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3185              get shadowed, and know that if we need to find a TYPE_DECL
3186              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3187              slot of the identifier.  */
3188           return 0;
3189         }
3190
3191       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3192            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3193           || (TREE_CODE (olddecl) == FUNCTION_DECL
3194               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3195         return 0;
3196
3197       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3198       if (TREE_CODE (olddecl) == TREE_LIST)
3199         olddecl = TREE_VALUE (olddecl);
3200       cp_error_at ("previous declaration of `%#D'", olddecl);
3201
3202       /* New decl is completely inconsistent with the old one =>
3203          tell caller to replace the old one.  */
3204
3205       return 0;
3206     }
3207   else if (!types_match)
3208     {
3209       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3210         /* These are certainly not duplicate declarations; they're
3211            from different scopes.  */
3212         return 0;
3213
3214       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3215         {
3216           /* The name of a class template may not be declared to refer to
3217              any other template, class, function, object, namespace, value,
3218              or type in the same scope.  */
3219           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3220               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3221             {
3222               cp_error ("declaration of template `%#D'", newdecl);
3223               cp_error_at ("conflicts with previous declaration `%#D'",
3224                            olddecl);
3225             }
3226           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3227                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3228                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3229                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3230                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3231                                            DECL_TEMPLATE_PARMS (olddecl)))
3232             {
3233               cp_error ("new declaration `%#D'", newdecl);
3234               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3235             }
3236           return 0;
3237         }
3238       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3239         {
3240           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3241             {
3242               cp_error ("declaration of C function `%#D' conflicts with",
3243                         newdecl);
3244               cp_error_at ("previous declaration `%#D' here", olddecl);
3245             }
3246           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3247                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3248             {
3249               cp_error ("new declaration `%#D'", newdecl);
3250               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3251             }
3252           else
3253             return 0;
3254         }
3255
3256       /* Already complained about this, so don't do so again.  */
3257       else if (current_class_type == NULL_TREE
3258           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3259         {
3260           cp_error ("conflicting types for `%#D'", newdecl);
3261           cp_error_at ("previous declaration as `%#D'", olddecl);
3262         }
3263     }
3264   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3265             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3266                  && (!DECL_TEMPLATE_INFO (newdecl)
3267                      || (DECL_TI_TEMPLATE (newdecl)
3268                          != DECL_TI_TEMPLATE (olddecl))))
3269                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3270                     && (!DECL_TEMPLATE_INFO (olddecl)
3271                         || (DECL_TI_TEMPLATE (olddecl)
3272                             != DECL_TI_TEMPLATE (newdecl))))))
3273     /* It's OK to have a template specialization and a non-template
3274        with the same type, or to have specializations of two
3275        different templates with the same type.  Note that if one is a
3276        specialization, and the other is an instantiation of the same
3277        template, that we do not exit at this point.  That situation
3278        can occur if we instantiate a template class, and then
3279        specialize one of its methods.  This situation is legal, but
3280        the declarations must be merged in the usual way.  */
3281     return 0;
3282   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3283            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3284                 && !DECL_USE_TEMPLATE (newdecl))
3285                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3286                    && !DECL_USE_TEMPLATE (olddecl))))
3287     /* One of the declarations is a template instantiation, and the
3288        other is not a template at all.  That's OK.  */
3289     return 0;
3290   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3291            && DECL_NAMESPACE_ALIAS (newdecl)
3292            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3293     /* Redeclaration of namespace alias, ignore it. */
3294     return 1;
3295   else
3296     {
3297       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3298       if (errmsg)
3299         {
3300           cp_error (errmsg, newdecl);
3301           if (DECL_NAME (olddecl) != NULL_TREE)
3302             cp_error_at ((DECL_INITIAL (olddecl)
3303                           && namespace_bindings_p ())
3304                          ? "`%#D' previously defined here"
3305                          : "`%#D' previously declared here", olddecl);
3306         }
3307       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3308                && DECL_INITIAL (olddecl) != NULL_TREE
3309                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3310                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3311         {
3312           /* Prototype decl follows defn w/o prototype.  */
3313           cp_warning_at ("prototype for `%#D'", newdecl);
3314           cp_warning_at ("follows non-prototype definition here", olddecl);
3315         }
3316       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3317                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3318         {
3319           /* extern "C" int foo ();
3320              int foo () { bar (); }
3321              is OK.  */
3322           if (current_lang_stack
3323               == &VARRAY_TREE (current_lang_base, 0))
3324             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3325           else
3326             {
3327               cp_error_at ("previous declaration of `%#D' with %L linkage",
3328                            olddecl, DECL_LANGUAGE (olddecl));
3329               cp_error ("conflicts with new declaration with %L linkage",
3330                         DECL_LANGUAGE (newdecl));
3331             }
3332         }
3333
3334       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3335         ;
3336       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3337         {
3338           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3339           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3340           int i = 1;
3341
3342           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3343             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3344
3345           for (; t1 && t1 != void_list_node;
3346                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3347             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3348               {
3349                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3350                                            TREE_PURPOSE (t2)))
3351                   {
3352                     if (pedantic)
3353                       {
3354                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3355                                     i, newdecl);
3356                         cp_pedwarn_at ("after previous specification in `%#D'",
3357                                        olddecl);
3358                       }
3359                   }
3360                 else
3361                   {
3362                     cp_error ("default argument given for parameter %d of `%#D'",
3363                               i, newdecl);
3364                     cp_error_at ("after previous specification in `%#D'",
3365                                  olddecl);
3366                   }
3367               }
3368
3369           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3370               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3371             {
3372               cp_warning ("`%#D' was used before it was declared inline",
3373                           newdecl);
3374               cp_warning_at ("previous non-inline declaration here",
3375                              olddecl);
3376             }
3377         }
3378     }
3379
3380   /* If new decl is `static' and an `extern' was seen previously,
3381      warn about it.  */
3382   warn_extern_redeclared_static (newdecl, olddecl);
3383
3384   /* We have committed to returning 1 at this point.  */
3385   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3386     {
3387       /* Now that functions must hold information normally held
3388          by field decls, there is extra work to do so that
3389          declaration information does not get destroyed during
3390          definition.  */
3391       if (DECL_VINDEX (olddecl))
3392         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3393       if (DECL_VIRTUAL_CONTEXT (olddecl))
3394         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3395       if (DECL_CONTEXT (olddecl))
3396         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3397       if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3398         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3399       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3400       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3401       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3402       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3403       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3404       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3405       DECL_LANG_SPECIFIC (newdecl)->u2 = DECL_LANG_SPECIFIC (olddecl)->u2;
3406       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3407
3408       /* Optionally warn about more than one declaration for the same
3409          name, but don't warn about a function declaration followed by a
3410          definition.  */
3411       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3412           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3413           /* Don't warn about extern decl followed by definition. */
3414           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3415           /* Don't warn about friends, let add_friend take care of it. */
3416           && ! DECL_FRIEND_P (newdecl))
3417         {
3418           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3419           cp_warning_at ("previous declaration of `%D'", olddecl);
3420         }
3421     }
3422
3423   /* Deal with C++: must preserve virtual function table size.  */
3424   if (TREE_CODE (olddecl) == TYPE_DECL)
3425     {
3426       register tree newtype = TREE_TYPE (newdecl);
3427       register tree oldtype = TREE_TYPE (olddecl);
3428
3429       if (newtype != error_mark_node && oldtype != error_mark_node
3430           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3431         {
3432           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3433           CLASSTYPE_FRIEND_CLASSES (newtype)
3434             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3435         }
3436
3437       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3438     }
3439
3440   /* Copy all the DECL_... slots specified in the new decl
3441      except for any that we copy here from the old type.  */
3442   DECL_MACHINE_ATTRIBUTES (newdecl)
3443     = merge_machine_decl_attributes (olddecl, newdecl);
3444
3445   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3446     {
3447       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3448       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3449         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3450                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3451
3452       return 1;
3453     }
3454
3455   if (types_match)
3456     {
3457       /* Automatically handles default parameters.  */
3458       tree oldtype = TREE_TYPE (olddecl);
3459       tree newtype;
3460
3461       /* Merge the data types specified in the two decls.  */
3462       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3463
3464       /* If common_type produces a non-typedef type, just use the old type.  */
3465       if (TREE_CODE (newdecl) == TYPE_DECL
3466           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3467         newtype = oldtype;
3468
3469       if (TREE_CODE (newdecl) == VAR_DECL)
3470         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3471       /* Do this after calling `common_type' so that default
3472          parameters don't confuse us.  */
3473       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3474           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3475               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3476         {
3477           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3478                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3479           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3480                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3481
3482           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3483               && DECL_SOURCE_LINE (olddecl) != 0
3484               && flag_exceptions
3485               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3486                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3487             {
3488               cp_error ("declaration of `%F' throws different exceptions",
3489                         newdecl);
3490               cp_error_at ("than previous declaration `%F'", olddecl);
3491             }
3492         }
3493       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3494
3495       /* Lay the type out, unless already done.  */
3496       if (! same_type_p (newtype, oldtype)
3497           && TREE_TYPE (newdecl) != error_mark_node
3498           && !(processing_template_decl && uses_template_parms (newdecl)))
3499         layout_type (TREE_TYPE (newdecl));
3500
3501       if ((TREE_CODE (newdecl) == VAR_DECL
3502            || TREE_CODE (newdecl) == PARM_DECL
3503            || TREE_CODE (newdecl) == RESULT_DECL
3504            || TREE_CODE (newdecl) == FIELD_DECL
3505            || TREE_CODE (newdecl) == TYPE_DECL)
3506           && !(processing_template_decl && uses_template_parms (newdecl)))
3507         layout_decl (newdecl, 0);
3508
3509       /* Merge the type qualifiers.  */
3510       if (TREE_READONLY (newdecl))
3511         TREE_READONLY (olddecl) = 1;
3512       if (TREE_THIS_VOLATILE (newdecl))
3513         TREE_THIS_VOLATILE (olddecl) = 1;
3514
3515       /* Merge the initialization information.  */
3516       if (DECL_INITIAL (newdecl) == NULL_TREE
3517           && DECL_INITIAL (olddecl) != NULL_TREE)
3518         {
3519           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3520           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3521           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3522           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3523               && DECL_LANG_SPECIFIC (newdecl)
3524               && DECL_LANG_SPECIFIC (olddecl))
3525             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3526         }
3527
3528       /* Merge the section attribute.
3529          We want to issue an error if the sections conflict but that must be
3530          done later in decl_attributes since we are called before attributes
3531          are assigned.  */
3532       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3533         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3534
3535       /* Keep the old rtl since we can safely use it.  */
3536       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3537
3538       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3539         {
3540           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3541             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3542           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3543             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3544           DECL_NO_LIMIT_STACK (newdecl)
3545             |= DECL_NO_LIMIT_STACK (olddecl);
3546         }
3547     }
3548   /* If cannot merge, then use the new type and qualifiers,
3549      and don't preserve the old rtl.  */
3550   else
3551     {
3552       /* Clean out any memory we had of the old declaration.  */
3553       tree oldstatic = value_member (olddecl, static_aggregates);
3554       if (oldstatic)
3555         TREE_VALUE (oldstatic) = error_mark_node;
3556
3557       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3558       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3559       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3560       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3561     }
3562
3563   /* Merge the storage class information.  */
3564   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3565   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3566   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3567   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3568   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3569   if (! DECL_EXTERNAL (olddecl))
3570     DECL_EXTERNAL (newdecl) = 0;
3571
3572   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3573     {
3574       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3575       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3576       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3577       DECL_TEMPLATE_INSTANTIATED (newdecl)
3578         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3579       /* Don't really know how much of the language-specific
3580          values we should copy from old to new.  */
3581       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3582       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3583       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3584       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3585       olddecl_friend = DECL_FRIEND_P (olddecl);
3586
3587       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3588       if (TREE_CODE (newdecl) == FUNCTION_DECL
3589           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3590         DECL_BEFRIENDING_CLASSES (newdecl)
3591           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3592                      DECL_BEFRIENDING_CLASSES (olddecl));
3593     }
3594
3595   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3596     {
3597       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3598           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3599         {
3600           /* If newdecl is not a specialization, then it is not a
3601              template-related function at all.  And that means that we
3602              shoud have exited above, returning 0.  */
3603           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3604                               0);
3605
3606           if (TREE_USED (olddecl))
3607             /* From [temp.expl.spec]:
3608
3609                If a template, a member template or the member of a class
3610                template is explicitly specialized then that
3611                specialization shall be declared before the first use of
3612                that specialization that would cause an implicit
3613                instantiation to take place, in every translation unit in
3614                which such a use occurs.  */
3615             cp_error ("explicit specialization of %D after first use",
3616                       olddecl);
3617
3618           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3619         }
3620       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3621
3622       /* If either decl says `inline', this fn is inline, unless its
3623          definition was passed already.  */
3624       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3625         DECL_INLINE (olddecl) = 1;
3626       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3627
3628       if (! types_match)
3629         {
3630           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3631           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3632           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3633         }
3634       if (! types_match || new_defines_function)
3635         {
3636           /* These need to be copied so that the names are available.
3637              Note that if the types do match, we'll preserve inline
3638              info and other bits, but if not, we won't.  */
3639           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3640           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3641         }
3642       if (new_defines_function)
3643         /* If defining a function declared with other language
3644            linkage, use the previously declared language linkage.  */
3645         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3646       else if (types_match)
3647         {
3648           /* If redeclaring a builtin function, and not a definition,
3649              it stays built in.  */
3650           if (DECL_BUILT_IN (olddecl))
3651             {
3652               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3653               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3654               /* If we're keeping the built-in definition, keep the rtl,
3655                  regardless of declaration matches.  */
3656               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3657             }
3658           else
3659             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3660
3661           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3662           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3663             /* Previously saved insns go together with
3664                the function's previous definition.  */
3665             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3666           /* Don't clear out the arguments if we're redefining a function.  */
3667           if (DECL_ARGUMENTS (olddecl))
3668             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3669         }
3670     }
3671
3672   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3673     {
3674       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3675     }
3676
3677   /* Now preserve various other info from the definition.  */
3678   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3679   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3680   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3681   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3682
3683   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3684     {
3685       int function_size;
3686
3687       function_size = sizeof (struct tree_decl);
3688
3689       bcopy ((char *) newdecl + sizeof (struct tree_common),
3690              (char *) olddecl + sizeof (struct tree_common),
3691              function_size - sizeof (struct tree_common));
3692
3693       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3694         {
3695           /* If newdecl is a template instantiation, it is possible that
3696              the following sequence of events has occurred:
3697
3698              o A friend function was declared in a class template.  The
3699              class template was instantiated.
3700
3701              o The instantiation of the friend declaration was
3702              recorded on the instantiation list, and is newdecl.
3703
3704              o Later, however, instantiate_class_template called pushdecl
3705              on the newdecl to perform name injection.  But, pushdecl in
3706              turn called duplicate_decls when it discovered that another
3707              declaration of a global function with the same name already
3708              existed.
3709
3710              o Here, in duplicate_decls, we decided to clobber newdecl.
3711
3712              If we're going to do that, we'd better make sure that
3713              olddecl, and not newdecl, is on the list of
3714              instantiations so that if we try to do the instantiation
3715              again we won't get the clobbered declaration.  */
3716
3717           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3718           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3719
3720           for (; decls; decls = TREE_CHAIN (decls))
3721             if (TREE_VALUE (decls) == newdecl)
3722               TREE_VALUE (decls) = olddecl;
3723         }
3724     }
3725   else
3726     {
3727       bcopy ((char *) newdecl + sizeof (struct tree_common),
3728              (char *) olddecl + sizeof (struct tree_common),
3729              sizeof (struct tree_decl) - sizeof (struct tree_common)
3730              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3731     }
3732
3733   DECL_UID (olddecl) = olddecl_uid;
3734   if (olddecl_friend)
3735     DECL_FRIEND_P (olddecl) = 1;
3736
3737   /* NEWDECL contains the merged attribute lists.
3738      Update OLDDECL to be the same.  */
3739   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3740
3741   return 1;
3742 }
3743
3744 /* Record a decl-node X as belonging to the current lexical scope.
3745    Check for errors (such as an incompatible declaration for the same
3746    name already seen in the same scope).
3747
3748    Returns either X or an old decl for the same name.
3749    If an old decl is returned, it may have been smashed
3750    to agree with what X says.  */
3751
3752 tree
3753 pushdecl (x)
3754      tree x;
3755 {
3756   register tree t;
3757   register tree name;
3758   int need_new_binding;
3759
3760   /* We shouldn't be calling pushdecl when we're generating RTL for a
3761      function that we already did semantic analysis on previously.  */
3762   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3763                       19990913);
3764
3765   need_new_binding = 1;
3766
3767   if (DECL_TEMPLATE_PARM_P (x))
3768     /* Template parameters have no context; they are not X::T even
3769        when declared within a class or namespace.  */
3770     ;
3771   else
3772     {
3773       if (current_function_decl && x != current_function_decl
3774           /* A local declaration for a function doesn't constitute
3775              nesting.  */
3776           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3777           /* A local declaration for an `extern' variable is in the
3778              scope of the current namespace, not the current
3779              function.  */
3780           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3781           && !DECL_CONTEXT (x))
3782         DECL_CONTEXT (x) = current_function_decl;
3783
3784       /* If this is the declaration for a namespace-scope function,
3785          but the declaration itself is in a local scope, mark the
3786          declaration.  */
3787       if (TREE_CODE (x) == FUNCTION_DECL
3788           && DECL_NAMESPACE_SCOPE_P (x)
3789           && current_function_decl
3790           && x != current_function_decl)
3791         DECL_LOCAL_FUNCTION_P (x) = 1;
3792     }
3793
3794   name = DECL_NAME (x);
3795   if (name)
3796     {
3797       int different_binding_level = 0;
3798
3799       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3800         name = TREE_OPERAND (name, 0);
3801
3802       /* In case this decl was explicitly namespace-qualified, look it
3803          up in its namespace context.  */
3804       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3805           && namespace_bindings_p ())
3806         t = namespace_binding (name, DECL_CONTEXT (x));
3807       else
3808         t = lookup_name_current_level (name);
3809
3810       /* [basic.link] If there is a visible declaration of an entity
3811          with linkage having the same name and type, ignoring entities
3812          declared outside the innermost enclosing namespace scope, the
3813          block scope declaration declares that same entity and
3814          receives the linkage of the previous declaration.  */
3815       if (! t && current_function_decl && x != current_function_decl
3816           && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3817           && DECL_EXTERNAL (x))
3818         {
3819           /* Look in block scope.  */
3820           t = IDENTIFIER_VALUE (name);
3821           /* Or in the innermost namespace.  */
3822           if (! t)
3823             t = namespace_binding (name, DECL_CONTEXT (x));
3824           /* Does it have linkage?  */
3825           if (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                 fatal ("parse errors have confused me too much");
3878
3879               /* Check for duplicate params.  */
3880               if (duplicate_decls (x, t))
3881                 return t;
3882             }
3883           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3884                     || DECL_FUNCTION_TEMPLATE_P (x))
3885                    && is_overloaded_fn (t))
3886             /* Don't do anything just yet. */;
3887           else if (t == wchar_decl_node)
3888             {
3889               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3890                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3891
3892               /* Throw away the redeclaration.  */
3893               return t;
3894             }
3895           else if (TREE_CODE (t) != TREE_CODE (x))
3896             {
3897               if (duplicate_decls (x, t))
3898                 return t;
3899             }
3900           else if (duplicate_decls (x, t))
3901             {
3902               if (TREE_CODE (t) == TYPE_DECL)
3903                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3904               else if (TREE_CODE (t) == FUNCTION_DECL)
3905                 check_default_args (t);
3906
3907               return t;
3908             }
3909           else if (DECL_MAIN_P (x))
3910             {
3911               /* A redeclaration of main, but not a duplicate of the
3912                  previous one.
3913
3914                  [basic.start.main]
3915
3916                  This function shall not be overloaded.  */
3917               cp_error_at ("invalid redeclaration of `%D'", t);
3918               cp_error ("as `%D'", x);
3919               /* We don't try to push this declaration since that
3920                  causes a crash.  */
3921               return x;
3922             }
3923         }
3924
3925       check_template_shadow (x);
3926
3927       /* If this is a function conjured up by the backend, massage it
3928          so it looks friendly.  */
3929       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3930         {
3931           retrofit_lang_decl (x);
3932           DECL_LANGUAGE (x) = lang_c;
3933         }
3934
3935       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3936         {
3937           t = push_overloaded_decl (x, PUSH_LOCAL);
3938           if (t != x)
3939             return t;
3940           if (!namespace_bindings_p ())
3941             /* We do not need to create a binding for this name;
3942                push_overloaded_decl will have already done so if
3943                necessary.  */
3944             need_new_binding = 0;
3945         }
3946       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3947         {
3948           t = push_overloaded_decl (x, PUSH_GLOBAL);
3949           if (t == x)
3950             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3951           return t;
3952         }
3953
3954       /* If declaring a type as a typedef, copy the type (unless we're
3955          at line 0), and install this TYPE_DECL as the new type's typedef
3956          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3957       if (TREE_CODE (x) == TYPE_DECL)
3958         {
3959           tree type = TREE_TYPE (x);
3960           if (DECL_SOURCE_LINE (x) == 0)
3961             {
3962               if (TYPE_NAME (type) == 0)
3963                 TYPE_NAME (type) = x;
3964             }
3965           else if (type != error_mark_node && TYPE_NAME (type) != x
3966                    /* We don't want to copy the type when all we're
3967                       doing is making a TYPE_DECL for the purposes of
3968                       inlining.  */
3969                    && (!TYPE_NAME (type)
3970                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3971             {
3972               DECL_ORIGINAL_TYPE (x) = type;
3973               type = build_type_copy (type);
3974               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3975               TYPE_NAME (type) = x;
3976               TREE_TYPE (x) = type;
3977             }
3978
3979           if (type != error_mark_node
3980               && TYPE_NAME (type)
3981               && TYPE_IDENTIFIER (type))
3982             set_identifier_type_value_with_scope (DECL_NAME (x), type,
3983                                                   current_binding_level);
3984
3985         }
3986
3987       /* Multiple external decls of the same identifier ought to match.
3988
3989          We get warnings about inline functions where they are defined.
3990          We get warnings about other functions from push_overloaded_decl.
3991
3992          Avoid duplicate warnings where they are used.  */
3993       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
3994         {
3995           tree decl;
3996
3997           decl = IDENTIFIER_NAMESPACE_VALUE (name);
3998           if (decl && TREE_CODE (decl) == OVERLOAD)
3999             decl = OVL_FUNCTION (decl);
4000
4001           if (decl && decl != error_mark_node
4002               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4003               /* If different sort of thing, we already gave an error.  */
4004               && TREE_CODE (decl) == TREE_CODE (x)
4005               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4006             {
4007               cp_pedwarn ("type mismatch with previous external decl", x);
4008               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4009             }
4010         }
4011
4012       /* This name is new in its binding level.
4013          Install the new declaration and return it.  */
4014       if (namespace_bindings_p ())
4015         {
4016           /* Install a global value.  */
4017
4018           /* If the first global decl has external linkage,
4019              warn if we later see static one.  */
4020           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4021             TREE_PUBLIC (name) = 1;
4022
4023           /* Bind the mangled name for the entity.  In the future, we
4024              should not need to do this; mangled names are an
4025              implementation detail of which the front-end should not
4026              need to be aware.  */
4027           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4028                 && t != NULL_TREE)
4029               /* For an ordinary function, we create a binding from
4030                  the mangled name (i.e., NAME) to the DECL.  But, for
4031                  an `extern "C"' function, the mangled name and the
4032                  ordinary name are the same so we need not do this.  */
4033               && !DECL_EXTERN_C_FUNCTION_P (x))
4034             {
4035               tree mangled_name;
4036
4037               if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
4038                   || TREE_CODE (x) == NAMESPACE_DECL)
4039                 mangled_name = name;
4040               else
4041                 mangled_name = DECL_ASSEMBLER_NAME (x);
4042
4043               if (TREE_CODE (x) == FUNCTION_DECL)
4044                 my_friendly_assert
4045                   ((IDENTIFIER_GLOBAL_VALUE (mangled_name) == NULL_TREE)
4046                   || (IDENTIFIER_GLOBAL_VALUE (mangled_name) == x), 378);
4047               SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name, x);
4048             }
4049
4050           /* Don't forget if the function was used via an implicit decl.  */
4051           if (IDENTIFIER_IMPLICIT_DECL (name)
4052               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4053             TREE_USED (x) = 1;
4054
4055           /* Don't forget if its address was taken in that way.  */
4056           if (IDENTIFIER_IMPLICIT_DECL (name)
4057               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4058             TREE_ADDRESSABLE (x) = 1;
4059
4060           /* Warn about mismatches against previous implicit decl.  */
4061           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4062               /* If this real decl matches the implicit, don't complain.  */
4063               && ! (TREE_CODE (x) == FUNCTION_DECL
4064                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4065             cp_warning
4066               ("`%D' was previously implicitly declared to return `int'", x);
4067
4068           /* If new decl is `static' and an `extern' was seen previously,
4069              warn about it.  */
4070           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4071             warn_extern_redeclared_static (x, t);
4072         }
4073       else
4074         {
4075           /* Here to install a non-global value.  */
4076           tree oldlocal = IDENTIFIER_VALUE (name);
4077           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4078
4079           if (need_new_binding)
4080             {
4081               push_local_binding (name, x, 0);
4082               /* Because push_local_binding will hook X on to the
4083                  current_binding_level's name list, we don't want to
4084                  do that again below.  */
4085               need_new_binding = 0;
4086             }
4087
4088           /* If this is a TYPE_DECL, push it into the type value slot.  */
4089           if (TREE_CODE (x) == TYPE_DECL)
4090             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4091                                                   current_binding_level);
4092
4093           /* Clear out any TYPE_DECL shadowed by a namespace so that
4094              we won't think this is a type.  The C struct hack doesn't
4095              go through namespaces.  */
4096           if (TREE_CODE (x) == NAMESPACE_DECL)
4097             set_identifier_type_value_with_scope (name, NULL_TREE,
4098                                                   current_binding_level);
4099
4100           if (oldlocal)
4101             {
4102               tree d = oldlocal;
4103
4104               while (oldlocal
4105                      && TREE_CODE (oldlocal) == VAR_DECL
4106                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4107                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4108
4109               if (oldlocal == NULL_TREE)
4110                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4111             }
4112
4113           /* If this is an extern function declaration, see if we
4114              have a global definition or declaration for the function.  */
4115           if (oldlocal == NULL_TREE
4116               && DECL_EXTERNAL (x)
4117               && oldglobal != NULL_TREE
4118               && TREE_CODE (x) == FUNCTION_DECL
4119               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4120             {
4121               /* We have one.  Their types must agree.  */
4122               if (decls_match (x, oldglobal))
4123                 /* OK */;
4124               else
4125                 {
4126                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4127                   cp_warning_at ("global declaration `%#D'", oldglobal);
4128                 }
4129             }
4130           /* If we have a local external declaration,
4131              and no file-scope declaration has yet been seen,
4132              then if we later have a file-scope decl it must not be static.  */
4133           if (oldlocal == NULL_TREE
4134               && oldglobal == NULL_TREE
4135               && DECL_EXTERNAL (x)
4136               && TREE_PUBLIC (x))
4137             TREE_PUBLIC (name) = 1;
4138
4139           /* Warn if shadowing an argument at the top level of the body.  */
4140           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4141               /* Inline decls shadow nothing.  */
4142               && !DECL_FROM_INLINE (x)
4143               && TREE_CODE (oldlocal) == PARM_DECL
4144               /* Don't complain if it's from an enclosing function.  */
4145               && DECL_CONTEXT (oldlocal) == current_function_decl
4146               && TREE_CODE (x) != PARM_DECL)
4147             {
4148               /* Go to where the parms should be and see if we
4149                  find them there.  */
4150               struct binding_level *b = current_binding_level->level_chain;
4151
4152               if (cleanup_label)
4153                 b = b->level_chain;
4154
4155               /* ARM $8.3 */
4156               if (b->parm_flag == 1)
4157                 cp_error ("declaration of `%#D' shadows a parameter", name);
4158             }
4159
4160           /* Maybe warn if shadowing something else.  */
4161           if (warn_shadow && !DECL_EXTERNAL (x)
4162               /* Inline decls shadow nothing.  */
4163               && !DECL_FROM_INLINE (x)
4164               /* No shadow warnings for internally generated vars.  */
4165               && ! DECL_ARTIFICIAL (x)
4166               /* No shadow warnings for vars made for inlining.  */
4167               && ! DECL_FROM_INLINE (x))
4168             {
4169               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4170                 warning ("declaration of `%s' shadows a parameter",
4171                         IDENTIFIER_POINTER (name));
4172               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4173                        && current_class_ptr
4174                        && !TREE_STATIC (name))
4175                 warning ("declaration of `%s' shadows a member of `this'",
4176                         IDENTIFIER_POINTER (name));
4177               else if (oldlocal != NULL_TREE)
4178                 warning ("declaration of `%s' shadows previous local",
4179                         IDENTIFIER_POINTER (name));
4180               else if (oldglobal != NULL_TREE)
4181                 /* XXX shadow warnings in outer-more namespaces */
4182                 warning ("declaration of `%s' shadows global declaration",
4183                         IDENTIFIER_POINTER (name));
4184             }
4185         }
4186
4187       if (TREE_CODE (x) == FUNCTION_DECL)
4188         check_default_args (x);
4189
4190       /* Keep count of variables in this level with incomplete type.  */
4191       if (TREE_CODE (x) == VAR_DECL
4192           && TREE_TYPE (x) != error_mark_node
4193           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4194                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4195               /* RTTI TD entries are created while defining the type_info.  */
4196               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4197                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4198         {
4199           if (namespace_bindings_p ())
4200             namespace_scope_incomplete
4201               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4202           else
4203             current_binding_level->incomplete
4204               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4205         }
4206     }
4207
4208   if (need_new_binding)
4209     add_decl_to_level (x,
4210                        DECL_NAMESPACE_SCOPE_P (x)
4211                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4212                        : current_binding_level);
4213
4214   return x;
4215 }
4216
4217 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4218    caller to set DECL_CONTEXT properly.  */
4219
4220 static tree
4221 pushdecl_with_scope (x, level)
4222      tree x;
4223      struct binding_level *level;
4224 {
4225   register struct binding_level *b;
4226   tree function_decl = current_function_decl;
4227
4228   current_function_decl = NULL_TREE;
4229   if (level->parm_flag == 2)
4230     {
4231       b = class_binding_level;
4232       class_binding_level = level;
4233       pushdecl_class_level (x);
4234       class_binding_level = b;
4235     }
4236   else
4237     {
4238       b = current_binding_level;
4239       current_binding_level = level;
4240       x = pushdecl (x);
4241       current_binding_level = b;
4242     }
4243   current_function_decl = function_decl;
4244   return x;
4245 }
4246
4247 /* Like pushdecl, only it places X in the current namespace,
4248    if appropriate.  */
4249
4250 tree
4251 pushdecl_namespace_level (x)
4252      tree x;
4253 {
4254   register struct binding_level *b = current_binding_level;
4255   register tree t;
4256
4257   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4258
4259   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4260      what we want.  */
4261   if (TREE_CODE (x) == TYPE_DECL)
4262     {
4263       tree name = DECL_NAME (x);
4264       tree newval;
4265       tree *ptr = (tree *)0;
4266       for (; b != global_binding_level; b = b->level_chain)
4267         {
4268           tree shadowed = b->type_shadowed;
4269           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4270             if (TREE_PURPOSE (shadowed) == name)
4271               {
4272                 ptr = &TREE_VALUE (shadowed);
4273                 /* Can't break out of the loop here because sometimes
4274                    a binding level will have duplicate bindings for
4275                    PT names.  It's gross, but I haven't time to fix it.  */
4276               }
4277         }
4278       newval = TREE_TYPE (x);
4279       if (ptr == (tree *)0)
4280         {
4281           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4282              up here if this is changed to an assertion.  --KR  */
4283           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4284         }
4285       else
4286         {
4287           *ptr = newval;
4288         }
4289     }
4290   return t;
4291 }
4292
4293 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4294    if appropriate.  */
4295
4296 tree
4297 pushdecl_top_level (x)
4298      tree x;
4299 {
4300   push_to_top_level ();
4301   x = pushdecl_namespace_level (x);
4302   pop_from_top_level ();
4303   return x;
4304 }
4305
4306 /* Make the declaration of X appear in CLASS scope.  */
4307
4308 void
4309 pushdecl_class_level (x)
4310      tree x;
4311 {
4312   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4313      scope looks for the pre-mangled name.  */
4314   register tree name;
4315
4316   if (TREE_CODE (x) == OVERLOAD)
4317     x = OVL_CURRENT (x);
4318   name = DECL_NAME (x);
4319
4320   if (name)
4321     {
4322       push_class_level_binding (name, x);
4323       if (TREE_CODE (x) == TYPE_DECL)
4324         set_identifier_type_value (name, TREE_TYPE (x));
4325     }
4326   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4327     {
4328       tree f;
4329
4330       for (f = TYPE_FIELDS (TREE_TYPE (x));
4331            f;
4332            f = TREE_CHAIN (f))
4333         pushdecl_class_level (f);
4334     }
4335 }
4336
4337 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4338    DECL, or a modified version thereof.  */
4339
4340 tree
4341 maybe_push_decl (decl)
4342      tree decl;
4343 {
4344   tree type = TREE_TYPE (decl);
4345
4346   /* Add this decl to the current binding level, but not if it comes
4347      from another scope, e.g. a static member variable.  TEM may equal
4348      DECL or it may be a previous decl of the same name.  */
4349   if (decl == error_mark_node
4350       || (TREE_CODE (decl) != PARM_DECL
4351           && DECL_CONTEXT (decl) != NULL_TREE
4352           /* Definitions of namespace members outside their namespace are
4353              possible. */
4354           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4355       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4356       || TREE_CODE (type) == UNKNOWN_TYPE
4357       /* The declaration of a template specialization does not affect
4358          the functions available for overload resolution, so we do not
4359          call pushdecl.  */
4360       || (TREE_CODE (decl) == FUNCTION_DECL
4361           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4362     return decl;
4363   else
4364     return pushdecl (decl);
4365 }
4366
4367 /* Make the declaration(s) of X appear in CLASS scope
4368    under the name NAME.  */
4369
4370 void
4371 push_class_level_binding (name, x)
4372      tree name;
4373      tree x;
4374 {
4375   tree binding;
4376   /* The class_binding_level will be NULL if x is a template
4377      parameter name in a member template.  */
4378   if (!class_binding_level)
4379     return;
4380
4381   /* Make sure that this new member does not have the same name
4382      as a template parameter.  */
4383   if (TYPE_BEING_DEFINED (current_class_type))
4384     check_template_shadow (x);
4385
4386   /* If this declaration shadows a declaration from an enclosing
4387      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4388      we leave this class.  Record the shadowed declaration here.  */
4389   binding = IDENTIFIER_BINDING (name);
4390   if (binding
4391       && ((TREE_CODE (x) == OVERLOAD
4392            && BINDING_VALUE (binding)
4393            && is_overloaded_fn (BINDING_VALUE (binding)))
4394           || INHERITED_VALUE_BINDING_P (binding)))
4395     {
4396       tree shadow;
4397       tree old_decl;
4398
4399       /* If the old binding was from a base class, and was for a tag
4400          name, slide it over to make room for the new binding.  The
4401          old binding is still visible if explicitly qualified with a
4402          class-key.  */
4403       if (INHERITED_VALUE_BINDING_P (binding)
4404           && BINDING_VALUE (binding)
4405           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4406           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4407           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4408         {
4409           old_decl = BINDING_TYPE (binding);
4410           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4411           BINDING_VALUE (binding) = NULL_TREE;
4412           INHERITED_VALUE_BINDING_P (binding) = 0;
4413         }
4414       else
4415         old_decl = BINDING_VALUE (binding);
4416
4417       /* There was already a binding for X containing fewer
4418          functions than are named in X.  Find the previous
4419          declaration of X on the class-shadowed list, and update it.  */
4420       for (shadow = class_binding_level->class_shadowed;
4421            shadow;
4422            shadow = TREE_CHAIN (shadow))
4423         if (TREE_PURPOSE (shadow) == name
4424             && TREE_TYPE (shadow) == old_decl)
4425           {
4426             BINDING_VALUE (binding) = x;
4427             INHERITED_VALUE_BINDING_P (binding) = 0;
4428             TREE_TYPE (shadow) = x;
4429             return;
4430           }
4431     }
4432
4433   /* If we didn't replace an existing binding, put the binding on the
4434      stack of bindings for the identifier, and update
4435      IDENTIFIER_CLASS_VALUE.  */
4436   if (push_class_binding (name, x))
4437     {
4438       class_binding_level->class_shadowed
4439         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4440                      class_binding_level->class_shadowed);
4441       /* Record the value we are binding NAME to so that we can know
4442          what to pop later.  */
4443       TREE_TYPE (class_binding_level->class_shadowed) = x;
4444     }
4445 }
4446
4447 /* Insert another USING_DECL into the current binding level, returning
4448    this declaration. If this is a redeclaration, do nothing, and
4449    return NULL_TREE if this not in namespace scope (in namespace
4450    scope, a using decl might extend any previous bindings).  */
4451
4452 tree
4453 push_using_decl (scope, name)
4454      tree scope;
4455      tree name;
4456 {
4457   tree decl;
4458
4459   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4460   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4461   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4462     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4463       break;
4464   if (decl)
4465     return namespace_bindings_p () ? decl : NULL_TREE;
4466   decl = build_lang_decl (USING_DECL, name, void_type_node);
4467   DECL_INITIAL (decl) = scope;
4468   TREE_CHAIN (decl) = current_binding_level->usings;
4469   current_binding_level->usings = decl;
4470   return decl;
4471 }
4472
4473 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4474    changed (i.e. there was already a directive), or the fresh
4475    TREE_LIST otherwise.  */
4476
4477 tree
4478 push_using_directive (used)
4479      tree used;
4480 {
4481   tree ud = current_binding_level->using_directives;
4482   tree iter, ancestor;
4483
4484   /* Check if we already have this. */
4485   if (purpose_member (used, ud) != NULL_TREE)
4486     return NULL_TREE;
4487
4488   /* Recursively add all namespaces used. */
4489   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4490     push_using_directive (TREE_PURPOSE (iter));
4491
4492   ancestor = namespace_ancestor (current_decl_namespace (), used);
4493   ud = current_binding_level->using_directives;
4494   ud = tree_cons (used, ancestor, ud);
4495   current_binding_level->using_directives = ud;
4496   return ud;
4497 }
4498
4499 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4500    other definitions already in place.  We get around this by making
4501    the value of the identifier point to a list of all the things that
4502    want to be referenced by that name.  It is then up to the users of
4503    that name to decide what to do with that list.
4504
4505    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4506    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4507
4508    FLAGS is a bitwise-or of the following values:
4509      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4510                  namespace scope.
4511      PUSH_USING: DECL is being pushed as the result of a using
4512                  declaration.
4513
4514    The value returned may be a previous declaration if we guessed wrong
4515    about what language DECL should belong to (C or C++).  Otherwise,
4516    it's always DECL (and never something that's not a _DECL).  */
4517
4518 tree
4519 push_overloaded_decl (decl, flags)
4520      tree decl;
4521      int flags;
4522 {
4523   tree name = DECL_NAME (decl);
4524   tree old;
4525   tree new_binding;
4526   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4527
4528   if (doing_global)
4529     old = namespace_binding (name, DECL_CONTEXT (decl));
4530   else
4531     old = lookup_name_current_level (name);
4532
4533   if (old)
4534     {
4535       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4536         {
4537           tree t = TREE_TYPE (old);
4538           if (IS_AGGR_TYPE (t) && warn_shadow
4539               && (! DECL_IN_SYSTEM_HEADER (decl)
4540                   || ! DECL_IN_SYSTEM_HEADER (old)))
4541             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4542           old = NULL_TREE;
4543         }
4544       else if (is_overloaded_fn (old))
4545         {
4546           tree tmp;
4547
4548           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4549             {
4550               tree fn = OVL_CURRENT (tmp);
4551
4552               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4553                   && !(flags & PUSH_USING)
4554                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4555                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4556                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4557                           decl, fn);
4558
4559               if (duplicate_decls (decl, fn))
4560                 return fn;
4561             }
4562         }
4563       else if (old == error_mark_node)
4564         /* Ignore the undefined symbol marker.  */
4565         old = NULL_TREE;
4566       else
4567         {
4568           cp_error_at ("previous non-function declaration `%#D'", old);
4569           cp_error ("conflicts with function declaration `%#D'", decl);
4570           return decl;
4571         }
4572     }
4573
4574   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4575     {
4576       if (old && TREE_CODE (old) != OVERLOAD)
4577         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4578       else
4579         new_binding = ovl_cons (decl, old);
4580       if (flags & PUSH_USING)
4581         OVL_USED (new_binding) = 1;
4582     }
4583   else
4584     /* NAME is not ambiguous.  */
4585     new_binding = decl;
4586
4587   if (doing_global)
4588     set_namespace_binding (name, current_namespace, new_binding);
4589   else
4590     {
4591       /* We only create an OVERLOAD if there was a previous binding at
4592          this level, or if decl is a template. In the former case, we
4593          need to remove the old binding and replace it with the new
4594          binding.  We must also run through the NAMES on the binding
4595          level where the name was bound to update the chain.  */
4596
4597       if (TREE_CODE (new_binding) == OVERLOAD && old)
4598         {
4599           tree *d;
4600
4601           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4602                *d;
4603                d = &TREE_CHAIN (*d))
4604             if (*d == old
4605                 || (TREE_CODE (*d) == TREE_LIST
4606                     && TREE_VALUE (*d) == old))
4607               {
4608                 if (TREE_CODE (*d) == TREE_LIST)
4609                   /* Just replace the old binding with the new.  */
4610                   TREE_VALUE (*d) = new_binding;
4611                 else
4612                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4613                   *d = tree_cons (NULL_TREE, new_binding,
4614                                   TREE_CHAIN (*d));
4615
4616                 /* And update the CPLUS_BINDING node.  */
4617                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4618                   = new_binding;
4619                 return decl;
4620               }
4621
4622           /* We should always find a previous binding in this case.  */
4623           my_friendly_abort (0);
4624         }
4625
4626       /* Install the new binding.  */
4627       push_local_binding (name, new_binding, flags);
4628     }
4629
4630   return decl;
4631 }
4632 \f
4633 /* Generate an implicit declaration for identifier FUNCTIONID
4634    as a function of type int ().  Print a warning if appropriate.  */
4635
4636 tree
4637 implicitly_declare (functionid)
4638      tree functionid;
4639 {
4640   register tree decl;
4641
4642   /* We used to reuse an old implicit decl here,
4643      but this loses with inline functions because it can clobber
4644      the saved decl chains.  */
4645   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4646
4647   DECL_EXTERNAL (decl) = 1;
4648   TREE_PUBLIC (decl) = 1;
4649
4650   /* ISO standard says implicit declarations are in the innermost block.
4651      So we record the decl in the standard fashion.  */
4652   pushdecl (decl);
4653   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4654
4655   if (warn_implicit
4656       /* Only one warning per identifier.  */
4657       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4658     {
4659       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4660     }
4661
4662   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4663
4664   return decl;
4665 }
4666
4667 /* Return zero if the declaration NEWDECL is valid
4668    when the declaration OLDDECL (assumed to be for the same name)
4669    has already been seen.
4670    Otherwise return an error message format string with a %s
4671    where the identifier should go.  */
4672
4673 static const char *
4674 redeclaration_error_message (newdecl, olddecl)
4675      tree newdecl, olddecl;
4676 {
4677   if (TREE_CODE (newdecl) == TYPE_DECL)
4678     {
4679       /* Because C++ can put things into name space for free,
4680          constructs like "typedef struct foo { ... } foo"
4681          would look like an erroneous redeclaration.  */
4682       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4683         return 0;
4684       else
4685         return "redefinition of `%#D'";
4686     }
4687   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4688     {
4689       /* If this is a pure function, its olddecl will actually be
4690          the original initialization to `0' (which we force to call
4691          abort()).  Don't complain about redefinition in this case.  */
4692       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4693         return 0;
4694
4695       /* If both functions come from different namespaces, this is not
4696          a redeclaration - this is a conflict with a used function. */
4697       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4698           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4699         return "`%D' conflicts with used function";
4700
4701       /* We'll complain about linkage mismatches in
4702          warn_extern_redeclared_static.  */
4703
4704       /* Defining the same name twice is no good.  */
4705       if (DECL_INITIAL (olddecl) != NULL_TREE
4706           && DECL_INITIAL (newdecl) != NULL_TREE)
4707         {
4708           if (DECL_NAME (olddecl) == NULL_TREE)
4709             return "`%#D' not declared in class";
4710           else
4711             return "redefinition of `%#D'";
4712         }
4713       return 0;
4714     }
4715   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4716     {
4717       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4718            && (DECL_TEMPLATE_RESULT (newdecl)
4719                != DECL_TEMPLATE_RESULT (olddecl))
4720            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4721            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4722           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4723               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4724               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4725         return "redefinition of `%#D'";
4726       return 0;
4727     }
4728   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4729     {
4730       /* Objects declared at top level:  */
4731       /* If at least one is a reference, it's ok.  */
4732       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4733         return 0;
4734       /* Reject two definitions.  */
4735       return "redefinition of `%#D'";
4736     }
4737   else
4738     {
4739       /* Objects declared with block scope:  */
4740       /* Reject two definitions, and reject a definition
4741          together with an external reference.  */
4742       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4743         return "redeclaration of `%#D'";
4744       return 0;
4745     }
4746 }
4747 \f
4748 /* Create a new label, named ID.  */
4749
4750 static tree
4751 make_label_decl (id, local_p)
4752      tree id;
4753      int local_p;
4754 {
4755   tree decl;
4756
4757   decl = build_decl (LABEL_DECL, id, void_type_node);
4758   if (expanding_p)
4759     /* Make sure every label has an rtx.  */
4760     label_rtx (decl);
4761
4762   DECL_CONTEXT (decl) = current_function_decl;
4763   DECL_MODE (decl) = VOIDmode;
4764   C_DECLARED_LABEL_FLAG (decl) = local_p;
4765
4766   /* Say where one reference is to the label, for the sake of the
4767      error if it is not defined.  */
4768   DECL_SOURCE_LINE (decl) = lineno;
4769   DECL_SOURCE_FILE (decl) = input_filename;
4770
4771   /* Record the fact that this identifier is bound to this label.  */
4772   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4773
4774   return decl;
4775 }
4776
4777 /* Record this label on the list of used labels so that we can check
4778    at the end of the function to see whether or not the label was
4779    actually defined, and so we can check when the label is defined whether
4780    this use is valid.  */
4781
4782 static void
4783 use_label (decl)
4784      tree decl;
4785 {
4786   if (named_label_uses == NULL
4787       || named_label_uses->names_in_scope != current_binding_level->names
4788       || named_label_uses->label_decl != decl)
4789     {
4790       struct named_label_use_list *new_ent;
4791       new_ent = ((struct named_label_use_list *)
4792                  ggc_alloc (sizeof (struct named_label_use_list)));
4793       new_ent->label_decl = decl;
4794       new_ent->names_in_scope = current_binding_level->names;
4795       new_ent->binding_level = current_binding_level;
4796       new_ent->lineno_o_goto = lineno;
4797       new_ent->filename_o_goto = input_filename;
4798       new_ent->next = named_label_uses;
4799       named_label_uses = new_ent;
4800     }
4801 }
4802
4803 /* Look for a label named ID in the current function.  If one cannot
4804    be found, create one.  (We keep track of used, but undefined,
4805    labels, and complain about them at the end of a function.)  */
4806
4807 tree
4808 lookup_label (id)
4809      tree id;
4810 {
4811   tree decl;
4812   struct named_label_list *ent;
4813
4814   /* You can't use labels at global scope.  */
4815   if (current_function_decl == NULL_TREE)
4816     {
4817       error ("label `%s' referenced outside of any function",
4818              IDENTIFIER_POINTER (id));
4819       return NULL_TREE;
4820     }
4821
4822   /* See if we've already got this label.  */
4823   decl = IDENTIFIER_LABEL_VALUE (id);
4824   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4825     return decl;
4826
4827   /* Record this label on the list of labels used in this function.
4828      We do this before calling make_label_decl so that we get the
4829      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4830   ent = ((struct named_label_list *)
4831          ggc_alloc_cleared (sizeof (struct named_label_list)));
4832   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4833   ent->next = named_labels;
4834   named_labels = ent;
4835
4836   /* We need a new label.  */
4837   decl = make_label_decl (id, /*local_p=*/0);
4838
4839   /* Now fill in the information we didn't have before.  */
4840   ent->label_decl = decl;
4841
4842   return decl;
4843 }
4844
4845 /* Declare a local label named ID.  */
4846
4847 tree
4848 declare_local_label (id)
4849      tree id;
4850 {
4851   tree decl;
4852
4853   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4854      this scope we can restore the old value of
4855      IDENTIFIER_TYPE_VALUE.  */
4856   current_binding_level->shadowed_labels
4857     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4858                  current_binding_level->shadowed_labels);
4859   /* Look for the label.  */
4860   decl = make_label_decl (id, /*local_p=*/1);
4861   /* Now fill in the information we didn't have before.  */
4862   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4863
4864   return decl;
4865 }
4866
4867 /* Returns nonzero if it is ill-formed to jump past the declaration of
4868    DECL.  Returns 2 if it's also a real problem.  */
4869
4870 static int
4871 decl_jump_unsafe (decl)
4872      tree decl;
4873 {
4874   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4875     return 0;
4876
4877   if (DECL_INITIAL (decl) == NULL_TREE
4878       && pod_type_p (TREE_TYPE (decl)))
4879     return 0;
4880
4881   /* This is really only important if we're crossing an initialization.
4882      The POD stuff is just pedantry; why should it matter if the class
4883      contains a field of pointer to member type?  */
4884   if (DECL_INITIAL (decl)
4885       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4886     return 2;
4887   return 1;
4888 }
4889
4890 /* Check that a single previously seen jump to a newly defined label
4891    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4892    the jump context; NAMES are the names in scope in LEVEL at the jump
4893    context; FILE and LINE are the source position of the jump or 0.  */
4894
4895 static void
4896 check_previous_goto_1 (decl, level, names, file, line)
4897      tree decl;
4898      struct binding_level *level;
4899      tree names;
4900      const char *file;
4901      int line;
4902 {
4903   int identified = 0;
4904   int saw_eh = 0;
4905   struct binding_level *b = current_binding_level;
4906   for (; b; b = b->level_chain)
4907     {
4908       tree new_decls = b->names;
4909       tree old_decls = (b == level ? names : NULL_TREE);
4910       for (; new_decls != old_decls;
4911            new_decls = TREE_CHAIN (new_decls))
4912         {
4913           int problem = decl_jump_unsafe (new_decls);
4914           if (! problem)
4915             continue;
4916
4917           if (! identified)
4918             {
4919               if (decl)
4920                 cp_pedwarn ("jump to label `%D'", decl);
4921               else
4922                 pedwarn ("jump to case label");
4923
4924               if (file)
4925                 pedwarn_with_file_and_line (file, line, "  from here");
4926               identified = 1;
4927             }
4928
4929           if (problem > 1 && DECL_ARTIFICIAL (new_decls))
4930             /* Can't skip init of __exception_info.  */
4931             cp_error_at ("  enters catch block", new_decls);
4932           else if (problem > 1)
4933             cp_error_at ("  crosses initialization of `%#D'",
4934                          new_decls);
4935           else
4936             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4937                            new_decls);
4938         }
4939
4940       if (b == level)
4941         break;
4942       if (b->eh_region && ! saw_eh)
4943         {
4944           if (! identified)
4945             {
4946               if (decl)
4947                 cp_pedwarn ("jump to label `%D'", decl);
4948               else
4949                 pedwarn ("jump to case label");
4950
4951               if (file)
4952                 pedwarn_with_file_and_line (file, line, "  from here");
4953               identified = 1;
4954             }
4955           error ("  enters try block");
4956           saw_eh = 1;
4957         }
4958     }
4959 }
4960
4961 static void
4962 check_previous_goto (use)
4963      struct named_label_use_list *use;
4964 {
4965   check_previous_goto_1 (use->label_decl, use->binding_level,
4966                          use->names_in_scope, use->filename_o_goto,
4967                          use->lineno_o_goto);
4968 }
4969
4970 static void
4971 check_switch_goto (level)
4972      struct binding_level *level;
4973 {
4974   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
4975 }
4976
4977 /* Check that any previously seen jumps to a newly defined label DECL
4978    are OK.  Called by define_label.  */
4979
4980 static void
4981 check_previous_gotos (decl)
4982      tree decl;
4983 {
4984   struct named_label_use_list **usep;
4985
4986   if (! TREE_USED (decl))
4987     return;
4988
4989   for (usep = &named_label_uses; *usep; )
4990     {
4991       struct named_label_use_list *use = *usep;
4992       if (use->label_decl == decl)
4993         {
4994           check_previous_goto (use);
4995           *usep = use->next;
4996         }
4997       else
4998         usep = &(use->next);
4999     }
5000 }
5001
5002 /* Check that a new jump to a label DECL is OK.  Called by
5003    finish_goto_stmt.  */
5004
5005 void
5006 check_goto (decl)
5007      tree decl;
5008 {
5009   int identified = 0;
5010   tree bad;
5011   struct named_label_list *lab;
5012
5013   /* We can't know where a computed goto is jumping.  So we assume
5014      that it's OK.  */
5015   if (! DECL_P (decl))
5016     return;
5017
5018   /* If the label hasn't been defined yet, defer checking.  */
5019   if (! DECL_INITIAL (decl))
5020     {
5021       use_label (decl);
5022       return;
5023     }
5024
5025   for (lab = named_labels; lab; lab = lab->next)
5026     if (decl == lab->label_decl)
5027       break;
5028
5029   /* If the label is not on named_labels it's a gcc local label, so
5030      it must be in an outer scope, so jumping to it is always OK.  */
5031   if (lab == 0)
5032     return;
5033
5034   if ((lab->eh_region || lab->bad_decls) && !identified)
5035     {
5036       cp_pedwarn_at ("jump to label `%D'", decl);
5037       pedwarn ("  from here");
5038       identified = 1;
5039     }
5040
5041   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5042     {
5043       tree b = TREE_VALUE (bad);
5044       int u = decl_jump_unsafe (b);
5045
5046       if (u > 1 && DECL_ARTIFICIAL (b))
5047         /* Can't skip init of __exception_info.  */
5048         cp_error_at ("  enters catch block", b);
5049       else if (u > 1)
5050         cp_error_at ("  skips initialization of `%#D'", b);
5051       else
5052         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5053     }
5054
5055   if (lab->eh_region)
5056     error ("  enters try block");
5057 }
5058
5059 /* Define a label, specifying the location in the source file.
5060    Return the LABEL_DECL node for the label, if the definition is valid.
5061    Otherwise return 0.  */
5062
5063 tree
5064 define_label (filename, line, name)
5065      const char *filename;
5066      int line;
5067      tree name;
5068 {
5069   tree decl = lookup_label (name);
5070   struct named_label_list *ent;
5071   register struct binding_level *p;
5072
5073   for (ent = named_labels; ent; ent = ent->next)
5074     if (ent->label_decl == decl)
5075       break;
5076
5077   /* After labels, make any new cleanups in the function go into their
5078      own new (temporary) binding contour.  */
5079   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5080     p->more_cleanups_ok = 0;
5081
5082   if (name == get_identifier ("wchar_t"))
5083     cp_pedwarn ("label named wchar_t");
5084
5085   if (DECL_INITIAL (decl) != NULL_TREE)
5086     {
5087       cp_error ("duplicate label `%D'", decl);
5088       return 0;
5089     }
5090   else
5091     {
5092       /* Mark label as having been defined.  */
5093       DECL_INITIAL (decl) = error_mark_node;
5094       /* Say where in the source.  */
5095       DECL_SOURCE_FILE (decl) = filename;
5096       DECL_SOURCE_LINE (decl) = line;
5097       if (ent)
5098         {
5099           ent->names_in_scope = current_binding_level->names;
5100           ent->binding_level = current_binding_level;
5101         }
5102       check_previous_gotos (decl);
5103       current_function_return_value = NULL_TREE;
5104       return decl;
5105     }
5106 }
5107
5108 struct cp_switch
5109 {
5110   struct binding_level *level;
5111   struct cp_switch *next;
5112   /* The SWITCH_STMT being built.  */
5113   tree switch_stmt;
5114   /* A splay-tree mapping the low element of a case range to the high
5115      element, or NULL_TREE if there is no high element.  Used to
5116      determine whether or not a new case label duplicates an old case
5117      label.  We need a tree, rather than simply a hash table, because
5118      of the GNU case range extension.  */
5119   splay_tree cases;
5120 };
5121
5122 /* A stack of the currently active switch statements.  The innermost
5123    switch statement is on the top of the stack.  There is no need to
5124    mark the stack for garbage collection because it is only active
5125    during the processing of the body of a function, and we never
5126    collect at that point.  */
5127
5128 static struct cp_switch *switch_stack;
5129
5130 /* Called right after a switch-statement condition is parsed.
5131    SWITCH_STMT is the switch statement being parsed.  */
5132
5133 void
5134 push_switch (switch_stmt)
5135      tree switch_stmt;
5136 {
5137   struct cp_switch *p
5138     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5139   p->level = current_binding_level;
5140   p->next = switch_stack;
5141   p->switch_stmt = switch_stmt;
5142   p->cases = splay_tree_new (case_compare, NULL, NULL);
5143   switch_stack = p;
5144 }
5145
5146 void
5147 pop_switch ()
5148 {
5149   struct cp_switch *cs;
5150
5151   cs = switch_stack;
5152   splay_tree_delete (cs->cases);
5153   switch_stack = switch_stack->next;
5154   free (cs);
5155 }
5156
5157 /* Note that we've seen a definition of a case label, and complain if this
5158    is a bad place for one.  */
5159
5160 void
5161 finish_case_label (low_value, high_value)
5162      tree low_value;
5163      tree high_value;
5164 {
5165   tree cond;
5166   register struct binding_level *p;
5167
5168   if (! switch_stack)
5169     {
5170       if (high_value)
5171         error ("case label not within a switch statement");
5172       else if (low_value)
5173         cp_error ("case label `%E' not within a switch statement",
5174                   low_value);
5175       else
5176         error ("`default' label not within a switch statement");
5177       return;
5178     }
5179
5180   if (processing_template_decl)
5181     {
5182       tree label;
5183
5184       /* For templates, just add the case label; we'll do semantic
5185          analysis at instantiation-time.  */
5186       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5187       add_stmt (build_case_label (low_value, high_value, label));
5188       return;
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   c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5197
5198   check_switch_goto (switch_stack->level);
5199
5200   /* After labels, make any new cleanups in the function go into their
5201      own new (temporary) binding contour.  */
5202   for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5203     p->more_cleanups_ok = 0;
5204   current_function_return_value = NULL_TREE;
5205 }
5206 \f
5207 /* Return the list of declarations of the current level.
5208    Note that this list is in reverse order unless/until
5209    you nreverse it; and when you do nreverse it, you must
5210    store the result back using `storedecls' or you will lose.  */
5211
5212 tree
5213 getdecls ()
5214 {
5215   return current_binding_level->names;
5216 }
5217
5218 /* Return the list of type-tags (for structs, etc) of the current level.  */
5219
5220 tree
5221 gettags ()
5222 {
5223   return current_binding_level->tags;
5224 }
5225
5226 /* Store the list of declarations of the current level.
5227    This is done for the parameter declarations of a function being defined,
5228    after they are modified in the light of any missing parameters.  */
5229
5230 static void
5231 storedecls (decls)
5232      tree decls;
5233 {
5234   current_binding_level->names = decls;
5235 }
5236
5237 /* Similarly, store the list of tags of the current level.  */
5238
5239 void
5240 storetags (tags)
5241      tree tags;
5242 {
5243   current_binding_level->tags = tags;
5244 }
5245 \f
5246 /* Given NAME, an IDENTIFIER_NODE,
5247    return the structure (or union or enum) definition for that name.
5248    Searches binding levels from BINDING_LEVEL up to the global level.
5249    If THISLEVEL_ONLY is nonzero, searches only the specified context
5250    (but skips any tag-transparent contexts to find one that is
5251    meaningful for tags).
5252    FORM says which kind of type the caller wants;
5253    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5254    If the wrong kind of type is found, and it's not a template, an error is
5255    reported.  */
5256
5257 static tree
5258 lookup_tag (form, name, binding_level, thislevel_only)
5259      enum tree_code form;
5260      tree name;
5261      struct binding_level *binding_level;
5262      int thislevel_only;
5263 {
5264   register struct binding_level *level;
5265   /* Non-zero if, we should look past a template parameter level, even
5266      if THISLEVEL_ONLY.  */
5267   int allow_template_parms_p = 1;
5268
5269   for (level = binding_level; level; level = level->level_chain)
5270     {
5271       register tree tail;
5272       if (ANON_AGGRNAME_P (name))
5273         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5274           {
5275             /* There's no need for error checking here, because
5276                anon names are unique throughout the compilation.  */
5277             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5278               return TREE_VALUE (tail);
5279           }
5280       else if (level->namespace_p)
5281         /* Do namespace lookup. */
5282         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5283           {
5284             tree old = binding_for_name (name, tail);
5285
5286             /* If we just skipped past a template parameter level,
5287                even though THISLEVEL_ONLY, and we find a template
5288                class declaration, then we use the _TYPE node for the
5289                template.  See the example below.  */
5290             if (thislevel_only && !allow_template_parms_p
5291                 && old && BINDING_VALUE (old)
5292                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5293               old = TREE_TYPE (BINDING_VALUE (old));
5294             else
5295               old = BINDING_TYPE (old);
5296
5297             /* If it has an original type, it is a typedef, and we
5298                should not return it.  */
5299             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5300               old = NULL_TREE;
5301             if (old && TREE_CODE (old) != form
5302                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5303               {
5304                 cp_error ("`%#D' redeclared as %C", old, form);
5305                 return NULL_TREE;
5306               }
5307             if (old)
5308               return old;
5309             if (thislevel_only || tail == global_namespace)
5310               return NULL_TREE;
5311           }
5312       else
5313         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5314           {
5315             if (TREE_PURPOSE (tail) == name)
5316               {
5317                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5318                 /* Should tighten this up; it'll probably permit
5319                    UNION_TYPE and a struct template, for example.  */
5320                 if (code != form
5321                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5322                   {
5323                     /* Definition isn't the kind we were looking for.  */
5324                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5325                               form);
5326                     return NULL_TREE;
5327                   }
5328                 return TREE_VALUE (tail);
5329               }
5330           }
5331       if (thislevel_only && ! level->tag_transparent)
5332         {
5333           if (level->template_parms_p && allow_template_parms_p)
5334             {
5335               /* We must deal with cases like this:
5336
5337                    template <class T> struct S;
5338                    template <class T> struct S {};
5339
5340                  When looking up `S', for the second declaration, we
5341                  would like to find the first declaration.  But, we
5342                  are in the pseudo-global level created for the
5343                  template parameters, rather than the (surrounding)
5344                  namespace level.  Thus, we keep going one more level,
5345                  even though THISLEVEL_ONLY is non-zero.  */
5346               allow_template_parms_p = 0;
5347               continue;
5348             }
5349           else
5350             return NULL_TREE;
5351         }
5352     }
5353   return NULL_TREE;
5354 }
5355
5356 #if 0
5357 void
5358 set_current_level_tags_transparency (tags_transparent)
5359      int tags_transparent;
5360 {
5361   current_binding_level->tag_transparent = tags_transparent;
5362 }
5363 #endif
5364
5365 /* Given a type, find the tag that was defined for it and return the tag name.
5366    Otherwise return 0.  However, the value can never be 0
5367    in the cases in which this is used.
5368
5369    C++: If NAME is non-zero, this is the new name to install.  This is
5370    done when replacing anonymous tags with real tag names.  */
5371
5372 static tree
5373 lookup_tag_reverse (type, name)
5374      tree type;
5375      tree name;
5376 {
5377   register struct binding_level *level;
5378
5379   for (level = current_binding_level; level; level = level->level_chain)
5380     {
5381       register tree tail;
5382       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5383         {
5384           if (TREE_VALUE (tail) == type)
5385             {
5386               if (name)
5387                 TREE_PURPOSE (tail) = name;
5388               return TREE_PURPOSE (tail);
5389             }
5390         }
5391     }
5392   return NULL_TREE;
5393 }
5394 \f
5395 /* Look up NAME in the NAMESPACE.  */
5396
5397 tree
5398 lookup_namespace_name (namespace, name)
5399      tree namespace, name;
5400 {
5401   tree val;
5402   tree template_id = NULL_TREE;
5403
5404   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5405
5406   if (TREE_CODE (name) == NAMESPACE_DECL)
5407     /* This happens for A::B<int> when B is a namespace. */
5408     return name;
5409   else if (TREE_CODE (name) == TEMPLATE_DECL)
5410     {
5411       /* This happens for A::B where B is a template, and there are no
5412          template arguments.  */
5413       cp_error ("invalid use of `%D'", name);
5414       return error_mark_node;
5415     }
5416
5417   namespace = ORIGINAL_NAMESPACE (namespace);
5418
5419   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5420     {
5421       template_id = name;
5422       name = TREE_OPERAND (name, 0);
5423       if (TREE_CODE (name) == OVERLOAD)
5424         name = DECL_NAME (OVL_CURRENT (name));
5425       else if (DECL_P (name))
5426         name = DECL_NAME (name);
5427     }
5428
5429   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5430
5431   val = make_node (CPLUS_BINDING);
5432   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5433     return error_mark_node;
5434
5435   if (BINDING_VALUE (val))
5436     {
5437       val = BINDING_VALUE (val);
5438
5439       if (template_id)
5440         {
5441           if (DECL_CLASS_TEMPLATE_P (val))
5442             val = lookup_template_class (val,
5443                                          TREE_OPERAND (template_id, 1),
5444                                          /*in_decl=*/NULL_TREE,
5445                                          /*context=*/NULL_TREE,
5446                                          /*entering_scope=*/0);
5447           else if (DECL_FUNCTION_TEMPLATE_P (val)
5448                    || TREE_CODE (val) == OVERLOAD)
5449             val = lookup_template_function (val,
5450                                             TREE_OPERAND (template_id, 1));
5451           else
5452             {
5453               cp_error ("`%D::%D' is not a template",
5454                         namespace, name);
5455               return error_mark_node;
5456             }
5457         }
5458
5459       /* If we have a single function from a using decl, pull it out.  */
5460       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5461         val = OVL_FUNCTION (val);
5462       return val;
5463     }
5464
5465   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5466   return error_mark_node;
5467 }
5468
5469 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5470
5471 static unsigned long
5472 typename_hash (k)
5473      hash_table_key k;
5474 {
5475   unsigned long hash;
5476   tree t;
5477
5478   t = (tree) k;
5479   hash = (((unsigned long) TYPE_CONTEXT (t))
5480           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5481
5482   return hash;
5483 }
5484
5485 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5486
5487 static boolean
5488 typename_compare (k1, k2)
5489      hash_table_key k1;
5490      hash_table_key k2;
5491 {
5492   tree t1;
5493   tree t2;
5494   tree d1;
5495   tree d2;
5496
5497   t1 = (tree) k1;
5498   t2 = (tree) k2;
5499   d1 = TYPE_NAME (t1);
5500   d2 = TYPE_NAME (t2);
5501
5502   return (DECL_NAME (d1) == DECL_NAME (d2)
5503           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5504           && ((TREE_TYPE (t1) != NULL_TREE)
5505               == (TREE_TYPE (t2) != NULL_TREE))
5506           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5507           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5508 }
5509
5510 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5511    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5512    is non-NULL, this type is being created by the implicit typename
5513    extension, and BASE_TYPE is a type named `t' in some base class of
5514    `T' which depends on template parameters.
5515
5516    Returns the new TYPENAME_TYPE.  */
5517
5518 tree
5519 build_typename_type (context, name, fullname, base_type)
5520      tree context;
5521      tree name;
5522      tree fullname;
5523      tree base_type;
5524 {
5525   tree t;
5526   tree d;
5527   struct hash_entry* e;
5528
5529   static struct hash_table ht;
5530
5531   if (!ht.table)
5532     {
5533       static struct hash_table *h = &ht;
5534       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5535                             &typename_compare))
5536         fatal ("virtual memory exhausted");
5537       ggc_add_tree_hash_table_root (&h, 1);
5538     }
5539
5540   /* Build the TYPENAME_TYPE.  */
5541   t = make_aggr_type (TYPENAME_TYPE);
5542   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5543   TYPENAME_TYPE_FULLNAME (t) = fullname;
5544   TREE_TYPE (t) = base_type;
5545
5546   /* Build the corresponding TYPE_DECL.  */
5547   d = build_decl (TYPE_DECL, name, t);
5548   TYPE_NAME (TREE_TYPE (d)) = d;
5549   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5550   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5551   DECL_ARTIFICIAL (d) = 1;
5552
5553   /* See if we already have this type.  */
5554   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5555   if (e)
5556     t = (tree) e->key;
5557   else
5558     /* Insert the type into the table.  */
5559     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5560
5561   return t;
5562 }
5563
5564 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5565    unless an error occurs, in which case error_mark_node is returned.
5566    If COMPLAIN zero, don't complain about any errors that occur.  */
5567
5568 tree
5569 make_typename_type (context, name, complain)
5570      tree context, name;
5571      int complain;
5572 {
5573   tree fullname;
5574
5575   if (TYPE_P (name))
5576     {
5577       if (!(TYPE_LANG_SPECIFIC (name)
5578             && (CLASSTYPE_IS_TEMPLATE (name)
5579                 || CLASSTYPE_USE_TEMPLATE (name))))
5580         name = TYPE_IDENTIFIER (name);
5581       else
5582         /* Create a TEMPLATE_ID_EXPR for the type.  */
5583         name = build_nt (TEMPLATE_ID_EXPR,
5584                          CLASSTYPE_TI_TEMPLATE (name),
5585                          CLASSTYPE_TI_ARGS (name));
5586     }
5587   else if (TREE_CODE (name) == TYPE_DECL)
5588     name = DECL_NAME (name);
5589
5590   fullname = name;
5591
5592   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5593     {
5594       name = TREE_OPERAND (name, 0);
5595       if (TREE_CODE (name) == TEMPLATE_DECL)
5596         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5597     }
5598   if (TREE_CODE (name) != IDENTIFIER_NODE)
5599     my_friendly_abort (2000);
5600
5601   if (TREE_CODE (context) == NAMESPACE_DECL)
5602     {
5603       /* We can get here from typename_sub0 in the explicit_template_type
5604          expansion.  Just fail.  */
5605       if (complain)
5606         cp_error ("no class template named `%#T' in `%#T'",
5607                   name, context);
5608       return error_mark_node;
5609     }
5610
5611   if (! uses_template_parms (context)
5612       || currently_open_class (context))
5613     {
5614       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5615         {
5616           tree tmpl = NULL_TREE;
5617           if (IS_AGGR_TYPE (context))
5618             tmpl = lookup_field (context, name, 0, 0);
5619           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5620             {
5621               if (complain)
5622                 cp_error ("no class template named `%#T' in `%#T'",
5623                           name, context);
5624               return error_mark_node;
5625             }
5626
5627           return lookup_template_class (tmpl,
5628                                         TREE_OPERAND (fullname, 1),
5629                                         NULL_TREE, context,
5630                                         /*entering_scope=*/0);
5631         }
5632       else
5633         {
5634           tree t;
5635
5636           if (!IS_AGGR_TYPE (context))
5637             {
5638               if (complain)
5639                 cp_error ("no type named `%#T' in `%#T'", name, context);
5640               return error_mark_node;
5641             }
5642
5643           t = lookup_field (context, name, 0, 1);
5644           if (t)
5645             return TREE_TYPE (t);
5646         }
5647     }
5648
5649   /* If the CONTEXT is not a template type, then either the field is
5650      there now or its never going to be.  */
5651   if (!uses_template_parms (context))
5652     {
5653       if (complain)
5654         cp_error ("no type named `%#T' in `%#T'", name, context);
5655       return error_mark_node;
5656     }
5657
5658
5659   return build_typename_type (context, name, fullname,  NULL_TREE);
5660 }
5661
5662 /* Select the right _DECL from multiple choices. */
5663
5664 static tree
5665 select_decl (binding, flags)
5666      tree binding;
5667      int flags;
5668 {
5669   tree val;
5670   val = BINDING_VALUE (binding);
5671
5672   /* When we implicitly declare some builtin entity, we mark it
5673      DECL_ANTICIPATED, so that we know to ignore it until it is
5674      really declared.  */
5675   if (val && DECL_P (val)
5676       && DECL_LANG_SPECIFIC (val)
5677       && DECL_ANTICIPATED (val))
5678     return NULL_TREE;
5679
5680   if (LOOKUP_NAMESPACES_ONLY (flags))
5681     {
5682       /* We are not interested in types. */
5683       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5684         return val;
5685       return NULL_TREE;
5686     }
5687
5688   /* If we could have a type and
5689      we have nothing or we need a type and have none.  */
5690   if (BINDING_TYPE (binding)
5691       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5692                    && TREE_CODE (val) != TYPE_DECL)))
5693     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5694   /* Don't return non-types if we really prefer types. */
5695   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5696            && (TREE_CODE (val) != TEMPLATE_DECL
5697                || !DECL_CLASS_TEMPLATE_P (val)))
5698     val = NULL_TREE;
5699
5700   return val;
5701 }
5702
5703 /* Unscoped lookup of a global: iterate over current namespaces,
5704    considering using-directives.  If SPACESP is non-NULL, store a list
5705    of the namespaces we've considered in it.  */
5706
5707 tree
5708 unqualified_namespace_lookup (name, flags, spacesp)
5709      tree name;
5710      int flags;
5711      tree *spacesp;
5712 {
5713   tree b = make_node (CPLUS_BINDING);
5714   tree initial = current_decl_namespace();
5715   tree scope = initial;
5716   tree siter;
5717   struct binding_level *level;
5718   tree val = NULL_TREE;
5719
5720   if (spacesp)
5721     *spacesp = NULL_TREE;
5722
5723   for (; !val; scope = CP_DECL_CONTEXT (scope))
5724     {
5725       if (spacesp)
5726         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5727       val = binding_for_name (name, scope);
5728
5729       /* Initialize binding for this context. */
5730       BINDING_VALUE (b) = BINDING_VALUE (val);
5731       BINDING_TYPE (b) = BINDING_TYPE (val);
5732
5733       /* Add all _DECLs seen through local using-directives. */
5734       for (level = current_binding_level;
5735            !level->namespace_p;
5736            level = level->level_chain)
5737         if (!lookup_using_namespace (name, b, level->using_directives,
5738                                      scope, flags, spacesp))
5739           /* Give up because of error. */
5740           return error_mark_node;
5741
5742       /* Add all _DECLs seen through global using-directives. */
5743       /* XXX local and global using lists should work equally. */
5744       siter = initial;
5745       while (1)
5746         {
5747           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5748                                        scope, flags, spacesp))
5749             /* Give up because of error. */
5750             return error_mark_node;
5751           if (siter == scope) break;
5752           siter = CP_DECL_CONTEXT (siter);
5753         }
5754
5755       val = select_decl (b, flags);
5756       if (scope == global_namespace)
5757         break;
5758     }
5759   return val;
5760 }
5761
5762 /* Combine prefer_type and namespaces_only into flags.  */
5763
5764 static int
5765 lookup_flags (prefer_type, namespaces_only)
5766   int prefer_type, namespaces_only;
5767 {
5768   if (namespaces_only)
5769     return LOOKUP_PREFER_NAMESPACES;
5770   if (prefer_type > 1)
5771     return LOOKUP_PREFER_TYPES;
5772   if (prefer_type > 0)
5773     return LOOKUP_PREFER_BOTH;
5774   return 0;
5775 }
5776
5777 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5778    ignore it or not.  Subroutine of lookup_name_real.  */
5779
5780 static tree
5781 qualify_lookup (val, flags)
5782      tree val;
5783      int flags;
5784 {
5785   if (val == NULL_TREE)
5786     return val;
5787   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5788     return val;
5789   if ((flags & LOOKUP_PREFER_TYPES)
5790       && (TREE_CODE (val) == TYPE_DECL
5791           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5792               && DECL_CLASS_TEMPLATE_P (val))))
5793     return val;
5794   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5795     return NULL_TREE;
5796   return val;
5797 }
5798
5799 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5800    that.  */
5801
5802 static void
5803 warn_about_implicit_typename_lookup (typename, binding)
5804      tree typename;
5805      tree binding;
5806 {
5807   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5808   tree name = DECL_NAME (typename);
5809
5810   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5811          && CLASSTYPE_TEMPLATE_INFO (subtype)
5812          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5813       && ! (TREE_CODE (binding) == TYPE_DECL
5814             && same_type_p (TREE_TYPE (binding), subtype)))
5815     {
5816       cp_warning ("lookup of `%D' finds `%#D'",
5817                   name, binding);
5818       cp_warning ("  instead of `%D' from dependent base class",
5819                   typename);
5820       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5821                   constructor_name (current_class_type), name);
5822     }
5823 }
5824
5825 /* Look up NAME in the current binding level and its superiors in the
5826    namespace of variables, functions and typedefs.  Return a ..._DECL
5827    node of some kind representing its definition if there is only one
5828    such declaration, or return a TREE_LIST with all the overloaded
5829    definitions if there are many, or return 0 if it is undefined.
5830
5831    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5832    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5833    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5834    Otherwise we prefer non-TYPE_DECLs.
5835
5836    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5837    using IDENTIFIER_CLASS_VALUE.  */
5838
5839 static tree
5840 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5841      tree name;
5842      int prefer_type, nonclass, namespaces_only;
5843 {
5844   tree t;
5845   tree val = NULL_TREE;
5846   int yylex = 0;
5847   tree from_obj = NULL_TREE;
5848   int flags;
5849   int val_is_implicit_typename = 0;
5850
5851   /* Hack: copy flag set by parser, if set. */
5852   if (only_namespace_names)
5853     namespaces_only = 1;
5854
5855   if (prefer_type == -2)
5856     {
5857       extern int looking_for_typename;
5858       tree type = NULL_TREE;
5859
5860       yylex = 1;
5861       prefer_type = looking_for_typename;
5862
5863       flags = lookup_flags (prefer_type, namespaces_only);
5864       /* If the next thing is '<', class templates are types. */
5865       if (looking_for_template)
5866         flags |= LOOKUP_TEMPLATES_EXPECTED;
5867
5868       /* std:: becomes :: for now.  */
5869       if (got_scope && got_scope == fake_std_node)
5870         got_scope = void_type_node;
5871
5872       if (got_scope)
5873         type = got_scope;
5874       else if (got_object != error_mark_node)
5875         type = got_object;
5876
5877       if (type)
5878         {
5879           if (type == error_mark_node)
5880             return error_mark_node;
5881           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5882             type = TREE_TYPE (type);
5883
5884           if (TYPE_P (type))
5885             type = complete_type (type);
5886
5887           if (TREE_CODE (type) == VOID_TYPE)
5888             type = global_namespace;
5889           if (TREE_CODE (type) == NAMESPACE_DECL)
5890             {
5891               val = make_node (CPLUS_BINDING);
5892               flags |= LOOKUP_COMPLAIN;
5893               if (!qualified_lookup_using_namespace (name, type, val, flags))
5894                 return NULL_TREE;
5895               val = select_decl (val, flags);
5896             }
5897           else if (! IS_AGGR_TYPE (type)
5898                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5899                    || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
5900                    || TREE_CODE (type) == TYPENAME_TYPE)
5901             /* Someone else will give an error about this if needed.  */
5902             val = NULL_TREE;
5903           else if (type == current_class_type)
5904             val = IDENTIFIER_CLASS_VALUE (name);
5905           else
5906             {
5907               val = lookup_member (type, name, 0, prefer_type);
5908               type_access_control (type, val);
5909
5910               /* Restore the containing TYPENAME_TYPE if we looked
5911                  through it before.  */
5912               if (got_scope && got_scope != type
5913                   && val && TREE_CODE (val) == TYPE_DECL
5914                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
5915                 TYPE_CONTEXT (TREE_TYPE (val)) = got_scope;
5916             }
5917         }
5918       else
5919         val = NULL_TREE;
5920
5921       if (got_scope)
5922         goto done;
5923       else if (got_object && val)
5924         {
5925           from_obj = val;
5926           val = NULL_TREE;
5927         }
5928     }
5929   else
5930     {
5931       flags = lookup_flags (prefer_type, namespaces_only);
5932       /* If we're not parsing, we need to complain. */
5933       flags |= LOOKUP_COMPLAIN;
5934     }
5935
5936   /* First, look in non-namespace scopes.  */
5937
5938   if (current_class_type == NULL_TREE)
5939     nonclass = 1;
5940
5941   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5942     {
5943       tree binding;
5944
5945       if (!LOCAL_BINDING_P (t) && nonclass)
5946         /* We're not looking for class-scoped bindings, so keep going.  */
5947         continue;
5948
5949       /* If this is the kind of thing we're looking for, we're done.  */
5950       if (qualify_lookup (BINDING_VALUE (t), flags))
5951         binding = BINDING_VALUE (t);
5952       else if ((flags & LOOKUP_PREFER_TYPES)
5953                && qualify_lookup (BINDING_TYPE (t), flags))
5954         binding = BINDING_TYPE (t);
5955       else
5956         binding = NULL_TREE;
5957
5958       /* Handle access control on types from enclosing or base classes.  */
5959       if (binding && ! yylex
5960           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5961         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5962
5963       if (binding
5964           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5965         {
5966           if (val_is_implicit_typename && !yylex)
5967             warn_about_implicit_typename_lookup (val, binding);
5968           val = binding;
5969           val_is_implicit_typename
5970             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5971           if (!val_is_implicit_typename)
5972             break;
5973         }
5974     }
5975
5976   /* Now lookup in namespace scopes.  */
5977   if (!val || val_is_implicit_typename)
5978     {
5979       t = unqualified_namespace_lookup (name, flags, 0);
5980       if (t)
5981         {
5982           if (val_is_implicit_typename && !yylex)
5983             warn_about_implicit_typename_lookup (val, t);
5984           val = t;
5985         }
5986     }
5987
5988  done:
5989   if (val)
5990     {
5991       /* This should only warn about types used in qualified-ids.  */
5992       if (from_obj && from_obj != val)
5993         {
5994           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5995               && TREE_CODE (val) == TYPE_DECL
5996               && ! same_type_p (TREE_TYPE (from_obj), TREE_TYPE (val)))
5997             cp_pedwarn ("\
5998 lookup of `%D' in the scope of `%#T' (`%#T') \
5999 does not match lookup in the current scope (`%#T')",
6000                         name, got_object, TREE_TYPE (from_obj),
6001                         TREE_TYPE (val));
6002
6003           /* We don't change val to from_obj if got_object depends on
6004              template parms because that breaks implicit typename for
6005              destructor calls.  */
6006           if (! uses_template_parms (got_object))
6007             val = from_obj;
6008         }
6009
6010       /* If we have a single function from a using decl, pull it out.  */
6011       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6012         val = OVL_FUNCTION (val);
6013     }
6014   else if (from_obj)
6015     val = from_obj;
6016
6017   return val;
6018 }
6019
6020 tree
6021 lookup_name_nonclass (name)
6022      tree name;
6023 {
6024   return lookup_name_real (name, 0, 1, 0);
6025 }
6026
6027 tree
6028 lookup_function_nonclass (name, args)
6029      tree name;
6030      tree args;
6031 {
6032   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6033 }
6034
6035 tree
6036 lookup_name_namespace_only (name)
6037      tree name;
6038 {
6039   /* type-or-namespace, nonclass, namespace_only */
6040   return lookup_name_real (name, 1, 1, 1);
6041 }
6042
6043 tree
6044 lookup_name (name, prefer_type)
6045      tree name;
6046      int prefer_type;
6047 {
6048   return lookup_name_real (name, prefer_type, 0, 0);
6049 }
6050
6051 /* Similar to `lookup_name' but look only in the innermost non-class
6052    binding level.  */
6053
6054 tree
6055 lookup_name_current_level (name)
6056      tree name;
6057 {
6058   struct binding_level *b;
6059   tree t = NULL_TREE;
6060
6061   b = current_binding_level;
6062   while (b->parm_flag == 2)
6063     b = b->level_chain;
6064
6065   if (b->namespace_p)
6066     {
6067       t = IDENTIFIER_NAMESPACE_VALUE (name);
6068
6069       /* extern "C" function() */
6070       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6071         t = TREE_VALUE (t);
6072     }
6073   else if (IDENTIFIER_BINDING (name)
6074            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6075     {
6076       while (1)
6077         {
6078           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6079             return IDENTIFIER_VALUE (name);
6080
6081           if (b->keep == 2)
6082             b = b->level_chain;
6083           else
6084             break;
6085         }
6086     }
6087
6088   return t;
6089 }
6090
6091 /* Like lookup_name_current_level, but for types.  */
6092
6093 tree
6094 lookup_type_current_level (name)
6095      tree name;
6096 {
6097   register tree t = NULL_TREE;
6098
6099   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6100
6101   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6102       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6103     {
6104       struct binding_level *b = current_binding_level;
6105       while (1)
6106         {
6107           if (purpose_member (name, b->type_shadowed))
6108             return REAL_IDENTIFIER_TYPE_VALUE (name);
6109           if (b->keep == 2)
6110             b = b->level_chain;
6111           else
6112             break;
6113         }
6114     }
6115
6116   return t;
6117 }
6118
6119 void
6120 begin_only_namespace_names ()
6121 {
6122   only_namespace_names = 1;
6123 }
6124
6125 void
6126 end_only_namespace_names ()
6127 {
6128   only_namespace_names = 0;
6129 }
6130 \f
6131 /* Push the declarations of builtin types into the namespace.
6132    RID_INDEX is the index of the builtin type
6133    in the array RID_POINTERS.  NAME is the name used when looking
6134    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6135
6136 static void
6137 record_builtin_type (rid_index, name, type)
6138      enum rid rid_index;
6139      const char *name;
6140      tree type;
6141 {
6142   tree rname = NULL_TREE, tname = NULL_TREE;
6143   tree tdecl = NULL_TREE;
6144
6145   if ((int) rid_index < (int) RID_MAX)
6146     rname = ridpointers[(int) rid_index];
6147   if (name)
6148     tname = get_identifier (name);
6149
6150   TYPE_BUILT_IN (type) = 1;
6151
6152   if (tname)
6153     {
6154       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6155       set_identifier_type_value (tname, NULL_TREE);
6156       if ((int) rid_index < (int) RID_MAX)
6157         /* Built-in types live in the global namespace. */
6158         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6159     }
6160   if (rname != NULL_TREE)
6161     {
6162       if (tname != NULL_TREE)
6163         {
6164           set_identifier_type_value (rname, NULL_TREE);
6165           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6166         }
6167       else
6168         {
6169           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6170           set_identifier_type_value (rname, NULL_TREE);
6171         }
6172     }
6173 }
6174
6175 /* Record one of the standard Java types.
6176  * Declare it as having the given NAME.
6177  * If SIZE > 0, it is the size of one of the integral types;
6178  * otherwise it is the negative of the size of one of the other types.  */
6179
6180 static tree
6181 record_builtin_java_type (name, size)
6182      const char *name;
6183      int size;
6184 {
6185   tree type, decl;
6186   if (size > 0)
6187     type = make_signed_type (size);
6188   else if (size > -32)
6189     { /* "__java_char" or ""__java_boolean". */
6190       type = make_unsigned_type (-size);
6191       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6192     }
6193   else
6194     { /* "__java_float" or ""__java_double". */
6195       type = make_node (REAL_TYPE);
6196       TYPE_PRECISION (type) = - size;
6197       layout_type (type);
6198     }
6199   record_builtin_type (RID_MAX, name, type);
6200   decl = TYPE_NAME (type);
6201
6202   /* Suppress generate debug symbol entries for these types,
6203      since for normal C++ they are just clutter.
6204      However, push_lang_context undoes this if extern "Java" is seen. */
6205   DECL_IGNORED_P (decl) = 1;
6206
6207   TYPE_FOR_JAVA (type) = 1;
6208   return type;
6209 }
6210
6211 /* Push a type into the namespace so that the back-ends ignore it. */
6212
6213 static void
6214 record_unknown_type (type, name)
6215      tree type;
6216      const char *name;
6217 {
6218   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6219   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6220   DECL_IGNORED_P (decl) = 1;
6221   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6222   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6223   TYPE_ALIGN (type) = 1;
6224   TYPE_USER_ALIGN (type) = 0;
6225   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6226 }
6227
6228 /* An string for which we should create an IDENTIFIER_NODE at
6229    startup.  */
6230
6231 typedef struct predefined_identifier
6232 {
6233   /* The name of the identifier.  */
6234   const char *name;
6235   /* The place where the IDENTIFIER_NODE should be stored.  */
6236   tree *node;
6237   /* Non-zero if this is the name of a constructor or destructor.  */
6238   int ctor_or_dtor_p;
6239 } predefined_identifier;
6240
6241 /* Create all the predefined identifiers.  */
6242
6243 static void
6244 initialize_predefined_identifiers ()
6245 {
6246   struct predefined_identifier *pid;
6247
6248   /* A table of identifiers to create at startup.  */
6249   static predefined_identifier predefined_identifiers[] = {
6250     { "C++", &lang_name_cplusplus, 0 },
6251     { "C", &lang_name_c, 0 },
6252     { "Java", &lang_name_java, 0 },
6253     { CTOR_NAME, &ctor_identifier, 1 },
6254     { "__base_ctor", &base_ctor_identifier, 1 },
6255     { "__comp_ctor", &complete_ctor_identifier, 1 },
6256     { DTOR_NAME, &dtor_identifier, 1 },
6257     { "__comp_dtor", &complete_dtor_identifier, 1 },
6258     { "__base_dtor", &base_dtor_identifier, 1 },
6259     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6260     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6261     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6262     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6263     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6264     { "nelts", &nelts_identifier, 0 },
6265     { THIS_NAME, &this_identifier, 0 },
6266     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6267     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6268     { "_vptr", &vptr_identifier, 0 },
6269     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6270     { "__vtt_parm", &vtt_parm_identifier, 0 },
6271     { "std", &std_identifier, 0 },
6272     { NULL, NULL, 0 }
6273   };
6274
6275   for (pid = predefined_identifiers; pid->name; ++pid)
6276     {
6277       *pid->node = get_identifier (pid->name);
6278       if (pid->ctor_or_dtor_p)
6279         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6280     }
6281 }
6282
6283 /* Create the predefined scalar types of C,
6284    and some nodes representing standard constants (0, 1, (void *)0).
6285    Initialize the global binding level.
6286    Make definitions for built-in primitive functions.  */
6287
6288 void
6289 init_decl_processing ()
6290 {
6291   tree fields[20];
6292   int wchar_type_size;
6293   tree array_domain_type;
6294
6295   /* Check to see that the user did not specify an invalid combination
6296      of command-line options.  */
6297   if (flag_new_abi && !flag_vtable_thunks)
6298     fatal ("the new ABI requires vtable thunks");
6299
6300   /* Create all the identifiers we need.  */
6301   initialize_predefined_identifiers ();
6302
6303   /* Fill in back-end hooks.  */
6304   init_lang_status = &push_cp_function_context;
6305   free_lang_status = &pop_cp_function_context;
6306   mark_lang_status = &mark_cp_function_context;
6307   lang_safe_from_p = &c_safe_from_p;
6308   lang_dump_tree = &cp_dump_tree;
6309
6310   cp_parse_init ();
6311   init_decl2 ();
6312   init_pt ();
6313
6314   /* Create the global variables.  */
6315   push_to_top_level ();
6316
6317   /* Enter the global namespace. */
6318   my_friendly_assert (global_namespace == NULL_TREE, 375);
6319   push_namespace (get_identifier ("::"));
6320   global_namespace = current_namespace;
6321   current_lang_name = NULL_TREE;
6322
6323   /* Adjust various flags based on command-line settings.  */
6324   if (! flag_permissive && ! pedantic)
6325     flag_pedantic_errors = 1;
6326   if (!flag_no_inline)
6327     flag_inline_trees = 1;
6328
6329   /* Initially, C.  */
6330   current_lang_name = lang_name_c;
6331
6332   current_function_decl = NULL_TREE;
6333   current_binding_level = NULL_BINDING_LEVEL;
6334   free_binding_level = NULL_BINDING_LEVEL;
6335
6336   build_common_tree_nodes (flag_signed_char);
6337
6338   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6339   TREE_TYPE (error_mark_list) = error_mark_node;
6340
6341   /* Make the binding_level structure for global names.  */
6342   pushlevel (0);
6343   global_binding_level = current_binding_level;
6344   /* The global level is the namespace level of ::.  */
6345   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6346   declare_namespace_level ();
6347
6348   /* Create the `std' namespace.  */
6349   if (flag_honor_std)
6350     {
6351       push_namespace (std_identifier);
6352       std_node = current_namespace;
6353       pop_namespace ();
6354       fake_std_node = error_mark_node;
6355     }
6356   else
6357     {
6358       fake_std_node = build_decl (NAMESPACE_DECL,
6359                                   std_identifier,
6360                                   void_type_node);
6361       pushdecl (fake_std_node);
6362     }
6363
6364   /* Define `int' and `char' first so that dbx will output them first.  */
6365   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6366   record_builtin_type (RID_CHAR, "char", char_type_node);
6367
6368   /* `signed' is the same as `int' */
6369   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6370   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6371   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6372   record_builtin_type (RID_MAX, "long unsigned int",
6373                        long_unsigned_type_node);
6374   record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6375   record_builtin_type (RID_MAX, "long long int",
6376                        long_long_integer_type_node);
6377   record_builtin_type (RID_MAX, "long long unsigned int",
6378                        long_long_unsigned_type_node);
6379   record_builtin_type (RID_MAX, "long long unsigned",
6380                        long_long_unsigned_type_node);
6381   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6382   record_builtin_type (RID_MAX, "short unsigned int",
6383                        short_unsigned_type_node);
6384   record_builtin_type (RID_MAX, "unsigned short",
6385                        short_unsigned_type_node);
6386
6387   /* Define both `signed char' and `unsigned char'.  */
6388   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6389   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6390
6391   /* `unsigned long' is the standard type for sizeof.
6392      Note that stddef.h uses `unsigned long',
6393      and this must agree, even if long and int are the same size.  */
6394   c_size_type_node =
6395     TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE)));
6396   signed_size_type_node = signed_type (c_size_type_node);
6397   set_sizetype (c_size_type_node);
6398
6399   /* Create the widest literal types. */
6400   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6401   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6402                         widest_integer_literal_type_node));
6403
6404   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6405   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6406                         widest_unsigned_literal_type_node));
6407
6408   /* These are types that type_for_size and type_for_mode use.  */
6409   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6410   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6411   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6412   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6413 #if HOST_BITS_PER_WIDE_INT >= 64
6414   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6415 #endif
6416   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6417   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6418   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6419   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6420 #if HOST_BITS_PER_WIDE_INT >= 64
6421   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6422 #endif
6423
6424   build_common_tree_nodes_2 (flag_short_double);
6425
6426   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6427   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6428   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6429   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6430   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6431   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6432   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6433   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6434
6435   integer_two_node = build_int_2 (2, 0);
6436   TREE_TYPE (integer_two_node) = integer_type_node;
6437   integer_three_node = build_int_2 (3, 0);
6438   TREE_TYPE (integer_three_node) = integer_type_node;
6439
6440   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6441   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6442   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6443   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6444   TYPE_PRECISION (boolean_type_node) = 1;
6445   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6446   boolean_false_node = build_int_2 (0, 0);
6447   TREE_TYPE (boolean_false_node) = boolean_type_node;
6448   boolean_true_node = build_int_2 (1, 0);
6449   TREE_TYPE (boolean_true_node) = boolean_type_node;
6450
6451   signed_size_zero_node = build_int_2 (0, 0);
6452   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6453   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6454   record_builtin_type (RID_MAX, "long double", long_double_type_node);
6455
6456   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6457                         complex_integer_type_node));
6458   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6459                         complex_float_type_node));
6460   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6461                         complex_double_type_node));
6462   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6463                         complex_long_double_type_node));
6464
6465   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6466
6467   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6468   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6469   TREE_PARMLIST (void_list_node) = 1;
6470
6471   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6472   /* Make a type to be the domain of a few array types
6473      whose domains don't really matter.
6474      200 is small enough that it always fits in size_t.  */
6475   array_domain_type = build_index_type (build_int_2 (200, 0));
6476
6477   /* Make a type for arrays of characters.
6478      With luck nothing will ever really depend on the length of this
6479      array type.  */
6480   char_array_type_node
6481     = build_array_type (char_type_node, array_domain_type);
6482
6483   /* Likewise for arrays of ints.  */
6484   int_array_type_node
6485     = build_array_type (integer_type_node, array_domain_type);
6486
6487   c_common_nodes_and_builtins ();
6488
6489 #if 0
6490   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6491 #endif
6492
6493   if (flag_new_abi)
6494     delta_type_node = ptrdiff_type_node;
6495   else if (flag_huge_objects)
6496     delta_type_node = long_integer_type_node;
6497   else
6498     delta_type_node = short_integer_type_node;
6499
6500   if (flag_new_abi)
6501     vtable_index_type = ptrdiff_type_node;
6502   else
6503     vtable_index_type = delta_type_node;
6504
6505   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6506   lang_type_promotes_to = convert_type_from_ellipsis;
6507
6508   void_ftype_ptr
6509     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6510
6511 #ifdef MD_INIT_BUILTINS
6512   MD_INIT_BUILTINS;
6513 #endif
6514
6515   /* C++ extensions */
6516
6517   unknown_type_node = make_node (UNKNOWN_TYPE);
6518   record_unknown_type (unknown_type_node, "unknown type");
6519
6520   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6521   TREE_TYPE (unknown_type_node) = unknown_type_node;
6522
6523   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6524
6525   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6526      result.  */
6527   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6528   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6529
6530   /* This is special for C++ so functions can be overloaded.  */
6531   wchar_type_node = get_identifier (flag_short_wchar
6532                                     ? "short unsigned int"
6533                                     : WCHAR_TYPE);
6534   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6535   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6536   if (TREE_UNSIGNED (wchar_type_node))
6537     wchar_type_node = make_signed_type (wchar_type_size);
6538   else
6539     wchar_type_node = make_unsigned_type (wchar_type_size);
6540   record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
6541
6542   /* This is for wide string constants.  */
6543   wchar_array_type_node
6544     = build_array_type (wchar_type_node, array_domain_type);
6545
6546   if (flag_vtable_thunks)
6547     {
6548       /* Make sure we get a unique function type, so we can give
6549          its pointer type a name.  (This wins for gdb.) */
6550       tree vfunc_type = make_node (FUNCTION_TYPE);
6551       TREE_TYPE (vfunc_type) = integer_type_node;
6552       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6553       layout_type (vfunc_type);
6554
6555       vtable_entry_type = build_pointer_type (vfunc_type);
6556     }
6557   else
6558     {
6559       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6560       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6561                               delta_type_node);
6562       fields[1] = build_decl (FIELD_DECL, index_identifier,
6563                               delta_type_node);
6564       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6565                               ptr_type_node);
6566       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6567                            double_type_node);
6568
6569       /* Make this part of an invisible union.  */
6570       fields[3] = copy_node (fields[2]);
6571       TREE_TYPE (fields[3]) = delta_type_node;
6572       DECL_NAME (fields[3]) = delta2_identifier;
6573       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6574       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6575       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6576       TREE_UNSIGNED (fields[3]) = 0;
6577       TREE_CHAIN (fields[2]) = fields[3];
6578       vtable_entry_type = build_qualified_type (vtable_entry_type,
6579                                                 TYPE_QUAL_CONST);
6580     }
6581   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6582
6583   vtbl_type_node
6584     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6585   layout_type (vtbl_type_node);
6586   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6587   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6588   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6589   layout_type (vtbl_ptr_type_node);
6590   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6591
6592   if (flag_new_abi)
6593     {
6594       push_namespace (get_identifier ("__cxxabiv1"));
6595       abi_node = current_namespace;
6596       pop_namespace ();
6597     }
6598
6599   global_type_node = make_node (LANG_TYPE);
6600   record_unknown_type (global_type_node, "global type");
6601
6602   /* Now, C++.  */
6603   current_lang_name = lang_name_cplusplus;
6604
6605   {
6606     tree bad_alloc_type_node, newtype, deltype;
6607     if (flag_honor_std)
6608       push_namespace (std_identifier);
6609     bad_alloc_type_node = xref_tag
6610       (class_type_node, get_identifier ("bad_alloc"), 1);
6611     if (flag_honor_std)
6612       pop_namespace ();
6613     newtype = build_exception_variant
6614       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6615     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6616     push_cp_library_fn (NEW_EXPR, newtype);
6617     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6618     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6619     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6620   }
6621
6622   abort_fndecl
6623     = build_library_fn_ptr ((flag_new_abi
6624                              ? "__cxa_pure_virtual"
6625                              : "__pure_virtual"),
6626                             void_ftype);
6627
6628   /* Perform other language dependent initializations.  */
6629   init_class_processing ();
6630   init_init_processing ();
6631   init_search_processing ();
6632   init_rtti_processing ();
6633
6634   if (flag_exceptions)
6635     init_exception_processing ();
6636   if (flag_no_inline)
6637     {
6638       flag_inline_functions = 0;
6639     }
6640
6641   if (! supports_one_only ())
6642     flag_weak = 0;
6643
6644   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6645   function_id_node = get_identifier ("__FUNCTION__");
6646   pretty_function_id_node = get_identifier ("__PRETTY_FUNCTION__");
6647   func_id_node = get_identifier ("__func__");
6648
6649   make_fname_decl = cp_make_fname_decl;
6650   declare_function_name ();
6651
6652   /* Prepare to check format strings against argument lists.  */
6653   init_function_format_info ();
6654
6655   /* Show we use EH for cleanups.  */
6656   using_eh_for_cleanups ();
6657
6658   valid_lang_attribute = cp_valid_lang_attribute;
6659
6660   /* Maintain consistency.  Perhaps we should just complain if they
6661      say -fwritable-strings?  */
6662   if (flag_writable_strings)
6663     flag_const_strings = 0;
6664
6665   /* Add GC roots for all of our global variables.  */
6666   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6667   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6668   ggc_add_tree_root (&integer_three_node, 1);
6669   ggc_add_tree_root (&integer_two_node, 1);
6670   ggc_add_tree_root (&signed_size_zero_node, 1);
6671   ggc_add_tree_root (&size_one_node, 1);
6672   ggc_add_tree_root (&size_zero_node, 1);
6673   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6674                 mark_binding_level);
6675   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6676   ggc_add_tree_root (&static_ctors, 1);
6677   ggc_add_tree_root (&static_dtors, 1);
6678   ggc_add_tree_root (&lastiddecl, 1);
6679
6680   ggc_add_tree_root (&last_function_parm_tags, 1);
6681   ggc_add_tree_root (&current_function_return_value, 1);
6682   ggc_add_tree_root (&current_function_parm_tags, 1);
6683   ggc_add_tree_root (&last_function_parms, 1);
6684   ggc_add_tree_root (&error_mark_list, 1);
6685
6686   ggc_add_tree_root (&global_namespace, 1);
6687   ggc_add_tree_root (&global_type_node, 1);
6688   ggc_add_tree_root (&anonymous_namespace_name, 1);
6689
6690   ggc_add_tree_root (&got_object, 1);
6691   ggc_add_tree_root (&got_scope, 1);
6692
6693   ggc_add_tree_root (&current_lang_name, 1);
6694   ggc_add_tree_root (&static_aggregates, 1);
6695 }
6696
6697 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6698    decl, NAME is the initialization string and TYPE_DEP indicates whether
6699    NAME depended on the type of the function. We make use of that to detect
6700    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6701    the function before emitting any of it, we don't need to treat the
6702    VAR_DECL specially. We can decide whether to emit it later, if it was
6703    used.  */
6704
6705 static tree
6706 cp_make_fname_decl (id, name, type_dep)
6707      tree id;
6708      const char *name;
6709      int type_dep;
6710 {
6711   tree decl, type, init;
6712   size_t length = strlen (name);
6713   tree domain = NULL_TREE;
6714
6715   if (!processing_template_decl)
6716     type_dep = 0;
6717   if (!type_dep)
6718     domain = build_index_type (build_int_2 (length, 0));
6719
6720   type =  build_cplus_array_type
6721           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6722            domain);
6723
6724   decl = build_decl (VAR_DECL, id, type);
6725   TREE_STATIC (decl) = 1;
6726   TREE_READONLY (decl) = 1;
6727   DECL_SOURCE_LINE (decl) = 0;
6728   DECL_ARTIFICIAL (decl) = 1;
6729   DECL_IN_SYSTEM_HEADER (decl) = 1;
6730   pushdecl (decl);
6731   if (processing_template_decl)
6732     decl = push_template_decl (decl);
6733   if (type_dep)
6734     {
6735       init = build (FUNCTION_NAME, type);
6736       DECL_PRETTY_FUNCTION_P (decl) = 1;
6737     }
6738   else
6739     {
6740       init = build_string (length + 1, name);
6741       TREE_TYPE (init) = type;
6742     }
6743   DECL_INITIAL (decl) = init;
6744   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6745
6746   /* We will have to make sure we only emit this, if it is actually used. */
6747   return decl;
6748 }
6749
6750 /* Entry point for the benefit of c_common_nodes_and_builtins.
6751
6752    Make a definition for a builtin function named NAME and whose data type
6753    is TYPE.  TYPE should be a function type with argument types.
6754
6755    CLASS and CODE tell later passes how to compile calls to this function.
6756    See tree.h for possible values.
6757
6758    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6759    the name to be called if we can't opencode the function.  */
6760
6761 tree
6762 builtin_function (name, type, code, class, libname)
6763      const char *name;
6764      tree type;
6765      int code;
6766      enum built_in_class class;
6767      const char *libname;
6768 {
6769   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6770   DECL_BUILT_IN_CLASS (decl) = class;
6771   DECL_FUNCTION_CODE (decl) = code;
6772
6773   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6774
6775   /* All builtins that don't begin with an `_' should go in the `std'
6776      namespace.  */
6777   if (flag_honor_std && name[0] != '_')
6778     {
6779       push_namespace (std_identifier);
6780       DECL_CONTEXT (decl) = std_node;
6781     }
6782   pushdecl (decl);
6783   if (flag_honor_std && name[0] != '_')
6784     pop_namespace ();
6785
6786   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6787      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6788      function in the namespace.  */
6789   if (libname)
6790     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6791   make_function_rtl (decl);
6792
6793   /* Warn if a function in the namespace for users
6794      is used without an occasion to consider it declared.  */
6795   if (name[0] != '_' || name[1] != '_')
6796     DECL_ANTICIPATED (decl) = 1;
6797
6798   return decl;
6799 }
6800
6801 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6802    function.  Not called directly.  */
6803
6804 static tree
6805 build_library_fn_1 (name, operator_code, type)
6806      tree name;
6807      enum tree_code operator_code;
6808      tree type;
6809 {
6810   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6811   DECL_EXTERNAL (fn) = 1;
6812   TREE_PUBLIC (fn) = 1;
6813   DECL_ARTIFICIAL (fn) = 1;
6814   TREE_NOTHROW (fn) = 1;
6815   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6816   return fn;
6817 }
6818
6819 /* Returns the _DECL for a library function with C linkage.
6820    We assume that such functions never throw; if this is incorrect,
6821    callers should unset TREE_NOTHROW.  */
6822
6823 tree
6824 build_library_fn (name, type)
6825      tree name;
6826      tree type;
6827 {
6828   tree fn = build_library_fn_1 (name, ERROR_MARK, type);
6829   make_function_rtl (fn);
6830   return fn;
6831 }
6832
6833 /* Returns the _DECL for a library function with C++ linkage.  */
6834
6835 static tree
6836 build_cp_library_fn (name, operator_code, type)
6837      tree name;
6838      enum tree_code operator_code;
6839      tree type;
6840 {
6841   tree fn = build_library_fn_1 (name, operator_code, type);
6842   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6843   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6844   set_mangled_name_for_decl (fn);
6845   make_function_rtl (fn);
6846   return fn;
6847 }
6848
6849 /* Like build_library_fn, but takes a C string instead of an
6850    IDENTIFIER_NODE.  */
6851
6852 tree
6853 build_library_fn_ptr (name, type)
6854      const char *name;
6855      tree type;
6856 {
6857   return build_library_fn (get_identifier (name), type);
6858 }
6859
6860 /* Like build_cp_library_fn, but takes a C string instead of an
6861    IDENTIFIER_NODE.  */
6862
6863 tree
6864 build_cp_library_fn_ptr (name, type)
6865      const char *name;
6866      tree type;
6867 {
6868   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6869 }
6870
6871 /* Like build_library_fn, but also pushes the function so that we will
6872    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6873
6874 tree
6875 push_library_fn (name, type)
6876      tree name, type;
6877 {
6878   tree fn = build_library_fn (name, type);
6879   pushdecl_top_level (fn);
6880   return fn;
6881 }
6882
6883 /* Like build_cp_library_fn, but also pushes the function so that it
6884    will be found by normal lookup.  */
6885
6886 static tree
6887 push_cp_library_fn (operator_code, type)
6888      enum tree_code operator_code;
6889      tree type;
6890 {
6891   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6892                                  operator_code,
6893                                  type);
6894   pushdecl (fn);
6895   return fn;
6896 }
6897
6898 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6899    a FUNCTION_TYPE.  */
6900
6901 tree
6902 push_void_library_fn (name, parmtypes)
6903      tree name, parmtypes;
6904 {
6905   tree type = build_function_type (void_type_node, parmtypes);
6906   return push_library_fn (name, type);
6907 }
6908
6909 /* Like push_library_fn, but also note that this function throws
6910    and does not return.  Used for __throw_foo and the like.  */
6911
6912 tree
6913 push_throw_library_fn (name, type)
6914      tree name, type;
6915 {
6916   tree fn = push_library_fn (name, type);
6917   TREE_THIS_VOLATILE (fn) = 1;
6918   TREE_NOTHROW (fn) = 0;
6919   return fn;
6920 }
6921 \f
6922 /* When we call finish_struct for an anonymous union, we create
6923    default copy constructors and such.  But, an anonymous union
6924    shouldn't have such things; this function undoes the damage to the
6925    anonymous union type T.
6926
6927    (The reason that we create the synthesized methods is that we don't
6928    distinguish `union { int i; }' from `typedef union { int i; } U'.
6929    The first is an anonymous union; the second is just an ordinary
6930    union type.)  */
6931
6932 void
6933 fixup_anonymous_aggr (t)
6934      tree t;
6935 {
6936   tree *q;
6937
6938   /* Wipe out memory of synthesized methods */
6939   TYPE_HAS_CONSTRUCTOR (t) = 0;
6940   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6941   TYPE_HAS_INIT_REF (t) = 0;
6942   TYPE_HAS_CONST_INIT_REF (t) = 0;
6943   TYPE_HAS_ASSIGN_REF (t) = 0;
6944   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6945
6946   /* Splice the implicitly generated functions out of the TYPE_METHODS
6947      list.  */
6948   q = &TYPE_METHODS (t);
6949   while (*q)
6950     {
6951       if (DECL_ARTIFICIAL (*q))
6952         *q = TREE_CHAIN (*q);
6953       else
6954         q = &TREE_CHAIN (*q);
6955     }
6956
6957   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6958   if (TYPE_METHODS (t))
6959     error ("an anonymous union cannot have function members");
6960 }
6961
6962 /* Make sure that a declaration with no declarator is well-formed, i.e.
6963    just defines a tagged type or anonymous union.
6964
6965    Returns the type defined, if any.  */
6966
6967 tree
6968 check_tag_decl (declspecs)
6969      tree declspecs;
6970 {
6971   int found_type = 0;
6972   int saw_friend = 0;
6973   tree ob_modifier = NULL_TREE;
6974   register tree link;
6975   register tree t = NULL_TREE;
6976
6977   for (link = declspecs; link; link = TREE_CHAIN (link))
6978     {
6979       register tree value = TREE_VALUE (link);
6980
6981       if (TYPE_P (value)
6982           || (TREE_CODE (value) == IDENTIFIER_NODE
6983               && IDENTIFIER_GLOBAL_VALUE (value)
6984               && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
6985         {
6986           ++found_type;
6987
6988           if ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
6989               || TREE_CODE (value) == ENUMERAL_TYPE)
6990             {
6991               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6992               t = value;
6993             }
6994         }
6995       else if (value == ridpointers[(int) RID_FRIEND])
6996         {
6997           if (current_class_type == NULL_TREE
6998               || current_scope () != current_class_type)
6999             ob_modifier = value;
7000           else
7001             saw_friend = 1;
7002         }
7003       else if (value == ridpointers[(int) RID_STATIC]
7004                || value == ridpointers[(int) RID_EXTERN]
7005                || value == ridpointers[(int) RID_AUTO]
7006                || value == ridpointers[(int) RID_REGISTER]
7007                || value == ridpointers[(int) RID_INLINE]
7008                || value == ridpointers[(int) RID_VIRTUAL]
7009                || value == ridpointers[(int) RID_CONST]
7010                || value == ridpointers[(int) RID_VOLATILE]
7011                || value == ridpointers[(int) RID_EXPLICIT])
7012         ob_modifier = value;
7013     }
7014
7015   if (found_type > 1)
7016     error ("multiple types in one declaration");
7017
7018   if (t == NULL_TREE && ! saw_friend)
7019     pedwarn ("declaration does not declare anything");
7020
7021   /* Check for an anonymous union.  We're careful
7022      accessing TYPE_IDENTIFIER because some built-in types, like
7023      pointer-to-member types, do not have TYPE_NAME.  */
7024   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7025            && TYPE_NAME (t)
7026            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
7027     {
7028       /* Anonymous unions are objects, so they can have specifiers.  */;
7029       SET_ANON_AGGR_TYPE_P (t);
7030
7031       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7032         pedwarn ("ISO C++ prohibits anonymous structs");
7033     }
7034
7035   else if (ob_modifier)
7036     {
7037       if (ob_modifier == ridpointers[(int) RID_INLINE]
7038           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7039         cp_error ("`%D' can only be specified for functions", ob_modifier);
7040       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7041         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7042       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7043         cp_error ("`%D' can only be specified for constructors",
7044                   ob_modifier);
7045       else
7046         cp_error ("`%D' can only be specified for objects and functions",
7047                   ob_modifier);
7048     }
7049
7050   return t;
7051 }
7052
7053 /* Called when a declaration is seen that contains no names to declare.
7054    If its type is a reference to a structure, union or enum inherited
7055    from a containing scope, shadow that tag name for the current scope
7056    with a forward reference.
7057    If its type defines a new named structure or union
7058    or defines an enum, it is valid but we need not do anything here.
7059    Otherwise, it is an error.
7060
7061    C++: may have to grok the declspecs to learn about static,
7062    complain for anonymous unions.  */
7063
7064 void
7065 shadow_tag (declspecs)
7066      tree declspecs;
7067 {
7068   tree t = check_tag_decl (declspecs);
7069
7070   if (t)
7071     maybe_process_partial_specialization (t);
7072
7073   /* This is where the variables in an anonymous union are
7074      declared.  An anonymous union declaration looks like:
7075      union { ... } ;
7076      because there is no declarator after the union, the parser
7077      sends that declaration here.  */
7078   if (t && ANON_AGGR_TYPE_P (t))
7079     {
7080       fixup_anonymous_aggr (t);
7081
7082       if (TYPE_FIELDS (t))
7083         {
7084           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7085                                       NULL_TREE);
7086           finish_anon_union (decl);
7087         }
7088     }
7089 }
7090 \f
7091 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7092
7093 tree
7094 groktypename (typename)
7095      tree typename;
7096 {
7097   if (TREE_CODE (typename) != TREE_LIST)
7098     return typename;
7099   return grokdeclarator (TREE_VALUE (typename),
7100                          TREE_PURPOSE (typename),
7101                          TYPENAME, 0, NULL_TREE);
7102 }
7103
7104 /* Decode a declarator in an ordinary declaration or data definition.
7105    This is called as soon as the type information and variable name
7106    have been parsed, before parsing the initializer if any.
7107    Here we create the ..._DECL node, fill in its type,
7108    and put it on the list of decls for the current context.
7109    The ..._DECL node is returned as the value.
7110
7111    Exception: for arrays where the length is not specified,
7112    the type is left null, to be filled in by `cp_finish_decl'.
7113
7114    Function definitions do not come here; they go to start_function
7115    instead.  However, external and forward declarations of functions
7116    do go through here.  Structure field declarations are done by
7117    grokfield and not through here.  */
7118
7119 tree
7120 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7121      tree declarator, declspecs;
7122      int initialized;
7123      tree attributes, prefix_attributes;
7124 {
7125   register tree decl;
7126   register tree type, tem;
7127   tree context;
7128   extern int have_extern_spec;
7129   extern int used_extern_spec;
7130   tree attrlist;
7131
7132 #if 0
7133   /* See code below that used this.  */
7134   int init_written = initialized;
7135 #endif
7136
7137   /* This should only be done once on the top most decl.  */
7138   if (have_extern_spec && !used_extern_spec)
7139     {
7140       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7141                              declspecs);
7142       used_extern_spec = 1;
7143     }
7144
7145   if (attributes || prefix_attributes)
7146     attrlist = build_tree_list (attributes, prefix_attributes);
7147   else
7148     attrlist = NULL_TREE;
7149
7150   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7151                          attrlist);
7152
7153   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7154     return NULL_TREE;
7155
7156   type = TREE_TYPE (decl);
7157
7158   if (type == error_mark_node)
7159     return NULL_TREE;
7160
7161   context = DECL_CONTEXT (decl);
7162
7163   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7164       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7165     {
7166       /* When parsing the initializer, lookup should use the object's
7167          namespace. */
7168       push_decl_namespace (context);
7169     }
7170
7171   /* We are only interested in class contexts, later. */
7172   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7173     context = NULL_TREE;
7174
7175   if (initialized)
7176     /* Is it valid for this decl to have an initializer at all?
7177        If not, set INITIALIZED to zero, which will indirectly
7178        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7179     switch (TREE_CODE (decl))
7180       {
7181       case TYPE_DECL:
7182         /* typedef foo = bar  means give foo the same type as bar.
7183            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7184            Any other case of an initialization in a TYPE_DECL is an error.  */
7185         if (pedantic || list_length (declspecs) > 1)
7186           {
7187             cp_error ("typedef `%D' is initialized", decl);
7188             initialized = 0;
7189           }
7190         break;
7191
7192       case FUNCTION_DECL:
7193         cp_error ("function `%#D' is initialized like a variable", decl);
7194         initialized = 0;
7195         break;
7196
7197       default:
7198         break;
7199       }
7200
7201   if (initialized)
7202     {
7203       if (! toplevel_bindings_p ()
7204           && DECL_EXTERNAL (decl))
7205         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7206                     decl);
7207       DECL_EXTERNAL (decl) = 0;
7208       if (toplevel_bindings_p ())
7209         TREE_STATIC (decl) = 1;
7210
7211       /* Tell `pushdecl' this is an initialized decl
7212          even though we don't yet have the initializer expression.
7213          Also tell `cp_finish_decl' it may store the real initializer.  */
7214       DECL_INITIAL (decl) = error_mark_node;
7215     }
7216
7217 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7218   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7219 #endif
7220
7221   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7222   cplus_decl_attributes (decl, attributes, prefix_attributes);
7223
7224   if (context && COMPLETE_TYPE_P (complete_type (context)))
7225     {
7226       push_nested_class (context, 2);
7227
7228       if (TREE_CODE (decl) == VAR_DECL)
7229         {
7230           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7231           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7232             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7233           else
7234             {
7235               if (DECL_CONTEXT (field) != context)
7236                 {
7237                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7238                               DECL_CONTEXT (field), DECL_NAME (decl),
7239                               context, DECL_NAME (decl));
7240                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7241                 }
7242               /* Static data member are tricky; an in-class initialization
7243                  still doesn't provide a definition, so the in-class
7244                  declaration will have DECL_EXTERNAL set, but will have an
7245                  initialization.  Thus, duplicate_decls won't warn
7246                  about this situation, and so we check here.  */
7247               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7248                 cp_error ("duplicate initialization of %D", decl);
7249               if (duplicate_decls (decl, field))
7250                 decl = field;
7251             }
7252         }
7253       else
7254         {
7255           tree field = check_classfn (context, decl);
7256           if (field && duplicate_decls (decl, field))
7257             decl = field;
7258         }
7259
7260       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7261       DECL_IN_AGGR_P (decl) = 0;
7262       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7263           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7264         {
7265           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7266           /* [temp.expl.spec] An explicit specialization of a static data
7267              member of a template is a definition if the declaration
7268              includes an initializer; otherwise, it is a declaration.
7269
7270              We check for processing_specialization so this only applies
7271              to the new specialization syntax.  */
7272           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7273             DECL_EXTERNAL (decl) = 1;
7274         }
7275
7276       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7277         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7278                     decl);
7279     }
7280
7281   /* Enter this declaration into the symbol table.  */
7282   tem = maybe_push_decl (decl);
7283
7284   if (processing_template_decl)
7285     tem = push_template_decl (tem);
7286
7287 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7288   /* Tell the back-end to use or not use .common as appropriate.  If we say
7289      -fconserve-space, we want this to save .data space, at the expense of
7290      wrong semantics.  If we say -fno-conserve-space, we want this to
7291      produce errors about redefs; to do this we force variables into the
7292      data segment.  */
7293   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7294 #endif
7295
7296   if (! processing_template_decl)
7297     start_decl_1 (tem);
7298
7299   return tem;
7300 }
7301
7302 void
7303 start_decl_1 (decl)
7304      tree decl;
7305 {
7306   tree type = TREE_TYPE (decl);
7307   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7308
7309   if (type == error_mark_node)
7310     return;
7311
7312   /* If this type of object needs a cleanup, but we're not allowed to
7313      add any more objects with cleanups to the current scope, create a
7314      new binding level.  */
7315   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7316       && current_binding_level->more_cleanups_ok == 0)
7317     {
7318       keep_next_level (2);
7319       pushlevel (1);
7320       clear_last_expr ();
7321       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7322     }
7323
7324   if (initialized)
7325     /* Is it valid for this decl to have an initializer at all?
7326        If not, set INITIALIZED to zero, which will indirectly
7327        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7328     {
7329       /* Don't allow initializations for incomplete types except for
7330          arrays which might be completed by the initialization.  */
7331       if (COMPLETE_TYPE_P (complete_type (type)))
7332         ;                       /* A complete type is ok.  */
7333       else if (TREE_CODE (type) != ARRAY_TYPE)
7334         {
7335           cp_error ("variable `%#D' has initializer but incomplete type",
7336                     decl);
7337           initialized = 0;
7338           type = TREE_TYPE (decl) = error_mark_node;
7339         }
7340       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7341         {
7342           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7343             cp_error ("elements of array `%#D' have incomplete type", decl);
7344           /* else we already gave an error in start_decl.  */
7345           initialized = 0;
7346         }
7347     }
7348
7349   if (!initialized
7350       && TREE_CODE (decl) != TYPE_DECL
7351       && TREE_CODE (decl) != TEMPLATE_DECL
7352       && type != error_mark_node
7353       && IS_AGGR_TYPE (type)
7354       && ! DECL_EXTERNAL (decl))
7355     {
7356       if ((! processing_template_decl || ! uses_template_parms (type))
7357           && !COMPLETE_TYPE_P (complete_type (type)))
7358         {
7359           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7360                  decl);
7361           /* Change the type so that assemble_variable will give
7362              DECL an rtl we can live with: (mem (const_int 0)).  */
7363           type = TREE_TYPE (decl) = error_mark_node;
7364         }
7365       else
7366         {
7367           /* If any base type in the hierarchy of TYPE needs a constructor,
7368              then we set initialized to 1.  This way any nodes which are
7369              created for the purposes of initializing this aggregate
7370              will live as long as it does.  This is necessary for global
7371              aggregates which do not have their initializers processed until
7372              the end of the file.  */
7373           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7374         }
7375     }
7376
7377   if (! initialized)
7378     DECL_INITIAL (decl) = NULL_TREE;
7379 }
7380
7381 /* Handle initialization of references.
7382    These three arguments are from `cp_finish_decl', and have the
7383    same meaning here that they do there.
7384
7385    Quotes on semantics can be found in ARM 8.4.3.  */
7386
7387 static void
7388 grok_reference_init (decl, type, init)
7389      tree decl, type, init;
7390 {
7391   tree tmp;
7392
7393   if (init == NULL_TREE)
7394     {
7395       if ((DECL_LANG_SPECIFIC (decl) == 0
7396            || DECL_IN_AGGR_P (decl) == 0)
7397           && ! DECL_THIS_EXTERN (decl))
7398         cp_error ("`%D' declared as reference but not initialized", decl);
7399       return;
7400     }
7401
7402   if (init == error_mark_node)
7403     return;
7404
7405   if (TREE_CODE (init) == CONSTRUCTOR)
7406     {
7407       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7408       return;
7409     }
7410
7411   if (TREE_CODE (init) == TREE_LIST)
7412     init = build_compound_expr (init);
7413
7414   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7415     init = convert_from_reference (init);
7416
7417   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7418       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7419     {
7420       /* Note: default conversion is only called in very special cases.  */
7421       init = default_conversion (init);
7422     }
7423
7424   /* Convert INIT to the reference type TYPE.  This may involve the
7425      creation of a temporary, whose lifetime must be the same as that
7426      of the reference.  If so, a DECL_STMT for the temporary will be
7427      added just after the DECL_STMT for DECL.  That's why we don't set
7428      DECL_INITIAL for local references (instead assigning to them
7429      explicitly); we need to allow the temporary to be initialized
7430      first.  */
7431   tmp = convert_to_reference
7432     (type, init, CONV_IMPLICIT,
7433      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7434      decl);
7435
7436   if (tmp == error_mark_node)
7437     return;
7438   else if (tmp != NULL_TREE)
7439     {
7440       init = tmp;
7441       tmp = save_expr (tmp);
7442       if (building_stmt_tree ())
7443         {
7444           /* Initialize the declaration.  */
7445           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7446           finish_expr_stmt (tmp);
7447         }
7448       else
7449         DECL_INITIAL (decl) = tmp;
7450     }
7451   else
7452     {
7453       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7454       return;
7455     }
7456
7457   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7458     {
7459       expand_static_init (decl, DECL_INITIAL (decl));
7460       DECL_INITIAL (decl) = NULL_TREE;
7461     }
7462   return;
7463 }
7464
7465 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7466    mucking with forces it does not comprehend (i.e. initialization with a
7467    constructor).  If we are at global scope and won't go into COMMON, fill
7468    it in with a dummy CONSTRUCTOR to force the variable into .data;
7469    otherwise we can use error_mark_node.  */
7470
7471 static tree
7472 obscure_complex_init (decl, init)
7473      tree decl, init;
7474 {
7475   if (! flag_no_inline && TREE_STATIC (decl))
7476     {
7477       if (extract_init (decl, init))
7478         return NULL_TREE;
7479     }
7480
7481 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7482   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7483     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7484                                  NULL_TREE);
7485   else
7486 #endif
7487     DECL_INITIAL (decl) = error_mark_node;
7488
7489   return init;
7490 }
7491
7492 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7493    array until we finish parsing the initializer.  If that's the
7494    situation we're in, update DECL accordingly.  */
7495
7496 static void
7497 maybe_deduce_size_from_array_init (decl, init)
7498      tree decl;
7499      tree init;
7500 {
7501   tree type = TREE_TYPE (decl);
7502
7503   if (TREE_CODE (type) == ARRAY_TYPE
7504       && TYPE_DOMAIN (type) == NULL_TREE
7505       && TREE_CODE (decl) != TYPE_DECL)
7506     {
7507       /* do_default is really a C-ism to deal with tentative definitions.
7508          But let's leave it here to ease the eventual merge.  */
7509       int do_default = !DECL_EXTERNAL (decl);
7510       tree initializer = init ? init : DECL_INITIAL (decl);
7511       int failure = complete_array_type (type, initializer, do_default);
7512
7513       if (failure == 1)
7514         cp_error ("initializer fails to determine size of `%D'", decl);
7515
7516       if (failure == 2)
7517         {
7518           if (do_default)
7519             cp_error ("array size missing in `%D'", decl);
7520           /* If a `static' var's size isn't known, make it extern as
7521              well as static, so it does not get allocated.  If it's not
7522              `static', then don't mark it extern; finish_incomplete_decl
7523              will give it a default size and it will get allocated.  */
7524           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7525             DECL_EXTERNAL (decl) = 1;
7526         }
7527
7528       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7529           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7530                               integer_zero_node))
7531         cp_error ("zero-size array `%D'", decl);
7532
7533       layout_decl (decl, 0);
7534     }
7535 }
7536
7537 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7538    any appropriate error messages regarding the layout.  */
7539
7540 static void
7541 layout_var_decl (decl)
7542      tree decl;
7543 {
7544   tree type = TREE_TYPE (decl);
7545 #if 0
7546   tree ttype = target_type (type);
7547 #endif
7548
7549   /* If we haven't already layed out this declaration, do so now.
7550      Note that we must not call complete type for an external object
7551      because it's type might involve templates that we are not
7552      supposed to isntantiate yet.  (And it's perfectly legal to say
7553      `extern X x' for some incomplete type `X'.)  */
7554   if (!DECL_EXTERNAL (decl))
7555     complete_type (type);
7556   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7557     layout_decl (decl, 0);
7558
7559   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7560     {
7561       /* An automatic variable with an incomplete type: that is an error.
7562          Don't talk about array types here, since we took care of that
7563          message in grokdeclarator.  */
7564       cp_error ("storage size of `%D' isn't known", decl);
7565       TREE_TYPE (decl) = error_mark_node;
7566     }
7567 #if 0
7568   /* Keep this code around in case we later want to control debug info
7569      based on whether a type is "used".  (jason 1999-11-11) */
7570
7571   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7572     /* Let debugger know it should output info for this type.  */
7573     note_debug_info_needed (ttype);
7574
7575   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7576     note_debug_info_needed (DECL_CONTEXT (decl));
7577 #endif
7578
7579   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7580       && DECL_SIZE (decl) != NULL_TREE
7581       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7582     {
7583       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7584         constant_expression_warning (DECL_SIZE (decl));
7585       else
7586         cp_error ("storage size of `%D' isn't constant", decl);
7587     }
7588 }
7589
7590 /* If a local static variable is declared in an inline function, or if
7591    we have a weak definition, we must endeavor to create only one
7592    instance of the variable at link-time.  */
7593
7594 static void
7595 maybe_commonize_var (decl)
7596      tree decl;
7597 {
7598   /* Static data in a function with comdat linkage also has comdat
7599      linkage.  */
7600   if (TREE_STATIC (decl)
7601       /* Don't mess with __FUNCTION__.  */
7602       && ! DECL_ARTIFICIAL (decl)
7603       && current_function_decl
7604       && DECL_CONTEXT (decl) == current_function_decl
7605       && (DECL_THIS_INLINE (current_function_decl)
7606           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7607       && TREE_PUBLIC (current_function_decl))
7608     {
7609       /* Rather than try to get this right with inlining, we suppress
7610          inlining of such functions.  */
7611       current_function_cannot_inline
7612         = "function with static variable cannot be inline";
7613       DECL_UNINLINABLE (current_function_decl) = 1;
7614
7615       /* If flag_weak, we don't need to mess with this, as we can just
7616          make the function weak, and let it refer to its unique local
7617          copy.  This works because we don't allow the function to be
7618          inlined.  */
7619       if (! flag_weak)
7620         {
7621           if (DECL_INTERFACE_KNOWN (current_function_decl))
7622             {
7623               TREE_PUBLIC (decl) = 1;
7624               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7625             }
7626           else if (DECL_INITIAL (decl) == NULL_TREE
7627                    || DECL_INITIAL (decl) == error_mark_node)
7628             {
7629               TREE_PUBLIC (decl) = 1;
7630               DECL_COMMON (decl) = 1;
7631             }
7632           /* else we lose. We can only do this if we can use common,
7633              which we can't if it has been initialized.  */
7634
7635           if (TREE_PUBLIC (decl))
7636             DECL_ASSEMBLER_NAME (decl)
7637               = build_static_name (current_function_decl, DECL_NAME (decl));
7638           else
7639             {
7640               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7641               cp_warning_at ("  you can work around this by removing the initializer", decl);
7642             }
7643         }
7644     }
7645   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7646     /* Set it up again; we might have set DECL_INITIAL since the last
7647        time.  */
7648     comdat_linkage (decl);
7649 }
7650
7651 /* Issue an error message if DECL is an uninitialized const variable.  */
7652
7653 static void
7654 check_for_uninitialized_const_var (decl)
7655      tree decl;
7656 {
7657   tree type = TREE_TYPE (decl);
7658
7659   /* ``Unless explicitly declared extern, a const object does not have
7660      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7661      7.1.6 */
7662   if (TREE_CODE (decl) == VAR_DECL
7663       && TREE_CODE (type) != REFERENCE_TYPE
7664       && CP_TYPE_CONST_P (type)
7665       && !TYPE_NEEDS_CONSTRUCTING (type)
7666       && !DECL_INITIAL (decl))
7667     cp_error ("uninitialized const `%D'", decl);
7668 }
7669
7670 /* Verify INIT (the initializer for DECL), and record the
7671    initialization in DECL_INITIAL, if appropriate.  Returns a new
7672    value for INIT.  */
7673
7674 static tree
7675 check_initializer (decl, init)
7676      tree decl;
7677      tree init;
7678 {
7679   tree type;
7680
7681   if (TREE_CODE (decl) == FIELD_DECL)
7682     return init;
7683
7684   type = TREE_TYPE (decl);
7685
7686   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7687   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7688     init = NULL_TREE;
7689
7690   /* Check the initializer.  */
7691   if (init)
7692     {
7693       /* Things that are going to be initialized need to have complete
7694          type.  */
7695       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7696
7697       if (type == error_mark_node)
7698         /* We will have already complained.  */
7699         init = NULL_TREE;
7700       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7701         {
7702           cp_error ("variable-sized object `%D' may not be initialized", decl);
7703           init = NULL_TREE;
7704         }
7705       else if (TREE_CODE (type) == ARRAY_TYPE
7706                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7707         {
7708           cp_error ("elements of array `%#D' have incomplete type", decl);
7709           init = NULL_TREE;
7710         }
7711       else if (!COMPLETE_TYPE_P (type))
7712         {
7713           cp_error ("`%D' has incomplete type", decl);
7714           TREE_TYPE (decl) = error_mark_node;
7715           init = NULL_TREE;
7716         }
7717     }
7718
7719   if (TREE_CODE (decl) == CONST_DECL)
7720     {
7721       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7722
7723       DECL_INITIAL (decl) = init;
7724
7725       /* This will keep us from needing to worry about our obstacks.  */
7726       my_friendly_assert (init != NULL_TREE, 149);
7727       init = NULL_TREE;
7728     }
7729   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7730     {
7731       if (TREE_STATIC (decl))
7732         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7733       grok_reference_init (decl, type, init);
7734       init = NULL_TREE;
7735     }
7736   else if (init)
7737     {
7738       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7739         {
7740           if (TREE_CODE (type) == ARRAY_TYPE)
7741             init = digest_init (type, init, (tree *) 0);
7742           else if (TREE_CODE (init) == CONSTRUCTOR
7743                    && TREE_HAS_CONSTRUCTOR (init))
7744             {
7745               if (TYPE_NON_AGGREGATE_CLASS (type))
7746                 {
7747                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7748                             decl);
7749                   init = error_mark_node;
7750                 }
7751               else
7752                 goto dont_use_constructor;
7753             }
7754         }
7755       else
7756         {
7757         dont_use_constructor:
7758           if (TREE_CODE (init) != TREE_VEC)
7759             init = store_init_value (decl, init);
7760         }
7761
7762       if (init)
7763         /* We must hide the initializer so that expand_decl
7764            won't try to do something it does not understand.  */
7765         init = obscure_complex_init (decl, init);
7766     }
7767   else if (DECL_EXTERNAL (decl))
7768     ;
7769   else if (TYPE_P (type)
7770            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7771     {
7772       tree core_type = strip_array_types (type);
7773
7774       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7775         {
7776           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7777             cp_error ("structure `%D' with uninitialized const members", decl);
7778           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7779             cp_error ("structure `%D' with uninitialized reference members",
7780                       decl);
7781         }
7782
7783       check_for_uninitialized_const_var (decl);
7784
7785       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7786         init = obscure_complex_init (decl, NULL_TREE);
7787
7788     }
7789   else
7790     check_for_uninitialized_const_var (decl);
7791
7792   return init;
7793 }
7794
7795 /* If DECL is not a local variable, give it RTL.  */
7796
7797 static void
7798 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7799      tree decl;
7800      tree init;
7801      const char *asmspec;
7802 {
7803   int toplev = toplevel_bindings_p ();
7804   int defer_p;
7805
7806   /* Handle non-variables up front.  */
7807   if (TREE_CODE (decl) != VAR_DECL)
7808     {
7809       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7810       return;
7811     }
7812
7813   /* If we see a class member here, it should be a static data
7814      member.  */
7815   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7816     {
7817       my_friendly_assert (TREE_STATIC (decl), 19990828);
7818       /* An in-class declaration of a static data member should be
7819          external; it is only a declaration, and not a definition.  */
7820       if (init == NULL_TREE)
7821         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7822     }
7823
7824   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7825   if (asmspec)
7826     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7827
7828   /* We don't create any RTL for local variables.  */
7829   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7830     return;
7831
7832   /* We defer emission of local statics until the corresponding
7833      DECL_STMT is expanded.  */
7834   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7835
7836   /* We try to defer namespace-scope static constants so that they are
7837      not emitted into the object file unncessarily.  */
7838   if (!DECL_VIRTUAL_P (decl)
7839       && TREE_READONLY (decl)
7840       && DECL_INITIAL (decl) != NULL_TREE
7841       && DECL_INITIAL (decl) != error_mark_node
7842       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7843       && toplev
7844       && !TREE_PUBLIC (decl))
7845     {
7846       /* Fool with the linkage according to #pragma interface.  */
7847       if (!interface_unknown)
7848         {
7849           TREE_PUBLIC (decl) = 1;
7850           DECL_EXTERNAL (decl) = interface_only;
7851         }
7852
7853       defer_p = 1;
7854     }
7855
7856   /* If we're deferring the variable, just make RTL.  Do not actually
7857      emit the variable.  */
7858   if (defer_p)
7859     make_decl_rtl (decl, asmspec, toplev);
7860   /* If we're not deferring, go ahead and assemble the variable.  */
7861   else
7862     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7863 }
7864
7865 /* The old ARM scoping rules injected variables declared in the
7866    initialization statement of a for-statement into the surrounding
7867    scope.  We support this usage, in order to be backward-compatible.
7868    DECL is a just-declared VAR_DECL; if necessary inject its
7869    declaration into the surrounding scope.  */
7870
7871 void
7872 maybe_inject_for_scope_var (decl)
7873      tree decl;
7874 {
7875   if (!DECL_NAME (decl))
7876     return;
7877
7878   if (current_binding_level->is_for_scope)
7879     {
7880       struct binding_level *outer
7881         = current_binding_level->level_chain;
7882
7883       /* Check to see if the same name is already bound at the outer
7884          level, either because it was directly declared, or because a
7885          dead for-decl got preserved.  In either case, the code would
7886          not have been valid under the ARM scope rules, so clear
7887          is_for_scope for the current_binding_level.
7888
7889          Otherwise, we need to preserve the temp slot for decl to last
7890          into the outer binding level.  */
7891
7892       tree outer_binding
7893         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7894
7895       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7896           && (TREE_CODE (BINDING_VALUE (outer_binding))
7897               == VAR_DECL)
7898           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7899         {
7900           BINDING_VALUE (outer_binding)
7901             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7902           current_binding_level->is_for_scope = 0;
7903         }
7904       else if (DECL_IN_MEMORY_P (decl))
7905         preserve_temp_slots (DECL_RTL (decl));
7906     }
7907 }
7908
7909 /* Generate code to initialize DECL (a local variable).  */
7910
7911 void
7912 initialize_local_var (decl, init, flags)
7913      tree decl;
7914      tree init;
7915      int flags;
7916 {
7917   tree type = TREE_TYPE (decl);
7918
7919   /* If the type is bogus, don't bother initializing the variable.  */
7920   if (type == error_mark_node)
7921     return;
7922
7923   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7924     {
7925       /* If we used it already as memory, it must stay in memory.  */
7926       DECL_INITIAL (decl) = NULL_TREE;
7927       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7928     }
7929
7930   /* Local statics are handled differently from ordinary automatic
7931      variables.  */
7932   if (TREE_STATIC (decl))
7933     {
7934       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7935           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7936         expand_static_init (decl, init);
7937       return;
7938     }
7939
7940   if (DECL_SIZE (decl) && type != error_mark_node)
7941     {
7942       int already_used;
7943
7944       /* Compute and store the initial value.  */
7945       already_used = TREE_USED (decl) || TREE_USED (type);
7946
7947       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7948         {
7949           int saved_stmts_are_full_exprs_p;
7950
7951           my_friendly_assert (building_stmt_tree (), 20000906);
7952           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7953           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
7954           finish_expr_stmt (build_aggr_init (decl, init, flags));
7955           current_stmt_tree ()->stmts_are_full_exprs_p =
7956             saved_stmts_are_full_exprs_p;
7957         }
7958
7959       /* Set this to 0 so we can tell whether an aggregate which was
7960          initialized was ever used.  Don't do this if it has a
7961          destructor, so we don't complain about the 'resource
7962          allocation is initialization' idiom.  Now set
7963          attribute((unused)) on types so decls of that type will be
7964          marked used. (see TREE_USED, above.)  */
7965       if (TYPE_NEEDS_CONSTRUCTING (type)
7966           && ! already_used
7967           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7968           && DECL_NAME (decl))
7969         TREE_USED (decl) = 0;
7970       else if (already_used)
7971         TREE_USED (decl) = 1;
7972     }
7973 }
7974
7975 /* Generate code to destroy DECL (a local variable).  */
7976
7977 static void
7978 destroy_local_var (decl)
7979      tree decl;
7980 {
7981   tree type = TREE_TYPE (decl);
7982   tree cleanup;
7983
7984   /* Only variables get cleaned up.  */
7985   if (TREE_CODE (decl) != VAR_DECL)
7986     return;
7987
7988   /* And only things with destructors need cleaning up.  */
7989   if (type == error_mark_node
7990       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7991     return;
7992
7993   if (TREE_CODE (decl) == VAR_DECL &&
7994       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7995     /* We don't clean up things that aren't defined in this
7996        translation unit, or that need a static cleanup.  The latter
7997        are handled by finish_file.  */
7998     return;
7999
8000   /* Compute the cleanup.  */
8001   cleanup = maybe_build_cleanup (decl);
8002
8003   /* Record the cleanup required for this declaration.  */
8004   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
8005       && cleanup)
8006     finish_decl_cleanup (decl, cleanup);
8007 }
8008
8009 /* Finish processing of a declaration;
8010    install its line number and initial value.
8011    If the length of an array type is not known before,
8012    it must be determined now, from the initial value, or it is an error.
8013
8014    INIT holds the value of an initializer that should be allowed to escape
8015    the normal rules.
8016
8017    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8018    if the (init) syntax was used.  */
8019
8020 void
8021 cp_finish_decl (decl, init, asmspec_tree, flags)
8022      tree decl, init;
8023      tree asmspec_tree;
8024      int flags;
8025 {
8026   register tree type;
8027   tree ttype = NULL_TREE;
8028   const char *asmspec = NULL;
8029   int was_readonly = 0;
8030
8031   if (! decl)
8032     {
8033       if (init)
8034         error ("assignment (not initialization) in declaration");
8035       return;
8036     }
8037
8038   /* If a name was specified, get the string.  */
8039   if (asmspec_tree)
8040       asmspec = TREE_STRING_POINTER (asmspec_tree);
8041
8042   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8043     {
8044       cp_error ("cannot initialize `%D' to namespace `%D'",
8045                 decl, init);
8046       init = NULL_TREE;
8047     }
8048
8049   if (current_class_type
8050       && CP_DECL_CONTEXT (decl) == current_class_type
8051       && TYPE_BEING_DEFINED (current_class_type)
8052       && (DECL_INITIAL (decl) || init))
8053     DECL_DEFINED_IN_CLASS_P (decl) = 1;
8054
8055   if (TREE_CODE (decl) == VAR_DECL
8056       && DECL_CONTEXT (decl)
8057       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8058       && DECL_CONTEXT (decl) != current_namespace
8059       && init)
8060     {
8061       /* Leave the namespace of the object. */
8062       pop_decl_namespace ();
8063     }
8064
8065   type = TREE_TYPE (decl);
8066
8067   if (type == error_mark_node)
8068     return;
8069
8070   /* Add this declaration to the statement-tree.  */
8071   if (building_stmt_tree ()
8072       && at_function_scope_p ()
8073       && TREE_CODE (decl) != RESULT_DECL)
8074     add_decl_stmt (decl);
8075
8076   if (TYPE_HAS_MUTABLE_P (type))
8077     TREE_READONLY (decl) = 0;
8078
8079   if (processing_template_decl)
8080     {
8081       if (init && DECL_INITIAL (decl))
8082         DECL_INITIAL (decl) = init;
8083       goto finish_end0;
8084     }
8085
8086   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8087   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8088
8089   /* Take care of TYPE_DECLs up front.  */
8090   if (TREE_CODE (decl) == TYPE_DECL)
8091     {
8092       if (init && DECL_INITIAL (decl))
8093         {
8094           /* typedef foo = bar; store the type of bar as the type of foo.  */
8095           TREE_TYPE (decl) = type = TREE_TYPE (init);
8096           DECL_INITIAL (decl) = init = NULL_TREE;
8097         }
8098       if (type != error_mark_node
8099           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8100         {
8101           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8102             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8103           set_identifier_type_value (DECL_NAME (decl), type);
8104           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8105         }
8106       GNU_xref_decl (current_function_decl, decl);
8107
8108       /* If we have installed this as the canonical typedef for this
8109          type, and that type has not been defined yet, delay emitting
8110          the debug information for it, as we will emit it later.  */
8111       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8112           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8113         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8114
8115       rest_of_decl_compilation (decl, NULL_PTR,
8116                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8117       goto finish_end;
8118     }
8119
8120   if (TREE_CODE (decl) != FUNCTION_DECL)
8121     ttype = target_type (type);
8122
8123   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8124       && TYPE_NEEDS_CONSTRUCTING (type))
8125     {
8126       /* Currently, GNU C++ puts constants in text space, making them
8127          impossible to initialize.  In the future, one would hope for
8128          an operating system which understood the difference between
8129          initialization and the running of a program.  */
8130       was_readonly = 1;
8131       TREE_READONLY (decl) = 0;
8132     }
8133
8134   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8135     {
8136       /* This must override the asm specifier which was placed by
8137          grokclassfn.  Lay this out fresh.  */
8138       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8139       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8140       make_decl_rtl (decl, asmspec, 0);
8141     }
8142
8143   /* Deduce size of array from initialization, if not already known.  */
8144   maybe_deduce_size_from_array_init (decl, init);
8145   init = check_initializer (decl, init);
8146
8147   GNU_xref_decl (current_function_decl, decl);
8148
8149   if (TREE_CODE (decl) == VAR_DECL)
8150     layout_var_decl (decl);
8151
8152   /* Output the assembler code and/or RTL code for variables and functions,
8153      unless the type is an undefined structure or union.
8154      If not, it will get done when the type is completed.  */
8155   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8156       || TREE_CODE (decl) == RESULT_DECL)
8157     {
8158       if (TREE_CODE (decl) == VAR_DECL)
8159         maybe_commonize_var (decl);
8160
8161       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8162
8163       if (TREE_CODE (type) == FUNCTION_TYPE
8164           || TREE_CODE (type) == METHOD_TYPE)
8165         abstract_virtuals_error (decl,
8166                                  strip_array_types (TREE_TYPE (type)));
8167       else
8168         abstract_virtuals_error (decl, strip_array_types (type));
8169
8170       if (TREE_CODE (decl) == FUNCTION_DECL)
8171         ;
8172       else if (DECL_EXTERNAL (decl)
8173                && ! (DECL_LANG_SPECIFIC (decl)
8174                      && DECL_NOT_REALLY_EXTERN (decl)))
8175         {
8176           if (init)
8177             DECL_INITIAL (decl) = init;
8178         }
8179       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8180         {
8181           /* This is a local declaration.  */
8182           if (doing_semantic_analysis_p ())
8183             maybe_inject_for_scope_var (decl);
8184           /* Initialize the local variable.  But, if we're building a
8185              statement-tree, we'll do the initialization when we
8186              expand the tree.  */
8187           if (processing_template_decl)
8188             {
8189               if (init || DECL_INITIAL (decl) == error_mark_node)
8190                 DECL_INITIAL (decl) = init;
8191             }
8192           else
8193             {
8194               /* If we're not building RTL, then we need to do so
8195                  now.  */
8196               my_friendly_assert (building_stmt_tree (), 20000906);
8197               /* Initialize the variable.  */
8198               initialize_local_var (decl, init, flags);
8199               /* Clean up the variable.  */
8200               destroy_local_var (decl);
8201             }
8202         }
8203       else if (TREE_STATIC (decl) && type != error_mark_node)
8204         {
8205           /* Cleanups for static variables are handled by `finish_file'.  */
8206           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8207               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8208             expand_static_init (decl, init);
8209         }
8210     finish_end0:
8211
8212       /* Undo call to `pushclass' that was done in `start_decl'
8213          due to initialization of qualified member variable.
8214          I.e., Foo::x = 10;  */
8215       {
8216         tree context = CP_DECL_CONTEXT (decl);
8217         if (context
8218             && TYPE_P (context)
8219             && (TREE_CODE (decl) == VAR_DECL
8220                 /* We also have a pushclass done that we need to undo here
8221                    if we're at top level and declare a method.  */
8222                 || TREE_CODE (decl) == FUNCTION_DECL)
8223             /* If size hasn't been set, we're still defining it,
8224                and therefore inside the class body; don't pop
8225                the binding level..  */
8226             && COMPLETE_TYPE_P (context)
8227             && context == current_class_type)
8228           pop_nested_class ();
8229       }
8230     }
8231
8232  finish_end:
8233
8234   if (was_readonly)
8235     TREE_READONLY (decl) = 1;
8236 }
8237
8238 /* This is here for a midend callback from c-common.c */
8239
8240 void
8241 finish_decl (decl, init, asmspec_tree)
8242      tree decl, init;
8243      tree asmspec_tree;
8244 {
8245   cp_finish_decl (decl, init, asmspec_tree, 0);
8246 }
8247
8248 /* Returns a declaration for a VAR_DECL as if:
8249
8250      extern "C" TYPE NAME;
8251
8252    had been seen.  Used to create compiler-generated global
8253    variables.  */
8254
8255 tree
8256 declare_global_var (name, type)
8257      tree name;
8258      tree type;
8259 {
8260   tree decl;
8261
8262   push_to_top_level ();
8263   decl = build_decl (VAR_DECL, name, type);
8264   TREE_PUBLIC (decl) = 1;
8265   DECL_EXTERNAL (decl) = 1;
8266   DECL_ARTIFICIAL (decl) = 1;
8267   pushdecl (decl);
8268   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8269   pop_from_top_level ();
8270
8271   return decl;
8272 }
8273
8274 /* Returns a pointer to the `atexit' function.  Note that if
8275    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8276    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8277
8278 static tree
8279 get_atexit_node ()
8280 {
8281   tree atexit_fndecl;
8282   tree arg_types;
8283   tree fn_type;
8284   tree fn_ptr_type;
8285   const char *name;
8286
8287   if (atexit_node)
8288     return atexit_node;
8289
8290   if (flag_use_cxa_atexit)
8291     {
8292       /* The declaration for `__cxa_atexit' is:
8293
8294            int __cxa_atexit (void (*)(void *), void *, void *)
8295
8296          We build up the argument types and then then function type
8297          itself.  */
8298
8299       /* First, build the pointer-to-function type for the first
8300          argument.  */
8301       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8302       fn_type = build_function_type (void_type_node, arg_types);
8303       fn_ptr_type = build_pointer_type (fn_type);
8304       /* Then, build the rest of the argument types.  */
8305       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8306       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8307       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8308       /* And the final __cxa_atexit type.  */
8309       fn_type = build_function_type (integer_type_node, arg_types);
8310       fn_ptr_type = build_pointer_type (fn_type);
8311       name = "__cxa_atexit";
8312     }
8313   else
8314     {
8315       /* The declaration for `atexit' is:
8316
8317            int atexit (void (*)());
8318
8319          We build up the argument types and then then function type
8320          itself.  */
8321       fn_type = build_function_type (void_type_node, void_list_node);
8322       fn_ptr_type = build_pointer_type (fn_type);
8323       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8324       /* Build the final atexit type.  */
8325       fn_type = build_function_type (integer_type_node, arg_types);
8326       name = "atexit";
8327     }
8328
8329   /* Now, build the function declaration.  */
8330   push_lang_context (lang_name_c);
8331   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8332   mark_used (atexit_fndecl);
8333   pop_lang_context ();
8334   atexit_node = default_conversion (atexit_fndecl);
8335
8336   return atexit_node;
8337 }
8338
8339 /* Returns the __dso_handle VAR_DECL.  */
8340
8341 static tree
8342 get_dso_handle_node ()
8343 {
8344   if (dso_handle_node)
8345     return dso_handle_node;
8346
8347   /* Declare the variable.  */
8348   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8349                                         ptr_type_node);
8350
8351   return dso_handle_node;
8352 }
8353
8354 /* Begin a new function with internal linkage whose job will be simply
8355    to destroy some particular variable.  */
8356
8357 static tree
8358 start_cleanup_fn ()
8359 {
8360   static int counter = 0;
8361   int old_interface_unknown = interface_unknown;
8362   char name[32];
8363   tree parmtypes;
8364   tree fntype;
8365   tree fndecl;
8366
8367   push_to_top_level ();
8368
8369   /* No need to mangle this.  */
8370   push_lang_context (lang_name_c);
8371
8372   interface_unknown = 1;
8373
8374   /* Build the parameter-types.  */
8375   parmtypes = void_list_node;
8376   /* Functions passed to __cxa_atexit take an additional parameter.
8377      We'll just ignore it.  After we implement the new calling
8378      convention for destructors, we can eliminate the use of
8379      additional cleanup functions entirely in the -fnew-abi case.  */
8380   if (flag_use_cxa_atexit)
8381     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8382   /* Build the function type itself.  */
8383   fntype = build_function_type (void_type_node, parmtypes);
8384   /* Build the name of the function.  */
8385   sprintf (name, "__tcf_%d", counter++);
8386   /* Build the function declaration.  */
8387   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8388   /* It's a function with internal linkage, generated by the
8389      compiler.  */
8390   TREE_PUBLIC (fndecl) = 0;
8391   DECL_ARTIFICIAL (fndecl) = 1;
8392   /* Make the function `inline' so that it is only emitted if it is
8393      actually needed.  It is unlikely that it will be inlined, since
8394      it is only called via a function pointer, but we avoid unncessary
8395      emissions this way.  */
8396   DECL_INLINE (fndecl) = 1;
8397   /* Build the parameter.  */
8398   if (flag_use_cxa_atexit)
8399     {
8400       tree parmdecl;
8401
8402       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8403       DECL_CONTEXT (parmdecl) = fndecl;
8404       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8405       TREE_USED (parmdecl) = 1;
8406       DECL_ARGUMENTS (fndecl) = parmdecl;
8407     }
8408
8409   pushdecl (fndecl);
8410   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8411   do_pushlevel ();
8412
8413   interface_unknown = old_interface_unknown;
8414
8415   pop_lang_context ();
8416
8417   return current_function_decl;
8418 }
8419
8420 /* Finish the cleanup function begun by start_cleanup_fn.  */
8421
8422 static void
8423 end_cleanup_fn ()
8424 {
8425   do_poplevel ();
8426
8427   expand_body (finish_function (0));
8428
8429   pop_from_top_level ();
8430 }
8431
8432 /* Generate code to handle the destruction of DECL, an object with
8433    static storage duration.  */
8434
8435 void
8436 register_dtor_fn (decl)
8437      tree decl;
8438 {
8439   tree cleanup;
8440   tree compound_stmt;
8441   tree args;
8442   tree fcall;
8443
8444   int saved_flag_access_control;
8445
8446   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8447     return;
8448
8449   /* Call build_cleanup before we enter the anonymous function so that
8450      any access checks will be done relative to the current scope,
8451      rather than the scope of the anonymous function.  */
8452   build_cleanup (decl);
8453
8454   /* Now start the function.  */
8455   cleanup = start_cleanup_fn ();
8456
8457   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8458      to the original function, rather than the anonymous one.  That
8459      will make the back-end think that nested functions are in use,
8460      which causes confusion.  */
8461   saved_flag_access_control = flag_access_control;
8462   flag_access_control = 0;
8463   fcall = build_cleanup (decl);
8464   flag_access_control = saved_flag_access_control;
8465
8466   /* Create the body of the anonymous function.  */
8467   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8468   finish_expr_stmt (fcall);
8469   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8470   end_cleanup_fn ();
8471
8472   /* Call atexit with the cleanup function.  */
8473   mark_addressable (cleanup);
8474   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8475   if (flag_use_cxa_atexit)
8476     {
8477       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8478       args = tree_cons (NULL_TREE, null_pointer_node, args);
8479       args = tree_cons (NULL_TREE, cleanup, args);
8480     }
8481   else
8482     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8483   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8484 }
8485
8486 void
8487 expand_static_init (decl, init)
8488      tree decl;
8489      tree init;
8490 {
8491   tree oldstatic = value_member (decl, static_aggregates);
8492
8493   if (oldstatic)
8494     {
8495       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8496         cp_error ("multiple initializations given for `%D'", decl);
8497     }
8498   else if (! toplevel_bindings_p ())
8499     {
8500       /* Emit code to perform this initialization but once.  */
8501       tree if_stmt;
8502       tree then_clause;
8503       tree assignment;
8504       tree guard;
8505       tree guard_init;
8506
8507       /* Emit code to perform this initialization but once.  This code
8508          looks like:
8509
8510            static int guard = 0;
8511            if (!guard) {
8512              // Do initialization.
8513              guard = 1;
8514              // Register variable for destruction at end of program.
8515            }
8516
8517          Note that the `temp' variable is only set to 1 *after* the
8518          initialization is complete.  This ensures that an exception,
8519          thrown during the construction, will cause the variable to
8520          reinitialized when we pass through this code again, as per:
8521
8522            [stmt.dcl]
8523
8524            If the initialization exits by throwing an exception, the
8525            initialization is not complete, so it will be tried again
8526            the next time control enters the declaration.
8527
8528          In theory, this process should be thread-safe, too; multiple
8529          threads should not be able to initialize the variable more
8530          than once.  We don't yet attempt to ensure thread-safety.  */
8531
8532       /* Create the guard variable.  */
8533       guard = get_guard (decl);
8534
8535       /* Begin the conditional initialization.  */
8536       if_stmt = begin_if_stmt ();
8537       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8538       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8539
8540       /* Do the initialization itself.  */
8541       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8542           || (init && TREE_CODE (init) == TREE_LIST))
8543         assignment = build_aggr_init (decl, init, 0);
8544       else if (init)
8545         /* The initialization we're doing here is just a bitwise
8546            copy.  */
8547         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8548       else
8549         assignment = NULL_TREE;
8550
8551       /* Once the assignment is complete, set TEMP to 1.  Since the
8552          construction of the static object is complete at this point,
8553          we want to make sure TEMP is set to 1 even if a temporary
8554          constructed during the initialization throws an exception
8555          when it is destroyed.  So, we combine the initialization and
8556          the assignment to TEMP into a single expression, ensuring
8557          that when we call finish_expr_stmt the cleanups will not be
8558          run until after TEMP is set to 1.  */
8559       guard_init = set_guard (guard);
8560       if (assignment)
8561         {
8562           assignment = tree_cons (NULL_TREE, assignment,
8563                                   build_tree_list (NULL_TREE,
8564                                                    guard_init));
8565           assignment = build_compound_expr (assignment);
8566         }
8567       else
8568         assignment = guard_init;
8569       finish_expr_stmt (assignment);
8570
8571       /* Use atexit to register a function for destroying this static
8572          variable.  */
8573       register_dtor_fn (decl);
8574
8575       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8576       finish_then_clause (if_stmt);
8577       finish_if_stmt ();
8578     }
8579   else
8580     static_aggregates = tree_cons (init, decl, static_aggregates);
8581 }
8582
8583 /* Finish the declaration of a catch-parameter.  */
8584
8585 tree
8586 start_handler_parms (declspecs, declarator)
8587      tree declspecs;
8588      tree declarator;
8589 {
8590   tree decl;
8591   if (declspecs)
8592     {
8593       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8594                              1, NULL_TREE);
8595       if (decl == NULL_TREE)
8596         error ("invalid catch parameter");
8597     }
8598   else
8599     decl = NULL_TREE;
8600
8601   return decl;
8602 }
8603
8604 \f
8605 /* Make TYPE a complete type based on INITIAL_VALUE.
8606    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8607    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8608
8609 int
8610 complete_array_type (type, initial_value, do_default)
8611      tree type, initial_value;
8612      int do_default;
8613 {
8614   register tree maxindex = NULL_TREE;
8615   int value = 0;
8616
8617   if (initial_value)
8618     {
8619       /* An array of character type can be initialized from a
8620          brace-enclosed string constant.  */
8621       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8622           && TREE_CODE (initial_value) == CONSTRUCTOR
8623           && CONSTRUCTOR_ELTS (initial_value)
8624           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8625               == STRING_CST)
8626           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8627         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8628
8629       /* Note MAXINDEX is really the maximum index, one less than the
8630          size.  */
8631       if (TREE_CODE (initial_value) == STRING_CST)
8632         {
8633           int eltsize
8634             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8635           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8636                                    / eltsize) - 1, 0);
8637         }
8638       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8639         {
8640           tree elts = CONSTRUCTOR_ELTS (initial_value);
8641
8642           maxindex = ssize_int (-1);
8643           for (; elts; elts = TREE_CHAIN (elts))
8644             {
8645               if (TREE_PURPOSE (elts))
8646                 maxindex = TREE_PURPOSE (elts);
8647               else
8648                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8649             }
8650           maxindex = copy_node (maxindex);
8651         }
8652       else
8653         {
8654           /* Make an error message unless that happened already.  */
8655           if (initial_value != error_mark_node)
8656             value = 1;
8657           else
8658             initial_value = NULL_TREE;
8659
8660           /* Prevent further error messages.  */
8661           maxindex = build_int_2 (0, 0);
8662         }
8663     }
8664
8665   if (!maxindex)
8666     {
8667       if (do_default)
8668         maxindex = build_int_2 (0, 0);
8669       value = 2;
8670     }
8671
8672   if (maxindex)
8673     {
8674       tree itype;
8675       tree domain;
8676
8677       domain = build_index_type (maxindex);
8678       TYPE_DOMAIN (type) = domain;
8679
8680       if (! TREE_TYPE (maxindex))
8681         TREE_TYPE (maxindex) = domain;
8682       if (initial_value)
8683         itype = TREE_TYPE (initial_value);
8684       else
8685         itype = NULL;
8686       if (itype && !TYPE_DOMAIN (itype))
8687         TYPE_DOMAIN (itype) = domain;
8688       /* The type of the main variant should never be used for arrays
8689          of different sizes.  It should only ever be completed with the
8690          size of the array.  */
8691       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8692         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8693     }
8694
8695   /* Lay out the type now that we can get the real answer.  */
8696
8697   layout_type (type);
8698
8699   return value;
8700 }
8701 \f
8702 /* Return zero if something is declared to be a member of type
8703    CTYPE when in the context of CUR_TYPE.  STRING is the error
8704    message to print in that case.  Otherwise, quietly return 1.  */
8705
8706 static int
8707 member_function_or_else (ctype, cur_type, flags)
8708      tree ctype, cur_type;
8709      enum overload_flags flags;
8710 {
8711   if (ctype && ctype != cur_type)
8712     {
8713       if (flags == DTOR_FLAG)
8714         cp_error ("destructor for alien class `%T' cannot be a member",
8715                   ctype);
8716       else
8717         cp_error ("constructor for alien class `%T' cannot be a member",
8718                   ctype);
8719       return 0;
8720     }
8721   return 1;
8722 }
8723 \f
8724 /* Subroutine of `grokdeclarator'.  */
8725
8726 /* Generate errors possibly applicable for a given set of specifiers.
8727    This is for ARM $7.1.2.  */
8728
8729 static void
8730 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8731      tree object;
8732      const char *type;
8733      int virtualp, quals, friendp, raises, inlinep;
8734 {
8735   if (virtualp)
8736     cp_error ("`%D' declared as a `virtual' %s", object, type);
8737   if (inlinep)
8738     cp_error ("`%D' declared as an `inline' %s", object, type);
8739   if (quals)
8740     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8741               object, type);
8742   if (friendp)
8743     cp_error_at ("`%D' declared as a friend", object);
8744   if (raises)
8745     cp_error_at ("`%D' declared with an exception specification", object);
8746 }
8747
8748 /* CTYPE is class type, or null if non-class.
8749    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8750    or METHOD_TYPE.
8751    DECLARATOR is the function's name.
8752    VIRTUALP is truthvalue of whether the function is virtual or not.
8753    FLAGS are to be passed through to `grokclassfn'.
8754    QUALS are qualifiers indicating whether the function is `const'
8755    or `volatile'.
8756    RAISES is a list of exceptions that this function can raise.
8757    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8758    not look, and -1 if we should not call `grokclassfn' at all.
8759
8760    Returns `NULL_TREE' if something goes wrong, after issuing
8761    applicable error messages.  */
8762
8763 static tree
8764 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8765             raises, check, friendp, publicp, inlinep, funcdef_flag,
8766             template_count, in_namespace)
8767      tree ctype, type;
8768      tree declarator;
8769      tree orig_declarator;
8770      int virtualp;
8771      enum overload_flags flags;
8772      tree quals, raises;
8773      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8774      tree in_namespace;
8775 {
8776   tree cname, decl;
8777   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8778   int has_default_arg = 0;
8779   tree t;
8780
8781   if (ctype)
8782     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8783       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8784   else
8785     cname = NULL_TREE;
8786
8787   if (raises)
8788     {
8789       type = build_exception_variant (type, raises);
8790     }
8791
8792   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8793   /* Propagate volatile out from type to decl. */
8794   if (TYPE_VOLATILE (type))
8795     TREE_THIS_VOLATILE (decl) = 1;
8796
8797   /* If this decl has namespace scope, set that up.  */
8798   if (in_namespace)
8799     set_decl_namespace (decl, in_namespace, friendp);
8800   else if (!ctype)
8801     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8802
8803   /* `main' and builtins have implicit 'C' linkage.  */
8804   if ((MAIN_NAME_P (declarator)
8805        || (IDENTIFIER_LENGTH (declarator) > 10
8806            && IDENTIFIER_POINTER (declarator)[0] == '_'
8807            && IDENTIFIER_POINTER (declarator)[1] == '_'
8808            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8809       && current_lang_name == lang_name_cplusplus
8810       && ctype == NULL_TREE
8811       /* NULL_TREE means global namespace.  */
8812       && DECL_CONTEXT (decl) == NULL_TREE)
8813     DECL_LANGUAGE (decl) = lang_c;
8814
8815   /* Should probably propagate const out from type to decl I bet (mrs).  */
8816   if (staticp)
8817     {
8818       DECL_STATIC_FUNCTION_P (decl) = 1;
8819       DECL_CONTEXT (decl) = ctype;
8820     }
8821
8822   if (ctype)
8823     DECL_CONTEXT (decl) = ctype;
8824
8825   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8826     {
8827       if (processing_template_decl)
8828         error ("cannot declare `::main' to be a template");
8829       if (inlinep)
8830         error ("cannot declare `::main' to be inline");
8831       if (!publicp)
8832         error ("cannot declare `::main' to be static");
8833       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8834                         integer_type_node))
8835         error ("`main' must return `int'");
8836       inlinep = 0;
8837       publicp = 1;
8838     }
8839
8840   /* Members of anonymous types and local classes have no linkage; make
8841      them internal.  */
8842   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8843                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8844     publicp = 0;
8845
8846   if (publicp)
8847     {
8848       /* [basic.link]: A name with no linkage (notably, the name of a class
8849          or enumeration declared in a local scope) shall not be used to
8850          declare an entity with linkage.
8851
8852          Only check this for public decls for now.  */
8853       t = no_linkage_check (TREE_TYPE (decl));
8854       if (t)
8855         {
8856           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8857             {
8858               if (DECL_EXTERN_C_P (decl))
8859                 /* Allow this; it's pretty common in C.  */;
8860               else
8861                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8862                             decl);
8863             }
8864           else
8865             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8866                         decl, t);
8867         }
8868     }
8869
8870   TREE_PUBLIC (decl) = publicp;
8871   if (! publicp)
8872     {
8873       DECL_INTERFACE_KNOWN (decl) = 1;
8874       DECL_NOT_REALLY_EXTERN (decl) = 1;
8875     }
8876
8877   if (inlinep)
8878     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8879
8880   DECL_EXTERNAL (decl) = 1;
8881   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8882     {
8883       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8884                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8885       quals = NULL_TREE;
8886     }
8887
8888   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8889     grok_op_properties (decl, virtualp, check < 0);
8890
8891   if (ctype && decl_function_context (decl))
8892     DECL_NO_STATIC_CHAIN (decl) = 1;
8893
8894   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8895     if (TREE_PURPOSE (t)
8896         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8897       {
8898         has_default_arg = 1;
8899         break;
8900       }
8901
8902   if (friendp
8903       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8904     {
8905       if (funcdef_flag)
8906         cp_error
8907           ("defining explicit specialization `%D' in friend declaration",
8908            orig_declarator);
8909       else
8910         {
8911           tree fns = TREE_OPERAND (orig_declarator, 0);
8912           tree args = TREE_OPERAND (orig_declarator, 1);
8913
8914           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8915             {
8916               /* Something like `template <class T> friend void f<T>()'.  */
8917               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8918                         orig_declarator);
8919               return NULL_TREE;
8920             }
8921
8922
8923           /* A friend declaration of the form friend void f<>().  Record
8924              the information in the TEMPLATE_ID_EXPR.  */
8925           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8926
8927           if (TREE_CODE (fns) == COMPONENT_REF)
8928             {
8929               /* Due to bison parser ickiness, we will have already looked
8930                  up an operator_name or PFUNCNAME within the current class
8931                  (see template_id in parse.y). If the current class contains
8932                  such a name, we'll get a COMPONENT_REF here. Undo that. */
8933
8934               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
8935                                   == current_class_type, 20001120);
8936               fns = TREE_OPERAND (fns, 1);
8937             }
8938           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
8939                               || TREE_CODE (fns) == LOOKUP_EXPR
8940                               || TREE_CODE (fns) == OVERLOAD, 20001120);
8941           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
8942
8943           if (has_default_arg)
8944             {
8945               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8946                         decl);
8947               return NULL_TREE;
8948             }
8949
8950           if (inlinep)
8951             {
8952               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8953                         decl);
8954               return NULL_TREE;
8955             }
8956         }
8957     }
8958
8959   if (has_default_arg)
8960     add_defarg_fn (decl);
8961
8962   /* Plain overloading: will not be grok'd by grokclassfn.  */
8963   if (! ctype && ! processing_template_decl
8964       && !DECL_EXTERN_C_P (decl)
8965       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8966     set_mangled_name_for_decl (decl);
8967
8968   if (funcdef_flag)
8969     /* Make the init_value nonzero so pushdecl knows this is not
8970        tentative.  error_mark_node is replaced later with the BLOCK.  */
8971     DECL_INITIAL (decl) = error_mark_node;
8972
8973   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8974     TREE_NOTHROW (decl) = 1;
8975
8976   /* Caller will do the rest of this.  */
8977   if (check < 0)
8978     return decl;
8979
8980   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8981     DECL_CONSTRUCTOR_P (decl) = 1;
8982
8983   /* Function gets the ugly name, field gets the nice one.  This call
8984      may change the type of the function (because of default
8985      parameters)!  */
8986   if (ctype != NULL_TREE)
8987     grokclassfn (ctype, decl, flags, quals);
8988
8989   decl = check_explicit_specialization (orig_declarator, decl,
8990                                         template_count,
8991                                         2 * (funcdef_flag != 0) +
8992                                         4 * (friendp != 0));
8993   if (decl == error_mark_node)
8994     return NULL_TREE;
8995
8996   if (ctype != NULL_TREE
8997       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8998       && check)
8999     {
9000       tree old_decl;
9001
9002       old_decl = check_classfn (ctype, decl);
9003
9004       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9005         /* Because grokfndecl is always supposed to return a
9006            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9007            here.  We depend on our callers to figure out that its
9008            really a template that's being returned.  */
9009         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9010
9011       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9012           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9013         {
9014           /* Remove the `this' parm added by grokclassfn.
9015              XXX Isn't this done in start_function, too?  */
9016           revert_static_member_fn (decl);
9017           last_function_parms = TREE_CHAIN (last_function_parms);
9018         }
9019       if (old_decl && DECL_ARTIFICIAL (old_decl))
9020         cp_error ("definition of implicitly-declared `%D'", old_decl);
9021
9022       if (old_decl)
9023         {
9024           /* Since we've smashed OLD_DECL to its
9025              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9026           if (TREE_CODE (decl) == TEMPLATE_DECL)
9027             decl = DECL_TEMPLATE_RESULT (decl);
9028
9029           /* Attempt to merge the declarations.  This can fail, in
9030              the case of some illegal specialization declarations.  */
9031           if (!duplicate_decls (decl, old_decl))
9032             cp_error ("no `%#D' member function declared in class `%T'",
9033                       decl, ctype);
9034           return old_decl;
9035         }
9036     }
9037
9038   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9039     return NULL_TREE;
9040
9041   if (ctype == NULL_TREE || check)
9042     return decl;
9043
9044   if (virtualp)
9045     DECL_VIRTUAL_P (decl) = 1;
9046
9047   return decl;
9048 }
9049
9050 static tree
9051 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9052      tree type;
9053      tree declarator;
9054      RID_BIT_TYPE *specbits_in;
9055      int initialized;
9056      int constp;
9057      tree in_namespace;
9058 {
9059   tree decl;
9060   RID_BIT_TYPE specbits;
9061
9062   specbits = *specbits_in;
9063
9064   if (TREE_CODE (type) == OFFSET_TYPE)
9065     {
9066       /* If you declare a static member so that it
9067          can be initialized, the code will reach here.  */
9068       tree basetype = TYPE_OFFSET_BASETYPE (type);
9069       type = TREE_TYPE (type);
9070       decl = build_lang_decl (VAR_DECL, declarator, type);
9071       DECL_CONTEXT (decl) = basetype;
9072       /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
9073          templates.  */
9074       if (!uses_template_parms (decl))
9075         {
9076           if (flag_new_abi)
9077             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9078           else
9079             DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype,
9080                                                             declarator);
9081         }
9082     }
9083   else
9084     {
9085       tree context;
9086
9087       if (in_namespace)
9088         context = in_namespace;
9089       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9090         context = current_namespace;
9091       else
9092         context = NULL_TREE;
9093
9094       if (processing_template_decl && context)
9095         /* For global variables, declared in a template, we need the
9096            full lang_decl.  */
9097         decl = build_lang_decl (VAR_DECL, declarator, type);
9098       else
9099         decl = build_decl (VAR_DECL, declarator, type);
9100
9101       if (context)
9102         set_decl_namespace (decl, context, 0);
9103
9104       context = DECL_CONTEXT (decl);
9105       if (declarator && context && current_lang_name != lang_name_c)
9106         {
9107           if (flag_new_abi)
9108             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9109           else
9110             DECL_ASSEMBLER_NAME (decl)
9111               = build_static_name (context, declarator);
9112         }
9113     }
9114
9115   if (in_namespace)
9116     set_decl_namespace (decl, in_namespace, 0);
9117
9118   if (RIDBIT_SETP (RID_EXTERN, specbits))
9119     {
9120       DECL_THIS_EXTERN (decl) = 1;
9121       DECL_EXTERNAL (decl) = !initialized;
9122     }
9123
9124   /* In class context, static means one per class,
9125      public access, and static storage.  */
9126   if (DECL_CLASS_SCOPE_P (decl))
9127     {
9128       TREE_PUBLIC (decl) = 1;
9129       TREE_STATIC (decl) = 1;
9130       DECL_EXTERNAL (decl) = 0;
9131     }
9132   /* At top level, either `static' or no s.c. makes a definition
9133      (perhaps tentative), and absence of `static' makes it public.  */
9134   else if (toplevel_bindings_p ())
9135     {
9136       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9137                             && (DECL_THIS_EXTERN (decl) || ! constp));
9138       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9139     }
9140   /* Not at top level, only `static' makes a static definition.  */
9141   else
9142     {
9143       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9144       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9145     }
9146
9147   if (TREE_PUBLIC (decl))
9148     {
9149       /* [basic.link]: A name with no linkage (notably, the name of a class
9150          or enumeration declared in a local scope) shall not be used to
9151          declare an entity with linkage.
9152
9153          Only check this for public decls for now.  */
9154       tree t = no_linkage_check (TREE_TYPE (decl));
9155       if (t)
9156         {
9157           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9158             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9159           else
9160             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9161                         decl, t);
9162         }
9163     }
9164
9165   return decl;
9166 }
9167
9168 /* Create and return a canonical pointer to member function type, for
9169    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9170
9171 tree
9172 build_ptrmemfunc_type (type)
9173      tree type;
9174 {
9175   tree fields[4];
9176   tree t;
9177   tree u;
9178   tree unqualified_variant = NULL_TREE;
9179
9180   if (type == error_mark_node)
9181     return type;
9182
9183   /* If a canonical type already exists for this type, use it.  We use
9184      this method instead of type_hash_canon, because it only does a
9185      simple equality check on the list of field members.  */
9186
9187   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9188     return t;
9189
9190   /* Make sure that we always have the unqualified pointer-to-member
9191      type first.  */
9192   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9193     unqualified_variant
9194       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9195
9196   t = make_aggr_type (RECORD_TYPE);
9197   /* Let the front-end know this is a pointer to member function...  */
9198   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9199   /* ... and not really an aggregate.  */
9200   SET_IS_AGGR_TYPE (t, 0);
9201
9202   if (!flag_new_abi)
9203     {
9204       u = make_aggr_type (UNION_TYPE);
9205       SET_IS_AGGR_TYPE (u, 0);
9206       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9207       fields[1] = build_decl (FIELD_DECL, delta2_identifier,
9208                               delta_type_node);
9209       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9210       TYPE_NAME (u) = NULL_TREE;
9211
9212       fields[0] = build_decl (FIELD_DECL, delta_identifier,
9213                               delta_type_node);
9214       fields[1] = build_decl (FIELD_DECL, index_identifier,
9215                               delta_type_node);
9216       fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9217       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9218     }
9219   else
9220     {
9221       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9222       fields[1] = build_decl (FIELD_DECL, delta_identifier,
9223                               delta_type_node);
9224       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9225     }
9226
9227   /* Zap out the name so that the back-end will give us the debugging
9228      information for this anonymous RECORD_TYPE.  */
9229   TYPE_NAME (t) = NULL_TREE;
9230
9231   /* If this is not the unqualified form of this pointer-to-member
9232      type, set the TYPE_MAIN_VARIANT for this type to be the
9233      unqualified type.  Since they are actually RECORD_TYPEs that are
9234      not variants of each other, we must do this manually.  */
9235   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9236     {
9237       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9238       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9239       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9240       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9241     }
9242
9243   /* Cache this pointer-to-member type so that we can find it again
9244      later.  */
9245   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9246
9247   /* Seems to be wanted.  */
9248   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9249
9250   return t;
9251 }
9252
9253 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9254    Check to see that the definition is valid.  Issue appropriate error
9255    messages.  Return 1 if the definition is particularly bad, or 0
9256    otherwise.  */
9257
9258 int
9259 check_static_variable_definition (decl, type)
9260      tree decl;
9261      tree type;
9262 {
9263   /* Motion 10 at San Diego: If a static const integral data member is
9264      initialized with an integral constant expression, the initializer
9265      may appear either in the declaration (within the class), or in
9266      the definition, but not both.  If it appears in the class, the
9267      member is a member constant.  The file-scope definition is always
9268      required.  */
9269   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9270     {
9271       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9272                 type);
9273       /* If we just return the declaration, crashes will sometimes
9274          occur.  We therefore return void_type_node, as if this was a
9275          friend declaration, to cause callers to completely ignore
9276          this declaration.  */
9277       return 1;
9278     }
9279   else if (!CP_TYPE_CONST_P (type))
9280     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9281               decl);
9282   else if (pedantic && !INTEGRAL_TYPE_P (type))
9283     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9284
9285   return 0;
9286 }
9287
9288 /* Given the SIZE (i.e., number of elements) in an array, compute an
9289    appropriate index type for the array.  If non-NULL, NAME is the
9290    name of the thing being declared.  */
9291
9292 tree
9293 compute_array_index_type (name, size)
9294      tree name;
9295      tree size;
9296 {
9297   tree itype;
9298
9299   /* The size might be the result of a cast. */
9300   STRIP_TYPE_NOPS (size);
9301
9302   /* It might be a const variable or enumeration constant.  */
9303   size = decl_constant_value (size);
9304
9305   /* If this involves a template parameter, it will be a constant at
9306      instantiation time, but we don't know what the value is yet.
9307      Even if no template parameters are involved, we may an expression
9308      that is not a constant; we don't even simplify `1 + 2' when
9309      processing a template.  */
9310   if (processing_template_decl)
9311     {
9312       /* Resolve a qualified reference to an enumerator or static
9313          const data member of ours.  */
9314       if (TREE_CODE (size) == SCOPE_REF
9315           && TREE_OPERAND (size, 0) == current_class_type)
9316         {
9317           tree t = lookup_field (current_class_type,
9318                                  TREE_OPERAND (size, 1), 0, 0);
9319           if (t)
9320             size = t;
9321         }
9322
9323       return build_index_type (build_min (MINUS_EXPR, sizetype,
9324                                           size, integer_one_node));
9325     }
9326
9327   /* The array bound must be an integer type.  */
9328   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9329       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9330       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9331     {
9332       if (name)
9333         cp_error ("size of array `%D' has non-integer type", name);
9334       else
9335         cp_error ("size of array has non-integer type");
9336       size = integer_one_node;
9337     }
9338
9339   /* Normally, the array-bound will be a constant.  */
9340   if (TREE_CODE (size) == INTEGER_CST)
9341     {
9342       /* Check to see if the array bound overflowed.  Make that an
9343          error, no matter how generous we're being.  */
9344       int old_flag_pedantic_errors = flag_pedantic_errors;
9345       int old_pedantic = pedantic;
9346       pedantic = flag_pedantic_errors = 1;
9347       constant_expression_warning (size);
9348       pedantic = old_pedantic;
9349       flag_pedantic_errors = old_flag_pedantic_errors;
9350
9351       /* An array must have a positive number of elements.  */
9352       if (INT_CST_LT (size, integer_zero_node))
9353         {
9354           if (name)
9355             cp_error ("size of array `%D' is negative", name);
9356           else
9357             cp_error ("size of array is negative");
9358           size = integer_one_node;
9359         }
9360       /* Except that an extension we allow zero-sized arrays.  We
9361          always allow them in system headers because glibc uses
9362          them.  */
9363       else if (integer_zerop (size) && pedantic && !in_system_header)
9364         {
9365           if (name)
9366             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9367           else
9368             cp_pedwarn ("ISO C++ forbids zero-size array");
9369         }
9370     }
9371   else if (TREE_CONSTANT (size))
9372     {
9373       /* `(int) &fn' is not a valid array bound.  */
9374       if (name)
9375         cp_error ("size of array `%D' is not an integral constant-expression",
9376                   name);
9377       else
9378         cp_error ("size of array is not an integral constant-expression");
9379     }
9380
9381   /* Compute the index of the largest element in the array.  It is
9382      one less than the number of elements in the array.  */
9383   itype
9384     = fold (cp_build_binary_op (MINUS_EXPR,
9385                                 cp_convert (ssizetype, size),
9386                                 cp_convert (ssizetype,
9387                                             integer_one_node)));
9388
9389   /* Check for variable-sized arrays.  We allow such things as an
9390      extension, even though they are not allowed in ANSI/ISO C++.  */
9391   if (!TREE_CONSTANT (itype))
9392     {
9393       if (pedantic)
9394         {
9395           if (name)
9396             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9397                         name);
9398           else
9399             cp_pedwarn ("ISO C++ forbids variable-size array");
9400         }
9401
9402       /* Create a variable-sized array index type.  */
9403       itype = variable_size (itype);
9404     }
9405   /* Make sure that there was no overflow when creating to a signed
9406      index type.  (For example, on a 32-bit machine, an array with
9407      size 2^32 - 1 is too big.)  */
9408   else if (TREE_OVERFLOW (itype))
9409     {
9410       error ("overflow in array dimension");
9411       TREE_OVERFLOW (itype) = 0;
9412     }
9413
9414   /* Create and return the appropriate index type.  */
9415   return build_index_type (itype);
9416 }
9417
9418 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9419    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9420    with this type.  */
9421
9422 static tree
9423 create_array_type_for_decl (name, type, size)
9424      tree name;
9425      tree type;
9426      tree size;
9427 {
9428   tree itype = NULL_TREE;
9429   const char* error_msg;
9430
9431   /* If things have already gone awry, bail now.  */
9432   if (type == error_mark_node || size == error_mark_node)
9433     return error_mark_node;
9434
9435   /* Assume that everything will go OK.  */
9436   error_msg = NULL;
9437
9438   /* There are some types which cannot be array elements.  */
9439   switch (TREE_CODE (type))
9440     {
9441     case VOID_TYPE:
9442       error_msg = "array of void";
9443       break;
9444
9445     case FUNCTION_TYPE:
9446       error_msg = "array of functions";
9447       break;
9448
9449     case REFERENCE_TYPE:
9450       error_msg = "array of references";
9451       break;
9452
9453     case OFFSET_TYPE:
9454       error_msg = "array of data members";
9455       break;
9456
9457     case METHOD_TYPE:
9458       error_msg = "array of function members";
9459       break;
9460
9461     default:
9462       break;
9463     }
9464
9465   /* If something went wrong, issue an error-message and return.  */
9466   if (error_msg)
9467     {
9468       if (name)
9469         cp_error ("declaration of `%D' as %s", name, error_msg);
9470       else
9471         cp_error ("creating %s", error_msg);
9472
9473       return error_mark_node;
9474     }
9475
9476   /* [dcl.array]
9477
9478      The constant expressions that specify the bounds of the arrays
9479      can be omitted only for the first member of the sequence.  */
9480   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9481     {
9482       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9483                 name);
9484
9485       return error_mark_node;
9486     }
9487
9488   /* Figure out the index type for the array.  */
9489   if (size)
9490     itype = compute_array_index_type (name, size);
9491
9492   return build_cplus_array_type (type, itype);
9493 }
9494
9495 /* Check that it's OK to declare a function with the indicated TYPE.
9496    SFK indicates the kind of special function (if any) that this
9497    function is.  CTYPE is the class of which this function is a
9498    member.  OPTYPE is the type given in a conversion operator
9499    declaration.  Returns the actual return type of the function; that
9500    may be different than TYPE if an error occurs, or for certain
9501    special functions.  */
9502
9503 static tree
9504 check_special_function_return_type (sfk, type, ctype, optype)
9505      special_function_kind sfk;
9506      tree type;
9507      tree ctype;
9508      tree optype;
9509 {
9510   switch (sfk)
9511     {
9512     case sfk_constructor:
9513       if (type)
9514         cp_error ("return type specification for constructor invalid");
9515
9516       /* In the old ABI, we return `this'; in the new ABI we don't
9517          bother.  */
9518       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9519       break;
9520
9521     case sfk_destructor:
9522       if (type)
9523         cp_error ("return type specification for destructor invalid");
9524       type = void_type_node;
9525       break;
9526
9527     case sfk_conversion:
9528       if (type && !same_type_p (type, optype))
9529         cp_error ("operator `%T' declared to return `%T'", optype, type);
9530       else if (type)
9531         cp_pedwarn ("return type specified for `operator %T'",  optype);
9532       type = optype;
9533       break;
9534
9535     default:
9536       my_friendly_abort (20000408);
9537       break;
9538     }
9539
9540   return type;
9541 }
9542
9543 /* Given declspecs and a declarator,
9544    determine the name and type of the object declared
9545    and construct a ..._DECL node for it.
9546    (In one case we can return a ..._TYPE node instead.
9547     For invalid input we sometimes return 0.)
9548
9549    DECLSPECS is a chain of tree_list nodes whose value fields
9550     are the storage classes and type specifiers.
9551
9552    DECL_CONTEXT says which syntactic context this declaration is in:
9553      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9554      FUNCDEF for a function definition.  Like NORMAL but a few different
9555       error messages in each case.  Return value may be zero meaning
9556       this definition is too screwy to try to parse.
9557      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9558       handle member functions (which have FIELD context).
9559       Return value may be zero meaning this definition is too screwy to
9560       try to parse.
9561      PARM for a parameter declaration (either within a function prototype
9562       or before a function body).  Make a PARM_DECL, or return void_type_node.
9563      CATCHPARM for a parameter declaration before a catch clause.
9564      TYPENAME if for a typename (in a cast or sizeof).
9565       Don't make a DECL node; just return the ..._TYPE node.
9566      FIELD for a struct or union field; make a FIELD_DECL.
9567      BITFIELD for a field with specified width.
9568    INITIALIZED is 1 if the decl has an initializer.
9569
9570    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9571    normal attributes in TREE_PURPOSE, or NULL_TREE.
9572
9573    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9574    It may also be so in the PARM case, for a prototype where the
9575    argument type is specified but not the name.
9576
9577    This function is where the complicated C meanings of `static'
9578    and `extern' are interpreted.
9579
9580    For C++, if there is any monkey business to do, the function which
9581    calls this one must do it, i.e., prepending instance variables,
9582    renaming overloaded function names, etc.
9583
9584    Note that for this C++, it is an error to define a method within a class
9585    which does not belong to that class.
9586
9587    Except in the case where SCOPE_REFs are implicitly known (such as
9588    methods within a class being redundantly qualified),
9589    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9590    (class_name::decl_name).  The caller must also deal with this.
9591
9592    If a constructor or destructor is seen, and the context is FIELD,
9593    then the type gains the attribute TREE_HAS_x.  If such a declaration
9594    is erroneous, NULL_TREE is returned.
9595
9596    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9597    function, these are the qualifiers to give to the `this' pointer. We
9598    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9599
9600    May return void_type_node if the declarator turned out to be a friend.
9601    See grokfield for details.  */
9602
9603 tree
9604 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9605      tree declspecs;
9606      tree declarator;
9607      enum decl_context decl_context;
9608      int initialized;
9609      tree attrlist;
9610 {
9611   RID_BIT_TYPE specbits;
9612   int nclasses = 0;
9613   tree spec;
9614   tree type = NULL_TREE;
9615   int longlong = 0;
9616   int constp;
9617   int restrictp;
9618   int volatilep;
9619   int type_quals;
9620   int virtualp, explicitp, friendp, inlinep, staticp;
9621   int explicit_int = 0;
9622   int explicit_char = 0;
9623   int defaulted_int = 0;
9624   tree typedef_decl = NULL_TREE;
9625   const char *name;
9626   tree typedef_type = NULL_TREE;
9627   int funcdef_flag = 0;
9628   enum tree_code innermost_code = ERROR_MARK;
9629   int bitfield = 0;
9630 #if 0
9631   /* See the code below that used this.  */
9632   tree decl_machine_attr = NULL_TREE;
9633 #endif
9634   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9635      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9636   tree init = NULL_TREE;
9637
9638   /* Keep track of what sort of function is being processed
9639      so that we can warn about default return values, or explicit
9640      return values which do not match prescribed defaults.  */
9641   special_function_kind sfk = sfk_none;
9642
9643   tree dname = NULL_TREE;
9644   tree ctype = current_class_type;
9645   tree ctor_return_type = NULL_TREE;
9646   enum overload_flags flags = NO_SPECIAL;
9647   tree quals = NULL_TREE;
9648   tree raises = NULL_TREE;
9649   int template_count = 0;
9650   tree in_namespace = NULL_TREE;
9651   tree inner_attrs;
9652   int ignore_attrs;
9653
9654   RIDBIT_RESET_ALL (specbits);
9655   if (decl_context == FUNCDEF)
9656     funcdef_flag = 1, decl_context = NORMAL;
9657   else if (decl_context == MEMFUNCDEF)
9658     funcdef_flag = -1, decl_context = FIELD;
9659   else if (decl_context == BITFIELD)
9660     bitfield = 1, decl_context = FIELD;
9661
9662   /* Look inside a declarator for the name being declared
9663      and get it as a string, for an error message.  */
9664   {
9665     tree *next = &declarator;
9666     register tree decl;
9667     name = NULL;
9668
9669     while (next && *next)
9670       {
9671         decl = *next;
9672         switch (TREE_CODE (decl))
9673           {
9674           case TREE_LIST:
9675             /* For attributes.  */
9676             next = &TREE_VALUE (decl);
9677             break;
9678
9679           case COND_EXPR:
9680             ctype = NULL_TREE;
9681             next = &TREE_OPERAND (decl, 0);
9682             break;
9683
9684           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9685             {
9686               tree name = TREE_OPERAND (decl, 0);
9687               tree rename = NULL_TREE;
9688
9689               my_friendly_assert (flags == NO_SPECIAL, 152);
9690               flags = DTOR_FLAG;
9691               sfk = sfk_destructor;
9692               if (TREE_CODE (name) == TYPE_DECL)
9693                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9694               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9695               if (ctype == NULL_TREE)
9696                 {
9697                   if (current_class_type == NULL_TREE)
9698                     {
9699                       error ("destructors must be member functions");
9700                       flags = NO_SPECIAL;
9701                     }
9702                   else
9703                     {
9704                       tree t = constructor_name (current_class_name);
9705                       if (t != name)
9706                         rename = t;
9707                     }
9708                 }
9709               else
9710                 {
9711                   tree t = constructor_name (ctype);
9712                   if (t != name)
9713                     rename = t;
9714                 }
9715
9716               if (rename)
9717                 {
9718                   cp_error ("destructor `%T' must match class name `%T'",
9719                             name, rename);
9720                   TREE_OPERAND (decl, 0) = rename;
9721                 }
9722               next = &name;
9723             }
9724             break;
9725
9726           case ADDR_EXPR:       /* C++ reference declaration */
9727             /* Fall through. */
9728           case ARRAY_REF:
9729           case INDIRECT_REF:
9730             ctype = NULL_TREE;
9731             innermost_code = TREE_CODE (decl);
9732             next = &TREE_OPERAND (decl, 0);
9733             break;
9734
9735           case CALL_EXPR:
9736             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9737               {
9738                 /* This is actually a variable declaration using
9739                    constructor syntax.  We need to call start_decl and
9740                    cp_finish_decl so we can get the variable
9741                    initialized...  */
9742
9743                 tree attributes, prefix_attributes;
9744
9745                 *next = TREE_OPERAND (decl, 0);
9746                 init = CALL_DECLARATOR_PARMS (decl);
9747
9748                 if (attrlist)
9749                   {
9750                     attributes = TREE_PURPOSE (attrlist);
9751                     prefix_attributes = TREE_VALUE (attrlist);
9752                   }
9753                 else
9754                   {
9755                     attributes = NULL_TREE;
9756                     prefix_attributes = NULL_TREE;
9757                   }
9758
9759                 decl = start_decl (declarator, declspecs, 1,
9760                                    attributes, prefix_attributes);
9761                 decl_type_access_control (decl);
9762                 if (decl)
9763                   {
9764                     /* Look for __unused__ attribute */
9765                     if (TREE_USED (TREE_TYPE (decl)))
9766                       TREE_USED (decl) = 1;
9767                     finish_decl (decl, init, NULL_TREE);
9768                   }
9769                 else
9770                   cp_error ("invalid declarator");
9771                 return 0;
9772               }
9773             innermost_code = TREE_CODE (decl);
9774             if (decl_context == FIELD && ctype == NULL_TREE)
9775               ctype = current_class_type;
9776             if (ctype
9777                 && TREE_OPERAND (decl, 0)
9778                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9779                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9780                          == constructor_name_full (ctype))
9781                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9782                             == constructor_name (ctype)))))
9783               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9784             next = &TREE_OPERAND (decl, 0);
9785             decl = *next;
9786             if (ctype != NULL_TREE
9787                 && decl != NULL_TREE && flags != DTOR_FLAG
9788                 && decl == constructor_name (ctype))
9789               {
9790                 sfk = sfk_constructor;
9791                 ctor_return_type = ctype;
9792               }
9793             ctype = NULL_TREE;
9794             break;
9795
9796           case TEMPLATE_ID_EXPR:
9797               {
9798                 tree fns = TREE_OPERAND (decl, 0);
9799
9800                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9801                   fns = TREE_OPERAND (fns, 0);
9802
9803                 dname = fns;
9804                 if (TREE_CODE (dname) == COMPONENT_REF)
9805                   dname = TREE_OPERAND (dname, 1);
9806                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9807                   {
9808                     my_friendly_assert (is_overloaded_fn (dname),
9809                                         19990331);
9810                     dname = DECL_NAME (get_first_fn (dname));
9811                   }
9812               }
9813           /* Fall through. */
9814
9815           case IDENTIFIER_NODE:
9816             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9817               dname = decl;
9818
9819             next = 0;
9820
9821             if (C_IS_RESERVED_WORD (dname))
9822               {
9823                 cp_error ("declarator-id missing; using reserved word `%D'",
9824                           dname);
9825                 name = IDENTIFIER_POINTER (dname);
9826               }
9827             else if (!IDENTIFIER_TYPENAME_P (dname))
9828               name = IDENTIFIER_POINTER (dname);
9829             else
9830               {
9831                 my_friendly_assert (flags == NO_SPECIAL, 154);
9832                 flags = TYPENAME_FLAG;
9833                 ctor_return_type = TREE_TYPE (dname);
9834                 sfk = sfk_conversion;
9835                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9836                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9837                         == TYPE_DECL))
9838                   name = IDENTIFIER_POINTER (dname);
9839                 else
9840                   name = "<invalid operator>";
9841               }
9842             break;
9843
9844             /* C++ extension */
9845           case SCOPE_REF:
9846             {
9847               /* Perform error checking, and decide on a ctype.  */
9848               tree cname = TREE_OPERAND (decl, 0);
9849               if (cname == NULL_TREE)
9850                 ctype = NULL_TREE;
9851               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9852                 {
9853                   ctype = NULL_TREE;
9854                   in_namespace = TREE_OPERAND (decl, 0);
9855                   TREE_OPERAND (decl, 0) = NULL_TREE;
9856                 }
9857               else if (! is_aggr_type (cname, 1))
9858                 TREE_OPERAND (decl, 0) = NULL_TREE;
9859               /* Must test TREE_OPERAND (decl, 1), in case user gives
9860                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9861               else if (TREE_OPERAND (decl, 1)
9862                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9863                 ctype = cname;
9864               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9865                        || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9866                 {
9867                   cp_error ("`%T::%D' is not a valid declarator", cname,
9868                             TREE_OPERAND (decl, 1));
9869                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9870                             cname, TREE_OPERAND (decl, 1));
9871                   return void_type_node;
9872                 }
9873               else if (ctype == NULL_TREE)
9874                 ctype = cname;
9875               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9876                 TREE_OPERAND (decl, 0) = ctype;
9877               else
9878                 {
9879                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9880                     {
9881                       cp_error ("type `%T' is not derived from type `%T'",
9882                                 cname, ctype);
9883                       TREE_OPERAND (decl, 0) = NULL_TREE;
9884                     }
9885                   else
9886                     ctype = cname;
9887                 }
9888
9889               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9890                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9891                        == constructor_name_full (ctype))
9892                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9893                           == constructor_name (ctype))))
9894                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9895               next = &TREE_OPERAND (decl, 1);
9896               decl = *next;
9897               if (ctype)
9898                 {
9899                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9900                       && constructor_name (ctype) == decl)
9901                     {
9902                       sfk = sfk_constructor;
9903                       ctor_return_type = ctype;
9904                     }
9905                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9906                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9907                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9908                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9909                     {
9910                       sfk = sfk_destructor;
9911                       ctor_return_type = ctype;
9912                       flags = DTOR_FLAG;
9913                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9914                       next = &TREE_OPERAND (decl, 0);
9915                     }
9916                 }
9917             }
9918             break;
9919
9920           case ERROR_MARK:
9921             next = 0;
9922             break;
9923
9924           case TYPE_DECL:
9925             /* Parse error puts this typespec where
9926                a declarator should go.  */
9927             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9928             if (TREE_TYPE (decl) == current_class_type)
9929               cp_error ("  perhaps you want `%T' for a constructor",
9930                         current_class_name);
9931             dname = DECL_NAME (decl);
9932             name = IDENTIFIER_POINTER (dname);
9933
9934             /* Avoid giving two errors for this.  */
9935             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9936
9937             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9938             *next = dname;
9939             next = 0;
9940             break;
9941
9942           default:
9943             cp_compiler_error ("`%D' as declarator", decl);
9944             return 0; /* We used to do a 155 abort here.  */
9945           }
9946       }
9947   }
9948
9949   /* A function definition's declarator must have the form of
9950      a function declarator.  */
9951
9952   if (funcdef_flag && innermost_code != CALL_EXPR)
9953     return 0;
9954
9955   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9956       && innermost_code != CALL_EXPR
9957       && ! (ctype && declspecs == NULL_TREE))
9958     {
9959       cp_error ("declaration of `%D' as non-function", dname);
9960       return void_type_node;
9961     }
9962
9963   /* Anything declared one level down from the top level
9964      must be one of the parameters of a function
9965      (because the body is at least two levels down).  */
9966
9967   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9968      by not allowing C++ class definitions to specify their parameters
9969      with xdecls (must be spec.d in the parmlist).
9970
9971      Since we now wait to push a class scope until we are sure that
9972      we are in a legitimate method context, we must set oldcname
9973      explicitly (since current_class_name is not yet alive).
9974
9975      We also want to avoid calling this a PARM if it is in a namespace.  */
9976
9977   if (decl_context == NORMAL && !toplevel_bindings_p ())
9978     {
9979       struct binding_level *b = current_binding_level;
9980       current_binding_level = b->level_chain;
9981       if (current_binding_level != 0 && toplevel_bindings_p ())
9982         decl_context = PARM;
9983       current_binding_level = b;
9984     }
9985
9986   if (name == NULL)
9987     name = decl_context == PARM ? "parameter" : "type name";
9988
9989   /* Look through the decl specs and record which ones appear.
9990      Some typespecs are defined as built-in typenames.
9991      Others, the ones that are modifiers of other types,
9992      are represented by bits in SPECBITS: set the bits for
9993      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9994
9995      If there is a typedef name or a type, store the type in TYPE.
9996      This includes builtin typedefs such as `int'.
9997
9998      Set EXPLICIT_INT if the type is `int' or `char' and did not
9999      come from a user typedef.
10000
10001      Set LONGLONG if `long' is mentioned twice.
10002
10003      For C++, constructors and destructors have their own fast treatment.  */
10004
10005   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10006     {
10007       register int i;
10008       register tree id;
10009
10010       /* Certain parse errors slip through.  For example,
10011          `int class;' is not caught by the parser. Try
10012          weakly to recover here.  */
10013       if (TREE_CODE (spec) != TREE_LIST)
10014         return 0;
10015
10016       id = TREE_VALUE (spec);
10017
10018       if (TREE_CODE (id) == IDENTIFIER_NODE)
10019         {
10020           if (id == ridpointers[(int) RID_INT]
10021               || id == ridpointers[(int) RID_CHAR]
10022               || id == ridpointers[(int) RID_BOOL]
10023               || id == ridpointers[(int) RID_WCHAR])
10024             {
10025               if (type)
10026                 {
10027                   if (id == ridpointers[(int) RID_BOOL])
10028                     error ("`bool' is now a keyword");
10029                   else
10030                     cp_error ("extraneous `%T' ignored", id);
10031                 }
10032               else
10033                 {
10034                   if (id == ridpointers[(int) RID_INT])
10035                     explicit_int = 1;
10036                   else if (id == ridpointers[(int) RID_CHAR])
10037                     explicit_char = 1;
10038                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10039                 }
10040               goto found;
10041             }
10042           /* C++ aggregate types.  */
10043           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10044             {
10045               if (type)
10046                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10047               else
10048                 type = IDENTIFIER_TYPE_VALUE (id);
10049               goto found;
10050             }
10051
10052           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10053             {
10054               if (ridpointers[i] == id)
10055                 {
10056                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10057                     {
10058                       if (pedantic && ! in_system_header && warn_long_long)
10059                         pedwarn ("ISO C++ does not support `long long'");
10060                       if (longlong)
10061                         error ("`long long long' is too long for GCC");
10062                       else
10063                         longlong = 1;
10064                     }
10065                   else if (RIDBIT_SETP (i, specbits))
10066                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10067                   RIDBIT_SET (i, specbits);
10068                   goto found;
10069                 }
10070             }
10071         }
10072       /* C++ aggregate types.  */
10073       else if (TREE_CODE (id) == TYPE_DECL)
10074         {
10075           if (type)
10076             cp_error ("multiple declarations `%T' and `%T'", type,
10077                       TREE_TYPE (id));
10078           else
10079             {
10080               type = TREE_TYPE (id);
10081               TREE_VALUE (spec) = type;
10082             }
10083           goto found;
10084         }
10085       if (type)
10086         error ("two or more data types in declaration of `%s'", name);
10087       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10088         {
10089           register tree t = lookup_name (id, 1);
10090           if (!t || TREE_CODE (t) != TYPE_DECL)
10091             error ("`%s' fails to be a typedef or built in type",
10092                    IDENTIFIER_POINTER (id));
10093           else
10094             {
10095               type = TREE_TYPE (t);
10096 #if 0
10097               /* See the code below that used this.  */
10098               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10099 #endif
10100               typedef_decl = t;
10101             }
10102         }
10103       else if (id != error_mark_node)
10104         /* Can't change CLASS nodes into RECORD nodes here!  */
10105         type = id;
10106
10107     found: ;
10108     }
10109
10110   typedef_type = type;
10111
10112   /* No type at all: default to `int', and set DEFAULTED_INT
10113      because it was not a user-defined typedef.  */
10114
10115   if (type == NULL_TREE
10116       && (RIDBIT_SETP (RID_SIGNED, specbits)
10117           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10118           || RIDBIT_SETP (RID_LONG, specbits)
10119           || RIDBIT_SETP (RID_SHORT, specbits)))
10120     {
10121       /* These imply 'int'.  */
10122       type = integer_type_node;
10123       defaulted_int = 1;
10124     }
10125
10126   if (sfk != sfk_none)
10127     type = check_special_function_return_type (sfk, type,
10128                                                ctor_return_type,
10129                                                ctor_return_type);
10130   else if (type == NULL_TREE)
10131     {
10132       int is_main;
10133
10134       explicit_int = -1;
10135
10136           /* We handle `main' specially here, because 'main () { }' is so
10137              common.  With no options, it is allowed.  With -Wreturn-type,
10138              it is a warning.  It is only an error with -pedantic-errors.  */
10139       is_main = (funcdef_flag
10140                  && MAIN_NAME_P (dname)
10141                  && ctype == NULL_TREE
10142                  && in_namespace == NULL_TREE
10143                  && current_namespace == global_namespace);
10144
10145       if (in_system_header || flag_ms_extensions)
10146         /* Allow it, sigh.  */;
10147       else if (pedantic || ! is_main)
10148         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10149                     name);
10150       else if (warn_return_type)
10151         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10152                     name);
10153
10154       type = integer_type_node;
10155     }
10156
10157   ctype = NULL_TREE;
10158
10159   /* Now process the modifiers that were specified
10160      and check for invalid combinations.  */
10161
10162   /* Long double is a special combination.  */
10163
10164   if (RIDBIT_SETP (RID_LONG, specbits)
10165       && TYPE_MAIN_VARIANT (type) == double_type_node)
10166     {
10167       RIDBIT_RESET (RID_LONG, specbits);
10168       type = build_qualified_type (long_double_type_node,
10169                                    CP_TYPE_QUALS (type));
10170     }
10171
10172   /* Check all other uses of type modifiers.  */
10173
10174   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10175       || RIDBIT_SETP (RID_SIGNED, specbits)
10176       || RIDBIT_SETP (RID_LONG, specbits)
10177       || RIDBIT_SETP (RID_SHORT, specbits))
10178     {
10179       int ok = 0;
10180
10181       if (TREE_CODE (type) == REAL_TYPE)
10182         error ("short, signed or unsigned invalid for `%s'", name);
10183       else if (TREE_CODE (type) != INTEGER_TYPE)
10184         error ("long, short, signed or unsigned invalid for `%s'", name);
10185       else if (RIDBIT_SETP (RID_LONG, specbits)
10186                && RIDBIT_SETP (RID_SHORT, specbits))
10187         error ("long and short specified together for `%s'", name);
10188       else if ((RIDBIT_SETP (RID_LONG, specbits)
10189                 || RIDBIT_SETP (RID_SHORT, specbits))
10190                && explicit_char)
10191         error ("long or short specified with char for `%s'", name);
10192       else if ((RIDBIT_SETP (RID_LONG, specbits)
10193                 || RIDBIT_SETP (RID_SHORT, specbits))
10194                && TREE_CODE (type) == REAL_TYPE)
10195         error ("long or short specified with floating type for `%s'", name);
10196       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10197                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10198         error ("signed and unsigned given together for `%s'", name);
10199       else
10200         {
10201           ok = 1;
10202           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10203             {
10204               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10205                        name);
10206               if (flag_pedantic_errors)
10207                 ok = 0;
10208             }
10209         }
10210
10211       /* Discard the type modifiers if they are invalid.  */
10212       if (! ok)
10213         {
10214           RIDBIT_RESET (RID_UNSIGNED, specbits);
10215           RIDBIT_RESET (RID_SIGNED, specbits);
10216           RIDBIT_RESET (RID_LONG, specbits);
10217           RIDBIT_RESET (RID_SHORT, specbits);
10218           longlong = 0;
10219         }
10220     }
10221
10222   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10223       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10224     {
10225       error ("complex invalid for `%s'", name);
10226       RIDBIT_RESET (RID_COMPLEX, specbits);
10227     }
10228
10229   /* Decide whether an integer type is signed or not.
10230      Optionally treat bitfields as signed by default.  */
10231   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10232       /* [class.bit]
10233
10234          It is implementation-defined whether a plain (neither
10235          explicitly signed or unsigned) char, short, int, or long
10236          bit-field is signed or unsigned.
10237
10238          Naturally, we extend this to long long as well.  Note that
10239          this does not include wchar_t.  */
10240       || (bitfield && !flag_signed_bitfields
10241           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10242           /* A typedef for plain `int' without `signed' can be
10243              controlled just like plain `int', but a typedef for
10244              `signed int' cannot be so controlled.  */
10245           && !(typedef_decl
10246                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10247           && (TREE_CODE (type) == INTEGER_TYPE
10248               || TREE_CODE (type) == CHAR_TYPE)
10249           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10250     {
10251       if (longlong)
10252         type = long_long_unsigned_type_node;
10253       else if (RIDBIT_SETP (RID_LONG, specbits))
10254         type = long_unsigned_type_node;
10255       else if (RIDBIT_SETP (RID_SHORT, specbits))
10256         type = short_unsigned_type_node;
10257       else if (type == char_type_node)
10258         type = unsigned_char_type_node;
10259       else if (typedef_decl)
10260         type = unsigned_type (type);
10261       else
10262         type = unsigned_type_node;
10263     }
10264   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10265            && type == char_type_node)
10266     type = signed_char_type_node;
10267   else if (longlong)
10268     type = long_long_integer_type_node;
10269   else if (RIDBIT_SETP (RID_LONG, specbits))
10270     type = long_integer_type_node;
10271   else if (RIDBIT_SETP (RID_SHORT, specbits))
10272     type = short_integer_type_node;
10273
10274   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10275     {
10276       /* If we just have "complex", it is equivalent to
10277          "complex double", but if any modifiers at all are specified it is
10278          the complex form of TYPE.  E.g, "complex short" is
10279          "complex short int".  */
10280
10281       if (defaulted_int && ! longlong
10282           && ! (RIDBIT_SETP (RID_LONG, specbits)
10283                 || RIDBIT_SETP (RID_SHORT, specbits)
10284                 || RIDBIT_SETP (RID_SIGNED, specbits)
10285                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10286         type = complex_double_type_node;
10287       else if (type == integer_type_node)
10288         type = complex_integer_type_node;
10289       else if (type == float_type_node)
10290         type = complex_float_type_node;
10291       else if (type == double_type_node)
10292         type = complex_double_type_node;
10293       else if (type == long_double_type_node)
10294         type = complex_long_double_type_node;
10295       else
10296         type = build_complex_type (type);
10297     }
10298
10299   if (sfk == sfk_conversion
10300       && (RIDBIT_SETP (RID_CONST, specbits)
10301           || RIDBIT_SETP (RID_VOLATILE, specbits)
10302           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10303     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10304               ctor_return_type);
10305
10306   /* Set CONSTP if this declaration is `const', whether by
10307      explicit specification or via a typedef.
10308      Likewise for VOLATILEP.  */
10309
10310   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10311   restrictp =
10312     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10313   volatilep =
10314     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10315   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10316                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10317                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10318   type = cp_build_qualified_type (type, type_quals);
10319   staticp = 0;
10320   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10321   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10322   RIDBIT_RESET (RID_VIRTUAL, specbits);
10323   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10324   RIDBIT_RESET (RID_EXPLICIT, specbits);
10325
10326   if (RIDBIT_SETP (RID_STATIC, specbits))
10327     staticp = 1 + (decl_context == FIELD);
10328
10329   if (virtualp && staticp == 2)
10330     {
10331       cp_error ("member `%D' cannot be declared both virtual and static",
10332                 dname);
10333       staticp = 0;
10334     }
10335   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10336   RIDBIT_RESET (RID_FRIEND, specbits);
10337
10338   /* Warn if two storage classes are given. Default to `auto'.  */
10339
10340   if (RIDBIT_ANY_SET (specbits))
10341     {
10342       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10343       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10344       if (decl_context == PARM && nclasses > 0)
10345         error ("storage class specifiers invalid in parameter declarations");
10346       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10347         {
10348           if (decl_context == PARM)
10349             error ("typedef declaration invalid in parameter declaration");
10350           nclasses++;
10351         }
10352       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10353       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10354     }
10355
10356   /* Give error if `virtual' is used outside of class declaration.  */
10357   if (virtualp
10358       && (current_class_name == NULL_TREE || decl_context != FIELD))
10359     {
10360       error ("virtual outside class declaration");
10361       virtualp = 0;
10362     }
10363
10364   /* Static anonymous unions are dealt with here.  */
10365   if (staticp && decl_context == TYPENAME
10366       && TREE_CODE (declspecs) == TREE_LIST
10367       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10368     decl_context = FIELD;
10369
10370   /* Warn about storage classes that are invalid for certain
10371      kinds of declarations (parameters, typenames, etc.).  */
10372
10373   if (nclasses > 1)
10374     error ("multiple storage classes in declaration of `%s'", name);
10375   else if (decl_context != NORMAL && nclasses > 0)
10376     {
10377       if ((decl_context == PARM || decl_context == CATCHPARM)
10378           && (RIDBIT_SETP (RID_REGISTER, specbits)
10379               || RIDBIT_SETP (RID_AUTO, specbits)))
10380         ;
10381       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10382         ;
10383       else if (decl_context == FIELD
10384                /* C++ allows static class elements  */
10385                && RIDBIT_SETP (RID_STATIC, specbits))
10386         /* C++ also allows inlines and signed and unsigned elements,
10387            but in those cases we don't come in here.  */
10388         ;
10389       else
10390         {
10391           if (decl_context == FIELD)
10392             {
10393               tree tmp = NULL_TREE;
10394               register int op = 0;
10395
10396               if (declarator)
10397                 {
10398                   /* Avoid trying to get an operand off an identifier node.  */
10399                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10400                     tmp = declarator;
10401                   else
10402                     tmp = TREE_OPERAND (declarator, 0);
10403                   op = IDENTIFIER_OPNAME_P (tmp);
10404                   if (IDENTIFIER_TYPENAME_P (tmp))
10405                     {
10406                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10407                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10408                               == TYPE_DECL))
10409                         name = IDENTIFIER_POINTER (tmp);
10410                       else
10411                         name = "<invalid operator>";
10412                     }
10413                 }
10414               error ("storage class specified for %s `%s'",
10415                      op ? "member operator" : "field",
10416                      name);
10417             }
10418           else
10419             {
10420               if (decl_context == PARM || decl_context == CATCHPARM)
10421                 error ("storage class specified for parameter `%s'", name);
10422               else
10423                 error ("storage class specified for typename");
10424             }
10425           RIDBIT_RESET (RID_REGISTER, specbits);
10426           RIDBIT_RESET (RID_AUTO, specbits);
10427           RIDBIT_RESET (RID_EXTERN, specbits);
10428         }
10429     }
10430   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10431     {
10432       if (toplevel_bindings_p ())
10433         {
10434           /* It's common practice (and completely valid) to have a const
10435              be initialized and declared extern.  */
10436           if (!(type_quals & TYPE_QUAL_CONST))
10437             warning ("`%s' initialized and declared `extern'", name);
10438         }
10439       else
10440         error ("`%s' has both `extern' and initializer", name);
10441     }
10442   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10443            && ! toplevel_bindings_p ())
10444     error ("nested function `%s' declared `extern'", name);
10445   else if (toplevel_bindings_p ())
10446     {
10447       if (RIDBIT_SETP (RID_AUTO, specbits))
10448         error ("top-level declaration of `%s' specifies `auto'", name);
10449     }
10450
10451   if (nclasses > 0 && friendp)
10452     error ("storage class specifiers invalid in friend function declarations");
10453
10454   /* Now figure out the structure of the declarator proper.
10455      Descend through it, creating more complex types, until we reach
10456      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10457
10458   inner_attrs = NULL_TREE;
10459   ignore_attrs = 0;
10460
10461   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10462          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10463     {
10464       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10465          an INDIRECT_REF (for *...),
10466          a CALL_EXPR (for ...(...)),
10467          an identifier (for the name being declared)
10468          or a null pointer (for the place in an absolute declarator
10469          where the name was omitted).
10470          For the last two cases, we have just exited the loop.
10471
10472          For C++ it could also be
10473          a SCOPE_REF (for class :: ...).  In this case, we have converted
10474          sensible names to types, and those are the values we use to
10475          qualify the member name.
10476          an ADDR_EXPR (for &...),
10477          a BIT_NOT_EXPR (for destructors)
10478
10479          At this point, TYPE is the type of elements of an array,
10480          or for a function to return, or for a pointer to point to.
10481          After this sequence of ifs, TYPE is the type of the
10482          array or function or pointer, and DECLARATOR has had its
10483          outermost layer removed.  */
10484
10485       if (type == error_mark_node)
10486         {
10487           if (TREE_CODE (declarator) == SCOPE_REF)
10488             declarator = TREE_OPERAND (declarator, 1);
10489           else
10490             declarator = TREE_OPERAND (declarator, 0);
10491           continue;
10492         }
10493       if (quals != NULL_TREE
10494           && (declarator == NULL_TREE
10495               || TREE_CODE (declarator) != SCOPE_REF))
10496         {
10497           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10498             ctype = TYPE_METHOD_BASETYPE (type);
10499           if (ctype != NULL_TREE)
10500             {
10501               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10502               grok_method_quals (ctype, dummy, quals);
10503               type = TREE_TYPE (dummy);
10504               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10505               quals = NULL_TREE;
10506             }
10507         }
10508
10509       /* See the comment for the TREE_LIST case, below.  */
10510       if (ignore_attrs)
10511         ignore_attrs = 0;
10512       else if (inner_attrs)
10513         {
10514           decl_attributes (type, inner_attrs, NULL_TREE);
10515           inner_attrs = NULL_TREE;
10516         }
10517
10518       switch (TREE_CODE (declarator))
10519         {
10520         case TREE_LIST:
10521           {
10522             /* We encode a declarator with embedded attributes using
10523                a TREE_LIST.  The attributes apply to the declarator
10524                directly inside them, so we have to skip an iteration
10525                before applying them to the type.  If the declarator just
10526                inside is the declarator-id, we apply the attrs to the
10527                decl itself.  */
10528             inner_attrs = TREE_PURPOSE (declarator);
10529             ignore_attrs = 1;
10530             declarator = TREE_VALUE (declarator);
10531           }
10532           break;
10533
10534         case ARRAY_REF:
10535           {
10536             register tree size;
10537
10538             size = TREE_OPERAND (declarator, 1);
10539
10540             /* VC++ spells a zero-sized array with [].  */
10541             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10542                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10543               size = integer_zero_node;
10544
10545             declarator = TREE_OPERAND (declarator, 0);
10546
10547             type = create_array_type_for_decl (dname, type, size);
10548
10549             /* VLAs never work as fields. */
10550             if (decl_context == FIELD && !processing_template_decl
10551                 && TREE_CODE (type) == ARRAY_TYPE
10552                 && TYPE_DOMAIN (type) != NULL_TREE
10553                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10554               {
10555                 cp_error ("size of member `%D' is not constant", dname);
10556                 /* Proceed with arbitrary constant size, so that offset
10557                    computations don't get confused. */
10558                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10559                                                    integer_one_node);
10560               }
10561
10562             ctype = NULL_TREE;
10563           }
10564           break;
10565
10566         case CALL_EXPR:
10567           {
10568             tree arg_types;
10569             int funcdecl_p;
10570             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10571             tree inner_decl = TREE_OPERAND (declarator, 0);
10572
10573             /* Declaring a function type.
10574                Make sure we have a valid type for the function to return.  */
10575
10576             /* We now know that the TYPE_QUALS don't apply to the
10577                decl, but to its return type.  */
10578             type_quals = TYPE_UNQUALIFIED;
10579
10580             /* Warn about some types functions can't return.  */
10581
10582             if (TREE_CODE (type) == FUNCTION_TYPE)
10583               {
10584                 error ("`%s' declared as function returning a function", name);
10585                 type = integer_type_node;
10586               }
10587             if (TREE_CODE (type) == ARRAY_TYPE)
10588               {
10589                 error ("`%s' declared as function returning an array", name);
10590                 type = integer_type_node;
10591               }
10592
10593             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10594               inner_decl = TREE_OPERAND (inner_decl, 1);
10595
10596             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10597               inner_decl = dname;
10598
10599             /* Pick up type qualifiers which should be applied to `this'.  */
10600             quals = CALL_DECLARATOR_QUALS (declarator);
10601
10602             /* Pick up the exception specifications.  */
10603             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10604
10605             /* Say it's a definition only for the CALL_EXPR
10606                closest to the identifier.  */
10607             funcdecl_p
10608               = inner_decl
10609               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10610                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10611                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10612
10613             if (ctype == NULL_TREE
10614                 && decl_context == FIELD
10615                 && funcdecl_p
10616                 && (friendp == 0 || dname == current_class_name))
10617               ctype = current_class_type;
10618
10619             if (ctype && sfk == sfk_conversion)
10620               TYPE_HAS_CONVERSION (ctype) = 1;
10621             if (ctype && constructor_name (ctype) == dname)
10622               {
10623                 /* We are within a class's scope. If our declarator name
10624                    is the same as the class name, and we are defining
10625                    a function, then it is a constructor/destructor, and
10626                    therefore returns a void type.  */
10627
10628                 if (flags == DTOR_FLAG)
10629                   {
10630                     /* ISO C++ 12.4/2.  A destructor may not be
10631                        declared const or volatile.  A destructor may
10632                        not be static.  */
10633                     if (staticp == 2)
10634                       error ("destructor cannot be static member function");
10635                     if (quals)
10636                       {
10637                         cp_error ("destructors may not be `%s'",
10638                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10639                         quals = NULL_TREE;
10640                       }
10641                     if (decl_context == FIELD)
10642                       {
10643                         if (! member_function_or_else (ctype,
10644                                                        current_class_type,
10645                                                        flags))
10646                           return void_type_node;
10647                       }
10648                   }
10649                 else            /* It's a constructor.  */
10650                   {
10651                     if (explicitp == 1)
10652                       explicitp = 2;
10653                     /* ISO C++ 12.1.  A constructor may not be
10654                        declared const or volatile.  A constructor may
10655                        not be virtual.  A constructor may not be
10656                        static.  */
10657                     if (staticp == 2)
10658                       error ("constructor cannot be static member function");
10659                     if (virtualp)
10660                       {
10661                         pedwarn ("constructors cannot be declared virtual");
10662                         virtualp = 0;
10663                       }
10664                     if (quals)
10665                       {
10666                         cp_error ("constructors may not be `%s'",
10667                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10668                         quals = NULL_TREE;
10669                       }
10670                     {
10671                       RID_BIT_TYPE tmp_bits;
10672                       memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
10673                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10674                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10675                       if (RIDBIT_ANY_SET (tmp_bits))
10676                         error ("return value type specifier for constructor ignored");
10677                     }
10678                     if (decl_context == FIELD)
10679                       {
10680                         if (! member_function_or_else (ctype,
10681                                                        current_class_type,
10682                                                        flags))
10683                           return void_type_node;
10684                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10685                         if (sfk != sfk_constructor)
10686                           return NULL_TREE;
10687                       }
10688                   }
10689                 if (decl_context == FIELD)
10690                   staticp = 0;
10691               }
10692             else if (friendp)
10693               {
10694                 if (initialized)
10695                   error ("can't initialize friend function `%s'", name);
10696                 if (virtualp)
10697                   {
10698                     /* Cannot be both friend and virtual.  */
10699                     error ("virtual functions cannot be friends");
10700                     RIDBIT_RESET (RID_FRIEND, specbits);
10701                     friendp = 0;
10702                   }
10703                 if (decl_context == NORMAL)
10704                   error ("friend declaration not in class definition");
10705                 if (current_function_decl && funcdef_flag)
10706                   cp_error ("can't define friend function `%s' in a local class definition",
10707                             name);
10708               }
10709
10710             /* Construct the function type and go to the next
10711                inner layer of declarator.  */
10712
10713             declarator = TREE_OPERAND (declarator, 0);
10714
10715             /* FIXME: This is where default args should be fully
10716                processed.  */
10717
10718             arg_types = grokparms (inner_parms);
10719
10720             if (declarator && flags == DTOR_FLAG)
10721               {
10722                 /* A destructor declared in the body of a class will
10723                    be represented as a BIT_NOT_EXPR.  But, we just
10724                    want the underlying IDENTIFIER.  */
10725                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10726                   declarator = TREE_OPERAND (declarator, 0);
10727
10728                 if (arg_types != void_list_node)
10729                   {
10730                     cp_error ("destructors may not have parameters");
10731                     arg_types = void_list_node;
10732                     last_function_parms = NULL_TREE;
10733                   }
10734               }
10735
10736             /* ANSI says that `const int foo ();'
10737                does not make the function foo const.  */
10738             type = build_function_type (type, arg_types);
10739
10740             {
10741               tree t;
10742               for (t = arg_types; t; t = TREE_CHAIN (t))
10743                 if (TREE_PURPOSE (t)
10744                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10745                   {
10746                     add_defarg_fn (type);
10747                     break;
10748                   }
10749             }
10750           }
10751           break;
10752
10753         case ADDR_EXPR:
10754         case INDIRECT_REF:
10755           /* Filter out pointers-to-references and references-to-references.
10756              We can get these if a TYPE_DECL is used.  */
10757
10758           if (TREE_CODE (type) == REFERENCE_TYPE)
10759             {
10760               error ("cannot declare %s to references",
10761                      TREE_CODE (declarator) == ADDR_EXPR
10762                      ? "references" : "pointers");
10763               declarator = TREE_OPERAND (declarator, 0);
10764               continue;
10765             }
10766
10767           if (TREE_CODE (type) == OFFSET_TYPE
10768               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10769                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10770             {
10771               cp_error ("cannot declare pointer to `%#T' member",
10772                         TREE_TYPE (type));
10773               type = TREE_TYPE (type);
10774             }
10775
10776           /* Merge any constancy or volatility into the target type
10777              for the pointer.  */
10778
10779           /* We now know that the TYPE_QUALS don't apply to the decl,
10780              but to the target of the pointer.  */
10781           type_quals = TYPE_UNQUALIFIED;
10782
10783           if (TREE_CODE (declarator) == ADDR_EXPR)
10784             {
10785               if (TREE_CODE (type) == VOID_TYPE)
10786                 error ("invalid type: `void &'");
10787               else
10788                 type = build_reference_type (type);
10789             }
10790           else if (TREE_CODE (type) == METHOD_TYPE)
10791             type = build_ptrmemfunc_type (build_pointer_type (type));
10792           else
10793             type = build_pointer_type (type);
10794
10795           /* Process a list of type modifier keywords (such as
10796              const or volatile) that were given inside the `*' or `&'.  */
10797
10798           if (TREE_TYPE (declarator))
10799             {
10800               register tree typemodlist;
10801               int erred = 0;
10802
10803               constp = 0;
10804               volatilep = 0;
10805               restrictp = 0;
10806               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10807                    typemodlist = TREE_CHAIN (typemodlist))
10808                 {
10809                   tree qualifier = TREE_VALUE (typemodlist);
10810
10811                   if (qualifier == ridpointers[(int) RID_CONST])
10812                     constp++;
10813                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10814                     volatilep++;
10815                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10816                     restrictp++;
10817                   else if (!erred)
10818                     {
10819                       erred = 1;
10820                       error ("invalid type modifier within pointer declarator");
10821                     }
10822                 }
10823               if (constp > 1)
10824                 pedwarn ("duplicate `const'");
10825               if (volatilep > 1)
10826                 pedwarn ("duplicate `volatile'");
10827               if (restrictp > 1)
10828                 pedwarn ("duplicate `restrict'");
10829
10830               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10831                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10832                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10833               if (TREE_CODE (declarator) == ADDR_EXPR
10834                   && (constp || volatilep))
10835                 {
10836                   if (constp)
10837                     pedwarn ("discarding `const' applied to a reference");
10838                   if (volatilep)
10839                     pedwarn ("discarding `volatile' applied to a reference");
10840                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10841                 }
10842               type = cp_build_qualified_type (type, type_quals);
10843             }
10844           declarator = TREE_OPERAND (declarator, 0);
10845           ctype = NULL_TREE;
10846           break;
10847
10848         case SCOPE_REF:
10849           {
10850             /* We have converted type names to NULL_TREE if the
10851                name was bogus, or to a _TYPE node, if not.
10852
10853                The variable CTYPE holds the type we will ultimately
10854                resolve to.  The code here just needs to build
10855                up appropriate member types.  */
10856             tree sname = TREE_OPERAND (declarator, 1);
10857             tree t;
10858
10859             /* Destructors can have their visibilities changed as well.  */
10860             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10861               sname = TREE_OPERAND (sname, 0);
10862
10863             if (TREE_COMPLEXITY (declarator) == 0)
10864               /* This needs to be here, in case we are called
10865                  multiple times.  */ ;
10866             else if (TREE_COMPLEXITY (declarator) == -1)
10867               /* Namespace member. */
10868               pop_decl_namespace ();
10869             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10870               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10871             else if (! IS_AGGR_TYPE_CODE
10872                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10873               ;
10874             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10875               {
10876                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10877                    that refer to ctype.  They couldn't be resolved earlier
10878                    because we hadn't pushed into the class yet.
10879                    Example: resolve 'B<T>::type' in
10880                    'B<typename B<T>::type> B<T>::f () { }'.  */
10881                 if (current_template_parms
10882                     && uses_template_parms (type)
10883                     && uses_template_parms (current_class_type))
10884                   {
10885                     tree args = current_template_args ();
10886                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10887                   }
10888
10889                 /* This pop_nested_class corresponds to the
10890                    push_nested_class used to push into class scope for
10891                    parsing the argument list of a function decl, in
10892                    qualified_id.  */
10893                 pop_nested_class ();
10894                 TREE_COMPLEXITY (declarator) = current_class_depth;
10895               }
10896             else
10897               my_friendly_abort (16);
10898
10899             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10900               {
10901                 /* We had a reference to a global decl, or
10902                    perhaps we were given a non-aggregate typedef,
10903                    in which case we cleared this out, and should just
10904                    keep going as though it wasn't there.  */
10905                 declarator = sname;
10906                 continue;
10907               }
10908             ctype = TREE_OPERAND (declarator, 0);
10909
10910             t = ctype;
10911             while (t != NULL_TREE && CLASS_TYPE_P (t))
10912               {
10913                 /* You're supposed to have one `template <...>'
10914                    for every template class, but you don't need one
10915                    for a full specialization.  For example:
10916
10917                      template <class T> struct S{};
10918                      template <> struct S<int> { void f(); };
10919                      void S<int>::f () {}
10920
10921                    is correct; there shouldn't be a `template <>' for
10922                    the definition of `S<int>::f'.  */
10923                 if (CLASSTYPE_TEMPLATE_INFO (t)
10924                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10925                         || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
10926                   template_count += 1;
10927
10928                 t = TYPE_MAIN_DECL (t);
10929                 if (DECL_LANG_SPECIFIC (t))
10930                   t = DECL_CONTEXT (t);
10931                 else
10932                   t = NULL_TREE;
10933               }
10934
10935             if (sname == NULL_TREE)
10936               goto done_scoping;
10937
10938             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10939               {
10940                 /* This is the `standard' use of the scoping operator:
10941                    basetype :: member .  */
10942
10943                 if (ctype == current_class_type)
10944                   {
10945                     /* class A {
10946                          void A::f ();
10947                        };
10948
10949                        Is this ill-formed?  */
10950
10951                     if (pedantic)
10952                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10953                                   ctype, name);
10954                   }
10955                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10956                   {
10957                     if (current_class_type == NULL_TREE || friendp)
10958                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10959                                                       TYPE_ARG_TYPES (type));
10960                     else
10961                       {
10962                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10963                                   ctype, name, current_class_type);
10964                         return void_type_node;
10965                       }
10966                   }
10967                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10968                          || COMPLETE_TYPE_P (complete_type (ctype)))
10969                   {
10970                     /* Have to move this code elsewhere in this function.
10971                        this code is used for i.e., typedef int A::M; M *pm;
10972
10973                        It is?  How? jason 10/2/94 */
10974
10975                     if (current_class_type)
10976                       {
10977                         cp_error ("cannot declare member `%T::%s' within `%T'",
10978                                   ctype, name, current_class_type);
10979                         return void_type_node;
10980                       }
10981                     type = build_offset_type (ctype, type);
10982                   }
10983                 else
10984                   {
10985                     incomplete_type_error (NULL_TREE, ctype);
10986                     return error_mark_node;
10987                   }
10988
10989                 declarator = sname;
10990               }
10991             else if (TREE_CODE (sname) == SCOPE_REF)
10992               my_friendly_abort (17);
10993             else
10994               {
10995               done_scoping:
10996                 declarator = TREE_OPERAND (declarator, 1);
10997                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10998                   /* In this case, we will deal with it later.  */
10999                   ;
11000                 else
11001                   {
11002                     if (TREE_CODE (type) == FUNCTION_TYPE)
11003                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11004                                                       TYPE_ARG_TYPES (type));
11005                     else
11006                       type = build_offset_type (ctype, type);
11007                   }
11008               }
11009           }
11010           break;
11011
11012         case BIT_NOT_EXPR:
11013           declarator = TREE_OPERAND (declarator, 0);
11014           break;
11015
11016         case RECORD_TYPE:
11017         case UNION_TYPE:
11018         case ENUMERAL_TYPE:
11019           declarator = NULL_TREE;
11020           break;
11021
11022         case ERROR_MARK:
11023           declarator = NULL_TREE;
11024           break;
11025
11026         default:
11027           my_friendly_abort (158);
11028         }
11029     }
11030
11031   /* See the comment for the TREE_LIST case, above.  */
11032   if (inner_attrs)
11033     {
11034       if (! ignore_attrs)
11035         decl_attributes (type, inner_attrs, NULL_TREE);
11036       else if (attrlist)
11037         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
11038       else
11039         attrlist = build_tree_list (NULL_TREE, inner_attrs);
11040     }
11041
11042   /* Now TYPE has the actual type.  */
11043
11044   if (explicitp == 1 || (explicitp && friendp))
11045     {
11046       /* [dcl.fct.spec] The explicit specifier shall only be used in
11047          declarations of constructors within a class definition.  */
11048       error ("only declarations of constructors can be `explicit'");
11049       explicitp = 0;
11050     }
11051
11052   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11053     {
11054       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11055         {
11056           error ("non-member `%s' cannot be declared `mutable'", name);
11057           RIDBIT_RESET (RID_MUTABLE, specbits);
11058         }
11059       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11060         {
11061           error ("non-object member `%s' cannot be declared `mutable'", name);
11062           RIDBIT_RESET (RID_MUTABLE, specbits);
11063         }
11064       else if (TREE_CODE (type) == FUNCTION_TYPE
11065                || TREE_CODE (type) == METHOD_TYPE)
11066         {
11067           error ("function `%s' cannot be declared `mutable'", name);
11068           RIDBIT_RESET (RID_MUTABLE, specbits);
11069         }
11070       else if (staticp)
11071         {
11072           error ("static `%s' cannot be declared `mutable'", name);
11073           RIDBIT_RESET (RID_MUTABLE, specbits);
11074         }
11075       else if (type_quals & TYPE_QUAL_CONST)
11076         {
11077           error ("const `%s' cannot be declared `mutable'", name);
11078           RIDBIT_RESET (RID_MUTABLE, specbits);
11079         }
11080     }
11081
11082   if (declarator == NULL_TREE
11083       || TREE_CODE (declarator) == IDENTIFIER_NODE
11084       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11085           && (TREE_CODE (type) == FUNCTION_TYPE
11086               || TREE_CODE (type) == METHOD_TYPE)))
11087     /* OK */;
11088   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11089     {
11090       cp_error ("template-id `%D' used as a declarator", declarator);
11091       declarator = dname;
11092     }
11093   else
11094     /* Unexpected declarator format.  */
11095     my_friendly_abort (990210);
11096
11097   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11098
11099   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11100     {
11101       tree decl;
11102
11103       /* Note that the grammar rejects storage classes
11104          in typenames, fields or parameters.  */
11105       if (current_lang_name == lang_name_java)
11106         TYPE_FOR_JAVA (type) = 1;
11107
11108       if (decl_context == FIELD)
11109         {
11110           if (declarator == constructor_name (current_class_type))
11111             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11112                         declarator);
11113           decl = build_lang_decl (TYPE_DECL, declarator, type);
11114         }
11115       else
11116         decl = build_decl (TYPE_DECL, declarator, type);
11117
11118       /* If the user declares "typedef struct {...} foo" then the
11119          struct will have an anonymous name.  Fill that name in now.
11120          Nothing can refer to it, so nothing needs know about the name
11121          change.  */
11122       if (type != error_mark_node
11123           && declarator
11124           && TYPE_NAME (type)
11125           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11126           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
11127           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11128         {
11129           tree oldname = TYPE_NAME (type);
11130           tree t;
11131
11132           /* Replace the anonymous name with the real name everywhere.  */
11133           lookup_tag_reverse (type, declarator);
11134           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11135             if (TYPE_NAME (t) == oldname)
11136               TYPE_NAME (t) = decl;
11137
11138           if (TYPE_LANG_SPECIFIC (type))
11139             TYPE_WAS_ANONYMOUS (type) = 1;
11140
11141           /* If this is a typedef within a template class, the nested
11142              type is a (non-primary) template.  The name for the
11143              template needs updating as well.  */
11144           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11145             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11146               = TYPE_IDENTIFIER (type);
11147
11148           if (flag_new_abi)
11149             DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
11150           else
11151             {
11152               /* XXX Temporarily set the scope.
11153                  When returning, start_decl expects it as NULL_TREE,
11154                  and will then then set it using pushdecl. */
11155               my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
11156               if (current_class_type)
11157                 DECL_CONTEXT (decl) = current_class_type;
11158               else
11159                 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11160
11161               DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
11162               DECL_ASSEMBLER_NAME (decl)
11163                 = get_identifier (build_overload_name (type, 1, 1));
11164               DECL_CONTEXT (decl) = NULL_TREE;
11165             }
11166
11167           /* FIXME remangle member functions; member functions of a
11168              type with external linkage have external linkage.  */
11169         }
11170
11171       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11172         {
11173           cp_error_at ("typedef name may not be class-qualified", decl);
11174           return NULL_TREE;
11175         }
11176       else if (quals)
11177         {
11178           if (ctype == NULL_TREE)
11179             {
11180               if (TREE_CODE (type) != METHOD_TYPE)
11181                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11182               else
11183                 ctype = TYPE_METHOD_BASETYPE (type);
11184             }
11185           if (ctype != NULL_TREE)
11186             grok_method_quals (ctype, decl, quals);
11187         }
11188
11189       if (RIDBIT_SETP (RID_SIGNED, specbits)
11190           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11191         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11192
11193       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11194                       inlinep, friendp, raises != NULL_TREE);
11195
11196       if (initialized)
11197         error ("typedef declaration includes an initializer");
11198
11199       return decl;
11200     }
11201
11202   /* Detect the case of an array type of unspecified size
11203      which came, as such, direct from a typedef name.
11204      We must copy the type, so that each identifier gets
11205      a distinct type, so that each identifier's size can be
11206      controlled separately by its own initializer.  */
11207
11208   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11209       && TYPE_DOMAIN (type) == NULL_TREE)
11210     {
11211       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11212     }
11213
11214   /* If this is a type name (such as, in a cast or sizeof),
11215      compute the type and return it now.  */
11216
11217   if (decl_context == TYPENAME)
11218     {
11219       /* Note that the grammar rejects storage classes
11220          in typenames, fields or parameters.  */
11221       if (type_quals != TYPE_UNQUALIFIED)
11222         type_quals = TYPE_UNQUALIFIED;
11223
11224       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11225       if (friendp)
11226         {
11227           if (type_quals != TYPE_UNQUALIFIED)
11228             {
11229               cp_error ("type qualifiers specified for friend class declaration");
11230               type_quals = TYPE_UNQUALIFIED;
11231             }
11232           if (inlinep)
11233             {
11234               cp_error ("`inline' specified for friend class declaration");
11235               inlinep = 0;
11236             }
11237
11238           /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11239              But don't allow implicit typenames except with a class-key.  */
11240           if (!current_aggr && (TREE_CODE (type) != TYPENAME_TYPE
11241                                 || IMPLICIT_TYPENAME_P (type)))
11242             {
11243               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11244                 cp_pedwarn ("template parameters cannot be friends");
11245               else if (TREE_CODE (type) == TYPENAME_TYPE)
11246                 cp_pedwarn ("\
11247 friend declaration requires class-key, i.e. `friend class %T::%T'",
11248                             constructor_name (current_class_type),
11249                             TYPE_IDENTIFIER (type));
11250               else
11251                 cp_pedwarn ("\
11252 friend declaration requires class-key, i.e. `friend %#T'",
11253                             type);
11254             }
11255
11256           /* Only try to do this stuff if we didn't already give up.  */
11257           if (type != integer_type_node)
11258             {
11259               decl_type_access_control (TYPE_NAME (type));
11260
11261               /* A friendly class?  */
11262               if (current_class_type)
11263                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11264               else
11265                 cp_error ("trying to make class `%T' a friend of global scope",
11266                           type);
11267
11268               type = void_type_node;
11269             }
11270         }
11271       else if (quals)
11272         {
11273           if (ctype == NULL_TREE)
11274             {
11275               if (TREE_CODE (type) != METHOD_TYPE)
11276                 cp_error ("invalid qualifiers on non-member function type");
11277               else
11278                 ctype = TYPE_METHOD_BASETYPE (type);
11279             }
11280           if (ctype)
11281             {
11282               tree dummy = build_decl (TYPE_DECL, declarator, type);
11283               grok_method_quals (ctype, dummy, quals);
11284               type = TREE_TYPE (dummy);
11285             }
11286         }
11287
11288       return type;
11289     }
11290   else if (declarator == NULL_TREE && decl_context != PARM
11291            && decl_context != CATCHPARM
11292            && TREE_CODE (type) != UNION_TYPE
11293            && ! bitfield)
11294     {
11295       cp_error ("abstract declarator `%T' used as declaration", type);
11296       declarator = make_anon_name ();
11297     }
11298
11299   /* `void' at top level (not within pointer)
11300      is allowed only in typedefs or type names.
11301      We don't complain about parms either, but that is because
11302      a better error message can be made later.  */
11303
11304   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11305     {
11306       if (! declarator)
11307         error ("unnamed variable or field declared void");
11308       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11309         {
11310           if (IDENTIFIER_OPNAME_P (declarator))
11311             my_friendly_abort (356);
11312           else
11313             error ("variable or field `%s' declared void", name);
11314         }
11315       else
11316         error ("variable or field declared void");
11317       type = integer_type_node;
11318     }
11319
11320   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11321      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11322
11323   if (decl_context == PARM || decl_context == CATCHPARM)
11324     {
11325       if (ctype || in_namespace)
11326         error ("cannot use `::' in parameter declaration");
11327
11328       /* A parameter declared as an array of T is really a pointer to T.
11329          One declared as a function is really a pointer to a function.
11330          One declared as a member is really a pointer to member.  */
11331
11332       if (TREE_CODE (type) == ARRAY_TYPE)
11333         {
11334           /* Transfer const-ness of array into that of type pointed to.  */
11335           type = build_pointer_type (TREE_TYPE (type));
11336           type_quals = TYPE_UNQUALIFIED;
11337         }
11338       else if (TREE_CODE (type) == FUNCTION_TYPE)
11339         type = build_pointer_type (type);
11340       else if (TREE_CODE (type) == OFFSET_TYPE)
11341         type = build_pointer_type (type);
11342     }
11343
11344   {
11345     register tree decl;
11346
11347     if (decl_context == PARM)
11348       {
11349         decl = build_decl (PARM_DECL, declarator, type);
11350
11351         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11352                         inlinep, friendp, raises != NULL_TREE);
11353
11354         /* Compute the type actually passed in the parmlist,
11355            for the case where there is no prototype.
11356            (For example, shorts and chars are passed as ints.)
11357            When there is a prototype, this is overridden later.  */
11358
11359         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11360       }
11361     else if (decl_context == FIELD)
11362       {
11363         if (type == error_mark_node)
11364           {
11365             /* Happens when declaring arrays of sizes which
11366                are error_mark_node, for example.  */
11367             decl = NULL_TREE;
11368           }
11369         else if (in_namespace && !friendp)
11370           {
11371             /* Something like struct S { int N::j; };  */
11372             cp_error ("invalid use of `::'");
11373             decl = NULL_TREE;
11374           }
11375         else if (TREE_CODE (type) == FUNCTION_TYPE)
11376           {
11377             int publicp = 0;
11378             tree function_context;
11379
11380             /* We catch the others as conflicts with the builtin
11381                typedefs.  */
11382             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11383               {
11384                 cp_error ("function `%D' cannot be declared friend",
11385                           declarator);
11386                 friendp = 0;
11387               }
11388
11389             if (friendp == 0)
11390               {
11391                 if (ctype == NULL_TREE)
11392                   ctype = current_class_type;
11393
11394                 if (ctype == NULL_TREE)
11395                   {
11396                     cp_error ("can't make `%D' into a method -- not in a class",
11397                               declarator);
11398                     return void_type_node;
11399                   }
11400
11401                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11402                    ARM 9.5 */
11403                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11404                   {
11405                     cp_error ("function `%D' declared virtual inside a union",
11406                               declarator);
11407                     return void_type_node;
11408                   }
11409
11410                 if (declarator == ansi_opname (NEW_EXPR)
11411                     || declarator == ansi_opname (VEC_NEW_EXPR)
11412                     || declarator == ansi_opname (DELETE_EXPR)
11413                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11414                   {
11415                     if (virtualp)
11416                       {
11417                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11418                                   declarator);
11419                         virtualp = 0;
11420                       }
11421                   }
11422                 else if (staticp < 2)
11423                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11424                                                   TYPE_ARG_TYPES (type));
11425               }
11426
11427             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11428             function_context = (ctype != NULL_TREE) ?
11429               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11430             publicp = (! friendp || ! staticp)
11431               && function_context == NULL_TREE;
11432             decl = grokfndecl (ctype, type,
11433                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11434                                ? declarator : dname,
11435                                declarator,
11436                                virtualp, flags, quals, raises,
11437                                friendp ? -1 : 0, friendp, publicp, inlinep,
11438                                funcdef_flag, template_count, in_namespace);
11439             if (decl == NULL_TREE)
11440               return decl;
11441 #if 0
11442             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11443             /* The decl and setting of decl_machine_attr is also turned off.  */
11444             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11445 #endif
11446
11447             /* [class.conv.ctor]
11448
11449                A constructor declared without the function-specifier
11450                explicit that can be called with a single parameter
11451                specifies a conversion from the type of its first
11452                parameter to the type of its class.  Such a constructor
11453                is called a converting constructor.  */
11454             if (explicitp == 2)
11455               DECL_NONCONVERTING_P (decl) = 1;
11456             else if (DECL_CONSTRUCTOR_P (decl))
11457               {
11458                 /* The constructor can be called with exactly one
11459                    parameter if there is at least one parameter, and
11460                    any subsequent parameters have default arguments.
11461                    We don't look at the first parameter, which is
11462                    really just the `this' parameter for the new
11463                    object.  */
11464                 tree arg_types =
11465                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11466
11467                 /* Skip the `in_chrg' argument too, if present.  */
11468                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11469                   arg_types = TREE_CHAIN (arg_types);
11470
11471                 if (arg_types == void_list_node
11472                     || (arg_types
11473                         && TREE_CHAIN (arg_types)
11474                         && TREE_CHAIN (arg_types) != void_list_node
11475                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11476                   DECL_NONCONVERTING_P (decl) = 1;
11477               }
11478           }
11479         else if (TREE_CODE (type) == METHOD_TYPE)
11480           {
11481             /* We only get here for friend declarations of
11482                members of other classes.  */
11483             /* All method decls are public, so tell grokfndecl to set
11484                TREE_PUBLIC, also.  */
11485             decl = grokfndecl (ctype, type, declarator, declarator,
11486                                virtualp, flags, quals, raises,
11487                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11488                                template_count, in_namespace);
11489             if (decl == NULL_TREE)
11490               return NULL_TREE;
11491           }
11492         else if (!staticp && ! processing_template_decl
11493                  && !COMPLETE_TYPE_P (complete_type (type))
11494                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11495           {
11496             if (declarator)
11497               cp_error ("field `%D' has incomplete type", declarator);
11498             else
11499               cp_error ("name `%T' has incomplete type", type);
11500
11501             /* If we're instantiating a template, tell them which
11502                instantiation made the field's type be incomplete.  */
11503             if (current_class_type
11504                 && TYPE_NAME (current_class_type)
11505                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11506                 && declspecs && TREE_VALUE (declspecs)
11507                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11508               cp_error ("  in instantiation of template `%T'",
11509                         current_class_type);
11510
11511             type = error_mark_node;
11512             decl = NULL_TREE;
11513           }
11514         else
11515           {
11516             if (friendp)
11517               {
11518                 error ("`%s' is neither function nor member function; cannot be declared friend",
11519                        IDENTIFIER_POINTER (declarator));
11520                 friendp = 0;
11521               }
11522             decl = NULL_TREE;
11523           }
11524
11525         if (friendp)
11526           {
11527             /* Friends are treated specially.  */
11528             if (ctype == current_class_type)
11529               warning ("member functions are implicitly friends of their class");
11530             else
11531               {
11532                 tree t = NULL_TREE;
11533                 if (decl && DECL_NAME (decl))
11534                   {
11535                     if (template_class_depth (current_class_type) == 0)
11536                       {
11537                         decl
11538                           = check_explicit_specialization
11539                           (declarator, decl,
11540                            template_count, 2 * (funcdef_flag != 0) + 4);
11541                         if (decl == error_mark_node)
11542                           return error_mark_node;
11543                       }
11544
11545                     t = do_friend (ctype, declarator, decl,
11546                                    last_function_parms, attrlist, flags, quals,
11547                                    funcdef_flag);
11548                   }
11549                 if (t && funcdef_flag)
11550                   return t;
11551
11552                 return void_type_node;
11553               }
11554           }
11555
11556         /* Structure field.  It may not be a function, except for C++ */
11557
11558         if (decl == NULL_TREE)
11559           {
11560             if (initialized)
11561               {
11562                 if (!staticp)
11563                   {
11564                     /* An attempt is being made to initialize a non-static
11565                        member.  But, from [class.mem]:
11566
11567                        4 A member-declarator can contain a
11568                        constant-initializer only if it declares a static
11569                        member (_class.static_) of integral or enumeration
11570                        type, see _class.static.data_.
11571
11572                        This used to be relatively common practice, but
11573                        the rest of the compiler does not correctly
11574                        handle the initialization unless the member is
11575                        static so we make it static below.  */
11576                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11577                                 declarator);
11578                     cp_pedwarn ("making `%D' static", declarator);
11579                     staticp = 1;
11580                   }
11581
11582                 if (uses_template_parms (type))
11583                   /* We'll check at instantiation time.  */
11584                   ;
11585                 else if (check_static_variable_definition (declarator,
11586                                                            type))
11587                   /* If we just return the declaration, crashes
11588                      will sometimes occur.  We therefore return
11589                      void_type_node, as if this was a friend
11590                      declaration, to cause callers to completely
11591                      ignore this declaration.  */
11592                   return void_type_node;
11593               }
11594
11595             /* 9.2p13 [class.mem] */
11596             if (declarator == constructor_name (current_class_type)
11597                 /* The standard does not allow non-static data members
11598                    here either, but we agreed at the 10/99 meeting
11599                    to change that in TC 1 so that they are allowed in
11600                    classes with no user-defined constructors.  */
11601                 && staticp)
11602               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11603                           declarator);
11604
11605             if (staticp)
11606               {
11607                 /* C++ allows static class members.  All other work
11608                    for this is done by grokfield.  */
11609                 decl = build_lang_decl (VAR_DECL, declarator, type);
11610                 TREE_STATIC (decl) = 1;
11611                 /* In class context, 'static' means public access.  */
11612                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11613               }
11614             else
11615               {
11616                 decl = build_decl (FIELD_DECL, declarator, type);
11617                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11618                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11619                   {
11620                     DECL_MUTABLE_P (decl) = 1;
11621                     RIDBIT_RESET (RID_MUTABLE, specbits);
11622                   }
11623               }
11624
11625             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11626                             inlinep, friendp, raises != NULL_TREE);
11627           }
11628       }
11629     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11630       {
11631         tree original_name;
11632         int publicp = 0;
11633
11634         if (! declarator)
11635           return NULL_TREE;
11636
11637         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11638           original_name = dname;
11639         else
11640           original_name = declarator;
11641
11642         if (RIDBIT_SETP (RID_AUTO, specbits))
11643           error ("storage class `auto' invalid for function `%s'", name);
11644         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11645           error ("storage class `register' invalid for function `%s'", name);
11646
11647         /* Function declaration not at top level.
11648            Storage classes other than `extern' are not allowed
11649            and `extern' makes no difference.  */
11650         if (! toplevel_bindings_p ()
11651             && (RIDBIT_SETP (RID_STATIC, specbits)
11652                 || RIDBIT_SETP (RID_INLINE, specbits))
11653             && pedantic)
11654           {
11655             if (RIDBIT_SETP (RID_STATIC, specbits))
11656               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11657             else
11658               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11659           }
11660
11661         if (ctype == NULL_TREE)
11662           {
11663             if (virtualp)
11664               {
11665                 error ("virtual non-class function `%s'", name);
11666                 virtualp = 0;
11667               }
11668           }
11669         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11670           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11671                                           TYPE_ARG_TYPES (type));
11672
11673         /* Record presence of `static'.  */
11674         publicp = (ctype != NULL_TREE
11675                    || RIDBIT_SETP (RID_EXTERN, specbits)
11676                    || !RIDBIT_SETP (RID_STATIC, specbits));
11677
11678         decl = grokfndecl (ctype, type, original_name, declarator,
11679                            virtualp, flags, quals, raises,
11680                            1, friendp,
11681                            publicp, inlinep, funcdef_flag,
11682                            template_count, in_namespace);
11683         if (decl == NULL_TREE)
11684           return NULL_TREE;
11685
11686         if (staticp == 1)
11687           {
11688             int illegal_static = 0;
11689
11690             /* Don't allow a static member function in a class, and forbid
11691                declaring main to be static.  */
11692             if (TREE_CODE (type) == METHOD_TYPE)
11693               {
11694                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11695                 illegal_static = 1;
11696               }
11697             else if (current_function_decl)
11698               {
11699                 /* FIXME need arm citation */
11700                 error ("cannot declare static function inside another function");
11701                 illegal_static = 1;
11702               }
11703
11704             if (illegal_static)
11705               {
11706                 staticp = 0;
11707                 RIDBIT_RESET (RID_STATIC, specbits);
11708               }
11709           }
11710       }
11711     else
11712       {
11713         /* It's a variable.  */
11714
11715         /* An uninitialized decl with `extern' is a reference.  */
11716         decl = grokvardecl (type, declarator, &specbits,
11717                             initialized,
11718                             (type_quals & TYPE_QUAL_CONST) != 0,
11719                             in_namespace);
11720         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11721                         inlinep, friendp, raises != NULL_TREE);
11722
11723         if (ctype)
11724           {
11725             DECL_CONTEXT (decl) = ctype;
11726             if (staticp == 1)
11727               {
11728                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11729                 staticp = 0;
11730                 RIDBIT_RESET (RID_STATIC, specbits);
11731               }
11732             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11733               {
11734                 cp_error ("static member `%D' declared `register'", decl);
11735                 RIDBIT_RESET (RID_REGISTER, specbits);
11736               }
11737             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11738               {
11739                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11740                             decl);
11741                 RIDBIT_RESET (RID_EXTERN, specbits);
11742               }
11743           }
11744       }
11745
11746     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11747
11748     /* Record `register' declaration for warnings on &
11749        and in case doing stupid register allocation.  */
11750
11751     if (RIDBIT_SETP (RID_REGISTER, specbits))
11752       DECL_REGISTER (decl) = 1;
11753
11754     if (RIDBIT_SETP (RID_EXTERN, specbits))
11755       DECL_THIS_EXTERN (decl) = 1;
11756
11757     if (RIDBIT_SETP (RID_STATIC, specbits))
11758       DECL_THIS_STATIC (decl) = 1;
11759
11760     /* Record constancy and volatility.  There's no need to do this
11761        when processing a template; we'll do this for the instantiated
11762        declaration based on the type of DECL.  */
11763     if (!processing_template_decl)
11764       c_apply_type_quals_to_decl (type_quals, decl);
11765
11766     return decl;
11767   }
11768 }
11769 \f
11770 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11771    An empty exprlist is a parmlist.  An exprlist which
11772    contains only identifiers at the global level
11773    is a parmlist.  Otherwise, it is an exprlist.  */
11774
11775 int
11776 parmlist_is_exprlist (exprs)
11777      tree exprs;
11778 {
11779   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11780     return 0;
11781
11782   if (toplevel_bindings_p ())
11783     {
11784       /* At the global level, if these are all identifiers,
11785          then it is a parmlist.  */
11786       while (exprs)
11787         {
11788           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11789             return 1;
11790           exprs = TREE_CHAIN (exprs);
11791         }
11792       return 0;
11793     }
11794   return 1;
11795 }
11796
11797 /* Subroutine of start_function.  Ensure that each of the parameter
11798    types (as listed in PARMS) is complete, as is required for a
11799    function definition.  */
11800
11801 static void
11802 require_complete_types_for_parms (parms)
11803      tree parms;
11804 {
11805   for (; parms; parms = TREE_CHAIN (parms))
11806     {
11807       if (VOID_TYPE_P (TREE_TYPE (parms)))
11808         /* grokparms will have already issued an error */
11809         TREE_TYPE (parms) = error_mark_node;
11810       else if (complete_type_or_else (TREE_TYPE (parms), parms))
11811         layout_decl (parms, 0);
11812       else
11813         TREE_TYPE (parms) = error_mark_node;
11814     }
11815 }
11816
11817 /* Returns non-zero if T is a local variable.  */
11818
11819 int
11820 local_variable_p (t)
11821      tree t;
11822 {
11823   if ((TREE_CODE (t) == VAR_DECL
11824        /* A VAR_DECL with a context that is a _TYPE is a static data
11825           member.  */
11826        && !TYPE_P (CP_DECL_CONTEXT (t))
11827        /* Any other non-local variable must be at namespace scope.  */
11828        && !DECL_NAMESPACE_SCOPE_P (t))
11829       || (TREE_CODE (t) == PARM_DECL))
11830     return 1;
11831
11832   return 0;
11833 }
11834
11835 /* Returns non-zero if T is an automatic local variable or a label.
11836    (These are the declarations that need to be remapped when the code
11837    containing them is duplicated.)  */
11838
11839 int
11840 nonstatic_local_decl_p (t)
11841      tree t;
11842 {
11843   return ((local_variable_p (t) && !TREE_STATIC (t))
11844           || TREE_CODE (t) == LABEL_DECL
11845           || TREE_CODE (t) == RESULT_DECL);
11846 }
11847
11848 /* Like local_variable_p, but suitable for use as a tree-walking
11849    function.  */
11850
11851 static tree
11852 local_variable_p_walkfn (tp, walk_subtrees, data)
11853      tree *tp;
11854      int *walk_subtrees ATTRIBUTE_UNUSED;
11855      void *data ATTRIBUTE_UNUSED;
11856 {
11857   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11858           ? *tp : NULL_TREE);
11859 }
11860
11861 /* Check that ARG, which is a default-argument expression for a
11862    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11863    something goes wrong.  DECL may also be a _TYPE node, rather than a
11864    DECL, if there is no DECL available.  */
11865
11866 tree
11867 check_default_argument (decl, arg)
11868      tree decl;
11869      tree arg;
11870 {
11871   tree var;
11872   tree decl_type;
11873
11874   if (TREE_CODE (arg) == DEFAULT_ARG)
11875     /* We get a DEFAULT_ARG when looking at an in-class declaration
11876        with a default argument.  Ignore the argument for now; we'll
11877        deal with it after the class is complete.  */
11878     return arg;
11879
11880   if (processing_template_decl || uses_template_parms (arg))
11881     /* We don't do anything checking until instantiation-time.  Note
11882        that there may be uninstantiated arguments even for an
11883        instantiated function, since default arguments are not
11884        instantiated until they are needed.  */
11885     return arg;
11886
11887   if (TYPE_P (decl))
11888     {
11889       decl_type = decl;
11890       decl = NULL_TREE;
11891     }
11892   else
11893     decl_type = TREE_TYPE (decl);
11894
11895   if (arg == error_mark_node
11896       || decl == error_mark_node
11897       || TREE_TYPE (arg) == error_mark_node
11898       || decl_type == error_mark_node)
11899     /* Something already went wrong.  There's no need to check
11900        further.  */
11901     return error_mark_node;
11902
11903   /* [dcl.fct.default]
11904
11905      A default argument expression is implicitly converted to the
11906      parameter type.  */
11907   if (!TREE_TYPE (arg)
11908       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11909     {
11910       if (decl)
11911         cp_error ("default argument for `%#D' has type `%T'",
11912                   decl, TREE_TYPE (arg));
11913       else
11914         cp_error ("default argument for parameter of type `%T' has type `%T'",
11915                   decl_type, TREE_TYPE (arg));
11916
11917       return error_mark_node;
11918     }
11919
11920   /* [dcl.fct.default]
11921
11922      Local variables shall not be used in default argument
11923      expressions.
11924
11925      The keyword `this' shall not be used in a default argument of a
11926      member function.  */
11927   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
11928                                       NULL);
11929   if (var)
11930     {
11931       cp_error ("default argument `%E' uses local variable `%D'",
11932                 arg, var);
11933       return error_mark_node;
11934     }
11935
11936   /* All is well.  */
11937   return arg;
11938 }
11939
11940 /* Decode the list of parameter types for a function type.
11941    Given the list of things declared inside the parens,
11942    return a list of types.
11943
11944    We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
11945    flag. If unset, we append void_list_node. A parmlist declared
11946    as `(void)' is accepted as the empty parmlist.
11947
11948    Also set last_function_parms to the chain of PARM_DECLs.  */
11949
11950 static tree
11951 grokparms (first_parm)
11952      tree first_parm;
11953 {
11954   tree result = NULL_TREE;
11955   tree decls = NULL_TREE;
11956   int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
11957   tree parm, chain;
11958   int any_error = 0;
11959
11960   my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
11961
11962   for (parm = first_parm; parm != NULL_TREE; parm = chain)
11963     {
11964       tree type = NULL_TREE;
11965       register tree decl = TREE_VALUE (parm);
11966       tree init = TREE_PURPOSE (parm);
11967
11968       chain = TREE_CHAIN (parm);
11969       /* @@ weak defense against parse errors.  */
11970       if (TREE_CODE (decl) != VOID_TYPE
11971           && TREE_CODE (decl) != TREE_LIST)
11972         {
11973           /* Give various messages as the need arises.  */
11974           if (TREE_CODE (decl) == STRING_CST)
11975             cp_error ("invalid string constant `%E'", decl);
11976           else if (TREE_CODE (decl) == INTEGER_CST)
11977             error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11978           continue;
11979         }
11980
11981       if (parm == void_list_node)
11982         break;
11983
11984       decl = grokdeclarator (TREE_VALUE (decl), TREE_PURPOSE (decl),
11985                              PARM, init != NULL_TREE, NULL_TREE);
11986       if (! decl || TREE_TYPE (decl) == error_mark_node)
11987         continue;
11988
11989       type = TREE_TYPE (decl);
11990       if (VOID_TYPE_P (type))
11991         {
11992           if (same_type_p (type, void_type_node)
11993               && !DECL_NAME (decl) && !result && !chain && !ellipsis)
11994             /* this is a parmlist of `(void)', which is ok.  */
11995             break;
11996           incomplete_type_error (decl, type);
11997           /* It's not a good idea to actually create parameters of
11998              type `void'; other parts of the compiler assume that a
11999              void type terminates the parameter list.  */
12000           type = error_mark_node;
12001           TREE_TYPE (decl) = error_mark_node;
12002         }
12003
12004       if (type != error_mark_node)
12005         {
12006           /* Top-level qualifiers on the parameters are
12007              ignored for function types.  */
12008           type = TYPE_MAIN_VARIANT (type);
12009           if (TREE_CODE (type) == METHOD_TYPE)
12010             {
12011               cp_error ("parameter `%D' invalidly declared method type", decl);
12012               type = build_pointer_type (type);
12013               TREE_TYPE (decl) = type;
12014             }
12015           else if (TREE_CODE (type) == OFFSET_TYPE)
12016             {
12017               cp_error ("parameter `%D' invalidly declared offset type", decl);
12018               type = build_pointer_type (type);
12019               TREE_TYPE (decl) = type;
12020             }
12021           else if (abstract_virtuals_error (decl, type))
12022             any_error = 1;  /* Seems like a good idea. */
12023           else if (POINTER_TYPE_P (type))
12024             {
12025               /* [dcl.fct]/6, parameter types cannot contain pointers
12026                  (references) to arrays of unknown bound.  */
12027               tree t = type;
12028
12029               while (POINTER_TYPE_P (t)
12030                      || (TREE_CODE (t) == ARRAY_TYPE
12031                          && TYPE_DOMAIN (t) != NULL_TREE))
12032                 t = TREE_TYPE (t);
12033               if (TREE_CODE (t) == ARRAY_TYPE)
12034                 cp_error ("parameter `%D' includes %s to array of unknown bound `%T'",
12035                           decl, TYPE_PTR_P (type) ? "pointer" : "reference", t);
12036             }
12037
12038           DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12039           if (PROMOTE_PROTOTYPES
12040               && (TREE_CODE (type) == INTEGER_TYPE
12041                   || TREE_CODE (type) == ENUMERAL_TYPE)
12042               && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12043             DECL_ARG_TYPE (decl) = integer_type_node;
12044           if (!any_error && init)
12045             init = check_default_argument (decl, init);
12046           else
12047             init = NULL_TREE;
12048         }
12049
12050       TREE_CHAIN (decl) = decls;
12051       decls = decl;
12052       result = tree_cons (init, type, result);
12053     }
12054   decls = nreverse (decls);
12055   result = nreverse (result);
12056   if (!ellipsis)
12057     result = chainon (result, void_list_node);
12058   last_function_parms = decls;
12059
12060   return result;
12061 }
12062
12063 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12064    FUNCTION_TYPE with the newly parsed version of its default argument, which
12065    was previously digested as text.  See snarf_defarg et al in lex.c.  */
12066
12067 void
12068 replace_defarg (arg, init)
12069      tree arg, init;
12070 {
12071   if (! processing_template_decl
12072       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
12073     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12074                 TREE_TYPE (init), TREE_VALUE (arg));
12075   TREE_PURPOSE (arg) = init;
12076 }
12077 \f
12078 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12079    D's arguments allow it to be a copy constructor, or copy assignment
12080    operator.  */
12081
12082 int
12083 copy_args_p (d)
12084      tree d;
12085 {
12086   tree t;
12087
12088   if (!DECL_FUNCTION_MEMBER_P (d))
12089     return 0;
12090
12091   t = FUNCTION_ARG_CHAIN (d);
12092   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
12093     t = TREE_CHAIN (t);
12094   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12095       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12096           == DECL_CONTEXT (d))
12097       && (TREE_CHAIN (t) == NULL_TREE
12098           || TREE_CHAIN (t) == void_list_node
12099           || TREE_PURPOSE (TREE_CHAIN (t))))
12100     return 1;
12101   return 0;
12102 }
12103
12104 /* These memoizing functions keep track of special properties which
12105    a class may have.  `grok_ctor_properties' notices whether a class
12106    has a constructor of the form X(X&), and also complains
12107    if the class has a constructor of the form X(X).
12108    `grok_op_properties' takes notice of the various forms of
12109    operator= which are defined, as well as what sorts of type conversion
12110    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12111
12112 int
12113 grok_ctor_properties (ctype, decl)
12114      tree ctype, decl;
12115 {
12116   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
12117   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12118
12119   /* When a type has virtual baseclasses, a magical first int argument is
12120      added to any ctor so we can tell if the class has been initialized
12121      yet.  This could screw things up in this function, so we deliberately
12122      ignore the leading int if we're in that situation.  */
12123   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
12124     {
12125       my_friendly_assert (parmtypes
12126                           && TREE_VALUE (parmtypes) == integer_type_node,
12127                           980529);
12128       parmtypes = TREE_CHAIN (parmtypes);
12129       parmtype = TREE_VALUE (parmtypes);
12130     }
12131
12132   /* [class.copy]
12133
12134      A non-template constructor for class X is a copy constructor if
12135      its first parameter is of type X&, const X&, volatile X& or const
12136      volatile X&, and either there are no other parameters or else all
12137      other parameters have default arguments.  */
12138   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12139       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12140       && sufficient_parms_p (TREE_CHAIN (parmtypes))
12141       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12142            && is_member_template (DECL_TI_TEMPLATE (decl))))
12143     {
12144       TYPE_HAS_INIT_REF (ctype) = 1;
12145       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12146         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12147     }
12148   /* [class.copy]
12149
12150      A declaration of a constructor for a class X is ill-formed if its
12151      first parameter is of type (optionally cv-qualified) X and either
12152      there are no other parameters or else all other parameters have
12153      default arguments.
12154
12155      We *don't* complain about member template instantiations that
12156      have this form, though; they can occur as we try to decide what
12157      constructor to use during overload resolution.  Since overload
12158      resolution will never prefer such a constructor to the
12159      non-template copy constructor (which is either explicitly or
12160      implicitly defined), there's no need to worry about their
12161      existence.  Theoretically, they should never even be
12162      instantiated, but that's hard to forestall.  */
12163   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12164            && sufficient_parms_p (TREE_CHAIN (parmtypes))
12165            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12166                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12167     {
12168       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12169                 ctype, ctype);
12170       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12171       return 0;
12172     }
12173   else if (TREE_CODE (parmtype) == VOID_TYPE
12174            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12175     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12176
12177   return 1;
12178 }
12179
12180 /* An operator with this code is unary, but can also be binary.  */
12181
12182 static int
12183 ambi_op_p (code)
12184      enum tree_code code;
12185 {
12186   return (code == INDIRECT_REF
12187           || code == ADDR_EXPR
12188           || code == CONVERT_EXPR
12189           || code == NEGATE_EXPR
12190           || code == PREINCREMENT_EXPR
12191           || code == PREDECREMENT_EXPR);
12192 }
12193
12194 /* An operator with this name can only be unary.  */
12195
12196 static int
12197 unary_op_p (code)
12198      enum tree_code code;
12199 {
12200   return (code == TRUTH_NOT_EXPR
12201           || code == BIT_NOT_EXPR
12202           || code == COMPONENT_REF
12203           || code == TYPE_EXPR);
12204 }
12205
12206 /* Do a little sanity-checking on how they declared their operator.  */
12207
12208 void
12209 grok_op_properties (decl, virtualp, friendp)
12210      tree decl;
12211      int virtualp, friendp;
12212 {
12213   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12214   tree argtype;
12215   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12216   tree name = DECL_NAME (decl);
12217   enum tree_code operator_code;
12218   int arity;
12219
12220   /* Count the number of arguments.  */
12221   for (argtype = argtypes, arity = 0;
12222        argtype && argtype != void_list_node;
12223        argtype = TREE_CHAIN (argtype))
12224     ++arity;
12225
12226   if (current_class_type == NULL_TREE)
12227     friendp = 1;
12228
12229   if (DECL_CONV_FN_P (decl))
12230     operator_code = TYPE_EXPR;
12231   else
12232     do
12233       {
12234 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P)  \
12235         if (ansi_opname (CODE) == name)                                     \
12236           {                                                                 \
12237             operator_code = CODE;                                           \
12238             break;                                                          \
12239           }                                                                 \
12240         else if (ansi_assopname (CODE) == name)                             \
12241           {                                                                 \
12242             operator_code = CODE;                                           \
12243             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;                          \
12244             break;                                                          \
12245           }
12246
12247 #include "operators.def"
12248 #undef DEF_OPERATOR
12249
12250         my_friendly_abort (20000527);
12251       }
12252     while (0);
12253   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12254   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12255
12256   if (! friendp)
12257     {
12258       switch (operator_code)
12259         {
12260         case CALL_EXPR:
12261           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12262           break;
12263
12264         case ARRAY_REF:
12265           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12266           break;
12267
12268         case COMPONENT_REF:
12269         case MEMBER_REF:
12270           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12271           break;
12272
12273         case NEW_EXPR:
12274           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12275           break;
12276
12277         case DELETE_EXPR:
12278           TYPE_GETS_DELETE (current_class_type) |= 1;
12279           break;
12280
12281         case VEC_NEW_EXPR:
12282           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12283           break;
12284
12285         case VEC_DELETE_EXPR:
12286           TYPE_GETS_DELETE (current_class_type) |= 2;
12287           break;
12288
12289         default:
12290           break;
12291         }
12292     }
12293
12294   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12295     {
12296       /* When the compiler encounters the definition of A::operator new, it
12297          doesn't look at the class declaration to find out if it's static.  */
12298       if (methodp)
12299         revert_static_member_fn (decl);
12300
12301       TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12302     }
12303   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12304     {
12305       if (methodp)
12306         revert_static_member_fn (decl);
12307
12308       TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12309     }
12310   else
12311     {
12312       /* An operator function must either be a non-static member function
12313          or have at least one parameter of a class, a reference to a class,
12314          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12315       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12316         {
12317           if (operator_code == TYPE_EXPR
12318               || operator_code == CALL_EXPR
12319               || operator_code == COMPONENT_REF
12320               || operator_code == ARRAY_REF
12321               || operator_code == NOP_EXPR)
12322             cp_error ("`%D' must be a nonstatic member function", decl);
12323           else
12324             {
12325               tree p = argtypes;
12326
12327               if (DECL_STATIC_FUNCTION_P (decl))
12328                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12329
12330               if (p)
12331                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12332                   {
12333                     tree arg = TREE_VALUE (p);
12334                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12335                       arg = TREE_TYPE (arg);
12336
12337                     /* This lets bad template code slip through.  */
12338                     if (IS_AGGR_TYPE (arg)
12339                         || TREE_CODE (arg) == ENUMERAL_TYPE
12340                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12341                         || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12342                       goto foundaggr;
12343                   }
12344               cp_error
12345                 ("`%D' must have an argument of class or enumerated type",
12346                  decl);
12347             foundaggr:
12348               ;
12349             }
12350         }
12351
12352       if (operator_code == CALL_EXPR)
12353         return;                 /* No restrictions on args. */
12354
12355       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12356         {
12357           tree t = TREE_TYPE (name);
12358           if (! friendp)
12359             {
12360               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12361               const char *what = 0;
12362
12363               if (ref)
12364                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12365
12366               if (TREE_CODE (t) == VOID_TYPE)
12367                 what = "void";
12368               else if (t == current_class_type)
12369                 what = "the same type";
12370               /* Don't force t to be complete here.  */
12371               else if (IS_AGGR_TYPE (t)
12372                        && COMPLETE_TYPE_P (t)
12373                        && DERIVED_FROM_P (t, current_class_type))
12374                 what = "a base class";
12375
12376               if (what)
12377                 warning ("conversion to %s%s will never use a type conversion operator",
12378                          ref ? "a reference to " : "", what);
12379             }
12380         }
12381
12382       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12383           && operator_code == NOP_EXPR)
12384         {
12385           tree parmtype;
12386
12387           if (arity != 2 && methodp)
12388             {
12389               cp_error ("`%D' must take exactly one argument", decl);
12390               return;
12391             }
12392           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12393
12394           /* [class.copy]
12395
12396              A user-declared copy assignment operator X::operator= is
12397              a non-static non-template member function of class X with
12398              exactly one parameter of type X, X&, const X&, volatile
12399              X& or const volatile X&.  */
12400           if (copy_assignment_arg_p (parmtype, virtualp)
12401               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12402                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12403               && ! friendp)
12404             {
12405               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12406               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12407                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12408                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12409             }
12410         }
12411       else if (operator_code == COND_EXPR)
12412         {
12413           /* 13.4.0.3 */
12414           cp_error ("ISO C++ prohibits overloading operator ?:");
12415         }
12416       else if (ambi_op_p (operator_code))
12417         {
12418           if (arity == 1)
12419             /* We pick the one-argument operator codes by default, so
12420                we don't have to change anything.  */
12421             ;
12422           else if (arity == 2)
12423             {
12424               /* If we thought this was a unary operator, we now know
12425                  it to be a binary operator.  */
12426               switch (operator_code)
12427                 {
12428                 case INDIRECT_REF:
12429                   operator_code = MULT_EXPR;
12430                   break;
12431
12432                 case ADDR_EXPR:
12433                   operator_code = BIT_AND_EXPR;
12434                   break;
12435
12436                 case CONVERT_EXPR:
12437                   operator_code = PLUS_EXPR;
12438                   break;
12439
12440                 case NEGATE_EXPR:
12441                   operator_code = MINUS_EXPR;
12442                   break;
12443
12444                 case PREINCREMENT_EXPR:
12445                   operator_code = POSTINCREMENT_EXPR;
12446                   break;
12447
12448                 case PREDECREMENT_EXPR:
12449                   operator_code = POSTDECREMENT_EXPR;
12450                   break;
12451
12452                 default:
12453                   my_friendly_abort (20000527);
12454                 }
12455
12456               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12457
12458               if ((operator_code == POSTINCREMENT_EXPR
12459                    || operator_code == POSTDECREMENT_EXPR)
12460                   && ! processing_template_decl
12461                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12462                 {
12463                   if (methodp)
12464                     cp_error ("postfix `%D' must take `int' as its argument",
12465                               decl);
12466                   else
12467                     cp_error
12468                       ("postfix `%D' must take `int' as its second argument",
12469                        decl);
12470                 }
12471             }
12472           else
12473             {
12474               if (methodp)
12475                 cp_error ("`%D' must take either zero or one argument", decl);
12476               else
12477                 cp_error ("`%D' must take either one or two arguments", decl);
12478             }
12479
12480           /* More Effective C++ rule 6.  */
12481           if (warn_ecpp
12482               && (operator_code == POSTINCREMENT_EXPR
12483                   || operator_code == POSTDECREMENT_EXPR
12484                   || operator_code == PREINCREMENT_EXPR
12485                   || operator_code == PREDECREMENT_EXPR))
12486             {
12487               tree arg = TREE_VALUE (argtypes);
12488               tree ret = TREE_TYPE (TREE_TYPE (decl));
12489               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12490                 arg = TREE_TYPE (arg);
12491               arg = TYPE_MAIN_VARIANT (arg);
12492               if (operator_code == PREINCREMENT_EXPR
12493                   || operator_code == PREDECREMENT_EXPR)
12494                 {
12495                   if (TREE_CODE (ret) != REFERENCE_TYPE
12496                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12497                                        arg))
12498                     cp_warning ("prefix `%D' should return `%T'", decl,
12499                                 build_reference_type (arg));
12500                 }
12501               else
12502                 {
12503                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12504                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12505                 }
12506             }
12507         }
12508       else if (unary_op_p (operator_code))
12509         {
12510           if (arity != 1)
12511             {
12512               if (methodp)
12513                 cp_error ("`%D' must take `void'", decl);
12514               else
12515                 cp_error ("`%D' must take exactly one argument", decl);
12516             }
12517         }
12518       else /* if (binary_op_p (operator_code)) */
12519         {
12520           if (arity != 2)
12521             {
12522               if (methodp)
12523                 cp_error ("`%D' must take exactly one argument", decl);
12524               else
12525                 cp_error ("`%D' must take exactly two arguments", decl);
12526             }
12527
12528           /* More Effective C++ rule 7.  */
12529           if (warn_ecpp
12530               && (operator_code == TRUTH_ANDIF_EXPR
12531                   || operator_code == TRUTH_ORIF_EXPR
12532                   || operator_code == COMPOUND_EXPR))
12533             cp_warning ("user-defined `%D' always evaluates both arguments",
12534                         decl);
12535         }
12536
12537       /* Effective C++ rule 23.  */
12538       if (warn_ecpp
12539           && arity == 2
12540           && (operator_code == PLUS_EXPR
12541               || operator_code == MINUS_EXPR
12542               || operator_code == TRUNC_DIV_EXPR
12543               || operator_code == MULT_EXPR)
12544           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12545         cp_warning ("`%D' should return by value", decl);
12546
12547       /* 13.4.0.8 */
12548       for (; argtypes && argtypes != void_list_node;
12549           argtypes = TREE_CHAIN (argtypes))
12550         if (TREE_PURPOSE (argtypes))
12551           {
12552             TREE_PURPOSE (argtypes) = NULL_TREE;
12553             if (operator_code == POSTINCREMENT_EXPR
12554                 || operator_code == POSTDECREMENT_EXPR)
12555               {
12556                 if (pedantic)
12557                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12558               }
12559             else
12560               cp_error ("`%D' cannot have default arguments", decl);
12561           }
12562
12563     }
12564 }
12565 \f
12566 static const char *
12567 tag_name (code)
12568      enum tag_types code;
12569 {
12570   switch (code)
12571     {
12572     case record_type:
12573       return "struct";
12574     case class_type:
12575       return "class";
12576     case union_type:
12577       return "union ";
12578     case enum_type:
12579       return "enum";
12580     default:
12581       my_friendly_abort (981122);
12582     }
12583 }
12584
12585 /* Get the struct, enum or union (CODE says which) with tag NAME.
12586    Define the tag as a forward-reference if it is not defined.
12587
12588    C++: If a class derivation is given, process it here, and report
12589    an error if multiple derivation declarations are not identical.
12590
12591    If this is a definition, come in through xref_tag and only look in
12592    the current frame for the name (since C++ allows new names in any
12593    scope.)  */
12594
12595 tree
12596 xref_tag (code_type_node, name, globalize)
12597      tree code_type_node;
12598      tree name;
12599      int globalize;
12600 {
12601   enum tag_types tag_code;
12602   enum tree_code code;
12603   register tree ref, t;
12604   struct binding_level *b = current_binding_level;
12605   int got_type = 0;
12606   tree attributes = NULL_TREE;
12607   tree context = NULL_TREE;
12608
12609   /* If we are called from the parser, code_type_node will sometimes be a
12610      TREE_LIST.  This indicates that the user wrote
12611      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12612      use them later.  */
12613   if (TREE_CODE (code_type_node) == TREE_LIST)
12614     {
12615       attributes = TREE_PURPOSE (code_type_node);
12616       code_type_node = TREE_VALUE (code_type_node);
12617     }
12618
12619   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12620   switch (tag_code)
12621     {
12622     case record_type:
12623     case class_type:
12624       code = RECORD_TYPE;
12625       break;
12626     case union_type:
12627       code = UNION_TYPE;
12628       break;
12629     case enum_type:
12630       code = ENUMERAL_TYPE;
12631       break;
12632     default:
12633       my_friendly_abort (18);
12634     }
12635
12636   /* If a cross reference is requested, look up the type
12637      already defined for this tag and return it.  */
12638   if (TYPE_P (name))
12639     {
12640       t = name;
12641       name = TYPE_IDENTIFIER (t);
12642       got_type = 1;
12643     }
12644   else
12645     t = IDENTIFIER_TYPE_VALUE (name);
12646
12647   /* Warn about 'friend struct Inherited;' doing the wrong thing.  */
12648   if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12649     {
12650       static int explained;
12651
12652       cp_warning ("`%s %T' declares a new type at namespace scope;\n\
12653 to refer to the inherited type, say `%s %T::%T'%s",
12654                   tag_name (tag_code), name, tag_name (tag_code),
12655                   constructor_name (current_class_type), TYPE_IDENTIFIER (t),
12656                   (!explained ? "\n\
12657 (names from dependent base classes are not visible to unqualified name lookup)"
12658                    : ""));
12659
12660       explained = 1;
12661     }
12662
12663   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12664       && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12665     t = NULL_TREE;
12666
12667   if (! globalize)
12668     {
12669       /* If we know we are defining this tag, only look it up in
12670          this scope and don't try to find it as a type.  */
12671       ref = lookup_tag (code, name, b, 1);
12672     }
12673   else
12674     {
12675       if (t)
12676         {
12677           /* [dcl.type.elab] If the identifier resolves to a
12678              typedef-name or a template type-parameter, the
12679              elaborated-type-specifier is ill-formed.  */
12680           if (t != TYPE_MAIN_VARIANT (t)
12681               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12682             cp_pedwarn ("using typedef-name `%D' after `%s'",
12683                         TYPE_NAME (t), tag_name (tag_code));
12684           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12685             cp_error ("using template type parameter `%T' after `%s'",
12686                       t, tag_name (tag_code));
12687
12688           ref = t;
12689         }
12690       else
12691         ref = lookup_tag (code, name, b, 0);
12692
12693       if (! ref)
12694         {
12695           /* Try finding it as a type declaration.  If that wins,
12696              use it.  */
12697           ref = lookup_name (name, 1);
12698
12699           if (ref != NULL_TREE
12700               && processing_template_decl
12701               && DECL_CLASS_TEMPLATE_P (ref)
12702               && template_class_depth (current_class_type) == 0)
12703             /* Since GLOBALIZE is true, we're declaring a global
12704                template, so we want this type.  */
12705             ref = DECL_TEMPLATE_RESULT (ref);
12706
12707           if (ref && TREE_CODE (ref) == TYPE_DECL
12708               && TREE_CODE (TREE_TYPE (ref)) == code)
12709             ref = TREE_TYPE (ref);
12710           else
12711             ref = NULL_TREE;
12712         }
12713
12714       if (ref && current_class_type
12715           && template_class_depth (current_class_type)
12716           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12717         {
12718           /* Since GLOBALIZE is non-zero, we are not looking at a
12719              definition of this tag.  Since, in addition, we are currently
12720              processing a (member) template declaration of a template
12721              class, we must be very careful; consider:
12722
12723                template <class X>
12724                struct S1
12725
12726                template <class U>
12727                struct S2
12728                { template <class V>
12729                friend struct S1; };
12730
12731              Here, the S2::S1 declaration should not be confused with the
12732              outer declaration.  In particular, the inner version should
12733              have a template parameter of level 2, not level 1.  This
12734              would be particularly important if the member declaration
12735              were instead:
12736
12737                template <class V = U> friend struct S1;
12738
12739              say, when we should tsubst into `U' when instantiating
12740              S2.  On the other hand, when presented with:
12741
12742                  template <class T>
12743                  struct S1 {
12744                    template <class U>
12745                    struct S2 {};
12746                    template <class U>
12747                    friend struct S2;
12748                  };
12749
12750               we must find the inner binding eventually.  We
12751               accomplish this by making sure that the new type we
12752               create to represent this declaration has the right
12753               TYPE_CONTEXT.  */
12754           context = TYPE_CONTEXT (ref);
12755           ref = NULL_TREE;
12756         }
12757     }
12758
12759   if (! ref)
12760     {
12761       /* If no such tag is yet defined, create a forward-reference node
12762          and record it as the "definition".
12763          When a real declaration of this type is found,
12764          the forward-reference will be altered into a real type.  */
12765       if (code == ENUMERAL_TYPE)
12766         {
12767           cp_error ("use of enum `%#D' without previous declaration", name);
12768
12769           ref = make_node (ENUMERAL_TYPE);
12770
12771           /* Give the type a default layout like unsigned int
12772              to avoid crashing if it does not get defined.  */
12773           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12774           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12775           TYPE_USER_ALIGN (ref) = 0;
12776           TREE_UNSIGNED (ref) = 1;
12777           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12778           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12779           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12780
12781           /* Enable us to recognize when a type is created in class context.
12782              To do nested classes correctly, this should probably be cleared
12783              out when we leave this classes scope.  Currently this in only
12784              done in `start_enum'.  */
12785
12786           pushtag (name, ref, globalize);
12787         }
12788       else
12789         {
12790           struct binding_level *old_b = class_binding_level;
12791
12792           ref = make_aggr_type (code);
12793           TYPE_CONTEXT (ref) = context;
12794
12795 #ifdef NONNESTED_CLASSES
12796           /* Class types don't nest the way enums do.  */
12797           class_binding_level = (struct binding_level *)0;
12798 #endif
12799           pushtag (name, ref, globalize);
12800           class_binding_level = old_b;
12801         }
12802     }
12803   else
12804     {
12805       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12806         redeclare_class_template (ref, current_template_parms);
12807     }
12808
12809   /* Until the type is defined, tentatively accept whatever
12810      structure tag the user hands us.  */
12811   if (!COMPLETE_TYPE_P (ref)
12812       && ref != current_class_type
12813       /* Have to check this, in case we have contradictory tag info.  */
12814       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12815     {
12816       if (tag_code == class_type)
12817         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12818       else if (tag_code == record_type)
12819         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12820     }
12821
12822   TREE_TYPE (ref) = attributes;
12823
12824   return ref;
12825 }
12826
12827 tree
12828 xref_tag_from_type (old, id, globalize)
12829      tree old, id;
12830      int globalize;
12831 {
12832   tree code_type_node;
12833
12834   if (TREE_CODE (old) == RECORD_TYPE)
12835     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12836                       ? class_type_node : record_type_node);
12837   else
12838     code_type_node = union_type_node;
12839
12840   if (id == NULL_TREE)
12841     id = TYPE_IDENTIFIER (old);
12842
12843   return xref_tag (code_type_node, id, globalize);
12844 }
12845
12846 /* REF is a type (named NAME), for which we have just seen some
12847    baseclasses.  BINFO is a list of those baseclasses; the
12848    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12849    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12850    struct, or union.  */
12851
12852 void
12853 xref_basetypes (code_type_node, name, ref, binfo)
12854      tree code_type_node;
12855      tree name, ref;
12856      tree binfo;
12857 {
12858   /* In the declaration `A : X, Y, ... Z' we mark all the types
12859      (A, X, Y, ..., Z) so we can check for duplicates.  */
12860   tree binfos;
12861   tree base;
12862
12863   int i, len;
12864   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12865
12866   if (tag_code == union_type)
12867     {
12868       cp_error ("derived union `%T' invalid", ref);
12869       return;
12870     }
12871
12872   len = list_length (binfo);
12873
12874   /* First, make sure that any templates in base-classes are
12875      instantiated.  This ensures that if we call ourselves recursively
12876      we do not get confused about which classes are marked and which
12877      are not.  */
12878   for (base = binfo; base; base = TREE_CHAIN (base))
12879     complete_type (TREE_VALUE (base));
12880
12881   SET_CLASSTYPE_MARKED (ref);
12882   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12883
12884   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12885     {
12886       /* The base of a derived struct is public by default.  */
12887       int via_public
12888         = (TREE_PURPOSE (binfo) == access_public_node
12889            || TREE_PURPOSE (binfo) == access_public_virtual_node
12890            || (tag_code != class_type
12891                && (TREE_PURPOSE (binfo) == access_default_node
12892                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12893       int via_protected
12894         = (TREE_PURPOSE (binfo) == access_protected_node
12895            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12896       int via_virtual
12897         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12898            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12899            || TREE_PURPOSE (binfo) == access_public_virtual_node
12900            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12901       tree basetype = TREE_VALUE (binfo);
12902       tree base_binfo;
12903
12904       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12905         basetype = TREE_TYPE (basetype);
12906       if (!basetype
12907           || (TREE_CODE (basetype) != RECORD_TYPE
12908               && TREE_CODE (basetype) != TYPENAME_TYPE
12909               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12910               && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
12911         {
12912           cp_error ("base type `%T' fails to be a struct or class type",
12913                     TREE_VALUE (binfo));
12914           continue;
12915         }
12916
12917       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12918
12919       /* This code replaces similar code in layout_basetypes.
12920          We put the complete_type first for implicit `typename'.  */
12921       if (!COMPLETE_TYPE_P (basetype)
12922           && ! (current_template_parms && uses_template_parms (basetype)))
12923         {
12924           cp_error ("base class `%T' has incomplete type", basetype);
12925           continue;
12926         }
12927       else
12928         {
12929           if (CLASSTYPE_MARKED (basetype))
12930             {
12931               if (basetype == ref)
12932                 cp_error ("recursive type `%T' undefined", basetype);
12933               else
12934                 cp_error ("duplicate base type `%T' invalid", basetype);
12935               continue;
12936             }
12937
12938           if (TYPE_FOR_JAVA (basetype)
12939               && (current_lang_stack
12940                   == &VARRAY_TREE (current_lang_base, 0)))
12941             TYPE_FOR_JAVA (ref) = 1;
12942
12943           /* Note that the BINFO records which describe individual
12944              inheritances are *not* shared in the lattice!  They
12945              cannot be shared because a given baseclass may be
12946              inherited with different `accessibility' by different
12947              derived classes.  (Each BINFO record describing an
12948              individual inheritance contains flags which say what
12949              the `accessibility' of that particular inheritance is.)  */
12950
12951           base_binfo
12952             = make_binfo (size_zero_node, basetype,
12953                           CLASS_TYPE_P (basetype)
12954                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12955                           CLASS_TYPE_P (basetype)
12956                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12957
12958           TREE_VEC_ELT (binfos, i) = base_binfo;
12959           TREE_VIA_PUBLIC (base_binfo) = via_public;
12960           TREE_VIA_PROTECTED (base_binfo) = via_protected;
12961           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12962           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12963
12964           /* We need to unshare the binfos now so that lookups during class
12965              definition work.  */
12966           unshare_base_binfos (base_binfo);
12967
12968           SET_CLASSTYPE_MARKED (basetype);
12969
12970           /* We are free to modify these bits because they are meaningless
12971              at top level, and BASETYPE is a top-level type.  */
12972           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12973             {
12974               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12975               /* Converting to a virtual base class requires looking
12976                  up the offset of the virtual base.  */
12977               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12978             }
12979
12980           if (CLASS_TYPE_P (basetype))
12981             {
12982               TYPE_HAS_NEW_OPERATOR (ref)
12983                 |= TYPE_HAS_NEW_OPERATOR (basetype);
12984               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12985                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12986               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12987               /* If the base-class uses multiple inheritance, so do we.  */
12988               TYPE_USES_MULTIPLE_INHERITANCE (ref)
12989                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12990               /* Likewise, if converting to a base of the base may require
12991                  code, then we may need to generate code to convert to a
12992                  base as well.  */
12993               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12994                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12995             }
12996
12997           i += 1;
12998         }
12999     }
13000   if (i)
13001     TREE_VEC_LENGTH (binfos) = i;
13002   else
13003     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13004
13005   if (i > 1)
13006     {
13007       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13008       /* If there is more than one non-empty they cannot be at the same
13009          address.  */
13010       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13011     }
13012
13013   /* Unmark all the types.  */
13014   while (--i >= 0)
13015     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13016   CLEAR_CLASSTYPE_MARKED (ref);
13017
13018   /* Now that we know all the base-classes, set up the list of virtual
13019      bases.  */
13020   get_vbase_types (ref);
13021 }
13022
13023 \f
13024 /* Begin compiling the definition of an enumeration type.
13025    NAME is its name (or null if anonymous).
13026    Returns the type object, as yet incomplete.
13027    Also records info about it so that build_enumerator
13028    may be used to declare the individual values as they are read.  */
13029
13030 tree
13031 start_enum (name)
13032      tree name;
13033 {
13034   register tree enumtype = NULL_TREE;
13035   struct binding_level *b = current_binding_level;
13036
13037   /* If this is the real definition for a previous forward reference,
13038      fill in the contents in the same object that used to be the
13039      forward reference.  */
13040
13041   if (name != NULL_TREE)
13042     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13043
13044   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13045     {
13046       cp_error ("multiple definition of `%#T'", enumtype);
13047       cp_error_at ("previous definition here", enumtype);
13048       /* Clear out TYPE_VALUES, and start again.  */
13049       TYPE_VALUES (enumtype) = NULL_TREE;
13050     }
13051   else
13052     {
13053       enumtype = make_node (ENUMERAL_TYPE);
13054       pushtag (name, enumtype, 0);
13055     }
13056
13057   if (current_class_type)
13058     TREE_ADDRESSABLE (b->tags) = 1;
13059
13060   GNU_xref_decl (current_function_decl, enumtype);
13061   return enumtype;
13062 }
13063
13064 /* After processing and defining all the values of an enumeration type,
13065    install their decls in the enumeration type and finish it off.
13066    ENUMTYPE is the type object and VALUES a list of name-value pairs.
13067    Returns ENUMTYPE.  */
13068
13069 tree
13070 finish_enum (enumtype)
13071      tree enumtype;
13072 {
13073   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
13074   /* Calculate the maximum value of any enumerator in this type.  */
13075
13076   tree values = TYPE_VALUES (enumtype);
13077   if (values)
13078     {
13079       tree pair;
13080
13081       for (pair = values; pair; pair = TREE_CHAIN (pair))
13082         {
13083           tree decl;
13084           tree value;
13085
13086           /* The TREE_VALUE is a CONST_DECL for this enumeration
13087              constant.  */
13088           decl = TREE_VALUE (pair);
13089
13090           /* [dcl.enum]
13091
13092              Following the closing brace of an enum-specifier, each
13093              enumerator has the type of its enumeration.  Prior to the
13094              closing brace, the type of each enumerator is the type of
13095              its initializing value.  */
13096           TREE_TYPE (decl) = enumtype;
13097
13098           /* The DECL_INITIAL will be NULL if we are processing a
13099              template declaration and this enumeration constant had no
13100              explicit initializer.  */
13101           value = DECL_INITIAL (decl);
13102           if (value && !processing_template_decl)
13103             {
13104               /* Set the TREE_TYPE for the VALUE as well.  That's so
13105                  that when we call decl_constant_value we get an
13106                  entity of the right type (but with the constant
13107                  value).  Since we shouldn't ever call
13108                  decl_constant_value on a template type, there's no
13109                  reason to do that when processing_template_decl.
13110                  And, if the expression is something like a
13111                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13112                  wreak havoc on the intended type of the expression.
13113
13114                  Of course, there's also no point in trying to compute
13115                  minimum or maximum values if we're in a template.  */
13116               TREE_TYPE (value) = enumtype;
13117
13118               if (!minnode)
13119                 minnode = maxnode = value;
13120               else if (tree_int_cst_lt (maxnode, value))
13121                 maxnode = value;
13122               else if (tree_int_cst_lt (value, minnode))
13123                 minnode = value;
13124             }
13125
13126           if (processing_template_decl)
13127             /* If this is just a template, leave the CONST_DECL
13128                alone.  That way tsubst_copy will find CONST_DECLs for
13129                CONST_DECLs, and not INTEGER_CSTs.  */
13130             ;
13131           else
13132             /* In the list we're building up, we want the enumeration
13133                values, not the CONST_DECLs.  */
13134             TREE_VALUE (pair) = value;
13135         }
13136     }
13137   else
13138     maxnode = minnode = integer_zero_node;
13139
13140   TYPE_VALUES (enumtype) = nreverse (values);
13141
13142   if (processing_template_decl)
13143     {
13144       tree scope = current_scope ();
13145       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13146         add_stmt (build_min (TAG_DEFN, enumtype));
13147     }
13148   else
13149     {
13150       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
13151       int lowprec = min_precision (minnode, unsignedp);
13152       int highprec = min_precision (maxnode, unsignedp);
13153       int precision = MAX (lowprec, highprec);
13154       tree tem;
13155
13156       TYPE_SIZE (enumtype) = NULL_TREE;
13157
13158       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13159
13160       TYPE_PRECISION (enumtype) = precision;
13161       if (unsignedp)
13162         fixup_unsigned_type (enumtype);
13163       else
13164         fixup_signed_type (enumtype);
13165
13166       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13167         /* Use the width of the narrowest normal C type which is wide
13168            enough.  */
13169         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13170                                                     (precision, 1));
13171       else
13172         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13173
13174       TYPE_SIZE (enumtype) = 0;
13175       layout_type (enumtype);
13176
13177       /* Fix up all variant types of this enum type.  */
13178       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
13179            tem = TYPE_NEXT_VARIANT (tem))
13180         {
13181           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
13182           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
13183           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
13184           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
13185           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
13186           TYPE_MODE (tem) = TYPE_MODE (enumtype);
13187           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
13188           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
13189           TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
13190           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
13191         }
13192
13193       /* Finish debugging output for this type.  */
13194       rest_of_type_compilation (enumtype, namespace_bindings_p ());
13195     }
13196
13197   return enumtype;
13198 }
13199
13200 /* Build and install a CONST_DECL for an enumeration constant of the
13201    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13202    Assignment of sequential values by default is handled here.  */
13203
13204 void
13205 build_enumerator (name, value, enumtype)
13206      tree name;
13207      tree value;
13208      tree enumtype;
13209 {
13210   tree decl;
13211   tree context;
13212   tree type;
13213   tree values;
13214
13215   /* Remove no-op casts from the value.  */
13216   if (value)
13217     STRIP_TYPE_NOPS (value);
13218
13219   if (! processing_template_decl)
13220     {
13221       /* Validate and default VALUE.  */
13222       if (value != NULL_TREE)
13223         {
13224           value = decl_constant_value (value);
13225
13226           if (TREE_CODE (value) == INTEGER_CST)
13227             {
13228               value = default_conversion (value);
13229               constant_expression_warning (value);
13230             }
13231           else
13232             {
13233               cp_error ("enumerator value for `%D' not integer constant", name);
13234               value = NULL_TREE;
13235             }
13236         }
13237
13238       /* Default based on previous value.  */
13239       if (value == NULL_TREE && ! processing_template_decl)
13240         {
13241           tree prev_value;
13242
13243           if (TYPE_VALUES (enumtype))
13244             {
13245               /* The next value is the previous value ... */
13246               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13247               /* ... plus one.  */
13248               value = cp_build_binary_op (PLUS_EXPR,
13249                                           prev_value,
13250                                           integer_one_node);
13251
13252               if (tree_int_cst_lt (value, prev_value))
13253                 cp_error ("overflow in enumeration values at `%D'", name);
13254             }
13255           else
13256             value = integer_zero_node;
13257         }
13258
13259       /* Remove no-op casts from the value.  */
13260       if (value)
13261         STRIP_TYPE_NOPS (value);
13262 #if 0
13263       /* To fix MAX_VAL enum consts. (bkoz)  */
13264       TREE_TYPE (value) = integer_type_node;
13265 #endif
13266     }
13267
13268   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13269      Even in other cases, we will later (in finish_enum) be setting
13270      the type of VALUE.  But, we don't need to make a copy if this
13271      VALUE is one of the enumeration constants for this same
13272      enumeration type.  */
13273   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13274     if (TREE_VALUE (values) == value)
13275       break;
13276   /* If we didn't break out of the loop, then we do need a copy.  */
13277   if (!values && value)
13278     value = copy_node (value);
13279
13280   /* C++ associates enums with global, function, or class declarations.  */
13281   context = current_scope ();
13282
13283   /* Build the actual enumeration constant.  Note that the enumeration
13284     constants have the type of their initializers until the
13285     enumeration is complete:
13286
13287       [ dcl.enum ]
13288
13289       Following the closing brace of an enum-specifier, each enumer-
13290       ator has the type of its enumeration.  Prior to the closing
13291       brace, the type of each enumerator is the type of its
13292       initializing value.
13293
13294     In finish_enum we will reset the type.  Of course, if we're
13295     processing a template, there may be no value.   */
13296   type = value ? TREE_TYPE (value) : NULL_TREE;
13297
13298   if (context && context == current_class_type)
13299     /* This enum declaration is local to the class.  We need the full
13300        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13301     decl = build_lang_decl (CONST_DECL, name, type);
13302   else
13303     /* It's a global enum, or it's local to a function.  (Note local to
13304       a function could mean local to a class method.  */
13305     decl = build_decl (CONST_DECL, name, type);
13306
13307   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13308   DECL_INITIAL (decl) = value;
13309   TREE_READONLY (decl) = 1;
13310
13311   if (context && context == current_class_type)
13312     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13313       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13314       things like `S::i' later.)  */
13315     finish_member_declaration (decl);
13316   else
13317     {
13318       pushdecl (decl);
13319       GNU_xref_decl (current_function_decl, decl);
13320     }
13321
13322   /* Add this enumeration constant to the list for this type.  */
13323   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13324 }
13325
13326 \f
13327 /* We're defining DECL.  Make sure that it's type is OK.  */
13328
13329 static void
13330 check_function_type (decl, current_function_parms)
13331      tree decl;
13332      tree current_function_parms;
13333 {
13334   tree fntype = TREE_TYPE (decl);
13335   tree return_type = complete_type (TREE_TYPE (fntype));
13336
13337   /* In a function definition, arg types must be complete.  */
13338   require_complete_types_for_parms (current_function_parms);
13339
13340   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13341     {
13342       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13343
13344       /* Make it return void instead, but don't change the
13345          type of the DECL_RESULT, in case we have a named return value.  */
13346       if (TREE_CODE (fntype) == METHOD_TYPE)
13347         {
13348           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13349           TREE_TYPE (decl)
13350             = build_cplus_method_type (ctype,
13351                                        void_type_node,
13352                                        FUNCTION_ARG_CHAIN (decl));
13353         }
13354       else
13355         TREE_TYPE (decl)
13356           = build_function_type (void_type_node,
13357                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13358       TREE_TYPE (decl)
13359         = build_exception_variant (fntype,
13360                                    TYPE_RAISES_EXCEPTIONS (fntype));
13361     }
13362   else
13363     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13364 }
13365
13366 /* Create the FUNCTION_DECL for a function definition.
13367    DECLSPECS and DECLARATOR are the parts of the declaration;
13368    they describe the function's name and the type it returns,
13369    but twisted together in a fashion that parallels the syntax of C.
13370
13371    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13372    DECLARATOR is really the DECL for the function we are about to
13373    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13374    indicating that the function is an inline defined in-class.
13375
13376    This function creates a binding context for the function body
13377    as well as setting up the FUNCTION_DECL in current_function_decl.
13378
13379    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13380    (it defines a datum instead), we return 0, which tells
13381    yyparse to report a parse error.
13382
13383    For C++, we must first check whether that datum makes any sense.
13384    For example, "class A local_a(1,2);" means that variable local_a
13385    is an aggregate of type A, which should have a constructor
13386    applied to it with the argument list [1, 2].  */
13387
13388 int
13389 start_function (declspecs, declarator, attrs, flags)
13390      tree declspecs, declarator, attrs;
13391      int flags;
13392 {
13393   tree decl1;
13394   tree ctype = NULL_TREE;
13395   tree fntype;
13396   tree restype;
13397   extern int have_extern_spec;
13398   extern int used_extern_spec;
13399   int doing_friend = 0;
13400   struct binding_level *bl;
13401   tree current_function_parms;
13402
13403   /* Sanity check.  */
13404   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13405   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13406
13407   /* This should only be done once on the top most decl.  */
13408   if (have_extern_spec && !used_extern_spec)
13409     {
13410       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13411       used_extern_spec = 1;
13412     }
13413
13414   if (flags & SF_PRE_PARSED)
13415     {
13416       decl1 = declarator;
13417
13418       fntype = TREE_TYPE (decl1);
13419       if (TREE_CODE (fntype) == METHOD_TYPE)
13420         ctype = TYPE_METHOD_BASETYPE (fntype);
13421
13422       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13423          the (lexical) scope of the class in which it is defined.  */
13424       if (!ctype && DECL_FRIEND_P (decl1))
13425         {
13426           ctype = DECL_FRIEND_CONTEXT (decl1);
13427
13428           /* CTYPE could be null here if we're dealing with a template;
13429              for example, `inline friend float foo()' inside a template
13430              will have no CTYPE set.  */
13431           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13432             ctype = NULL_TREE;
13433           else
13434             doing_friend = 1;
13435         }
13436
13437       last_function_parms = DECL_ARGUMENTS (decl1);
13438       last_function_parm_tags = NULL_TREE;
13439     }
13440   else
13441     {
13442       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13443       /* If the declarator is not suitable for a function definition,
13444          cause a syntax error.  */
13445       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13446
13447       fntype = TREE_TYPE (decl1);
13448
13449       restype = TREE_TYPE (fntype);
13450       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13451         {
13452           cp_error ("semicolon missing after declaration of `%#T'", restype);
13453           shadow_tag (build_tree_list (NULL_TREE, restype));
13454           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13455           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13456             fntype = build_function_type (integer_type_node,
13457                                           TYPE_ARG_TYPES (fntype));
13458           else
13459             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13460                                               integer_type_node,
13461                                               TYPE_ARG_TYPES (fntype));
13462           TREE_TYPE (decl1) = fntype;
13463         }
13464
13465       if (TREE_CODE (fntype) == METHOD_TYPE)
13466         ctype = TYPE_METHOD_BASETYPE (fntype);
13467       else if (DECL_MAIN_P (decl1))
13468         {
13469           /* If this doesn't return integer_type, complain.  */
13470           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13471             {
13472               if (pedantic || warn_return_type)
13473                 pedwarn ("return type for `main' changed to `int'");
13474               TREE_TYPE (decl1) = fntype = default_function_type;
13475             }
13476         }
13477     }
13478
13479   /* Sometimes we don't notice that a function is a static member, and
13480      build a METHOD_TYPE for it.  Fix that up now.  */
13481   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13482       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13483     {
13484       revert_static_member_fn (decl1);
13485       last_function_parms = TREE_CHAIN (last_function_parms);
13486       ctype = NULL_TREE;
13487     }
13488
13489   /* Warn if function was previously implicitly declared
13490      (but not if we warned then).  */
13491   if (! warn_implicit
13492       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13493     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13494
13495   /* Set up current_class_type, and enter the scope of the class, if
13496      appropriate.  */
13497   if (ctype)
13498     push_nested_class (ctype, 1);
13499   else if (DECL_STATIC_FUNCTION_P (decl1))
13500     push_nested_class (DECL_CONTEXT (decl1), 2);
13501
13502   /* Now that we have entered the scope of the class, we must restore
13503      the bindings for any template parameters surrounding DECL1, if it
13504      is an inline member template.  (Order is important; consider the
13505      case where a template parameter has the same name as a field of
13506      the class.)  It is not until after this point that
13507      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13508   if (flags & SF_INCLASS_INLINE)
13509     maybe_begin_member_template_processing (decl1);
13510
13511   /* Effective C++ rule 15.  */
13512   if (warn_ecpp
13513       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13514       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13515     cp_warning ("`operator=' should return a reference to `*this'");
13516
13517   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13518      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13519   if (!DECL_INITIAL (decl1))
13520     DECL_INITIAL (decl1) = error_mark_node;
13521
13522 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13523   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13524 #endif
13525
13526   /* This function exists in static storage.
13527      (This does not mean `static' in the C sense!)  */
13528   TREE_STATIC (decl1) = 1;
13529
13530   /* We must call push_template_decl after current_class_type is set
13531      up.  (If we are processing inline definitions after exiting a
13532      class scope, current_class_type will be NULL_TREE until set above
13533      by push_nested_class.)  */
13534   if (processing_template_decl)
13535     decl1 = push_template_decl (decl1);
13536
13537   /* We are now in the scope of the function being defined.  */
13538   current_function_decl = decl1;
13539
13540   /* Save the parm names or decls from this function's declarator
13541      where store_parm_decls will find them.  */
13542   current_function_parms = last_function_parms;
13543   current_function_parm_tags = last_function_parm_tags;
13544
13545   /* Make sure the parameter and return types are reasonable.  When
13546      you declare a function, these types can be incomplete, but they
13547      must be complete when you define the function.  */
13548   if (! processing_template_decl)
13549     check_function_type (decl1, current_function_parms);
13550
13551   /* Build the return declaration for the function.  */
13552   restype = TREE_TYPE (fntype);
13553   if (!processing_template_decl)
13554     {
13555       if (!DECL_RESULT (decl1))
13556         {
13557           DECL_RESULT (decl1)
13558             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13559           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13560                                       DECL_RESULT (decl1));
13561         }
13562     }
13563   else
13564     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13565     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13566
13567   /* Initialize RTL machinery.  We cannot do this until
13568      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13569      even when processing a template; this is how we get
13570      CFUN set up, and our per-function variables initialized.
13571      FIXME factor out the non-RTL stuff.  */
13572   bl = current_binding_level;
13573   init_function_start (decl1, input_filename, lineno);
13574   current_binding_level = bl;
13575
13576   /* Even though we're inside a function body, we still don't want to
13577      call expand_expr to calculate the size of a variable-sized array.
13578      We haven't necessarily assigned RTL to all variables yet, so it's
13579      not safe to try to expand expressions involving them.  */
13580   immediate_size_expand = 0;
13581   cfun->x_dont_save_pending_sizes_p = 1;
13582
13583   /* Start the statement-tree, start the tree now.  */
13584   begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13585
13586   /* Let the user know we're compiling this function.  */
13587   announce_function (decl1);
13588
13589   /* Record the decl so that the function name is defined.
13590      If we already have a decl for this name, and it is a FUNCTION_DECL,
13591      use the old decl.  */
13592   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13593     {
13594       /* A specialization is not used to guide overload resolution.  */
13595       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13596           && ! DECL_FUNCTION_MEMBER_P (decl1))
13597         decl1 = pushdecl (decl1);
13598       else
13599         {
13600           /* We need to set the DECL_CONTEXT. */
13601           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13602             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13603           /* And make sure we have enough default args.  */
13604           check_default_args (decl1);
13605         }
13606       fntype = TREE_TYPE (decl1);
13607     }
13608
13609   /* Reset these in case the call to pushdecl changed them.  */
13610   current_function_decl = decl1;
13611   cfun->decl = decl1;
13612
13613   /* If we are (erroneously) defining a function that we have already
13614      defined before, wipe out what we knew before.  */
13615   if (!DECL_PENDING_INLINE_P (decl1)
13616       && DECL_SAVED_FUNCTION_DATA (decl1))
13617     {
13618       free (DECL_SAVED_FUNCTION_DATA (decl1));
13619       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13620     }
13621
13622   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13623     {
13624       /* We know that this was set up by `grokclassfn'.  We do not
13625          wait until `store_parm_decls', since evil parse errors may
13626          never get us to that point.  Here we keep the consistency
13627          between `current_class_type' and `current_class_ptr'.  */
13628       tree t = DECL_ARGUMENTS (decl1);
13629
13630       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13631                           162);
13632       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13633                           19990811);
13634
13635       cp_function_chain->x_current_class_ref
13636         = build_indirect_ref (t, NULL_PTR);
13637       cp_function_chain->x_current_class_ptr = t;
13638
13639       /* Constructors and destructors need to know whether they're "in
13640          charge" of initializing virtual base classes.  */
13641       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13642         current_in_charge_parm = TREE_CHAIN (t);
13643     }
13644
13645   if (DECL_INTERFACE_KNOWN (decl1))
13646     {
13647       tree ctx = decl_function_context (decl1);
13648
13649       if (DECL_NOT_REALLY_EXTERN (decl1))
13650         DECL_EXTERNAL (decl1) = 0;
13651
13652       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13653           && TREE_PUBLIC (ctx))
13654         /* This is a function in a local class in an extern inline
13655            function.  */
13656         comdat_linkage (decl1);
13657     }
13658   /* If this function belongs to an interface, it is public.
13659      If it belongs to someone else's interface, it is also external.
13660      This only affects inlines and template instantiations.  */
13661   else if (interface_unknown == 0
13662            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13663                || flag_alt_external_templates))
13664     {
13665       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13666           || processing_template_decl)
13667         {
13668           DECL_EXTERNAL (decl1)
13669             = (interface_only
13670                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13671                    && !DECL_VINDEX (decl1)));
13672
13673           /* For WIN32 we also want to put these in linkonce sections.  */
13674           maybe_make_one_only (decl1);
13675         }
13676       else
13677         DECL_EXTERNAL (decl1) = 0;
13678       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13679       DECL_INTERFACE_KNOWN (decl1) = 1;
13680     }
13681   else if (interface_unknown && interface_only
13682            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13683                || flag_alt_external_templates))
13684     {
13685       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13686          interface, we will have interface_only set but not
13687          interface_known.  In that case, we don't want to use the normal
13688          heuristics because someone will supply a #pragma implementation
13689          elsewhere, and deducing it here would produce a conflict.  */
13690       comdat_linkage (decl1);
13691       DECL_EXTERNAL (decl1) = 0;
13692       DECL_INTERFACE_KNOWN (decl1) = 1;
13693       DECL_DEFER_OUTPUT (decl1) = 1;
13694     }
13695   else
13696     {
13697       /* This is a definition, not a reference.
13698          So clear DECL_EXTERNAL.  */
13699       DECL_EXTERNAL (decl1) = 0;
13700
13701       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13702           && ! DECL_INTERFACE_KNOWN (decl1)
13703           /* Don't try to defer nested functions for now.  */
13704           && ! decl_function_context (decl1))
13705         DECL_DEFER_OUTPUT (decl1) = 1;
13706       else
13707         DECL_INTERFACE_KNOWN (decl1) = 1;
13708     }
13709
13710   pushlevel (0);
13711   current_binding_level->parm_flag = 1;
13712
13713   if (attrs)
13714     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13715
13716   /* We need to do this even if we aren't expanding yet so that
13717      assemble_external works.  */
13718   make_function_rtl (decl1);
13719
13720   /* Promote the value to int before returning it.  */
13721   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13722     restype = type_promotes_to (restype);
13723
13724   /* If this fcn was already referenced via a block-scope `extern' decl
13725      (or an implicit decl), propagate certain information about the usage.  */
13726   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13727     TREE_ADDRESSABLE (decl1) = 1;
13728
13729   if (DECL_RESULT (decl1) == NULL_TREE)
13730     {
13731       DECL_RESULT (decl1)
13732         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13733       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13734       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13735     }
13736
13737   ++function_depth;
13738
13739   if (DECL_DESTRUCTOR_P (decl1))
13740     {
13741       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13742       DECL_CONTEXT (dtor_label) = current_function_decl;
13743     }
13744   /* Under the old ABI we return `this' from constructors, so we make
13745      ordinary `return' statements in constructors jump to CTOR_LABEL;
13746      from there we return `this'.  Under the new ABI, we don't bother
13747      with any of this.  By not setting CTOR_LABEL the remainder of the
13748      machinery is automatically disabled.  */
13749   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13750     {
13751       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13752       DECL_CONTEXT (ctor_label) = current_function_decl;
13753     }
13754
13755   store_parm_decls (current_function_parms);
13756
13757   return 1;
13758 }
13759 \f
13760 /* Store the parameter declarations into the current function declaration.
13761    This is called after parsing the parameter declarations, before
13762    digesting the body of the function.
13763
13764    Also install to binding contour return value identifier, if any.  */
13765
13766 static void
13767 store_parm_decls (current_function_parms)
13768      tree current_function_parms;
13769 {
13770   register tree fndecl = current_function_decl;
13771   register tree parm;
13772   int parms_have_cleanups = 0;
13773   tree cleanups = NULL_TREE;
13774
13775   /* This is a list of types declared among parms in a prototype.  */
13776   tree parmtags = current_function_parm_tags;
13777
13778   /* This is a chain of any other decls that came in among the parm
13779      declarations.  If a parm is declared with  enum {foo, bar} x;
13780      then CONST_DECLs for foo and bar are put here.  */
13781   tree nonparms = NULL_TREE;
13782
13783   if (current_function_parms)
13784     {
13785       /* This case is when the function was defined with an ANSI prototype.
13786          The parms already have decls, so we need not do anything here
13787          except record them as in effect
13788          and complain if any redundant old-style parm decls were written.  */
13789
13790       tree specparms = current_function_parms;
13791       tree next;
13792
13793       /* Must clear this because it might contain TYPE_DECLs declared
13794              at class level.  */
13795       storedecls (NULL_TREE);
13796
13797       /* If we're doing semantic analysis, then we'll call pushdecl
13798              for each of these.  We must do them in reverse order so that
13799              they end in the correct forward order.  */
13800       specparms = nreverse (specparms);
13801
13802       for (parm = specparms; parm; parm = next)
13803         {
13804           next = TREE_CHAIN (parm);
13805           if (TREE_CODE (parm) == PARM_DECL)
13806             {
13807               tree cleanup;
13808
13809               if (DECL_NAME (parm) == NULL_TREE
13810                   || TREE_CODE (parm) != VOID_TYPE)
13811                 pushdecl (parm);
13812               else
13813                 cp_error ("parameter `%D' declared void", parm);
13814
13815               cleanup = (processing_template_decl
13816                          ? NULL_TREE
13817                          : maybe_build_cleanup (parm));
13818
13819               if (cleanup)
13820                 cleanups = tree_cons (parm, cleanup, cleanups);
13821             }
13822           else
13823             {
13824               /* If we find an enum constant or a type tag,
13825                  put it aside for the moment.  */
13826               TREE_CHAIN (parm) = NULL_TREE;
13827               nonparms = chainon (nonparms, parm);
13828             }
13829         }
13830
13831       /* Get the decls in their original chain order and record in the
13832          function.  This is all and only the PARM_DECLs that were
13833          pushed into scope by the loop above.  */
13834       DECL_ARGUMENTS (fndecl) = getdecls ();
13835       storetags (chainon (parmtags, gettags ()));
13836     }
13837   else
13838     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13839
13840   /* Now store the final chain of decls for the arguments
13841      as the decl-chain of the current lexical scope.
13842      Put the enumerators in as well, at the front so that
13843      DECL_ARGUMENTS is not modified.  */
13844   storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13845
13846   /* Now that we have initialized the parms, we can start their
13847      cleanups.  We cannot do this before, since expand_decl_cleanup
13848      should not be called before the parm can be used.  */
13849   while (cleanups)
13850     {
13851       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13852                            TREE_VALUE (cleanups));
13853       cleanups = TREE_CHAIN (cleanups);
13854     }
13855
13856   /* Create a binding contour which can be used to catch
13857      cleanup-generated temporaries.  */
13858   if (parms_have_cleanups)
13859     pushlevel (0);
13860
13861   /* Do the starting of the exception specifications, if we have any.  */
13862   if (flag_exceptions && !processing_template_decl
13863       && flag_enforce_eh_specs
13864       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13865     current_eh_spec_try_block = expand_start_eh_spec ();
13866 }
13867
13868 \f
13869 /* We have finished doing semantic analysis on DECL, but have not yet
13870    generated RTL for its body.  Save away our current state, so that
13871    when we want to generate RTL later we know what to do.  */
13872
13873 static void
13874 save_function_data (decl)
13875      tree decl;
13876 {
13877   struct cp_language_function *f;
13878
13879   /* Save the language-specific per-function data so that we can
13880      get it back when we really expand this function.  */
13881   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13882                       19990908);
13883
13884   /* Make a copy.  */
13885   f = ((struct cp_language_function *)
13886        xmalloc (sizeof (struct cp_language_function)));
13887   memcpy (f, cp_function_chain, sizeof (struct cp_language_function));
13888   DECL_SAVED_FUNCTION_DATA (decl) = f;
13889
13890   /* Clear out the bits we don't need.  */
13891   f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
13892   f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
13893   f->x_named_label_uses = NULL;
13894   f->bindings = NULL;
13895
13896   /* When we get back here again, we will be expanding.  */
13897   f->x_expanding_p = 1;
13898
13899   /* If we've already decided that we cannot inline this function, we
13900      must remember that fact when we actually go to expand the
13901      function.  */
13902   f->cannot_inline = current_function_cannot_inline;
13903 }
13904
13905 /* At the end of every constructor we generate to code to return
13906    `this'.  Do that now.  */
13907
13908 static void
13909 finish_constructor_body ()
13910 {
13911   /* Any return from a constructor will end up here.  */
13912   if (ctor_label)
13913     add_stmt (build_stmt (LABEL_STMT, ctor_label));
13914
13915   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13916      generate the return, rather than a goto to CTOR_LABEL.  */
13917   ctor_label = NULL_TREE;
13918   /* In check_return_expr we translate an empty return from a
13919      constructor to a return of `this'.  */
13920   finish_return_stmt (NULL_TREE);
13921   /* Mark the end of the constructor.  */
13922   add_stmt (build_stmt (CTOR_STMT));
13923 }
13924
13925 /* At the end of every destructor we generate code to restore virtual
13926    function tables to the values desired by base classes and to call
13927    to base class destructors.  Do that now.  */
13928
13929 static void
13930 finish_destructor_body ()
13931 {
13932   tree compound_stmt;
13933   tree virtual_size;
13934   tree exprstmt;
13935   tree if_stmt;
13936
13937   /* Create a block to contain all the extra code.  */
13938   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13939
13940   /* Any return from a destructor will end up here.  */
13941   add_stmt (build_stmt (LABEL_STMT, dtor_label));
13942
13943   /* Generate the code to call destructor on base class.  If this
13944      destructor belongs to a class with virtual functions, then set
13945      the virtual function table pointer to represent the type of our
13946      base class.  */
13947
13948   /* This side-effect makes call to `build_delete' generate the code
13949      we have to have at the end of this destructor.  `build_delete'
13950      will set the flag again.  */
13951   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13952
13953   exprstmt = build_delete (current_class_type,
13954                            current_class_ref,
13955                            sfk_base_destructor,
13956                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13957                            0);
13958
13959   if (exprstmt != error_mark_node
13960       && (TREE_CODE (exprstmt) != NOP_EXPR
13961           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13962           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13963     {
13964       if (exprstmt != void_zero_node)
13965         /* Don't call `expand_expr_stmt' if we're not going to do
13966            anything, since -Wall will give a diagnostic.  */
13967         finish_expr_stmt (exprstmt);
13968
13969       /* Run destructors for all virtual baseclasses.  */
13970       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13971         {
13972           tree vbases;
13973           tree if_stmt;
13974
13975           if_stmt = begin_if_stmt ();
13976           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13977                                       current_in_charge_parm,
13978                                       integer_two_node),
13979                                if_stmt);
13980
13981           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
13982           /* The CLASSTYPE_VBASECLASSES list is in initialization
13983              order, so we have to march through it in reverse order.  */
13984           for (vbases = nreverse (copy_list (vbases));
13985                vbases;
13986                vbases = TREE_CHAIN (vbases))
13987             {
13988               tree vbase = TREE_VALUE (vbases);
13989
13990               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase)))
13991                 {
13992                   tree vb = get_vbase
13993                     (BINFO_TYPE (vbase),
13994                      TYPE_BINFO (current_class_type));
13995                   finish_expr_stmt
13996                     (build_scoped_method_call
13997                      (current_class_ref, vb, base_dtor_identifier,
13998                       NULL_TREE));
13999                 }
14000             }
14001
14002           finish_then_clause (if_stmt);
14003           finish_if_stmt ();
14004         }
14005     }
14006
14007   virtual_size = c_sizeof (current_class_type);
14008
14009   /* At the end, call delete if that's what's requested.  */
14010
14011   /* FDIS sez: At the point of definition of a virtual destructor
14012      (including an implicit definition), non-placement operator delete
14013      shall be looked up in the scope of the destructor's class and if
14014      found shall be accessible and unambiguous.
14015
14016      This is somewhat unclear, but I take it to mean that if the class
14017      only defines placement deletes we don't do anything here.  So we
14018      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14019      they ever try to delete one of these.  */
14020   exprstmt = build_op_delete_call
14021     (DELETE_EXPR, current_class_ptr, virtual_size,
14022      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14023
14024   if_stmt = begin_if_stmt ();
14025   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14026                               current_in_charge_parm,
14027                               integer_one_node),
14028                        if_stmt);
14029   finish_expr_stmt (exprstmt);
14030   finish_then_clause (if_stmt);
14031   finish_if_stmt ();
14032
14033   /* Close the block we started above.  */
14034   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14035 }
14036
14037 /* Finish up a function declaration and compile that function
14038    all the way to assembler language output.  The free the storage
14039    for the function definition.
14040
14041    FLAGS is a bitwise or of the following values:
14042      1 - CALL_POPLEVEL
14043        An extra call to poplevel (and expand_end_bindings) must be
14044        made to take care of the binding contour for the base
14045        initializers.  This is only relevant for constructors.
14046      2 - INCLASS_INLINE
14047        We just finished processing the body of an in-class inline
14048        function definition.  (This processing will have taken place
14049        after the class definition is complete.)  */
14050
14051 tree
14052 finish_function (flags)
14053      int flags;
14054 {
14055   register tree fndecl = current_function_decl;
14056   tree fntype, ctype = NULL_TREE;
14057   int call_poplevel = (flags & 1) != 0;
14058   int inclass_inline = (flags & 2) != 0;
14059   int nested;
14060
14061   /* When we get some parse errors, we can end up without a
14062      current_function_decl, so cope.  */
14063   if (fndecl == NULL_TREE)
14064     return error_mark_node;
14065
14066   nested = function_depth > 1;
14067   fntype = TREE_TYPE (fndecl);
14068
14069   /*  TREE_READONLY (fndecl) = 1;
14070       This caused &foo to be of type ptr-to-const-function
14071       which then got a warning when stored in a ptr-to-function variable.  */
14072
14073   my_friendly_assert (building_stmt_tree (), 20000911);
14074
14075   /* For a cloned function, we've already got all the code we need;
14076      there's no need to add any extra bits.  */
14077   if (!DECL_CLONED_FUNCTION_P (fndecl))
14078     {
14079       if (DECL_CONSTRUCTOR_P (fndecl))
14080         {
14081           finish_constructor_body ();
14082           if (call_poplevel)
14083             do_poplevel ();
14084         }
14085       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14086         finish_destructor_body ();
14087       else if (DECL_MAIN_P (fndecl))
14088         {
14089           /* Make it so that `main' always returns 0 by default.  */
14090 #ifdef VMS
14091           finish_return_stmt (integer_one_node);
14092 #else
14093           finish_return_stmt (integer_zero_node);
14094 #endif
14095         }
14096
14097       /* Finish dealing with exception specifiers.  */
14098       if (flag_exceptions && !processing_template_decl
14099           && flag_enforce_eh_specs
14100           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14101         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14102                             (TREE_TYPE (current_function_decl)),
14103                             current_eh_spec_try_block);
14104     }
14105
14106   /* If we're saving up tree structure, tie off the function now.  */
14107   finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14108
14109   /* This must come after expand_function_end because cleanups might
14110      have declarations (from inline functions) that need to go into
14111      this function's blocks.  */
14112   if (current_binding_level->parm_flag != 1)
14113     my_friendly_abort (122);
14114   poplevel (1, 0, 1);
14115
14116   /* Remember that we were in class scope.  */
14117   if (current_class_name)
14118     ctype = current_class_type;
14119
14120   /* Must mark the RESULT_DECL as being in this function.  */
14121   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14122
14123   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14124      to the FUNCTION_DECL node itself.  */
14125   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14126
14127   /* Save away current state, if appropriate.  */
14128   if (!processing_template_decl)
14129     save_function_data (fndecl);
14130
14131   /* If this function calls `setjmp' it cannot be inlined.  When
14132      `longjmp' is called it is not guaranteed to restore the value of
14133      local variables that have been modified since the call to
14134      `setjmp'.  So, if were to inline this function into some caller
14135      `c', then when we `longjmp', we might not restore all variables
14136      in `c'.  (It might seem, at first blush, that there's no way for
14137      this function to modify local variables in `c', but their
14138      addresses may have been stored somewhere accessible to this
14139      function.)  */
14140   if (!processing_template_decl && calls_setjmp_p (fndecl))
14141     DECL_UNINLINABLE (fndecl) = 1;
14142
14143   /* Clear out memory we no longer need.  */
14144   free_after_parsing (cfun);
14145   /* Since we never call rest_of_compilation, we never clear
14146      CFUN.  Do so explicitly.  */
14147   free_after_compilation (cfun);
14148   cfun = NULL;
14149
14150   /* If this is a in-class inline definition, we may have to pop the
14151      bindings for the template parameters that we added in
14152      maybe_begin_member_template_processing when start_function was
14153      called.  */
14154   if (inclass_inline)
14155     maybe_end_member_template_processing ();
14156
14157   /* Leave the scope of the class.  */
14158   if (ctype)
14159     pop_nested_class ();
14160
14161   --function_depth;
14162
14163   /* Clean up.  */
14164   if (! nested)
14165     /* Let the error reporting routines know that we're outside a
14166        function.  For a nested function, this value is used in
14167        pop_cp_function_context and then reset via pop_function_context.  */
14168     current_function_decl = NULL_TREE;
14169
14170   return fndecl;
14171 }
14172 \f
14173 /* Create the FUNCTION_DECL for a function definition.
14174    DECLSPECS and DECLARATOR are the parts of the declaration;
14175    they describe the return type and the name of the function,
14176    but twisted together in a fashion that parallels the syntax of C.
14177
14178    This function creates a binding context for the function body
14179    as well as setting up the FUNCTION_DECL in current_function_decl.
14180
14181    Returns a FUNCTION_DECL on success.
14182
14183    If the DECLARATOR is not suitable for a function (it defines a datum
14184    instead), we return 0, which tells yyparse to report a parse error.
14185
14186    May return void_type_node indicating that this method is actually
14187    a friend.  See grokfield for more details.
14188
14189    Came here with a `.pushlevel' .
14190
14191    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14192    CHANGES TO CODE IN `grokfield'.  */
14193
14194 tree
14195 start_method (declspecs, declarator, attrlist)
14196      tree declarator, declspecs, attrlist;
14197 {
14198   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14199                                 attrlist);
14200
14201   /* Something too ugly to handle.  */
14202   if (fndecl == NULL_TREE)
14203     return NULL_TREE;
14204
14205   /* Pass friends other than inline friend functions back.  */
14206   if (fndecl == void_type_node)
14207     return fndecl;
14208
14209   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14210     /* Not a function, tell parser to report parse error.  */
14211     return NULL_TREE;
14212
14213   if (DECL_IN_AGGR_P (fndecl))
14214     {
14215       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14216         {
14217           if (DECL_CONTEXT (fndecl)
14218               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14219             cp_error ("`%D' is already defined in class `%T'", fndecl,
14220                       DECL_CONTEXT (fndecl));
14221         }
14222       return void_type_node;
14223     }
14224
14225   check_template_shadow (fndecl);
14226
14227   DECL_THIS_INLINE (fndecl) = 1;
14228
14229   if (flag_default_inline)
14230     DECL_INLINE (fndecl) = 1;
14231
14232   /* We process method specializations in finish_struct_1.  */
14233   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14234     fndecl = push_template_decl (fndecl);
14235
14236   if (! DECL_FRIEND_P (fndecl))
14237     {
14238       if (TREE_CHAIN (fndecl))
14239         {
14240           fndecl = copy_node (fndecl);
14241           TREE_CHAIN (fndecl) = NULL_TREE;
14242         }
14243
14244       if (DECL_CONSTRUCTOR_P (fndecl))
14245         {
14246           if (! grok_ctor_properties (current_class_type, fndecl))
14247             return void_type_node;
14248         }
14249       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14250         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14251     }
14252
14253   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14254
14255   /* Make a place for the parms */
14256   pushlevel (0);
14257   current_binding_level->parm_flag = 1;
14258
14259   DECL_IN_AGGR_P (fndecl) = 1;
14260   return fndecl;
14261 }
14262
14263 /* Go through the motions of finishing a function definition.
14264    We don't compile this method until after the whole class has
14265    been processed.
14266
14267    FINISH_METHOD must return something that looks as though it
14268    came from GROKFIELD (since we are defining a method, after all).
14269
14270    This is called after parsing the body of the function definition.
14271    STMTS is the chain of statements that makes up the function body.
14272
14273    DECL is the ..._DECL that `start_method' provided.  */
14274
14275 tree
14276 finish_method (decl)
14277      tree decl;
14278 {
14279   register tree fndecl = decl;
14280   tree old_initial;
14281
14282   register tree link;
14283
14284   if (decl == void_type_node)
14285     return decl;
14286
14287   old_initial = DECL_INITIAL (fndecl);
14288
14289   /* Undo the level for the parms (from start_method).
14290      This is like poplevel, but it causes nothing to be
14291      saved.  Saving information here confuses symbol-table
14292      output routines.  Besides, this information will
14293      be correctly output when this method is actually
14294      compiled.  */
14295
14296   /* Clear out the meanings of the local variables of this level;
14297      also record in each decl which block it belongs to.  */
14298
14299   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14300     {
14301       if (DECL_NAME (link) != NULL_TREE)
14302         pop_binding (DECL_NAME (link), link);
14303       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14304       DECL_CONTEXT (link) = NULL_TREE;
14305     }
14306
14307   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14308                       (HOST_WIDE_INT) current_binding_level->level_chain,
14309                       current_binding_level->parm_flag,
14310                       current_binding_level->keep);
14311
14312   poplevel (0, 0, 0);
14313
14314   DECL_INITIAL (fndecl) = old_initial;
14315
14316   /* We used to check if the context of FNDECL was different from
14317      current_class_type as another way to get inside here.  This didn't work
14318      for String.cc in libg++.  */
14319   if (DECL_FRIEND_P (fndecl))
14320     {
14321       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14322         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14323       decl = void_type_node;
14324     }
14325
14326   return decl;
14327 }
14328 \f
14329 /* Called when a new struct TYPE is defined.
14330    If this structure or union completes the type of any previous
14331    variable declaration, lay it out and output its rtl.  */
14332
14333 void
14334 hack_incomplete_structures (type)
14335      tree type;
14336 {
14337   tree *list;
14338   struct binding_level *level;
14339
14340   if (!type) /* Don't do this for class templates.  */
14341     return;
14342
14343   if (namespace_bindings_p ())
14344     {
14345       level = 0;
14346       list = &namespace_scope_incomplete;
14347     }
14348   else
14349     {
14350       level = innermost_nonclass_level ();
14351       list = &level->incomplete;
14352     }
14353
14354   while (1)
14355     {
14356       while (*list)
14357         {
14358           tree decl = TREE_VALUE (*list);
14359           if ((decl && TREE_TYPE (decl) == type)
14360               || (TREE_TYPE (decl)
14361                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14362                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14363             {
14364               int toplevel = toplevel_bindings_p ();
14365               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14366                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14367                 layout_type (TREE_TYPE (decl));
14368               layout_decl (decl, 0);
14369               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14370               if (! toplevel)
14371                 {
14372                   tree cleanup;
14373                   expand_decl (decl);
14374                   cleanup = maybe_build_cleanup (decl);
14375                   expand_decl_init (decl);
14376                   if (! expand_decl_cleanup (decl, cleanup))
14377                     cp_error ("parser lost in parsing declaration of `%D'",
14378                               decl);
14379                 }
14380               *list = TREE_CHAIN (*list);
14381             }
14382           else
14383             list = &TREE_CHAIN (*list);
14384         }
14385
14386       /* Keep looking through artificial binding levels generated
14387          for local variables.  */
14388       if (level && level->keep == 2)
14389         {
14390           level = level->level_chain;
14391           list = &level->incomplete;
14392         }
14393       else
14394         break;
14395     }
14396 }
14397
14398 /* If DECL is of a type which needs a cleanup, build that cleanup
14399    here.  */
14400
14401 tree
14402 maybe_build_cleanup (decl)
14403      tree decl;
14404 {
14405   tree type = TREE_TYPE (decl);
14406
14407   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14408     {
14409       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14410       tree rval;
14411
14412       if (TREE_CODE (type) == ARRAY_TYPE)
14413         rval = decl;
14414       else
14415         {
14416           mark_addressable (decl);
14417           rval = build_unary_op (ADDR_EXPR, decl, 0);
14418         }
14419
14420       /* Optimize for space over speed here.  */
14421       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14422           || flag_expensive_optimizations)
14423         flags |= LOOKUP_NONVIRTUAL;
14424
14425       rval = build_delete (TREE_TYPE (rval), rval,
14426                            sfk_complete_destructor, flags, 0);
14427
14428       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14429           && ! TYPE_HAS_DESTRUCTOR (type))
14430         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14431                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14432
14433       return rval;
14434     }
14435   return 0;
14436 }
14437 \f
14438 /* When a stmt has been parsed, this function is called.  */
14439
14440 void
14441 finish_stmt ()
14442 {
14443   /* Always assume this statement was not an expression statement.  If
14444      it actually was an expression statement, its our callers
14445      responsibility to fix this up.  */
14446   last_expr_type = NULL_TREE;
14447 }
14448
14449 /* DECL was originally constructed as a non-static member function,
14450    but turned out to be static.  Update it accordingly.  */
14451
14452 void
14453 revert_static_member_fn (decl)
14454      tree decl;
14455 {
14456   tree tmp;
14457   tree function = TREE_TYPE (decl);
14458   tree args = TYPE_ARG_TYPES (function);
14459
14460   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14461       != TYPE_UNQUALIFIED)
14462     cp_error ("static member function `%#D' declared with type qualifiers",
14463               decl);
14464
14465   args = TREE_CHAIN (args);
14466   tmp = build_function_type (TREE_TYPE (function), args);
14467   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14468   tmp = build_exception_variant (tmp,
14469                                  TYPE_RAISES_EXCEPTIONS (function));
14470   TREE_TYPE (decl) = tmp;
14471   if (DECL_ARGUMENTS (decl))
14472     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14473   DECL_STATIC_FUNCTION_P (decl) = 1;
14474 }
14475
14476 /* Initialize the variables used during compilation of a C++
14477    function.  */
14478
14479 static void
14480 push_cp_function_context (f)
14481      struct function *f;
14482 {
14483   struct cp_language_function *p
14484     = ((struct cp_language_function *)
14485        xcalloc (1, sizeof (struct cp_language_function)));
14486   f->language = (struct language_function *) p;
14487
14488   /* It takes an explicit call to expand_body to generate RTL for a
14489      function.  */
14490   expanding_p = 0;
14491
14492   /* Whenever we start a new function, we destroy temporaries in the
14493      usual way.  */
14494   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14495 }
14496
14497 /* Free the language-specific parts of F, now that we've finished
14498    compiling the function.  */
14499
14500 static void
14501 pop_cp_function_context (f)
14502      struct function *f;
14503 {
14504   if (f->language)
14505     free (f->language);
14506   f->language = 0;
14507 }
14508
14509 /* Mark P for GC.  */
14510
14511 static void
14512 mark_lang_function (p)
14513      struct cp_language_function *p;
14514 {
14515   if (!p)
14516     return;
14517
14518   mark_c_language_function (&p->base);
14519
14520   ggc_mark_tree (p->x_ctor_label);
14521   ggc_mark_tree (p->x_dtor_label);
14522   ggc_mark_tree (p->x_current_class_ptr);
14523   ggc_mark_tree (p->x_current_class_ref);
14524   ggc_mark_tree (p->x_eh_spec_try_block);
14525
14526   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14527   mark_binding_level (&p->bindings);
14528 }
14529
14530 /* Mark the language-specific data in F for GC.  */
14531
14532 static void
14533 mark_cp_function_context (f)
14534      struct function *f;
14535 {
14536   mark_lang_function ((struct cp_language_function *) f->language);
14537 }
14538
14539 void
14540 lang_mark_tree (t)
14541      tree t;
14542 {
14543   enum tree_code code = TREE_CODE (t);
14544   if (code == IDENTIFIER_NODE)
14545     {
14546       struct lang_identifier *li = (struct lang_identifier *) t;
14547       struct lang_id2 *li2 = li->x;
14548       ggc_mark_tree (li->namespace_bindings);
14549       ggc_mark_tree (li->bindings);
14550       ggc_mark_tree (li->class_value);
14551       ggc_mark_tree (li->class_template_info);
14552
14553       if (li2)
14554         {
14555           ggc_mark_tree (li2->label_value);
14556           ggc_mark_tree (li2->implicit_decl);
14557           ggc_mark_tree (li2->error_locus);
14558         }
14559     }
14560   else if (code == CPLUS_BINDING)
14561     {
14562       if (BINDING_HAS_LEVEL_P (t))
14563         mark_binding_level (&BINDING_LEVEL (t));
14564       else
14565         ggc_mark_tree (BINDING_SCOPE (t));
14566       ggc_mark_tree (BINDING_VALUE (t));
14567     }
14568   else if (code == OVERLOAD)
14569     ggc_mark_tree (OVL_FUNCTION (t));
14570   else if (code == TEMPLATE_PARM_INDEX)
14571     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14572   else if (TREE_CODE_CLASS (code) == 'd')
14573     {
14574       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14575
14576       if (ld)
14577         {
14578           ggc_mark (ld);
14579           c_mark_lang_decl (&ld->decl_flags.base);
14580           if (!DECL_GLOBAL_CTOR_P (t)
14581               && !DECL_GLOBAL_DTOR_P (t)
14582               && !DECL_THUNK_P (t))
14583             ggc_mark_tree (ld->decl_flags.u2.access);
14584           else if (DECL_THUNK_P (t))
14585             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
14586           if (TREE_CODE (t) != NAMESPACE_DECL)
14587             ggc_mark_tree (ld->decl_flags.u.template_info);
14588           else
14589             mark_binding_level (&NAMESPACE_LEVEL (t));
14590           if (CAN_HAVE_FULL_LANG_DECL_P (t))
14591             {
14592               ggc_mark_tree (ld->befriending_classes);
14593               ggc_mark_tree (ld->context);
14594               ggc_mark_tree (ld->cloned_function);
14595               if (!DECL_OVERLOADED_OPERATOR_P (t))
14596                 ggc_mark_tree (ld->u2.vtt_parm);
14597               if (TREE_CODE (t) == TYPE_DECL)
14598                 ggc_mark_tree (ld->u.sorted_fields);
14599               else if (TREE_CODE (t) == FUNCTION_DECL
14600                        && !DECL_PENDING_INLINE_P (t))
14601                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14602             }
14603         }
14604     }
14605   else if (TREE_CODE_CLASS (code) == 't')
14606     {
14607       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14608
14609       if (lt && !(TREE_CODE (t) == POINTER_TYPE
14610                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14611         {
14612           ggc_mark (lt);
14613           ggc_mark_tree (lt->primary_base);
14614           ggc_mark_tree (lt->vfields);
14615           ggc_mark_tree (lt->vbases);
14616           ggc_mark_tree (lt->tags);
14617           ggc_mark_tree (lt->size);
14618           ggc_mark_tree (lt->pure_virtuals);
14619           ggc_mark_tree (lt->friend_classes);
14620           ggc_mark_tree (lt->rtti);
14621           ggc_mark_tree (lt->methods);
14622           ggc_mark_tree (lt->template_info);
14623           ggc_mark_tree (lt->befriending_classes);
14624         }
14625       else if (lt)
14626         /* In the case of pointer-to-member function types, the
14627            TYPE_LANG_SPECIFIC is really just a tree.  */
14628         ggc_mark_tree ((tree) lt);
14629     }
14630 }
14631
14632 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14633    the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
14634
14635 tree
14636 identifier_global_value (t)
14637      tree t;
14638 {
14639   return IDENTIFIER_GLOBAL_VALUE (t);
14640 }