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 "defaults.h"
  46 #include "ggc.h"
  47
  48 extern int current_class_depth;
  49
  50 extern tree static_ctors, static_dtors;
  51
  52 extern tree global_namespace;
  53
  54 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  55
  56 /* Use garbage collection.  */
  57
  58 int ggc_p = 1;
  59
  60 #ifndef WCHAR_UNSIGNED
  61 #define WCHAR_UNSIGNED 0
  62 #endif
  63
  64 #ifndef CHAR_TYPE_SIZE
  65 #define CHAR_TYPE_SIZE BITS_PER_UNIT
  66 #endif
  67
  68 #ifndef BOOL_TYPE_SIZE
  69 #ifdef SLOW_BYTE_ACCESS
  70 /* In the new ABI, `bool' has size and alignment `1', on all
  71    platforms.  */
  72 #define BOOL_TYPE_SIZE \
  73   ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
  74 #else
  75 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  76 #endif
  77 #endif
  78
  79 /* We let tm.h override the types used here, to handle trivial differences
  80    such as the choice of unsigned int or long unsigned int for size_t.
  81    When machines start needing nontrivial differences in the size type,
  82    it would be best to do something here to figure out automatically
  83    from other information what type to use.  */
  84
  85 #ifndef SIZE_TYPE
  86 #define SIZE_TYPE "long unsigned int"
  87 #endif
  88
  89 #ifndef PTRDIFF_TYPE
  90 #define PTRDIFF_TYPE "long int"
  91 #endif
  92
  93 #ifndef WCHAR_TYPE
  94 #define WCHAR_TYPE "int"
  95 #endif
  96
  97 static tree grokparms                           PARAMS ((tree, int));
  98 static const char *redeclaration_error_message  PARAMS ((tree, tree));
  99
 100 static void push_binding_level PARAMS ((struct binding_level *, int,
 101                                       int));
 102 static void pop_binding_level PARAMS ((void));
 103 static void suspend_binding_level PARAMS ((void));
 104 static void resume_binding_level PARAMS ((struct binding_level *));
 105 static struct binding_level *make_binding_level PARAMS ((void));
 106 static void declare_namespace_level PARAMS ((void));
 107 static int decl_jump_unsafe PARAMS ((tree));
 108 static void storedecls PARAMS ((tree));
 109 static void require_complete_types_for_parms PARAMS ((tree));
 110 static int ambi_op_p PARAMS ((enum tree_code));
 111 static int unary_op_p PARAMS ((enum tree_code));
 112 static tree store_bindings PARAMS ((tree, tree));
 113 static tree lookup_tag_reverse PARAMS ((tree, tree));
 114 static tree obscure_complex_init PARAMS ((tree, tree));
 115 static tree lookup_name_real PARAMS ((tree, int, int, int));
 116 static void warn_extern_redeclared_static PARAMS ((tree, tree));
 117 static void grok_reference_init PARAMS ((tree, tree, tree));
 118 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
 119                               enum overload_flags, tree,
 120                               tree, int, int, int, int, int, int, tree));
 121 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
 122 static tree lookup_tag PARAMS ((enum tree_code, tree,
 123                               struct binding_level *, int));
 124 static void set_identifier_type_value_with_scope
 125         PARAMS ((tree, tree, struct binding_level *));
 126 static void record_builtin_type PARAMS ((enum rid, const char *, tree));
 127 static void record_unknown_type PARAMS ((tree, const char *));
 128 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
 129 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
 130 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
 131                                   int));
 132 static void lang_print_error_function PARAMS ((const char *));
 133 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
 134 static void check_for_uninitialized_const_var PARAMS ((tree));
 135 static unsigned long typename_hash PARAMS ((hash_table_key));
 136 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
 137 static void push_binding PARAMS ((tree, tree, struct binding_level*));
 138 static int add_binding PARAMS ((tree, tree));
 139 static void pop_binding PARAMS ((tree, tree));
 140 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 141 static tree find_binding PARAMS ((tree, tree));
 142 static tree select_decl PARAMS ((tree, int));
 143 static int lookup_flags PARAMS ((int, int));
 144 static tree qualify_lookup PARAMS ((tree, int));
 145 static tree record_builtin_java_type PARAMS ((const char *, int));
 146 static const char *tag_name PARAMS ((enum tag_types code));
 147 static void find_class_binding_level PARAMS ((void));
 148 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 149 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 150 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 151 static int walk_globals_r PARAMS ((tree, void *));
 152 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 153 static tree make_label_decl PARAMS ((tree, int));
 154 static void use_label PARAMS ((tree));
 155 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 156                                            const char *, int));
 157 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 158 static void check_switch_goto PARAMS ((struct binding_level *));
 159 static void check_previous_gotos PARAMS ((tree));
 160 static void pop_label PARAMS ((tree, tree));
 161 static void pop_labels PARAMS ((tree));
 162 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 163 static void layout_var_decl PARAMS ((tree));
 164 static void maybe_commonize_var PARAMS ((tree));
 165 static tree check_initializer PARAMS ((tree, tree));
 166 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 167 static void push_cp_function_context PARAMS ((struct function *));
 168 static void pop_cp_function_context PARAMS ((struct function *));
 169 static void mark_binding_level PARAMS ((void *));
 170 static void mark_named_label_lists PARAMS ((void *, void *));
 171 static void mark_cp_function_context PARAMS ((struct function *));
 172 static void mark_saved_scope PARAMS ((void *));
 173 static void mark_lang_function PARAMS ((struct language_function *));
 174 static void mark_stmt_tree PARAMS ((struct stmt_tree *));
 175 static void save_function_data PARAMS ((tree));
 176 static void check_function_type PARAMS ((tree));
 177 static void destroy_local_var PARAMS ((tree));
 178 static void finish_constructor_body PARAMS ((void));
 179 static void finish_destructor_body PARAMS ((void));
 180 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 181 static tree get_atexit_node PARAMS ((void));
 182 static tree get_dso_handle_node PARAMS ((void));
 183 static tree start_cleanup_fn PARAMS ((void));
 184 static void end_cleanup_fn PARAMS ((void));
 185 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
 186 static void initialize_predefined_identifiers PARAMS ((void));
 187 static tree check_special_function_return_type
 188   PARAMS ((special_function_kind, tree, tree, tree));
 189 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 190 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 191
 192 #if defined (DEBUG_CP_BINDING_LEVELS)
 193 static void indent PARAMS ((void));
 194 #endif
 195
 196 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 197 tree error_mark_list;
 198
 199 /* The following symbols are subsumed in the cp_global_trees array, and
 200    listed here individually for documentation purposes.
 201
 202    C++ extensions
 203         tree wchar_decl_node;
 204         tree void_zero_node;
 205
 206         tree vtable_entry_type;
 207         tree delta_type_node;
 208 #if 0
 209    Old rtti stuff.
 210         tree __baselist_desc_type_node;
 211         tree __i_desc_type_node, __m_desc_type_node;
 212         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 213 #endif
 214         tree __t_desc_type_node;
 215 #if 0
 216         tree __tp_desc_type_node;
 217 #endif
 218         tree ti_desc_type_node;
 219         tree bltn_desc_type_node, ptr_desc_type_node;
 220         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 221         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 222         tree ptm_desc_type_node;
 223         tree base_desc_type_node;
 224 #if 0
 225    Not needed yet?  May be needed one day?
 226         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 227         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 228         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 229 #endif
 230
 231         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 232         tree unknown_type_node;
 233
 234    Array type `vtable_entry_type[]'
 235
 236         tree vtbl_type_node;
 237         tree vtbl_ptr_type_node;
 238
 239    Namespaces,
 240
 241         tree std_node;
 242         tree abi_node;
 243
 244    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 245    one that the user will declare, but sufficient to be called
 246    by routines that want to abort the program.
 247
 248         tree abort_fndecl;
 249
 250    The FUNCTION_DECL for the default `::operator delete'.
 251
 252         tree global_delete_fndecl;
 253
 254    Used by RTTI
 255         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 256         tree tinfo_var_id;
 257
 258 */
 259
 260 tree cp_global_trees[CPTI_MAX];
 261
 262 /* Indicates that there is a type value in some namespace, although
 263    that is not necessarily in scope at the moment.  */
 264
 265 static tree global_type_node;
 266
 267 /* Namespace std.  */
 268 int in_std;
 269
 270 /* Expect only namespace names now. */
 271 static int only_namespace_names;
 272
 273 /* If original DECL_RESULT of current function was a register,
 274    but due to being an addressable named return value, would up
 275    on the stack, this variable holds the named return value's
 276    original location.  */
 277
 278 #define original_result_rtx cp_function_chain->x_result_rtx
 279
 280 /* Used only for jumps to as-yet undefined labels, since jumps to
 281    defined labels can have their validity checked immediately.  */
 282
 283 struct named_label_use_list
 284 {
 285   struct binding_level *binding_level;
 286   tree names_in_scope;
 287   tree label_decl;
 288   const char *filename_o_goto;
 289   int lineno_o_goto;
 290   struct named_label_use_list *next;
 291 };
 292
 293 #define named_label_uses cp_function_chain->x_named_label_uses
 294
 295 /* A list of objects which have constructors or destructors
 296    which reside in the global scope.  The decl is stored in
 297    the TREE_VALUE slot and the initializer is stored
 298    in the TREE_PURPOSE slot.  */
 299 tree static_aggregates;
 300
 301 /* -- end of C++ */
 302
 303 /* A node for the integer constants 2, and 3.  */
 304
 305 tree integer_two_node, integer_three_node;
 306
 307 /* Parsing a function declarator leaves here a chain of structure
 308    and enum types declared in the parmlist.  */
 309
 310 static tree last_function_parm_tags;
 311
 312 /* Similar, for last_function_parm_tags.  */
 313 tree last_function_parms;
 314 static tree current_function_parm_tags;
 315
 316 /* A list of all LABEL_DECLs in the function that have names.  Here so
 317    we can clear out their names' definitions at the end of the
 318    function, and so we can check the validity of jumps to these labels.  */
 319
 320 struct named_label_list
 321 {
 322   struct binding_level *binding_level;
 323   tree names_in_scope;
 324   tree old_value;
 325   tree label_decl;
 326   tree bad_decls;
 327   int eh_region;
 328   struct named_label_list *next;
 329 };
 330
 331 #define named_labels cp_function_chain->x_named_labels
 332
 333 /* Set to 0 at beginning of a function definition, and whenever
 334    a label (case or named) is defined.  Set to value of expression
 335    returned from function when that value can be transformed into
 336    a named return value.  */
 337
 338 tree current_function_return_value;
 339
 340 /* Nonzero means use the ISO C94 dialect of C.  */
 341
 342 int flag_isoc94;
 343
 344 /* Nonzero means use the ISO C99 dialect of C.  */
 345
 346 int flag_isoc99;
 347
 348 /* Nonzero means give `double' the same size as `float'.  */
 349
 350 extern int flag_short_double;
 351
 352 /* Nonzero means don't recognize any builtin functions.  */
 353
 354 extern int flag_no_builtin;
 355
 356 /* Nonzero means don't recognize the non-ANSI builtin functions.
 357    -ansi sets this.  */
 358
 359 extern int flag_no_nonansi_builtin;
 360
 361 /* Nonzero if we want to conserve space in the .o files.  We do this
 362    by putting uninitialized data and runtime initialized data into
 363    .common instead of .data at the expense of not flagging multiple
 364    definitions.  */
 365 extern int flag_conserve_space;
 366 \f
 367 /* C and C++ flags are in decl2.c.  */
 368
 369 /* Flag used when debugging spew.c */
 370
 371 extern int spew_debug;
 372
 373 /* A expression of value 0 with the same precision as a sizetype
 374    node, but signed.  */
 375 tree signed_size_zero_node;
 376
 377 /* The name of the anonymous namespace, throughout this translation
 378    unit.  */
 379 tree anonymous_namespace_name;
 380
 381 /* The number of function bodies which we are currently processing.
 382    (Zero if we are at namespace scope, one inside the body of a
 383    function, two inside the body of a function in a local class, etc.)  */
 384 int function_depth;
 385 \f
 386 /* For each binding contour we allocate a binding_level structure
 387    which records the names defined in that contour.
 388    Contours include:
 389     0) the global one
 390     1) one for each function definition,
 391        where internal declarations of the parameters appear.
 392     2) one for each compound statement,
 393        to record its declarations.
 394
 395    The current meaning of a name can be found by searching the levels
 396    from the current one out to the global one.
 397
 398    Off to the side, may be the class_binding_level.  This exists only
 399    to catch class-local declarations.  It is otherwise nonexistent.
 400
 401    Also there may be binding levels that catch cleanups that must be
 402    run when exceptions occur.  Thus, to see whether a name is bound in
 403    the current scope, it is not enough to look in the
 404    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 405    instead.  */
 406
 407 /* Note that the information in the `names' component of the global contour
 408    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 409
 410 struct binding_level
 411   {
 412     /* A chain of _DECL nodes for all variables, constants, functions,
 413        and typedef types.  These are in the reverse of the order
 414        supplied.  There may be OVERLOADs on this list, too, but they
 415        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 416     tree names;
 417
 418     /* A list of structure, union and enum definitions, for looking up
 419        tag names.
 420        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 421        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 422        or ENUMERAL_TYPE node.
 423
 424        C++: the TREE_VALUE nodes can be simple types for
 425        component_bindings.  */
 426     tree tags;
 427
 428     /* A list of USING_DECL nodes. */
 429     tree usings;
 430
 431     /* A list of used namespaces. PURPOSE is the namespace,
 432        VALUE the common ancestor with this binding_level's namespace. */
 433     tree using_directives;
 434
 435     /* If this binding level is the binding level for a class, then
 436        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 437        is the name of an entity bound in the class; the TREE_VALUE is
 438        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 439        when leaving class scope, we can restore the
 440        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 441        the DECL bound by this name in the class.  */
 442     tree class_shadowed;
 443
 444     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 445        is used for all binding levels.  */
 446     tree type_shadowed;
 447
 448     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 449        label in this scope.  The TREE_PURPOSE is the previous value of
 450        the IDENTIFIER_LABEL VALUE.  */
 451     tree shadowed_labels;
 452
 453     /* For each level (except not the global one),
 454        a chain of BLOCK nodes for all the levels
 455        that were entered and exited one level down.  */
 456     tree blocks;
 457
 458     /* The BLOCK node for this level, if one has been preallocated.
 459        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 460     tree this_block;
 461
 462     /* The _TYPE node for this level, if parm_flag == 2.  */
 463     tree this_class;
 464
 465     /* The binding level which this one is contained in (inherits from).  */
 466     struct binding_level *level_chain;
 467
 468     /* List of decls in `names' that have incomplete
 469        structure or union types.  */
 470     tree incomplete;
 471
 472     /* List of VAR_DECLS saved from a previous for statement.
 473        These would be dead in ISO-conforming code, but might
 474        be referenced in ARM-era code.  These are stored in a
 475        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 476     tree dead_vars_from_for;
 477
 478     /* 1 for the level that holds the parameters of a function.
 479        2 for the level that holds a class declaration.  */
 480     unsigned parm_flag : 2;
 481
 482     /* 1 means make a BLOCK for this level regardless of all else.
 483        2 for temporary binding contours created by the compiler.  */
 484     unsigned keep : 2;
 485
 486     /* Nonzero if this level "doesn't exist" for tags.  */
 487     unsigned tag_transparent : 1;
 488
 489     /* Nonzero if this level can safely have additional
 490        cleanup-needing variables added to it.  */
 491     unsigned more_cleanups_ok : 1;
 492     unsigned have_cleanups : 1;
 493
 494     /* Nonzero if this scope is for storing the decls for template
 495        parameters and generic decls; these decls will be discarded and
 496        replaced with a TEMPLATE_DECL.  */
 497     unsigned template_parms_p : 1;
 498
 499     /* Nonzero if this scope corresponds to the `<>' in a
 500        `template <>' clause.  Whenever this flag is set,
 501        TEMPLATE_PARMS_P will be set as well.  */
 502     unsigned template_spec_p : 1;
 503
 504     /* This is set for a namespace binding level.  */
 505     unsigned namespace_p : 1;
 506
 507     /* True if this level is that of a for-statement where we need to
 508        worry about ambiguous (ARM or ISO) scope rules.  */
 509     unsigned is_for_scope : 1;
 510
 511     /* True if this level corresponds to an EH region, as for a try block.
 512        Currently this information is only available while building the
 513        tree structure.  */
 514     unsigned eh_region : 1;
 515
 516     /* Four bits left for this word.  */
 517
 518 #if defined(DEBUG_CP_BINDING_LEVELS)
 519     /* Binding depth at which this level began.  */
 520     unsigned binding_depth;
 521 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 522   };
 523
 524 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 525
 526 /* The binding level currently in effect.  */
 527
 528 #define current_binding_level                   \
 529   (cfun                                         \
 530    ? cp_function_chain->bindings                \
 531    : scope_chain->bindings)
 532
 533 /* The binding level of the current class, if any.  */
 534
 535 #define class_binding_level scope_chain->class_bindings
 536
 537 /* A chain of binding_level structures awaiting reuse.  */
 538
 539 static struct binding_level *free_binding_level;
 540
 541 /* The outermost binding level, for names of file scope.
 542    This is created when the compiler is started and exists
 543    through the entire run.  */
 544
 545 static struct binding_level *global_binding_level;
 546
 547 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 548
 549 static int keep_next_level_flag;
 550
 551 #if defined(DEBUG_CP_BINDING_LEVELS)
 552 static int binding_depth = 0;
 553 static int is_class_level = 0;
 554
 555 static void
 556 indent ()
 557 {
 558   register unsigned i;
 559
 560   for (i = 0; i < binding_depth*2; i++)
 561     putc (' ', stderr);
 562 }
 563 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 564
 565 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 566
 567 static void
 568 push_binding_level (newlevel, tag_transparent, keep)
 569      struct binding_level *newlevel;
 570      int tag_transparent, keep;
 571 {
 572   /* Add this level to the front of the chain (stack) of levels that
 573      are active.  */
 574   bzero ((char*) newlevel, sizeof (struct binding_level));
 575   newlevel->level_chain = current_binding_level;
 576   current_binding_level = newlevel;
 577   newlevel->tag_transparent = tag_transparent;
 578   newlevel->more_cleanups_ok = 1;
 579
 580   newlevel->keep = keep;
 581 #if defined(DEBUG_CP_BINDING_LEVELS)
 582   newlevel->binding_depth = binding_depth;
 583   indent ();
 584   fprintf (stderr, "push %s level 0x%08x line %d\n",
 585            (is_class_level) ? "class" : "block", newlevel, lineno);
 586   is_class_level = 0;
 587   binding_depth++;
 588 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 589 }
 590
 591 /* Find the innermost enclosing class scope, and reset
 592    CLASS_BINDING_LEVEL appropriately.  */
 593
 594 static void
 595 find_class_binding_level ()
 596 {
 597   struct binding_level *level = current_binding_level;
 598
 599   while (level && level->parm_flag != 2)
 600     level = level->level_chain;
 601   if (level && level->parm_flag == 2)
 602     class_binding_level = level;
 603   else
 604     class_binding_level = 0;
 605 }
 606
 607 static void
 608 pop_binding_level ()
 609 {
 610   if (global_binding_level)
 611     {
 612       /* Cannot pop a level, if there are none left to pop.  */
 613       if (current_binding_level == global_binding_level)
 614         my_friendly_abort (123);
 615     }
 616   /* Pop the current level, and free the structure for reuse.  */
 617 #if defined(DEBUG_CP_BINDING_LEVELS)
 618   binding_depth--;
 619   indent ();
 620   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 621           (is_class_level) ? "class" : "block",
 622           current_binding_level, lineno);
 623   if (is_class_level != (current_binding_level == class_binding_level))
 624     {
 625       indent ();
 626       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 627     }
 628   is_class_level = 0;
 629 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 630   {
 631     register struct binding_level *level = current_binding_level;
 632     current_binding_level = current_binding_level->level_chain;
 633     level->level_chain = free_binding_level;
 634 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 635     if (level->binding_depth != binding_depth)
 636       abort ();
 637 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 638     free_binding_level = level;
 639     find_class_binding_level ();
 640   }
 641 }
 642
 643 static void
 644 suspend_binding_level ()
 645 {
 646   if (class_binding_level)
 647     current_binding_level = class_binding_level;
 648
 649   if (global_binding_level)
 650     {
 651       /* Cannot suspend a level, if there are none left to suspend.  */
 652       if (current_binding_level == global_binding_level)
 653         my_friendly_abort (123);
 654     }
 655   /* Suspend the current level.  */
 656 #if defined(DEBUG_CP_BINDING_LEVELS)
 657   binding_depth--;
 658   indent ();
 659   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 660           (is_class_level) ? "class" : "block",
 661           current_binding_level, lineno);
 662   if (is_class_level != (current_binding_level == class_binding_level))
 663     {
 664       indent ();
 665       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 666     }
 667   is_class_level = 0;
 668 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 669   current_binding_level = current_binding_level->level_chain;
 670   find_class_binding_level ();
 671 }
 672
 673 static void
 674 resume_binding_level (b)
 675      struct binding_level *b;
 676 {
 677   /* Resuming binding levels is meant only for namespaces,
 678      and those cannot nest into classes. */
 679   my_friendly_assert(!class_binding_level, 386);
 680   /* Also, resuming a non-directly nested namespace is a no-no.  */
 681   my_friendly_assert(b->level_chain == current_binding_level, 386);
 682   current_binding_level = b;
 683 #if defined(DEBUG_CP_BINDING_LEVELS)
 684   b->binding_depth = binding_depth;
 685   indent ();
 686   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 687            (is_class_level) ? "class" : "block", b, lineno);
 688   is_class_level = 0;
 689   binding_depth++;
 690 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 691 }
 692 \f
 693 /* Create a new `struct binding_level'.  */
 694
 695 static
 696 struct binding_level *
 697 make_binding_level ()
 698 {
 699   /* NOSTRICT */
 700   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 701 }
 702
 703 /* Nonzero if we are currently in the global binding level.  */
 704
 705 int
 706 global_bindings_p ()
 707 {
 708   return current_binding_level == global_binding_level;
 709 }
 710
 711 /* Return the innermost binding level that is not for a class scope.  */
 712
 713 static struct binding_level *
 714 innermost_nonclass_level ()
 715 {
 716   struct binding_level *b;
 717
 718   b = current_binding_level;
 719   while (b->parm_flag == 2)
 720     b = b->level_chain;
 721
 722   return b;
 723 }
 724
 725 /* Nonzero if we are currently in a toplevel binding level.  This
 726    means either the global binding level or a namespace in a toplevel
 727    binding level.  Since there are no non-toplevel namespace levels,
 728    this really means any namespace or template parameter level.  We
 729    also include a class whose context is toplevel.  */
 730
 731 int
 732 toplevel_bindings_p ()
 733 {
 734   struct binding_level *b = innermost_nonclass_level ();
 735
 736   return b->namespace_p || b->template_parms_p;
 737 }
 738
 739 /* Nonzero if this is a namespace scope, or if we are defining a class
 740    which is itself at namespace scope, or whose enclosing class is
 741    such a class, etc.  */
 742
 743 int
 744 namespace_bindings_p ()
 745 {
 746   struct binding_level *b = innermost_nonclass_level ();
 747
 748   return b->namespace_p;
 749 }
 750
 751 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 752    unconditionally.  Otherwise, use the normal logic to decide whether
 753    or not to create a BLOCK.  */
 754
 755 void
 756 keep_next_level (keep)
 757      int keep;
 758 {
 759   keep_next_level_flag = keep;
 760 }
 761
 762 /* Nonzero if the current level needs to have a BLOCK made.  */
 763
 764 int
 765 kept_level_p ()
 766 {
 767   return (current_binding_level->blocks != NULL_TREE
 768           || current_binding_level->keep
 769           || current_binding_level->names != NULL_TREE
 770           || (current_binding_level->tags != NULL_TREE
 771               && !current_binding_level->tag_transparent));
 772 }
 773
 774 static void
 775 declare_namespace_level ()
 776 {
 777   current_binding_level->namespace_p = 1;
 778 }
 779
 780 /* Returns non-zero if this scope was created to store template
 781    parameters.  */
 782
 783 int
 784 template_parm_scope_p ()
 785 {
 786   return current_binding_level->template_parms_p;
 787 }
 788
 789 /* Returns the kind of template specialization we are currently
 790    processing, given that it's declaration contained N_CLASS_SCOPES
 791    explicit scope qualifications.  */
 792
 793 tmpl_spec_kind
 794 current_tmpl_spec_kind (n_class_scopes)
 795      int n_class_scopes;
 796 {
 797   int n_template_parm_scopes = 0;
 798   int seen_specialization_p = 0;
 799   int innermost_specialization_p = 0;
 800   struct binding_level *b;
 801
 802   /* Scan through the template parameter scopes.  */
 803   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 804     {
 805       /* If we see a specialization scope inside a parameter scope,
 806          then something is wrong.  That corresponds to a declaration
 807          like:
 808
 809             template <class T> template <> ...
 810
 811          which is always illegal since [temp.expl.spec] forbids the
 812          specialization of a class member template if the enclosing
 813          class templates are not explicitly specialized as well.  */
 814       if (b->template_spec_p)
 815         {
 816           if (n_template_parm_scopes == 0)
 817             innermost_specialization_p = 1;
 818           else
 819             seen_specialization_p = 1;
 820         }
 821       else if (seen_specialization_p == 1)
 822         return tsk_invalid_member_spec;
 823
 824       ++n_template_parm_scopes;
 825     }
 826
 827   /* Handle explicit instantiations.  */
 828   if (processing_explicit_instantiation)
 829     {
 830       if (n_template_parm_scopes != 0)
 831         /* We've seen a template parameter list during an explicit
 832            instantiation.  For example:
 833
 834              template <class T> template void f(int);
 835
 836            This is erroneous.  */
 837         return tsk_invalid_expl_inst;
 838       else
 839         return tsk_expl_inst;
 840     }
 841
 842   if (n_template_parm_scopes < n_class_scopes)
 843     /* We've not seen enough template headers to match all the
 844        specialized classes present.  For example:
 845
 846          template <class T> void R<T>::S<T>::f(int);
 847
 848        This is illegal; there needs to be one set of template
 849        parameters for each class.  */
 850     return tsk_insufficient_parms;
 851   else if (n_template_parm_scopes == n_class_scopes)
 852     /* We're processing a non-template declaration (even though it may
 853        be a member of a template class.)  For example:
 854
 855          template <class T> void S<T>::f(int);
 856
 857        The `class T' maches the `S<T>', leaving no template headers
 858        corresponding to the `f'.  */
 859     return tsk_none;
 860   else if (n_template_parm_scopes > n_class_scopes + 1)
 861     /* We've got too many template headers.  For example:
 862
 863          template <> template <class T> void f (T);
 864
 865        There need to be more enclosing classes.  */
 866     return tsk_excessive_parms;
 867   else
 868     /* This must be a template.  It's of the form:
 869
 870          template <class T> template <class U> void S<T>::f(U);
 871
 872        This is a specialization if the innermost level was a
 873        specialization; otherwise it's just a definition of the
 874        template.  */
 875     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 876 }
 877
 878 void
 879 set_class_shadows (shadows)
 880      tree shadows;
 881 {
 882   class_binding_level->class_shadowed = shadows;
 883 }
 884
 885 /* Enter a new binding level.
 886    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 887    not for that of tags.  */
 888
 889 void
 890 pushlevel (tag_transparent)
 891      int tag_transparent;
 892 {
 893   struct binding_level *newlevel;
 894
 895   if (cfun && !doing_semantic_analysis_p ())
 896     return;
 897
 898   /* Reuse or create a struct for this binding level.  */
 899 #if defined(DEBUG_CP_BINDING_LEVELS)
 900   if (0)
 901 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 902   if (free_binding_level)
 903 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 904     {
 905       newlevel = free_binding_level;
 906       free_binding_level = free_binding_level->level_chain;
 907     }
 908   else
 909     newlevel = make_binding_level ();
 910
 911   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 912   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 913   keep_next_level_flag = 0;
 914 }
 915
 916 /* Enter a new scope.  The KIND indicates what kind of scope is being
 917    created.  */
 918
 919 void
 920 begin_scope (sk)
 921      scope_kind sk;
 922 {
 923   pushlevel (0);
 924
 925   switch (sk)
 926     {
 927     case sk_template_spec:
 928       current_binding_level->template_spec_p = 1;
 929       /* Fall through.  */
 930
 931     case sk_template_parms:
 932       current_binding_level->template_parms_p = 1;
 933       break;
 934
 935     default:
 936       my_friendly_abort (20000309);
 937     }
 938 }
 939
 940 /* Exit the current scope.  */
 941
 942 void
 943 finish_scope ()
 944 {
 945   poplevel (0, 0, 0);
 946 }
 947
 948 void
 949 note_level_for_for ()
 950 {
 951   current_binding_level->is_for_scope = 1;
 952 }
 953
 954 /* Record that the current binding level represents a try block.  */
 955
 956 void
 957 note_level_for_eh ()
 958 {
 959   current_binding_level->eh_region = 1;
 960 }
 961
 962 /* For a binding between a name and an entity at a block scope,
 963    this is the `struct binding_level' for the block.  */
 964 #define BINDING_LEVEL(NODE) \
 965    (((struct tree_binding*)NODE)->scope.level)
 966
 967 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 968    level at which this declaration is being bound.  */
 969
 970 static void
 971 push_binding (id, decl, level)
 972      tree id;
 973      tree decl;
 974      struct binding_level* level;
 975 {
 976   tree binding;
 977
 978   binding = make_node (CPLUS_BINDING);
 979
 980   /* Now, fill in the binding information.  */
 981   BINDING_VALUE (binding) = decl;
 982   BINDING_TYPE (binding) = NULL_TREE;
 983   BINDING_LEVEL (binding) = level;
 984   INHERITED_VALUE_BINDING_P (binding) = 0;
 985   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 986   BINDING_HAS_LEVEL_P (binding) = 1;
 987
 988   /* And put it on the front of the list of bindings for ID.  */
 989   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 990   IDENTIFIER_BINDING (id) = binding;
 991 }
 992
 993 /* ID is already bound in the current scope.  But, DECL is an
 994    additional binding for ID in the same scope.  This is the `struct
 995    stat' hack whereby a non-typedef class-name or enum-name can be
 996    bound at the same level as some other kind of entity.  It's the
 997    responsibility of the caller to check that inserting this name is
 998    legal here.  Returns nonzero if the new binding was successful.  */
 999 static int
1000 add_binding (id, decl)
1001      tree id;
1002      tree decl;
1003 {
1004   tree binding = IDENTIFIER_BINDING (id);
1005   int ok = 1;
1006
1007   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
1008     /* The new name is the type name.  */
1009     BINDING_TYPE (binding) = decl;
1010   else if (!BINDING_VALUE (binding))
1011     /* This situation arises when push_class_level_binding moves an
1012        inherited type-binding out of the way to make room for a new
1013        value binding.  */
1014     BINDING_VALUE (binding) = decl;
1015   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1016            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
1017     {
1018       /* The old binding was a type name.  It was placed in
1019          BINDING_VALUE because it was thought, at the point it was
1020          declared, to be the only entity with such a name.  Move the
1021          type name into the type slot; it is now hidden by the new
1022          binding.  */
1023       BINDING_TYPE (binding) = BINDING_VALUE (binding);
1024       BINDING_VALUE (binding) = decl;
1025       INHERITED_VALUE_BINDING_P (binding) = 0;
1026     }
1027   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1028            && TREE_CODE (decl) == TYPE_DECL
1029            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1030            && same_type_p (TREE_TYPE (decl),
1031                            TREE_TYPE (BINDING_VALUE (binding))))
1032     /* We have two typedef-names, both naming the same type to have
1033        the same name.  This is OK because of:
1034
1035          [dcl.typedef]
1036
1037          In a given scope, a typedef specifier can be used to redefine
1038          the name of any type declared in that scope to refer to the
1039          type to which it already refers.  */
1040     ok = 0;
1041   /* There can be two block-scope declarations of the same variable,
1042      so long as they are `extern' declarations.  */
1043   else if (TREE_CODE (decl) == VAR_DECL
1044            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1045            && DECL_EXTERNAL (decl)
1046            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1047     {
1048       duplicate_decls (decl, BINDING_VALUE (binding));
1049       ok = 0;
1050     }
1051   else
1052     {
1053       cp_error ("declaration of `%#D'", decl);
1054       cp_error_at ("conflicts with previous declaration `%#D'",
1055                    BINDING_VALUE (binding));
1056       ok = 0;
1057     }
1058
1059   return ok;
1060 }
1061
1062 /* Add DECL to the list of things declared in B.  */
1063
1064 static void
1065 add_decl_to_level (decl, b)
1066      tree decl;
1067      struct binding_level *b;
1068 {
1069   /* We build up the list in reverse order, and reverse it later if
1070      necessary.  */
1071   TREE_CHAIN (decl) = b->names;
1072   b->names = decl;
1073 }
1074
1075 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1076    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1077    doesn't really belong to this binding level, that it got here
1078    through a using-declaration.  */
1079
1080 void
1081 push_local_binding (id, decl, flags)
1082      tree id;
1083      tree decl;
1084      int flags;
1085 {
1086   struct binding_level *b;
1087
1088   /* Skip over any local classes.  This makes sense if we call
1089      push_local_binding with a friend decl of a local class.  */
1090   b = current_binding_level;
1091   while (b->parm_flag == 2)
1092     b = b->level_chain;
1093
1094   if (lookup_name_current_level (id))
1095     {
1096       /* Supplement the existing binding.  */
1097       if (!add_binding (id, decl))
1098         /* It didn't work.  Something else must be bound at this
1099            level.  Do not add DECL to the list of things to pop
1100            later.  */
1101         return;
1102     }
1103   else
1104     /* Create a new binding.  */
1105     push_binding (id, decl, b);
1106
1107   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1108     /* We must put the OVERLOAD into a TREE_LIST since the
1109        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1110        decls that got here through a using-declaration.  */
1111     decl = build_tree_list (NULL_TREE, decl);
1112
1113   /* And put DECL on the list of things declared by the current
1114      binding level.  */
1115   add_decl_to_level (decl, b);
1116 }
1117
1118 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1119    binding was successful.  */
1120
1121 int
1122 push_class_binding (id, decl)
1123      tree id;
1124      tree decl;
1125 {
1126   int result = 1;
1127   tree binding = IDENTIFIER_BINDING (id);
1128   tree context;
1129
1130   /* Note that we declared this value so that we can issue an error if
1131      this an illegal redeclaration of a name already used for some
1132      other purpose.  */
1133   note_name_declared_in_class (id, decl);
1134
1135   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1136     /* Supplement the existing binding.  */
1137     result = add_binding (id, decl);
1138   else
1139     /* Create a new binding.  */
1140     push_binding (id, decl, class_binding_level);
1141
1142   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1143      class-level declaration.  Note that we do not use DECL here
1144      because of the possibility of the `struct stat' hack; if DECL is
1145      a class-name or enum-name we might prefer a field-name, or some
1146      such.  */
1147   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1148
1149   /* If this is a binding from a base class, mark it as such.  */
1150   binding = IDENTIFIER_BINDING (id);
1151   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1152     {
1153       /* Any implicit typename must be from a base-class.  The
1154          context for an implicit typename declaration is always
1155          the derived class in which the lookup was done, so the checks
1156          based on the context of DECL below will not trigger.  */
1157       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1158         INHERITED_VALUE_BINDING_P (binding) = 1;
1159       else
1160         {
1161           if (TREE_CODE (decl) == OVERLOAD)
1162             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1163           else
1164             {
1165               my_friendly_assert (DECL_P (decl), 0);
1166               context = CP_DECL_CONTEXT (decl);
1167             }
1168
1169           if (is_properly_derived_from (current_class_type, context))
1170             INHERITED_VALUE_BINDING_P (binding) = 1;
1171           else
1172             INHERITED_VALUE_BINDING_P (binding) = 0;
1173         }
1174     }
1175   else if (BINDING_VALUE (binding) == decl)
1176     /* We only encounter a TREE_LIST when push_class_decls detects an
1177        ambiguity.  Such an ambiguity can be overridden by a definition
1178        in this class.  */
1179     INHERITED_VALUE_BINDING_P (binding) = 1;
1180
1181   return result;
1182 }
1183
1184 /* Remove the binding for DECL which should be the innermost binding
1185    for ID.  */
1186
1187 static void
1188 pop_binding (id, decl)
1189      tree id;
1190      tree decl;
1191 {
1192   tree binding;
1193
1194   if (id == NULL_TREE)
1195     /* It's easiest to write the loops that call this function without
1196        checking whether or not the entities involved have names.  We
1197        get here for such an entity.  */
1198     return;
1199
1200   /* Get the innermost binding for ID.  */
1201   binding = IDENTIFIER_BINDING (id);
1202
1203   /* The name should be bound.  */
1204   my_friendly_assert (binding != NULL_TREE, 0);
1205
1206   /* The DECL will be either the ordinary binding or the type
1207      binding for this identifier.  Remove that binding.  */
1208   if (BINDING_VALUE (binding) == decl)
1209     BINDING_VALUE (binding) = NULL_TREE;
1210   else if (BINDING_TYPE (binding) == decl)
1211     BINDING_TYPE (binding) = NULL_TREE;
1212   else
1213     my_friendly_abort (0);
1214
1215   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1216     /* We're completely done with the innermost binding for this
1217        identifier.  Unhook it from the list of bindings.  */
1218     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1219 }
1220
1221 /* When a label goes out of scope, check to see if that label was used
1222    in a valid manner, and issue any appropriate warnings or errors.  */
1223
1224 static void
1225 pop_label (label, old_value)
1226      tree label;
1227      tree old_value;
1228 {
1229   if (!processing_template_decl && doing_semantic_analysis_p ())
1230     {
1231       if (DECL_INITIAL (label) == NULL_TREE)
1232         {
1233           cp_error_at ("label `%D' used but not defined", label);
1234           /* Avoid crashing later.  */
1235           define_label (input_filename, 1, DECL_NAME (label));
1236         }
1237       else if (warn_unused_label && !TREE_USED (label))
1238         cp_warning_at ("label `%D' defined but not used", label);
1239     }
1240
1241   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1242 }
1243
1244 /* At the end of a function, all labels declared within the function
1245    go out of scope.  BLOCK is the top-level block for the
1246    function.  */
1247
1248 static void
1249 pop_labels (block)
1250      tree block;
1251 {
1252   struct named_label_list *link;
1253
1254   /* Clear out the definitions of all label names, since their scopes
1255      end here.  */
1256   for (link = named_labels; link; link = link->next)
1257     {
1258       pop_label (link->label_decl, link->old_value);
1259       /* Put the labels into the "variables" of the top-level block,
1260          so debugger can see them.  */
1261       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1262       BLOCK_VARS (block) = link->label_decl;
1263     }
1264
1265   named_labels = NULL;
1266 }
1267
1268 /* Exit a binding level.
1269    Pop the level off, and restore the state of the identifier-decl mappings
1270    that were in effect when this level was entered.
1271
1272    If KEEP == 1, this level had explicit declarations, so
1273    and create a "block" (a BLOCK node) for the level
1274    to record its declarations and subblocks for symbol table output.
1275
1276    If FUNCTIONBODY is nonzero, this level is the body of a function,
1277    so create a block as if KEEP were set and also clear out all
1278    label names.
1279
1280    If REVERSE is nonzero, reverse the order of decls before putting
1281    them into the BLOCK.  */
1282
1283 tree
1284 poplevel (keep, reverse, functionbody)
1285      int keep;
1286      int reverse;
1287      int functionbody;
1288 {
1289   register tree link;
1290   /* The chain of decls was accumulated in reverse order.
1291      Put it into forward order, just for cleanliness.  */
1292   tree decls;
1293   int tmp = functionbody;
1294   int real_functionbody;
1295   tree tags;
1296   tree subblocks;
1297   tree block = NULL_TREE;
1298   tree decl;
1299   int block_previously_created;
1300   int leaving_for_scope;
1301
1302   if (cfun && !doing_semantic_analysis_p ())
1303     return NULL_TREE;
1304
1305   my_friendly_assert (current_binding_level->parm_flag != 2,
1306                       19990916);
1307
1308   real_functionbody = (current_binding_level->keep == 2
1309                        ? ((functionbody = 0), tmp) : functionbody);
1310   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1311   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1312
1313   my_friendly_assert (!current_binding_level->class_shadowed,
1314                       19990414);
1315
1316   /* We used to use KEEP == 2 to indicate that the new block should go
1317      at the beginning of the list of blocks at this binding level,
1318      rather than the end.  This hack is no longer used.  */
1319   my_friendly_assert (keep == 0 || keep == 1, 0);
1320
1321   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1322                       (HOST_WIDE_INT) current_binding_level->level_chain,
1323                       current_binding_level->parm_flag,
1324                       current_binding_level->keep);
1325
1326   if (current_binding_level->keep == 1)
1327     keep = 1;
1328
1329   /* Any uses of undefined labels, and any defined labels, now operate
1330      under constraints of next binding contour.  */
1331   if (cfun && !functionbody)
1332     {
1333       struct binding_level *level_chain;
1334       level_chain = current_binding_level->level_chain;
1335       if (level_chain)
1336         {
1337           struct named_label_use_list *uses;
1338           struct named_label_list *labels;
1339           for (labels = named_labels; labels; labels = labels->next)
1340             if (labels->binding_level == current_binding_level)
1341               {
1342                 tree decl;
1343                 if (current_binding_level->eh_region)
1344                   labels->eh_region = 1;
1345                 for (decl = labels->names_in_scope; decl;
1346                      decl = TREE_CHAIN (decl))
1347                   if (decl_jump_unsafe (decl))
1348                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1349                                                    labels->bad_decls);
1350                 labels->binding_level = level_chain;
1351                 labels->names_in_scope = level_chain->names;
1352               }
1353
1354           for (uses = named_label_uses; uses; uses = uses->next)
1355             if (uses->binding_level == current_binding_level)
1356               {
1357                 uses->binding_level = level_chain;
1358                 uses->names_in_scope = level_chain->names;
1359               }
1360         }
1361     }
1362
1363   /* Get the decls in the order they were written.
1364      Usually current_binding_level->names is in reverse order.
1365      But parameter decls were previously put in forward order.  */
1366
1367   if (reverse)
1368     current_binding_level->names
1369       = decls = nreverse (current_binding_level->names);
1370   else
1371     decls = current_binding_level->names;
1372
1373   /* Output any nested inline functions within this block
1374      if they weren't already output.  */
1375   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1376     if (TREE_CODE (decl) == FUNCTION_DECL
1377         && ! TREE_ASM_WRITTEN (decl)
1378         && DECL_INITIAL (decl) != NULL_TREE
1379         && TREE_ADDRESSABLE (decl)
1380         && decl_function_context (decl) == current_function_decl)
1381       {
1382         /* If this decl was copied from a file-scope decl
1383            on account of a block-scope extern decl,
1384            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1385         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1386           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1387         else
1388           {
1389             push_function_context ();
1390             output_inline_function (decl);
1391             pop_function_context ();
1392           }
1393       }
1394
1395   /* When not in function-at-a-time mode, expand_end_bindings will
1396      warn about unused variables.  But, in function-at-a-time mode
1397      expand_end_bindings is not passed the list of variables in the
1398      current scope, and therefore no warning is emitted.  So, we
1399      explicitly warn here.  */
1400   if (!processing_template_decl)
1401     warn_about_unused_variables (getdecls ());
1402
1403   /* If there were any declarations or structure tags in that level,
1404      or if this level is a function body,
1405      create a BLOCK to record them for the life of this function.  */
1406   block = NULL_TREE;
1407   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1408   if (block_previously_created)
1409     block = current_binding_level->this_block;
1410   else if (keep == 1 || functionbody)
1411     block = make_node (BLOCK);
1412   if (block != NULL_TREE)
1413     {
1414       if (block_previously_created)
1415         {
1416           if (decls || tags || subblocks)
1417             {
1418               if (BLOCK_VARS (block))
1419                 warning ("internal compiler error: debugging info corrupted");
1420
1421               BLOCK_VARS (block) = decls;
1422
1423               /* We can have previous subblocks and new subblocks when
1424                  doing fixup_gotos with complex cleanups.  We chain the new
1425                  subblocks onto the end of any pre-existing subblocks.  */
1426               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1427                                                  subblocks);
1428             }
1429         }
1430       else
1431         {
1432           BLOCK_VARS (block) = decls;
1433           BLOCK_SUBBLOCKS (block) = subblocks;
1434         }
1435     }
1436
1437   /* In each subblock, record that this is its superior.  */
1438   if (keep >= 0)
1439     for (link = subblocks; link; link = TREE_CHAIN (link))
1440       BLOCK_SUPERCONTEXT (link) = block;
1441
1442   /* We still support the old for-scope rules, whereby the variables
1443      in a for-init statement were in scope after the for-statement
1444      ended.  We only use the new rules in flag_new_for_scope is
1445      nonzero.  */
1446   leaving_for_scope
1447     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1448
1449   /* Remove declarations for all the DECLs in this level.  */
1450   for (link = decls; link; link = TREE_CHAIN (link))
1451     {
1452       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1453           && DECL_NAME (link))
1454         {
1455           tree outer_binding
1456             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1457           tree ns_binding;
1458
1459           if (!outer_binding)
1460             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1461           else
1462             ns_binding = NULL_TREE;
1463
1464           if (outer_binding
1465               && (BINDING_LEVEL (outer_binding)
1466                   == current_binding_level->level_chain))
1467             /* We have something like:
1468
1469                  int i;
1470                  for (int i; ;);
1471
1472                and we are leaving the `for' scope.  There's no reason to
1473                keep the binding of the inner `i' in this case.  */
1474             pop_binding (DECL_NAME (link), link);
1475           else if ((outer_binding
1476                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1477                         == TYPE_DECL))
1478                    || (ns_binding
1479                        && TREE_CODE (ns_binding) == TYPE_DECL))
1480             /* Here, we have something like:
1481
1482                  typedef int I;
1483
1484                  void f () {
1485                    for (int I; ;);
1486                  }
1487
1488                We must pop the for-scope binding so we know what's a
1489                type and what isn't.  */
1490             pop_binding (DECL_NAME (link), link);
1491           else
1492             {
1493               /* Mark this VAR_DECL as dead so that we can tell we left it
1494                  there only for backward compatibility.  */
1495               DECL_DEAD_FOR_LOCAL (link) = 1;
1496
1497               /* Keep track of what should of have happenned when we
1498                  popped the binding.  */
1499               if (outer_binding && BINDING_VALUE (outer_binding))
1500                 DECL_SHADOWED_FOR_VAR (link)
1501                   = BINDING_VALUE (outer_binding);
1502
1503               /* Add it to the list of dead variables in the next
1504                  outermost binding to that we can remove these when we
1505                  leave that binding.  */
1506               current_binding_level->level_chain->dead_vars_from_for
1507                 = tree_cons (NULL_TREE, link,
1508                              current_binding_level->level_chain->
1509                              dead_vars_from_for);
1510
1511               /* Although we don't pop the CPLUS_BINDING, we do clear
1512                  its BINDING_LEVEL since the level is going away now.  */
1513               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1514                 = 0;
1515             }
1516         }
1517       else
1518         {
1519           /* Remove the binding.  */
1520           decl = link;
1521           if (TREE_CODE (decl) == TREE_LIST)
1522             decl = TREE_VALUE (decl);
1523           if (DECL_P (decl))
1524             pop_binding (DECL_NAME (decl), decl);
1525           else if (TREE_CODE (decl) == OVERLOAD)
1526             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1527           else
1528             my_friendly_abort (0);
1529         }
1530     }
1531
1532   /* Remove declarations for any `for' variables from inner scopes
1533      that we kept around.  */
1534   for (link = current_binding_level->dead_vars_from_for;
1535        link; link = TREE_CHAIN (link))
1536     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1537
1538   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1539   for (link = current_binding_level->type_shadowed;
1540        link; link = TREE_CHAIN (link))
1541     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1542
1543   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1544   for (link = current_binding_level->shadowed_labels;
1545        link;
1546        link = TREE_CHAIN (link))
1547     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1548
1549   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1550      list if a `using' declaration put them there.  The debugging
1551      back-ends won't understand OVERLOAD, so we remove them here.
1552      Because the BLOCK_VARS are (temporarily) shared with
1553      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1554      popped all the bindings.  */
1555   if (block)
1556     {
1557       tree* d;
1558
1559       for (d = &BLOCK_VARS (block); *d; )
1560         {
1561           if (TREE_CODE (*d) == TREE_LIST)
1562             *d = TREE_CHAIN (*d);
1563           else
1564             d = &TREE_CHAIN (*d);
1565         }
1566     }
1567
1568   /* If the level being exited is the top level of a function,
1569      check over all the labels.  */
1570   if (functionbody)
1571     {
1572       /* Since this is the top level block of a function, the vars are
1573          the function's parameters.  Don't leave them in the BLOCK
1574          because they are found in the FUNCTION_DECL instead.  */
1575       BLOCK_VARS (block) = 0;
1576       pop_labels (block);
1577     }
1578
1579   tmp = current_binding_level->keep;
1580
1581   pop_binding_level ();
1582   if (functionbody)
1583     DECL_INITIAL (current_function_decl) = block;
1584   else if (block)
1585     {
1586       if (!block_previously_created)
1587         current_binding_level->blocks
1588           = chainon (current_binding_level->blocks, block);
1589     }
1590   /* If we did not make a block for the level just exited,
1591      any blocks made for inner levels
1592      (since they cannot be recorded as subblocks in that level)
1593      must be carried forward so they will later become subblocks
1594      of something else.  */
1595   else if (subblocks)
1596     current_binding_level->blocks
1597       = chainon (current_binding_level->blocks, subblocks);
1598
1599   /* Each and every BLOCK node created here in `poplevel' is important
1600      (e.g. for proper debugging information) so if we created one
1601      earlier, mark it as "used".  */
1602   if (block)
1603     TREE_USED (block) = 1;
1604
1605   /* Take care of compiler's internal binding structures.  */
1606   if (tmp == 2)
1607     {
1608       tree scope_stmts;
1609
1610       scope_stmts
1611         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1612       if (block)
1613         {
1614           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1615           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1616         }
1617
1618       block = poplevel (keep, reverse, functionbody);
1619     }
1620
1621   return block;
1622 }
1623
1624 /* Delete the node BLOCK from the current binding level.
1625    This is used for the block inside a stmt expr ({...})
1626    so that the block can be reinserted where appropriate.  */
1627
1628 void
1629 delete_block (block)
1630      tree block;
1631 {
1632   tree t;
1633   if (current_binding_level->blocks == block)
1634     current_binding_level->blocks = TREE_CHAIN (block);
1635   for (t = current_binding_level->blocks; t;)
1636     {
1637       if (TREE_CHAIN (t) == block)
1638         TREE_CHAIN (t) = TREE_CHAIN (block);
1639       else
1640         t = TREE_CHAIN (t);
1641     }
1642   TREE_CHAIN (block) = NULL_TREE;
1643   /* Clear TREE_USED which is always set by poplevel.
1644      The flag is set again if insert_block is called.  */
1645   TREE_USED (block) = 0;
1646 }
1647
1648 /* Insert BLOCK at the end of the list of subblocks of the
1649    current binding level.  This is used when a BIND_EXPR is expanded,
1650    to handle the BLOCK node inside the BIND_EXPR.  */
1651
1652 void
1653 insert_block (block)
1654      tree block;
1655 {
1656   TREE_USED (block) = 1;
1657   current_binding_level->blocks
1658     = chainon (current_binding_level->blocks, block);
1659 }
1660
1661 /* Set the BLOCK node for the innermost scope
1662    (the one we are currently in).  */
1663
1664 void
1665 set_block (block)
1666     register tree block;
1667 {
1668   current_binding_level->this_block = block;
1669 }
1670
1671 /* Do a pushlevel for class declarations.  */
1672
1673 void
1674 pushlevel_class ()
1675 {
1676   register struct binding_level *newlevel;
1677
1678   /* Reuse or create a struct for this binding level.  */
1679 #if defined(DEBUG_CP_BINDING_LEVELS)
1680   if (0)
1681 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1682   if (free_binding_level)
1683 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1684     {
1685       newlevel = free_binding_level;
1686       free_binding_level = free_binding_level->level_chain;
1687     }
1688   else
1689     newlevel = make_binding_level ();
1690
1691 #if defined(DEBUG_CP_BINDING_LEVELS)
1692   is_class_level = 1;
1693 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1694
1695   push_binding_level (newlevel, 0, 0);
1696
1697   class_binding_level = current_binding_level;
1698   class_binding_level->parm_flag = 2;
1699   class_binding_level->this_class = current_class_type;
1700 }
1701
1702 /* ...and a poplevel for class declarations.  */
1703
1704 void
1705 poplevel_class ()
1706 {
1707   register struct binding_level *level = class_binding_level;
1708   tree shadowed;
1709
1710   my_friendly_assert (level != 0, 354);
1711
1712   /* If we're leaving a toplevel class, don't bother to do the setting
1713      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1714      shouldn't even be used when current_class_type isn't set, and second,
1715      if we don't touch it here, we're able to use the cache effect if the
1716      next time we're entering a class scope, it is the same class.  */
1717   if (current_class_depth != 1)
1718     {
1719       struct binding_level* b;
1720
1721       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1722       for (shadowed = level->class_shadowed;
1723            shadowed;
1724            shadowed = TREE_CHAIN (shadowed))
1725         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1726
1727       /* Find the next enclosing class, and recreate
1728          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1729       b = level->level_chain;
1730       while (b && b->parm_flag != 2)
1731         b = b->level_chain;
1732
1733       if (b)
1734         for (shadowed = b->class_shadowed;
1735              shadowed;
1736              shadowed = TREE_CHAIN (shadowed))
1737           {
1738             tree t;
1739
1740             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1741             while (t && BINDING_LEVEL (t) != b)
1742               t = TREE_CHAIN (t);
1743
1744             if (t)
1745               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1746                 = BINDING_VALUE (t);
1747           }
1748     }
1749   else
1750     /* Remember to save what IDENTIFIER's were bound in this scope so we
1751        can recover from cache misses.  */
1752     {
1753       previous_class_type = current_class_type;
1754       previous_class_values = class_binding_level->class_shadowed;
1755     }
1756   for (shadowed = level->type_shadowed;
1757        shadowed;
1758        shadowed = TREE_CHAIN (shadowed))
1759     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1760
1761   /* Remove the bindings for all of the class-level declarations.  */
1762   for (shadowed = level->class_shadowed;
1763        shadowed;
1764        shadowed = TREE_CHAIN (shadowed))
1765     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1766
1767   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1768                       (HOST_WIDE_INT) class_binding_level->level_chain,
1769                       class_binding_level->parm_flag,
1770                       class_binding_level->keep);
1771
1772   /* Now, pop out of the binding level which we created up in the
1773      `pushlevel_class' routine.  */
1774 #if defined(DEBUG_CP_BINDING_LEVELS)
1775   is_class_level = 1;
1776 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1777
1778   pop_binding_level ();
1779 }
1780
1781 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1782    for any names in enclosing classes.  */
1783
1784 void
1785 clear_identifier_class_values ()
1786 {
1787   tree t;
1788
1789   if (!class_binding_level)
1790     return;
1791
1792   for (t = class_binding_level->class_shadowed;
1793        t;
1794        t = TREE_CHAIN (t))
1795     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1796 }
1797
1798 /* Returns non-zero if T is a virtual function table.  */
1799
1800 int
1801 vtable_decl_p (t, data)
1802      tree t;
1803      void *data ATTRIBUTE_UNUSED;
1804 {
1805   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1806 }
1807
1808 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1809    functions.  */
1810
1811 int
1812 vtype_decl_p (t, data)
1813      tree t;
1814      void *data ATTRIBUTE_UNUSED;
1815 {
1816   return (TREE_CODE (t) == TYPE_DECL
1817           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1818           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1819 }
1820
1821 /* Return the declarations that are members of the namespace NS.  */
1822
1823 tree
1824 cp_namespace_decls (ns)
1825      tree ns;
1826 {
1827   return NAMESPACE_LEVEL (ns)->names;
1828 }
1829
1830 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1831    itself, calling F for each.  The DATA is passed to F as well.  */
1832
1833 static int
1834 walk_namespaces_r (namespace, f, data)
1835      tree namespace;
1836      walk_namespaces_fn f;
1837      void *data;
1838 {
1839   tree current;
1840   int result = 0;
1841
1842   result |= (*f) (namespace, data);
1843
1844   for (current = cp_namespace_decls (namespace);
1845        current;
1846        current = TREE_CHAIN (current))
1847     {
1848       if (TREE_CODE (current) != NAMESPACE_DECL
1849           || DECL_NAMESPACE_ALIAS (current))
1850         continue;
1851       if (!DECL_LANG_SPECIFIC (current))
1852         {
1853           /* Hmm. std. */
1854           my_friendly_assert (current == std_node, 393);
1855           continue;
1856         }
1857
1858       /* We found a namespace.  */
1859       result |= walk_namespaces_r (current, f, data);
1860     }
1861
1862   return result;
1863 }
1864
1865 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1866    F as well.  */
1867
1868 int
1869 walk_namespaces (f, data)
1870      walk_namespaces_fn f;
1871      void *data;
1872 {
1873   return walk_namespaces_r (global_namespace, f, data);
1874 }
1875
1876 struct walk_globals_data {
1877   walk_globals_pred p;
1878   walk_globals_fn f;
1879   void *data;
1880 };
1881
1882 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1883    for which P returns non-zero, call F with its address.  If any call
1884    to F returns a non-zero value, return a non-zero value.  */
1885
1886 static int
1887 walk_globals_r (namespace, data)
1888      tree namespace;
1889      void *data;
1890 {
1891   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1892   walk_globals_pred p = wgd->p;
1893   walk_globals_fn f = wgd->f;
1894   void *d = wgd->data;
1895   tree *t;
1896   int result = 0;
1897
1898   t = &NAMESPACE_LEVEL (namespace)->names;
1899
1900   while (*t)
1901     {
1902       tree glbl = *t;
1903
1904       if ((*p) (glbl, d))
1905         result |= (*f) (t, d);
1906
1907       /* If F changed *T, then *T still points at the next item to
1908          examine.  */
1909       if (*t == glbl)
1910         t = &TREE_CHAIN (*t);
1911     }
1912
1913   return result;
1914 }
1915
1916 /* Walk the global declarations.  Whenever one is found for which P
1917    returns non-zero, call F with its address.  If any call to F
1918    returns a non-zero value, return a non-zero value.  */
1919
1920 int
1921 walk_globals (p, f, data)
1922      walk_globals_pred p;
1923      walk_globals_fn f;
1924      void *data;
1925 {
1926   struct walk_globals_data wgd;
1927   wgd.p = p;
1928   wgd.f = f;
1929   wgd.data = data;
1930
1931   return walk_namespaces (walk_globals_r, &wgd);
1932 }
1933
1934 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1935    DATA is non-NULL, this is the last time we will call
1936    wrapup_global_declarations for this NAMESPACE.  */
1937
1938 int
1939 wrapup_globals_for_namespace (namespace, data)
1940      tree namespace;
1941      void *data;
1942 {
1943   tree globals = cp_namespace_decls (namespace);
1944   int len = list_length (globals);
1945   tree *vec = (tree *) alloca (sizeof (tree) * len);
1946   int i;
1947   int result;
1948   tree decl;
1949   int last_time = (data != 0);
1950
1951   if (last_time && namespace == global_namespace)
1952     /* Let compile_file handle the global namespace.  */
1953     return 0;
1954
1955   /* Process the decls in reverse order--earliest first.
1956      Put them into VEC from back to front, then take out from front.  */
1957
1958   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1959     {
1960       /* Pretend we've output an unused static variable.  This ensures
1961          that the toplevel __FUNCTION__ etc won't be emitted, unless
1962          needed. */
1963       if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)
1964           && !TREE_PUBLIC (decl) && !TREE_USED (decl))
1965         {
1966           TREE_ASM_WRITTEN (decl) = 1;
1967           DECL_IGNORED_P (decl) = 1;
1968         }
1969       vec[len - i - 1] = decl;
1970     }
1971
1972   if (last_time)
1973     {
1974       check_global_declarations (vec, len);
1975       return 0;
1976     }
1977
1978   /* Temporarily mark vtables as external.  That prevents
1979      wrapup_global_declarations from writing them out; we must process
1980      them ourselves in finish_vtable_vardecl.  */
1981   for (i = 0; i < len; ++i)
1982     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1983       {
1984         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1985         DECL_EXTERNAL (vec[i]) = 1;
1986       }
1987
1988   /* Write out any globals that need to be output.  */
1989   result = wrapup_global_declarations (vec, len);
1990
1991   /* Undo the hack to DECL_EXTERNAL above.  */
1992   for (i = 0; i < len; ++i)
1993     if (vtable_decl_p (vec[i], /*data=*/0)
1994         && DECL_NOT_REALLY_EXTERN (vec[i]))
1995       {
1996         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1997         DECL_EXTERNAL (vec[i]) = 0;
1998       }
1999
2000   return result;
2001 }
2002
2003 \f
2004 /* Mark ARG (which is really a struct binding_level **) for GC.  */
2005
2006 static void
2007 mark_binding_level (arg)
2008      void *arg;
2009 {
2010   struct binding_level *lvl = *(struct binding_level **)arg;
2011
2012   for (; lvl; lvl = lvl->level_chain)
2013     {
2014       ggc_mark_tree (lvl->names);
2015       ggc_mark_tree (lvl->tags);
2016       ggc_mark_tree (lvl->usings);
2017       ggc_mark_tree (lvl->using_directives);
2018       ggc_mark_tree (lvl->class_shadowed);
2019       ggc_mark_tree (lvl->type_shadowed);
2020       ggc_mark_tree (lvl->shadowed_labels);
2021       ggc_mark_tree (lvl->blocks);
2022       ggc_mark_tree (lvl->this_block);
2023       ggc_mark_tree (lvl->this_class);
2024       ggc_mark_tree (lvl->incomplete);
2025       ggc_mark_tree (lvl->dead_vars_from_for);
2026     }
2027 }
2028
2029 static void
2030 mark_named_label_lists (labs, uses)
2031      void *labs;
2032      void *uses;
2033 {
2034   struct named_label_list *l = *(struct named_label_list **)labs;
2035   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
2036
2037   for (; l; l = l->next)
2038     {
2039       ggc_mark (l);
2040       mark_binding_level (l->binding_level);
2041       ggc_mark_tree (l->old_value);
2042       ggc_mark_tree (l->label_decl);
2043       ggc_mark_tree (l->bad_decls);
2044     }
2045
2046   for (; u; u = u->next)
2047     ggc_mark (u);
2048 }
2049 \f
2050 /* For debugging.  */
2051 static int no_print_functions = 0;
2052 static int no_print_builtins = 0;
2053
2054 void
2055 print_binding_level (lvl)
2056      struct binding_level *lvl;
2057 {
2058   tree t;
2059   int i = 0, len;
2060   fprintf (stderr, " blocks=");
2061   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2062   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2063            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2064   if (lvl->tag_transparent)
2065     fprintf (stderr, " tag-transparent");
2066   if (lvl->more_cleanups_ok)
2067     fprintf (stderr, " more-cleanups-ok");
2068   if (lvl->have_cleanups)
2069     fprintf (stderr, " have-cleanups");
2070   fprintf (stderr, "\n");
2071   if (lvl->names)
2072     {
2073       fprintf (stderr, " names:\t");
2074       /* We can probably fit 3 names to a line?  */
2075       for (t = lvl->names; t; t = TREE_CHAIN (t))
2076         {
2077           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2078             continue;
2079           if (no_print_builtins
2080               && (TREE_CODE (t) == TYPE_DECL)
2081               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2082             continue;
2083
2084           /* Function decls tend to have longer names.  */
2085           if (TREE_CODE (t) == FUNCTION_DECL)
2086             len = 3;
2087           else
2088             len = 2;
2089           i += len;
2090           if (i > 6)
2091             {
2092               fprintf (stderr, "\n\t");
2093               i = len;
2094             }
2095           print_node_brief (stderr, "", t, 0);
2096           if (t == error_mark_node)
2097             break;
2098         }
2099       if (i)
2100         fprintf (stderr, "\n");
2101     }
2102   if (lvl->tags)
2103     {
2104       fprintf (stderr, " tags:\t");
2105       i = 0;
2106       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2107         {
2108           if (TREE_PURPOSE (t) == NULL_TREE)
2109             len = 3;
2110           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2111             len = 2;
2112           else
2113             len = 4;
2114           i += len;
2115           if (i > 5)
2116             {
2117               fprintf (stderr, "\n\t");
2118               i = len;
2119             }
2120           if (TREE_PURPOSE (t) == NULL_TREE)
2121             {
2122               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2123               fprintf (stderr, ">");
2124             }
2125           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2126             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2127           else
2128             {
2129               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2130               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2131               fprintf (stderr, ">");
2132             }
2133         }
2134       if (i)
2135         fprintf (stderr, "\n");
2136     }
2137   if (lvl->class_shadowed)
2138     {
2139       fprintf (stderr, " class-shadowed:");
2140       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2141         {
2142           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2143         }
2144       fprintf (stderr, "\n");
2145     }
2146   if (lvl->type_shadowed)
2147     {
2148       fprintf (stderr, " type-shadowed:");
2149       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2150         {
2151           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2152         }
2153       fprintf (stderr, "\n");
2154     }
2155 }
2156
2157 void
2158 print_other_binding_stack (stack)
2159      struct binding_level *stack;
2160 {
2161   struct binding_level *level;
2162   for (level = stack; level != global_binding_level; level = level->level_chain)
2163     {
2164       fprintf (stderr, "binding level ");
2165       fprintf (stderr, HOST_PTR_PRINTF, level);
2166       fprintf (stderr, "\n");
2167       print_binding_level (level);
2168     }
2169 }
2170
2171 void
2172 print_binding_stack ()
2173 {
2174   struct binding_level *b;
2175   fprintf (stderr, "current_binding_level=");
2176   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2177   fprintf (stderr, "\nclass_binding_level=");
2178   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2179   fprintf (stderr, "\nglobal_binding_level=");
2180   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2181   fprintf (stderr, "\n");
2182   if (class_binding_level)
2183     {
2184       for (b = class_binding_level; b; b = b->level_chain)
2185         if (b == current_binding_level)
2186           break;
2187       if (b)
2188         b = class_binding_level;
2189       else
2190         b = current_binding_level;
2191     }
2192   else
2193     b = current_binding_level;
2194   print_other_binding_stack (b);
2195   fprintf (stderr, "global:\n");
2196   print_binding_level (global_binding_level);
2197 }
2198
2199 /* Namespace binding access routines: The namespace_bindings field of
2200    the identifier is polymorphic, with three possible values:
2201    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2202    indicating the BINDING_VALUE of global_namespace. */
2203
2204 /* Check whether the a binding for the name to scope is known.
2205    Assumes that the bindings of the name are already a list
2206    of bindings. Returns the binding found, or NULL_TREE. */
2207
2208 static tree
2209 find_binding (name, scope)
2210      tree name;
2211      tree scope;
2212 {
2213   tree iter, prev = NULL_TREE;
2214
2215   scope = ORIGINAL_NAMESPACE (scope);
2216
2217   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2218        iter = TREE_CHAIN (iter))
2219     {
2220       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2221       if (BINDING_SCOPE (iter) == scope)
2222         {
2223           /* Move binding found to the front of the list, so
2224              subsequent lookups will find it faster. */
2225           if (prev)
2226             {
2227               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2228               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2229               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2230             }
2231           return iter;
2232         }
2233       prev = iter;
2234     }
2235   return NULL_TREE;
2236 }
2237
2238 /* Always returns a binding for name in scope. If the
2239    namespace_bindings is not a list, convert it to one first.
2240    If no binding is found, make a new one. */
2241
2242 tree
2243 binding_for_name (name, scope)
2244      tree name;
2245      tree scope;
2246 {
2247   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2248   tree result;
2249
2250   scope = ORIGINAL_NAMESPACE (scope);
2251
2252   if (b && TREE_CODE (b) != CPLUS_BINDING)
2253     {
2254       /* Get rid of optimization for global scope. */
2255       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2256       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2257       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2258     }
2259   if (b && (result = find_binding (name, scope)))
2260     return result;
2261   /* Not found, make a new one. */
2262   result = make_node (CPLUS_BINDING);
2263   TREE_CHAIN (result) = b;
2264   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2265   BINDING_SCOPE (result) = scope;
2266   BINDING_TYPE (result) = NULL_TREE;
2267   BINDING_VALUE (result) = NULL_TREE;
2268   return result;
2269 }
2270
2271 /* Return the binding value for name in scope, considering that
2272    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2273
2274 tree
2275 namespace_binding (name, scope)
2276      tree name;
2277      tree scope;
2278 {
2279   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2280   if (b == NULL_TREE)
2281     return NULL_TREE;
2282   if (scope == NULL_TREE)
2283     scope = global_namespace;
2284   if (TREE_CODE (b) != CPLUS_BINDING)
2285     return (scope == global_namespace) ? b : NULL_TREE;
2286   name = find_binding (name,scope);
2287   if (name == NULL_TREE)
2288     return name;
2289   return BINDING_VALUE (name);
2290 }
2291
2292 /* Set the binding value for name in scope. If modifying the binding
2293    of global_namespace is attempted, try to optimize it. */
2294
2295 void
2296 set_namespace_binding (name, scope, val)
2297      tree name;
2298      tree scope;
2299      tree val;
2300 {
2301   tree b;
2302
2303   if (scope == NULL_TREE)
2304     scope = global_namespace;
2305
2306   if (scope == global_namespace)
2307     {
2308       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2309       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2310         {
2311           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2312           return;
2313         }
2314     }
2315   b = binding_for_name (name, scope);
2316   BINDING_VALUE (b) = val;
2317 }
2318
2319 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2320    select a name that is unique to this compilation unit.  */
2321
2322 void
2323 push_namespace (name)
2324      tree name;
2325 {
2326   tree d = NULL_TREE;
2327   int need_new = 1;
2328   int implicit_use = 0;
2329   int global = 0;
2330   if (!global_namespace)
2331     {
2332       /* This must be ::. */
2333       my_friendly_assert (name == get_identifier ("::"), 377);
2334       global = 1;
2335     }
2336   else if (!name)
2337     {
2338       /* The name of anonymous namespace is unique for the translation
2339          unit.  */
2340       if (!anonymous_namespace_name)
2341         anonymous_namespace_name = get_file_function_name ('N');
2342       name = anonymous_namespace_name;
2343       d = IDENTIFIER_NAMESPACE_VALUE (name);
2344       if (d)
2345         /* Reopening anonymous namespace.  */
2346         need_new = 0;
2347       implicit_use = 1;
2348     }
2349   else if (current_namespace == global_namespace
2350            && name == DECL_NAME (std_node))
2351     {
2352       in_std++;
2353       return;
2354     }
2355   else
2356     {
2357       /* Check whether this is an extended namespace definition. */
2358       d = IDENTIFIER_NAMESPACE_VALUE (name);
2359       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2360         {
2361           need_new = 0;
2362           if (DECL_NAMESPACE_ALIAS (d))
2363             {
2364               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2365                         d, DECL_NAMESPACE_ALIAS (d));
2366               d = DECL_NAMESPACE_ALIAS (d);
2367             }
2368         }
2369     }
2370
2371   if (need_new)
2372     {
2373       /* Make a new namespace, binding the name to it. */
2374       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2375       /* The global namespace is not pushed, and the global binding
2376          level is set elsewhere.  */
2377       if (!global)
2378         {
2379           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2380           d = pushdecl (d);
2381           pushlevel (0);
2382           declare_namespace_level ();
2383           NAMESPACE_LEVEL (d) = current_binding_level;
2384         }
2385     }
2386   else
2387     resume_binding_level (NAMESPACE_LEVEL (d));
2388
2389   if (implicit_use)
2390     do_using_directive (d);
2391   /* Enter the name space. */
2392   current_namespace = d;
2393 }
2394
2395 /* Pop from the scope of the current namespace.  */
2396
2397 void
2398 pop_namespace ()
2399 {
2400   if (current_namespace == global_namespace)
2401     {
2402       my_friendly_assert (in_std>0, 980421);
2403       in_std--;
2404       return;
2405     }
2406   current_namespace = CP_DECL_CONTEXT (current_namespace);
2407   /* The binding level is not popped, as it might be re-opened later.  */
2408   suspend_binding_level ();
2409 }
2410
2411 /* Push into the scope of the namespace NS, even if it is deeply
2412    nested within another namespace.  */
2413
2414 void
2415 push_nested_namespace (ns)
2416      tree ns;
2417 {
2418   if (ns == global_namespace)
2419     push_to_top_level ();
2420   else
2421     {
2422       push_nested_namespace (CP_DECL_CONTEXT (ns));
2423       push_namespace (DECL_NAME (ns));
2424     }
2425 }
2426
2427 /* Pop back from the scope of the namespace NS, which was previously
2428    entered with push_nested_namespace.  */
2429
2430 void
2431 pop_nested_namespace (ns)
2432      tree ns;
2433 {
2434   while (ns != global_namespace)
2435     {
2436       pop_namespace ();
2437       ns = CP_DECL_CONTEXT (ns);
2438     }
2439
2440   pop_from_top_level ();
2441 }
2442
2443 \f
2444 /* Subroutines for reverting temporarily to top-level for instantiation
2445    of templates and such.  We actually need to clear out the class- and
2446    local-value slots of all identifiers, so that only the global values
2447    are at all visible.  Simply setting current_binding_level to the global
2448    scope isn't enough, because more binding levels may be pushed.  */
2449 struct saved_scope *scope_chain;
2450
2451 /* Mark ST for GC.  */
2452
2453 static void
2454 mark_stmt_tree (st)
2455      struct stmt_tree *st;
2456 {
2457   ggc_mark_tree (st->x_last_stmt);
2458   ggc_mark_tree (st->x_last_expr_type);
2459 }
2460
2461 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2462
2463 static void
2464 mark_saved_scope (arg)
2465      void *arg;
2466 {
2467   struct saved_scope *t = *(struct saved_scope **)arg;
2468   while (t)
2469     {
2470       mark_binding_level (&t->class_bindings);
2471       ggc_mark_tree (t->old_bindings);
2472       ggc_mark_tree (t->old_namespace);
2473       ggc_mark_tree (t->class_name);
2474       ggc_mark_tree (t->class_type);
2475       ggc_mark_tree (t->access_specifier);
2476       ggc_mark_tree (t->function_decl);
2477       if (t->lang_base)
2478         ggc_mark_tree_varray (t->lang_base);
2479       ggc_mark_tree (t->lang_name);
2480       ggc_mark_tree (t->x_function_parms);
2481       ggc_mark_tree (t->template_parms);
2482       ggc_mark_tree (t->x_previous_class_type);
2483       ggc_mark_tree (t->x_previous_class_values);
2484       ggc_mark_tree (t->x_saved_tree);
2485       ggc_mark_tree (t->incomplete);
2486       ggc_mark_tree (t->lookups);
2487
2488       mark_stmt_tree (&t->x_stmt_tree);
2489       mark_binding_level (&t->bindings);
2490       t = t->prev;
2491     }
2492 }
2493
2494 static tree
2495 store_bindings (names, old_bindings)
2496      tree names, old_bindings;
2497 {
2498   tree t;
2499   for (t = names; t; t = TREE_CHAIN (t))
2500     {
2501       tree binding, t1, id;
2502
2503       if (TREE_CODE (t) == TREE_LIST)
2504         id = TREE_PURPOSE (t);
2505       else
2506         id = DECL_NAME (t);
2507
2508       if (!id
2509           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2510              we have no IDENTIFIER_BINDING if we have left the class
2511              scope, but cached the class-level declarations.  */
2512           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2513         continue;
2514
2515       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2516         if (TREE_VEC_ELT (t1, 0) == id)
2517           goto skip_it;
2518
2519       binding = make_tree_vec (4);
2520
2521       if (id)
2522         {
2523           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2524           TREE_VEC_ELT (binding, 0) = id;
2525           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2526           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2527           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2528           IDENTIFIER_BINDING (id) = NULL_TREE;
2529           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2530         }
2531       TREE_CHAIN (binding) = old_bindings;
2532       old_bindings = binding;
2533     skip_it:
2534       ;
2535     }
2536   return old_bindings;
2537 }
2538
2539 void
2540 maybe_push_to_top_level (pseudo)
2541      int pseudo;
2542 {
2543   struct saved_scope *s;
2544   struct binding_level *b;
2545   tree old_bindings;
2546   int need_pop;
2547
2548   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2549
2550   b = scope_chain ? current_binding_level : 0;
2551
2552   /* If we're in the middle of some function, save our state.  */
2553   if (cfun)
2554     {
2555       need_pop = 1;
2556       push_function_context_to (NULL_TREE);
2557     }
2558   else
2559     need_pop = 0;
2560
2561   old_bindings = NULL_TREE;
2562   if (scope_chain && previous_class_type)
2563     old_bindings = store_bindings (previous_class_values, old_bindings);
2564
2565   /* Have to include global_binding_level, because class-level decls
2566      aren't listed anywhere useful.  */
2567   for (; b; b = b->level_chain)
2568     {
2569       tree t;
2570
2571       /* Template IDs are inserted into the global level. If they were
2572          inserted into namespace level, finish_file wouldn't find them
2573          when doing pending instantiations. Therefore, don't stop at
2574          namespace level, but continue until :: .  */
2575       if (b == global_binding_level || (pseudo && b->template_parms_p))
2576         break;
2577
2578       old_bindings = store_bindings (b->names, old_bindings);
2579       /* We also need to check class_shadowed to save class-level type
2580          bindings, since pushclass doesn't fill in b->names.  */
2581       if (b->parm_flag == 2)
2582         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2583
2584       /* Unwind type-value slots back to top level.  */
2585       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2586         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2587     }
2588   s->prev = scope_chain;
2589   s->old_bindings = old_bindings;
2590   s->bindings = b;
2591   s->need_pop_function_context = need_pop;
2592   s->function_decl = current_function_decl;
2593
2594   scope_chain = s;
2595   current_function_decl = NULL_TREE;
2596   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2597   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2598   current_lang_name = lang_name_cplusplus;
2599   current_namespace = global_namespace;
2600 }
2601
2602 void
2603 push_to_top_level ()
2604 {
2605   maybe_push_to_top_level (0);
2606 }
2607
2608 void
2609 pop_from_top_level ()
2610 {
2611   struct saved_scope *s = scope_chain;
2612   tree t;
2613
2614   /* Clear out class-level bindings cache.  */
2615   if (previous_class_type)
2616     invalidate_class_lookup_cache ();
2617
2618   VARRAY_FREE (current_lang_base);
2619
2620   scope_chain = s->prev;
2621   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2622     {
2623       tree id = TREE_VEC_ELT (t, 0);
2624       if (id)
2625         {
2626           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2627           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2628           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2629         }
2630     }
2631
2632   /* If we were in the middle of compiling a function, restore our
2633      state.  */
2634   if (s->need_pop_function_context)
2635     pop_function_context_from (NULL_TREE);
2636   current_function_decl = s->function_decl;
2637
2638   free (s);
2639 }
2640 \f
2641 /* Push a definition of struct, union or enum tag "name".
2642    into binding_level "b".   "type" should be the type node,
2643    We assume that the tag "name" is not already defined.
2644
2645    Note that the definition may really be just a forward reference.
2646    In that case, the TYPE_SIZE will be a NULL_TREE.
2647
2648    C++ gratuitously puts all these tags in the name space.  */
2649
2650 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2651    record the shadowed value for this binding contour.  TYPE is
2652    the type that ID maps to.  */
2653
2654 static void
2655 set_identifier_type_value_with_scope (id, type, b)
2656      tree id;
2657      tree type;
2658      struct binding_level *b;
2659 {
2660   if (!b->namespace_p)
2661     {
2662       /* Shadow the marker, not the real thing, so that the marker
2663          gets restored later. */
2664       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2665       b->type_shadowed
2666         = tree_cons (id, old_type_value, b->type_shadowed);
2667     }
2668   else
2669     {
2670       tree binding = binding_for_name (id, current_namespace);
2671       BINDING_TYPE (binding) = type;
2672       /* Store marker instead of real type. */
2673       type = global_type_node;
2674     }
2675   SET_IDENTIFIER_TYPE_VALUE (id, type);
2676 }
2677
2678 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2679
2680 void
2681 set_identifier_type_value (id, type)
2682      tree id;
2683      tree type;
2684 {
2685   set_identifier_type_value_with_scope (id, type, current_binding_level);
2686 }
2687
2688 /* Return the type associated with id. */
2689
2690 tree
2691 identifier_type_value (id)
2692      tree id;
2693 {
2694   /* There is no type with that name, anywhere. */
2695   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2696     return NULL_TREE;
2697   /* This is not the type marker, but the real thing. */
2698   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2699     return REAL_IDENTIFIER_TYPE_VALUE (id);
2700   /* Have to search for it. It must be on the global level, now.
2701      Ask lookup_name not to return non-types. */
2702   id = lookup_name_real (id, 2, 1, 0);
2703   if (id)
2704     return TREE_TYPE (id);
2705   return NULL_TREE;
2706 }
2707
2708 /* Pop off extraneous binding levels left over due to syntax errors.
2709
2710    We don't pop past namespaces, as they might be valid.  */
2711
2712 void
2713 pop_everything ()
2714 {
2715 #ifdef DEBUG_CP_BINDING_LEVELS
2716   fprintf (stderr, "XXX entering pop_everything ()\n");
2717 #endif
2718   while (!toplevel_bindings_p ())
2719     {
2720       if (current_binding_level->parm_flag == 2)
2721         pop_nested_class ();
2722       else
2723         poplevel (0, 0, 0);
2724     }
2725 #ifdef DEBUG_CP_BINDING_LEVELS
2726   fprintf (stderr, "XXX leaving pop_everything ()\n");
2727 #endif
2728 }
2729
2730 /* The type TYPE is being declared.  If it is a class template, or a
2731    specialization of a class template, do any processing required and
2732    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2733    being declared a friend.  B is the binding level at which this TYPE
2734    should be bound.
2735
2736    Returns the TYPE_DECL for TYPE, which may have been altered by this
2737    processing.  */
2738
2739 static tree
2740 maybe_process_template_type_declaration (type, globalize, b)
2741      tree type;
2742      int globalize;
2743      struct binding_level* b;
2744 {
2745   tree decl = TYPE_NAME (type);
2746
2747   if (processing_template_parmlist)
2748     /* You can't declare a new template type in a template parameter
2749        list.  But, you can declare a non-template type:
2750
2751          template <class A*> struct S;
2752
2753        is a forward-declaration of `A'.  */
2754     ;
2755   else
2756     {
2757       maybe_check_template_type (type);
2758
2759       my_friendly_assert (IS_AGGR_TYPE (type)
2760                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2761
2762
2763       if (processing_template_decl)
2764         {
2765           /* This may change after the call to
2766              push_template_decl_real, but we want the original value.  */
2767           tree name = DECL_NAME (decl);
2768
2769           decl = push_template_decl_real (decl, globalize);
2770           /* If the current binding level is the binding level for the
2771              template parameters (see the comment in
2772              begin_template_parm_list) and the enclosing level is a class
2773              scope, and we're not looking at a friend, push the
2774              declaration of the member class into the class scope.  In the
2775              friend case, push_template_decl will already have put the
2776              friend into global scope, if appropriate.  */
2777           if (TREE_CODE (type) != ENUMERAL_TYPE
2778               && !globalize && b->template_parms_p
2779               && b->level_chain->parm_flag == 2)
2780             {
2781               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2782               /* Put this tag on the list of tags for the class, since
2783                  that won't happen below because B is not the class
2784                  binding level, but is instead the pseudo-global level.  */
2785               b->level_chain->tags =
2786                 tree_cons (name, type, b->level_chain->tags);
2787               if (!COMPLETE_TYPE_P (current_class_type))
2788                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2789             }
2790         }
2791     }
2792
2793   return decl;
2794 }
2795
2796 /* In C++, you don't have to write `struct S' to refer to `S'; you
2797    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2798    if the user had written `typedef struct S S'.  Create and return
2799    the TYPE_DECL for TYPE.  */
2800
2801 tree
2802 create_implicit_typedef (name, type)
2803      tree name;
2804      tree type;
2805 {
2806   tree decl;
2807
2808   decl = build_decl (TYPE_DECL, name, type);
2809   DECL_ARTIFICIAL (decl) = 1;
2810   /* There are other implicit type declarations, like the one *within*
2811      a class that allows you to write `S::S'.  We must distinguish
2812      amongst these.  */
2813   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2814   TYPE_NAME (type) = decl;
2815
2816   return decl;
2817 }
2818
2819 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2820    Normally put it into the inner-most non-tag-transparent scope,
2821    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2822    The latter is needed for implicit declarations.  */
2823
2824 void
2825 pushtag (name, type, globalize)
2826      tree name, type;
2827      int globalize;
2828 {
2829   register struct binding_level *b;
2830
2831   b = current_binding_level;
2832   while (b->tag_transparent
2833          || (globalize && b->parm_flag == 2))
2834     b = b->level_chain;
2835
2836   b->tags = tree_cons (name, type, b->tags);
2837
2838   if (name)
2839     {
2840       /* Do C++ gratuitous typedefing.  */
2841       if (IDENTIFIER_TYPE_VALUE (name) != type)
2842         {
2843           register tree d = NULL_TREE;
2844           int in_class = 0;
2845           tree context = TYPE_CONTEXT (type);
2846
2847           if (! context)
2848             {
2849               tree cs = current_scope ();
2850
2851               if (! globalize)
2852                 context = cs;
2853               else if (cs != NULL_TREE && TYPE_P (cs))
2854                 /* When declaring a friend class of a local class, we want
2855                    to inject the newly named class into the scope
2856                    containing the local class, not the namespace scope.  */
2857                 context = decl_function_context (get_type_decl (cs));
2858             }
2859           if (!context)
2860             context = current_namespace;
2861
2862           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2863               || b->parm_flag == 2)
2864             in_class = 1;
2865
2866           if (current_lang_name == lang_name_java)
2867             TYPE_FOR_JAVA (type) = 1;
2868
2869           d = create_implicit_typedef (name, type);
2870           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2871           if (! in_class)
2872             set_identifier_type_value_with_scope (name, type, b);
2873
2874           d = maybe_process_template_type_declaration (type,
2875                                                        globalize, b);
2876
2877           if (b->parm_flag == 2)
2878             {
2879               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2880                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2881                    class.  But if it's a member template class, we
2882                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2883                    is done later.  */
2884                 finish_member_declaration (d);
2885               else
2886                 pushdecl_class_level (d);
2887             }
2888           else
2889             d = pushdecl_with_scope (d, b);
2890
2891           if (ANON_AGGRNAME_P (name))
2892             DECL_IGNORED_P (d) = 1;
2893
2894           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2895           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2896
2897           /* If this is a local class, keep track of it.  We need this
2898              information for name-mangling, and so that it is possible to find
2899              all function definitions in a translation unit in a convenient
2900              way.  (It's otherwise tricky to find a member function definition
2901              it's only pointed to from within a local class.)  */
2902           if (TYPE_CONTEXT (type)
2903               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2904               && !processing_template_decl)
2905             VARRAY_PUSH_TREE (local_classes, type);
2906
2907           if (!uses_template_parms (type))
2908             {
2909               if (flag_new_abi)
2910                 DECL_ASSEMBLER_NAME (d) = mangle_type (type);
2911               else
2912                 DECL_ASSEMBLER_NAME (d)
2913                   = get_identifier (build_overload_name (type, 1, 1));
2914             }
2915         }
2916       if (b->parm_flag == 2)
2917         {
2918           if (!COMPLETE_TYPE_P (current_class_type))
2919             CLASSTYPE_TAGS (current_class_type) = b->tags;
2920         }
2921     }
2922
2923   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2924     /* Use the canonical TYPE_DECL for this node.  */
2925     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2926   else
2927     {
2928       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2929          will be the tagged type we just added to the current
2930          binding level.  This fake NULL-named TYPE_DECL node helps
2931          dwarfout.c to know when it needs to output a
2932          representation of a tagged type, and it also gives us a
2933          convenient place to record the "scope start" address for
2934          the tagged type.  */
2935
2936       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2937       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2938     }
2939 }
2940
2941 /* Counter used to create anonymous type names.  */
2942
2943 static int anon_cnt = 0;
2944
2945 /* Return an IDENTIFIER which can be used as a name for
2946    anonymous structs and unions.  */
2947
2948 tree
2949 make_anon_name ()
2950 {
2951   char buf[32];
2952
2953   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2954   return get_identifier (buf);
2955 }
2956
2957 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2958    This keeps dbxout from getting confused.  */
2959
2960 void
2961 clear_anon_tags ()
2962 {
2963   register struct binding_level *b;
2964   register tree tags;
2965   static int last_cnt = 0;
2966
2967   /* Fast out if no new anon names were declared.  */
2968   if (last_cnt == anon_cnt)
2969     return;
2970
2971   b = current_binding_level;
2972   while (b->tag_transparent)
2973     b = b->level_chain;
2974   tags = b->tags;
2975   while (tags)
2976     {
2977       /* A NULL purpose means we have already processed all tags
2978          from here to the end of the list.  */
2979       if (TREE_PURPOSE (tags) == NULL_TREE)
2980         break;
2981       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2982         TREE_PURPOSE (tags) = NULL_TREE;
2983       tags = TREE_CHAIN (tags);
2984     }
2985   last_cnt = anon_cnt;
2986 }
2987 \f
2988 /* Subroutine of duplicate_decls: return truthvalue of whether
2989    or not types of these decls match.
2990
2991    For C++, we must compare the parameter list so that `int' can match
2992    `int&' in a parameter position, but `int&' is not confused with
2993    `const int&'.  */
2994
2995 int
2996 decls_match (newdecl, olddecl)
2997      tree newdecl, olddecl;
2998 {
2999   int types_match;
3000
3001   if (newdecl == olddecl)
3002     return 1;
3003
3004   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
3005     /* If the two DECLs are not even the same kind of thing, we're not
3006        interested in their types.  */
3007     return 0;
3008
3009   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3010     {
3011       tree f1 = TREE_TYPE (newdecl);
3012       tree f2 = TREE_TYPE (olddecl);
3013       tree p1 = TYPE_ARG_TYPES (f1);
3014       tree p2 = TYPE_ARG_TYPES (f2);
3015
3016       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
3017           && ! (DECL_EXTERN_C_P (newdecl)
3018                 && DECL_EXTERN_C_P (olddecl)))
3019         return 0;
3020
3021       if (TREE_CODE (f1) != TREE_CODE (f2))
3022         return 0;
3023
3024       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
3025         {
3026           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
3027               && (DECL_BUILT_IN (olddecl)
3028 #ifndef NO_IMPLICIT_EXTERN_C
3029                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
3030                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
3031 #endif
3032               ))
3033             {
3034               types_match = self_promoting_args_p (p1);
3035               if (p1 == void_list_node)
3036                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3037             }
3038 #ifndef NO_IMPLICIT_EXTERN_C
3039           else if (p1 == NULL_TREE
3040                    && (DECL_EXTERN_C_P (olddecl)
3041                        && DECL_IN_SYSTEM_HEADER (olddecl)
3042                        && !DECL_CLASS_SCOPE_P (olddecl))
3043                    && (DECL_EXTERN_C_P (newdecl)
3044                        && DECL_IN_SYSTEM_HEADER (newdecl)
3045                        && !DECL_CLASS_SCOPE_P (newdecl)))
3046             {
3047               types_match = self_promoting_args_p (p2);
3048               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3049             }
3050 #endif
3051           else
3052             types_match = compparms (p1, p2);
3053         }
3054       else
3055         types_match = 0;
3056     }
3057   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3058     {
3059       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3060                                 DECL_TEMPLATE_PARMS (olddecl)))
3061         return 0;
3062
3063       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
3064           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
3065         return 0;
3066
3067       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3068         types_match = 1;
3069       else
3070         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3071                                    DECL_TEMPLATE_RESULT (newdecl));
3072     }
3073   else
3074     {
3075       if (TREE_TYPE (newdecl) == error_mark_node)
3076         types_match = TREE_TYPE (olddecl) == error_mark_node;
3077       else if (TREE_TYPE (olddecl) == NULL_TREE)
3078         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3079       else if (TREE_TYPE (newdecl) == NULL_TREE)
3080         types_match = 0;
3081       else
3082         types_match = comptypes (TREE_TYPE (newdecl),
3083                                  TREE_TYPE (olddecl),
3084                                  COMPARE_REDECLARATION);
3085     }
3086
3087   return types_match;
3088 }
3089
3090 /* If NEWDECL is `static' and an `extern' was seen previously,
3091    warn about it.  OLDDECL is the previous declaration.
3092
3093    Note that this does not apply to the C++ case of declaring
3094    a variable `extern const' and then later `const'.
3095
3096    Don't complain about built-in functions, since they are beyond
3097    the user's control.  */
3098
3099 static void
3100 warn_extern_redeclared_static (newdecl, olddecl)
3101      tree newdecl, olddecl;
3102 {
3103   static const char *explicit_extern_static_warning
3104     = "`%D' was declared `extern' and later `static'";
3105   static const char *implicit_extern_static_warning
3106     = "`%D' was declared implicitly `extern' and later `static'";
3107
3108   tree name;
3109
3110   if (TREE_CODE (newdecl) == TYPE_DECL
3111       || TREE_CODE (newdecl) == TEMPLATE_DECL
3112       || TREE_CODE (newdecl) == CONST_DECL)
3113     return;
3114
3115   /* Don't get confused by static member functions; that's a different
3116      use of `static'.  */
3117   if (TREE_CODE (newdecl) == FUNCTION_DECL
3118       && DECL_STATIC_FUNCTION_P (newdecl))
3119     return;
3120
3121   /* If the old declaration was `static', or the new one isn't, then
3122      then everything is OK.  */
3123   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3124     return;
3125
3126   /* It's OK to declare a builtin function as `static'.  */
3127   if (TREE_CODE (olddecl) == FUNCTION_DECL
3128       && DECL_ARTIFICIAL (olddecl))
3129     return;
3130
3131   name = DECL_ASSEMBLER_NAME (newdecl);
3132   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3133               ? implicit_extern_static_warning
3134               : explicit_extern_static_warning, newdecl);
3135   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3136 }
3137
3138 /* Handle when a new declaration NEWDECL has the same name as an old
3139    one OLDDECL in the same binding contour.  Prints an error message
3140    if appropriate.
3141
3142    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3143    Otherwise, return 0.  */
3144
3145 int
3146 duplicate_decls (newdecl, olddecl)
3147      tree newdecl, olddecl;
3148 {
3149   unsigned olddecl_uid = DECL_UID (olddecl);
3150   int olddecl_friend = 0, types_match = 0;
3151   int new_defines_function = 0;
3152
3153   if (newdecl == olddecl)
3154     return 1;
3155
3156   types_match = decls_match (newdecl, olddecl);
3157
3158   /* If either the type of the new decl or the type of the old decl is an
3159      error_mark_node, then that implies that we have already issued an
3160      error (earlier) for some bogus type specification, and in that case,
3161      it is rather pointless to harass the user with yet more error message
3162      about the same declaration, so just pretend the types match here.  */
3163   if (TREE_TYPE (newdecl) == error_mark_node
3164       || TREE_TYPE (olddecl) == error_mark_node)
3165     types_match = 1;
3166
3167   /* Check for redeclaration and other discrepancies. */
3168   if (TREE_CODE (olddecl) == FUNCTION_DECL
3169       && DECL_ARTIFICIAL (olddecl))
3170     {
3171       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3172         {
3173           /* If you declare a built-in or predefined function name as static,
3174              the old definition is overridden, but optionally warn this was a
3175              bad choice of name.  */
3176           if (! TREE_PUBLIC (newdecl))
3177             {
3178               if (warn_shadow)
3179                 cp_warning ("shadowing %s function `%#D'",
3180                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3181                             olddecl);
3182               /* Discard the old built-in function.  */
3183               return 0;
3184             }
3185           /* If the built-in is not ansi, then programs can override
3186              it even globally without an error.  */
3187           else if (! DECL_BUILT_IN (olddecl))
3188             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3189                         olddecl, newdecl);
3190           else
3191             {
3192               cp_error ("declaration of `%#D'", newdecl);
3193               cp_error ("conflicts with built-in declaration `%#D'",
3194                         olddecl);
3195             }
3196           return 0;
3197         }
3198       else if (!types_match)
3199         {
3200           if ((DECL_EXTERN_C_P (newdecl)
3201                && DECL_EXTERN_C_P (olddecl))
3202               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3203                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3204             {
3205               /* A near match; override the builtin.  */
3206
3207               if (TREE_PUBLIC (newdecl))
3208                 {
3209                   cp_warning ("new declaration `%#D'", newdecl);
3210                   cp_warning ("ambiguates built-in declaration `%#D'",
3211                               olddecl);
3212                 }
3213               else if (warn_shadow)
3214                 cp_warning ("shadowing %s function `%#D'",
3215                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3216                             olddecl);
3217             }
3218           else
3219             /* Discard the old built-in function.  */
3220             return 0;
3221         }
3222
3223       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3224         {
3225           /* If a builtin function is redeclared as `static', merge
3226              the declarations, but make the original one static.  */
3227           DECL_THIS_STATIC (olddecl) = 1;
3228           TREE_PUBLIC (olddecl) = 0;
3229
3230           /* Make the old declaration consistent with the new one so
3231              that all remnants of the builtin-ness of this function
3232              will be banished.  */
3233           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3234           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3235           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3236           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3237                                        newdecl);
3238         }
3239     }
3240   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3241     {
3242       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3243            && TREE_CODE (newdecl) != TYPE_DECL
3244            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3245                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3246           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3247               && TREE_CODE (olddecl) != TYPE_DECL
3248               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3249                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3250                         == TYPE_DECL))))
3251         {
3252           /* We do nothing special here, because C++ does such nasty
3253              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3254              get shadowed, and know that if we need to find a TYPE_DECL
3255              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3256              slot of the identifier.  */
3257           return 0;
3258         }
3259
3260       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3261            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3262           || (TREE_CODE (olddecl) == FUNCTION_DECL
3263               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3264         return 0;
3265
3266       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3267       if (TREE_CODE (olddecl) == TREE_LIST)
3268         olddecl = TREE_VALUE (olddecl);
3269       cp_error_at ("previous declaration of `%#D'", olddecl);
3270
3271       /* New decl is completely inconsistent with the old one =>
3272          tell caller to replace the old one.  */
3273
3274       return 0;
3275     }
3276   else if (!types_match)
3277     {
3278       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3279         /* These are certainly not duplicate declarations; they're
3280            from different scopes.  */
3281         return 0;
3282
3283       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3284         {
3285           /* The name of a class template may not be declared to refer to
3286              any other template, class, function, object, namespace, value,
3287              or type in the same scope.  */
3288           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3289               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3290             {
3291               cp_error ("declaration of template `%#D'", newdecl);
3292               cp_error_at ("conflicts with previous declaration `%#D'",
3293                            olddecl);
3294             }
3295           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3296                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3297                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3298                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3299                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3300                                            DECL_TEMPLATE_PARMS (olddecl)))
3301             {
3302               cp_error ("new declaration `%#D'", newdecl);
3303               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3304             }
3305           return 0;
3306         }
3307       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3308         {
3309           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3310             {
3311               cp_error ("declaration of C function `%#D' conflicts with",
3312                         newdecl);
3313               cp_error_at ("previous declaration `%#D' here", olddecl);
3314             }
3315           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3316                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3317             {
3318               cp_error ("new declaration `%#D'", newdecl);
3319               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3320             }
3321           else
3322             return 0;
3323         }
3324
3325       /* Already complained about this, so don't do so again.  */
3326       else if (current_class_type == NULL_TREE
3327           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3328         {
3329           cp_error ("conflicting types for `%#D'", newdecl);
3330           cp_error_at ("previous declaration as `%#D'", olddecl);
3331         }
3332     }
3333   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3334             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3335                  && (!DECL_TEMPLATE_INFO (newdecl)
3336                      || (DECL_TI_TEMPLATE (newdecl)
3337                          != DECL_TI_TEMPLATE (olddecl))))
3338                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3339                     && (!DECL_TEMPLATE_INFO (olddecl)
3340                         || (DECL_TI_TEMPLATE (olddecl)
3341                             != DECL_TI_TEMPLATE (newdecl))))))
3342     /* It's OK to have a template specialization and a non-template
3343        with the same type, or to have specializations of two
3344        different templates with the same type.  Note that if one is a
3345        specialization, and the other is an instantiation of the same
3346        template, that we do not exit at this point.  That situation
3347        can occur if we instantiate a template class, and then
3348        specialize one of its methods.  This situation is legal, but
3349        the declarations must be merged in the usual way.  */
3350     return 0;
3351   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3352            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3353                 && !DECL_USE_TEMPLATE (newdecl))
3354                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3355                    && !DECL_USE_TEMPLATE (olddecl))))
3356     /* One of the declarations is a template instantiation, and the
3357        other is not a template at all.  That's OK.  */
3358     return 0;
3359   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3360            && DECL_NAMESPACE_ALIAS (newdecl)
3361            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3362     /* Redeclaration of namespace alias, ignore it. */
3363     return 1;
3364   else
3365     {
3366       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3367       if (errmsg)
3368         {
3369           cp_error (errmsg, newdecl);
3370           if (DECL_NAME (olddecl) != NULL_TREE)
3371             cp_error_at ((DECL_INITIAL (olddecl)
3372                           && namespace_bindings_p ())
3373                          ? "`%#D' previously defined here"
3374                          : "`%#D' previously declared here", olddecl);
3375         }
3376       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3377                && DECL_INITIAL (olddecl) != NULL_TREE
3378                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3379                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3380         {
3381           /* Prototype decl follows defn w/o prototype.  */
3382           cp_warning_at ("prototype for `%#D'", newdecl);
3383           cp_warning_at ("follows non-prototype definition here", olddecl);
3384         }
3385       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3386                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3387         {
3388           /* extern "C" int foo ();
3389              int foo () { bar (); }
3390              is OK.  */
3391           if (current_lang_stack
3392               == &VARRAY_TREE (current_lang_base, 0))
3393             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3394           else
3395             {
3396               cp_error_at ("previous declaration of `%#D' with %L linkage",
3397                            olddecl, DECL_LANGUAGE (olddecl));
3398               cp_error ("conflicts with new declaration with %L linkage",
3399                         DECL_LANGUAGE (newdecl));
3400             }
3401         }
3402
3403       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3404         ;
3405       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3406         {
3407           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3408           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3409           int i = 1;
3410
3411           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3412             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3413
3414           for (; t1 && t1 != void_list_node;
3415                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3416             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3417               {
3418                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3419                                            TREE_PURPOSE (t2)))
3420                   {
3421                     if (pedantic)
3422                       {
3423                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3424                                     i, newdecl);
3425                         cp_pedwarn_at ("after previous specification in `%#D'",
3426                                        olddecl);
3427                       }
3428                   }
3429                 else
3430                   {
3431                     cp_error ("default argument given for parameter %d of `%#D'",
3432                               i, newdecl);
3433                     cp_error_at ("after previous specification in `%#D'",
3434                                  olddecl);
3435                   }
3436               }
3437
3438           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3439               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3440             {
3441               cp_warning ("`%#D' was used before it was declared inline",
3442                           newdecl);
3443               cp_warning_at ("previous non-inline declaration here",
3444                              olddecl);
3445             }
3446         }
3447     }
3448
3449   /* If new decl is `static' and an `extern' was seen previously,
3450      warn about it.  */
3451   warn_extern_redeclared_static (newdecl, olddecl);
3452
3453   /* We have committed to returning 1 at this point.  */
3454   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3455     {
3456       /* Now that functions must hold information normally held
3457          by field decls, there is extra work to do so that
3458          declaration information does not get destroyed during
3459          definition.  */
3460       if (DECL_VINDEX (olddecl))
3461         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3462       if (DECL_VIRTUAL_CONTEXT (olddecl))
3463         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3464       if (DECL_CONTEXT (olddecl))
3465         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3466       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3467         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3468       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3469       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3470       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3471       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3472       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3473       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3474       DECL_LANG_SPECIFIC (newdecl)->u2 = DECL_LANG_SPECIFIC (olddecl)->u2;
3475       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3476
3477       /* Optionally warn about more than one declaration for the same
3478          name, but don't warn about a function declaration followed by a
3479          definition.  */
3480       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3481           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3482           /* Don't warn about extern decl followed by definition. */
3483           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3484           /* Don't warn about friends, let add_friend take care of it. */
3485           && ! DECL_FRIEND_P (newdecl))
3486         {
3487           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3488           cp_warning_at ("previous declaration of `%D'", olddecl);
3489         }
3490     }
3491
3492   /* Deal with C++: must preserve virtual function table size.  */
3493   if (TREE_CODE (olddecl) == TYPE_DECL)
3494     {
3495       register tree newtype = TREE_TYPE (newdecl);
3496       register tree oldtype = TREE_TYPE (olddecl);
3497
3498       if (newtype != error_mark_node && oldtype != error_mark_node
3499           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3500         {
3501           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3502           CLASSTYPE_FRIEND_CLASSES (newtype)
3503             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3504         }
3505
3506       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3507     }
3508
3509   /* Copy all the DECL_... slots specified in the new decl
3510      except for any that we copy here from the old type.  */
3511   DECL_MACHINE_ATTRIBUTES (newdecl)
3512     = merge_machine_decl_attributes (olddecl, newdecl);
3513
3514   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3515     {
3516       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3517       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3518         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3519                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3520
3521       return 1;
3522     }
3523
3524   if (types_match)
3525     {
3526       /* Automatically handles default parameters.  */
3527       tree oldtype = TREE_TYPE (olddecl);
3528       tree newtype;
3529
3530       /* Merge the data types specified in the two decls.  */
3531       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3532
3533       /* If common_type produces a non-typedef type, just use the old type.  */
3534       if (TREE_CODE (newdecl) == TYPE_DECL
3535           && newtype == DECL_ORIGINAL_TYPE (newdecl))
3536         newtype = oldtype;
3537
3538       if (TREE_CODE (newdecl) == VAR_DECL)
3539         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3540       /* Do this after calling `common_type' so that default
3541          parameters don't confuse us.  */
3542       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3543           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3544               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3545         {
3546           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3547                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3548           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3549                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3550
3551           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3552               && DECL_SOURCE_LINE (olddecl) != 0
3553               && flag_exceptions
3554               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3555                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3556             {
3557               cp_error ("declaration of `%F' throws different exceptions",
3558                         newdecl);
3559               cp_error_at ("than previous declaration `%F'", olddecl);
3560             }
3561         }
3562       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3563
3564       /* Lay the type out, unless already done.  */
3565       if (! same_type_p (newtype, oldtype)
3566           && TREE_TYPE (newdecl) != error_mark_node
3567           && !(processing_template_decl && uses_template_parms (newdecl)))
3568         layout_type (TREE_TYPE (newdecl));
3569
3570       if ((TREE_CODE (newdecl) == VAR_DECL
3571            || TREE_CODE (newdecl) == PARM_DECL
3572            || TREE_CODE (newdecl) == RESULT_DECL
3573            || TREE_CODE (newdecl) == FIELD_DECL
3574            || TREE_CODE (newdecl) == TYPE_DECL)
3575           && !(processing_template_decl && uses_template_parms (newdecl)))
3576         layout_decl (newdecl, 0);
3577
3578       /* Merge the type qualifiers.  */
3579       if (TREE_READONLY (newdecl))
3580         TREE_READONLY (olddecl) = 1;
3581       if (TREE_THIS_VOLATILE (newdecl))
3582         TREE_THIS_VOLATILE (olddecl) = 1;
3583
3584       /* Merge the initialization information.  */
3585       if (DECL_INITIAL (newdecl) == NULL_TREE
3586           && DECL_INITIAL (olddecl) != NULL_TREE)
3587         {
3588           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3589           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3590           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3591           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3592               && DECL_LANG_SPECIFIC (newdecl)
3593               && DECL_LANG_SPECIFIC (olddecl))
3594             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3595         }
3596
3597       /* Merge the section attribute.
3598          We want to issue an error if the sections conflict but that must be
3599          done later in decl_attributes since we are called before attributes
3600          are assigned.  */
3601       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3602         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3603
3604       /* Keep the old rtl since we can safely use it.  */
3605       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3606
3607       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3608         {
3609           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3610             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3611           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3612             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3613           DECL_NO_LIMIT_STACK (newdecl)
3614             |= DECL_NO_LIMIT_STACK (olddecl);
3615         }
3616     }
3617   /* If cannot merge, then use the new type and qualifiers,
3618      and don't preserve the old rtl.  */
3619   else
3620     {
3621       /* Clean out any memory we had of the old declaration.  */
3622       tree oldstatic = value_member (olddecl, static_aggregates);
3623       if (oldstatic)
3624         TREE_VALUE (oldstatic) = error_mark_node;
3625
3626       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3627       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3628       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3629       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3630     }
3631
3632   /* Merge the storage class information.  */
3633   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3634   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3635   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3636   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3637   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3638   if (! DECL_EXTERNAL (olddecl))
3639     DECL_EXTERNAL (newdecl) = 0;
3640
3641   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3642     {
3643       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3644       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3645       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3646       DECL_TEMPLATE_INSTANTIATED (newdecl)
3647         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3648       /* Don't really know how much of the language-specific
3649          values we should copy from old to new.  */
3650       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3651       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3652       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3653       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3654       olddecl_friend = DECL_FRIEND_P (olddecl);
3655
3656       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3657       if (TREE_CODE (newdecl) == FUNCTION_DECL
3658           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3659         DECL_BEFRIENDING_CLASSES (newdecl)
3660           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3661                      DECL_BEFRIENDING_CLASSES (olddecl));
3662     }
3663
3664   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3665     {
3666       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3667           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3668         {
3669           /* If newdecl is not a specialization, then it is not a
3670              template-related function at all.  And that means that we
3671              shoud have exited above, returning 0.  */
3672           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3673                               0);
3674
3675           if (TREE_USED (olddecl))
3676             /* From [temp.expl.spec]:
3677
3678                If a template, a member template or the member of a class
3679                template is explicitly specialized then that
3680                specialization shall be declared before the first use of
3681                that specialization that would cause an implicit
3682                instantiation to take place, in every translation unit in
3683                which such a use occurs.  */
3684             cp_error ("explicit specialization of %D after first use",
3685                       olddecl);
3686
3687           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3688         }
3689       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3690
3691       /* If either decl says `inline', this fn is inline, unless its
3692          definition was passed already.  */
3693       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3694         DECL_INLINE (olddecl) = 1;
3695       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3696
3697       if (! types_match)
3698         {
3699           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3700           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3701           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3702         }
3703       if (! types_match || new_defines_function)
3704         {
3705           /* These need to be copied so that the names are available.
3706              Note that if the types do match, we'll preserve inline
3707              info and other bits, but if not, we won't.  */
3708           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3709           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3710         }
3711       if (new_defines_function)
3712         /* If defining a function declared with other language
3713            linkage, use the previously declared language linkage.  */
3714         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3715       else if (types_match)
3716         {
3717           /* If redeclaring a builtin function, and not a definition,
3718              it stays built in.  */
3719           if (DECL_BUILT_IN (olddecl))
3720             {
3721               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3722               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3723               /* If we're keeping the built-in definition, keep the rtl,
3724                  regardless of declaration matches.  */
3725               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3726             }
3727           else
3728             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3729
3730           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3731           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3732             /* Previously saved insns go together with
3733                the function's previous definition.  */
3734             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3735           /* Don't clear out the arguments if we're redefining a function.  */
3736           if (DECL_ARGUMENTS (olddecl))
3737             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3738         }
3739     }
3740
3741   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3742     {
3743       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3744     }
3745
3746   /* Now preserve various other info from the definition.  */
3747   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3748   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3749   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3750   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3751
3752   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3753     {
3754       int function_size;
3755
3756       function_size = sizeof (struct tree_decl);
3757
3758       bcopy ((char *) newdecl + sizeof (struct tree_common),
3759              (char *) olddecl + sizeof (struct tree_common),
3760              function_size - sizeof (struct tree_common));
3761
3762       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3763         {
3764           /* If newdecl is a template instantiation, it is possible that
3765              the following sequence of events has occurred:
3766
3767              o A friend function was declared in a class template.  The
3768              class template was instantiated.
3769
3770              o The instantiation of the friend declaration was
3771              recorded on the instantiation list, and is newdecl.
3772
3773              o Later, however, instantiate_class_template called pushdecl
3774              on the newdecl to perform name injection.  But, pushdecl in
3775              turn called duplicate_decls when it discovered that another
3776              declaration of a global function with the same name already
3777              existed.
3778
3779              o Here, in duplicate_decls, we decided to clobber newdecl.
3780
3781              If we're going to do that, we'd better make sure that
3782              olddecl, and not newdecl, is on the list of
3783              instantiations so that if we try to do the instantiation
3784              again we won't get the clobbered declaration.  */
3785
3786           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3787           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3788
3789           for (; decls; decls = TREE_CHAIN (decls))
3790             if (TREE_VALUE (decls) == newdecl)
3791               TREE_VALUE (decls) = olddecl;
3792         }
3793     }
3794   else
3795     {
3796       bcopy ((char *) newdecl + sizeof (struct tree_common),
3797              (char *) olddecl + sizeof (struct tree_common),
3798              sizeof (struct tree_decl) - sizeof (struct tree_common)
3799              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3800     }
3801
3802   DECL_UID (olddecl) = olddecl_uid;
3803   if (olddecl_friend)
3804     DECL_FRIEND_P (olddecl) = 1;
3805
3806   /* NEWDECL contains the merged attribute lists.
3807      Update OLDDECL to be the same.  */
3808   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3809
3810   return 1;
3811 }
3812
3813 /* Record a decl-node X as belonging to the current lexical scope.
3814    Check for errors (such as an incompatible declaration for the same
3815    name already seen in the same scope).
3816
3817    Returns either X or an old decl for the same name.
3818    If an old decl is returned, it may have been smashed
3819    to agree with what X says.  */
3820
3821 tree
3822 pushdecl (x)
3823      tree x;
3824 {
3825   register tree t;
3826   register tree name;
3827   int need_new_binding;
3828
3829   /* We shouldn't be calling pushdecl when we're generating RTL for a
3830      function that we already did semantic analysis on previously.  */
3831   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3832                       19990913);
3833
3834   need_new_binding = 1;
3835
3836   if (DECL_TEMPLATE_PARM_P (x))
3837     /* Template parameters have no context; they are not X::T even
3838        when declared within a class or namespace.  */
3839     ;
3840   else
3841     {
3842       if (current_function_decl && x != current_function_decl
3843           /* A local declaration for a function doesn't constitute
3844              nesting.  */
3845           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3846           /* A local declaration for an `extern' variable is in the
3847              scoped of the current namespace, not the current
3848              function.  */
3849           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3850           && !DECL_CONTEXT (x))
3851         DECL_CONTEXT (x) = current_function_decl;
3852
3853       /* If this is the declaration for a namespace-scope function,
3854          but the declaration itself is in a local scope, mark the
3855          declaration.  */
3856       if (TREE_CODE (x) == FUNCTION_DECL
3857           && DECL_NAMESPACE_SCOPE_P (x)
3858           && current_function_decl
3859           && x != current_function_decl)
3860         DECL_LOCAL_FUNCTION_P (x) = 1;
3861     }
3862
3863   name = DECL_NAME (x);
3864   if (name)
3865     {
3866 #if 0
3867       /* Not needed...see below.  */
3868       char *file;
3869       int line;
3870 #endif
3871       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3872         name = TREE_OPERAND (name, 0);
3873
3874       /* Namespace-scoped variables are not found in the current level. */
3875       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3876         t = namespace_binding (name, DECL_CONTEXT (x));
3877       else
3878         t = lookup_name_current_level (name);
3879
3880       /* If we are declaring a function, and the result of name-lookup
3881          was an OVERLOAD, look for an overloaded instance that is
3882          actually the same as the function we are declaring.  (If
3883          there is one, we have to merge our declaration with the
3884          previous declaration.)  */
3885       if (t && TREE_CODE (t) == OVERLOAD)
3886         {
3887           tree match;
3888
3889           if (TREE_CODE (x) == FUNCTION_DECL)
3890             for (match = t; match; match = OVL_NEXT (match))
3891               {
3892                 if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t))
3893                     == DECL_ASSEMBLER_NAME (x))
3894                   break;
3895               }
3896           else
3897             /* Just choose one.  */
3898             match = t;
3899
3900           if (match)
3901             t = OVL_CURRENT (match);
3902           else
3903             t = NULL_TREE;
3904         }
3905
3906       if (t == error_mark_node)
3907         {
3908           /* error_mark_node is 0 for a while during initialization!  */
3909           t = NULL_TREE;
3910           cp_error_at ("`%#D' used prior to declaration", x);
3911         }
3912       else if (t != NULL_TREE)
3913         {
3914           if (TREE_CODE (t) == PARM_DECL)
3915             {
3916               if (DECL_CONTEXT (t) == NULL_TREE)
3917                 fatal ("parse errors have confused me too much");
3918
3919               /* Check for duplicate params.  */
3920               if (duplicate_decls (x, t))
3921                 return t;
3922             }
3923           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3924                     || DECL_FUNCTION_TEMPLATE_P (x))
3925                    && is_overloaded_fn (t))
3926             /* Don't do anything just yet. */;
3927           else if (t == wchar_decl_node)
3928             {
3929               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3930                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3931
3932               /* Throw away the redeclaration.  */
3933               return t;
3934             }
3935           else if (TREE_CODE (t) != TREE_CODE (x))
3936             {
3937               if (duplicate_decls (x, t))
3938                 return t;
3939             }
3940           else if (duplicate_decls (x, t))
3941             {
3942               if (TREE_CODE (t) == TYPE_DECL)
3943                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3944               else if (TREE_CODE (t) == FUNCTION_DECL)
3945                 check_default_args (t);
3946
3947               return t;
3948             }
3949           else if (DECL_MAIN_P (x))
3950             {
3951               /* A redeclaration of main, but not a duplicate of the
3952                  previous one.
3953
3954                  [basic.start.main]
3955
3956                  This function shall not be overloaded.  */
3957               cp_error_at ("invalid redeclaration of `%D'", t);
3958               cp_error ("as `%D'", x);
3959               /* We don't try to push this declaration since that
3960                  causes a crash.  */
3961               return x;
3962             }
3963         }
3964
3965       check_template_shadow (x);
3966
3967       /* If this is a function conjured up by the backend, massage it
3968          so it looks friendly.  */
3969       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3970         {
3971           retrofit_lang_decl (x);
3972           DECL_LANGUAGE (x) = lang_c;
3973         }
3974
3975       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3976         {
3977           t = push_overloaded_decl (x, PUSH_LOCAL);
3978           if (t != x)
3979             return t;
3980           if (!namespace_bindings_p ())
3981             /* We do not need to create a binding for this name;
3982                push_overloaded_decl will have already done so if
3983                necessary.  */
3984             need_new_binding = 0;
3985         }
3986       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3987         {
3988           t = push_overloaded_decl (x, PUSH_GLOBAL);
3989           if (t == x)
3990             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3991           return t;
3992         }
3993
3994       /* If declaring a type as a typedef, copy the type (unless we're
3995          at line 0), and install this TYPE_DECL as the new type's typedef
3996          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3997       if (TREE_CODE (x) == TYPE_DECL)
3998         {
3999           tree type = TREE_TYPE (x);
4000           if (DECL_SOURCE_LINE (x) == 0)
4001             {
4002               if (TYPE_NAME (type) == 0)
4003                 TYPE_NAME (type) = x;
4004             }
4005           else if (type != error_mark_node && TYPE_NAME (type) != x
4006                    /* We don't want to copy the type when all we're
4007                       doing is making a TYPE_DECL for the purposes of
4008                       inlining.  */
4009                    && (!TYPE_NAME (type)
4010                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
4011             {
4012               DECL_ORIGINAL_TYPE (x) = type;
4013               type = build_type_copy (type);
4014               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
4015               TYPE_NAME (type) = x;
4016               TREE_TYPE (x) = type;
4017             }
4018
4019           if (type != error_mark_node
4020               && TYPE_NAME (type)
4021               && TYPE_IDENTIFIER (type))
4022             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4023                                                   current_binding_level);
4024
4025         }
4026
4027       /* Multiple external decls of the same identifier ought to match.
4028
4029          We get warnings about inline functions where they are defined.
4030          We get warnings about other functions from push_overloaded_decl.
4031
4032          Avoid duplicate warnings where they are used.  */
4033       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4034         {
4035           tree decl;
4036
4037           decl = IDENTIFIER_NAMESPACE_VALUE (name);
4038           if (decl && TREE_CODE (decl) == OVERLOAD)
4039             decl = OVL_FUNCTION (decl);
4040
4041           if (decl && decl != error_mark_node
4042               && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
4043               /* If different sort of thing, we already gave an error.  */
4044               && TREE_CODE (decl) == TREE_CODE (x)
4045               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4046             {
4047               cp_pedwarn ("type mismatch with previous external decl", x);
4048               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4049             }
4050         }
4051
4052       /* This name is new in its binding level.
4053          Install the new declaration and return it.  */
4054       if (namespace_bindings_p ())
4055         {
4056           /* Install a global value.  */
4057
4058           /* If the first global decl has external linkage,
4059              warn if we later see static one.  */
4060           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4061             TREE_PUBLIC (name) = 1;
4062
4063           /* Bind the mangled name for the entity.  In the future, we
4064              should not need to do this; mangled names are an
4065              implementation detail of which the front-end should not
4066              need to be aware.  */
4067           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4068                 && t != NULL_TREE)
4069               /* For an ordinary function, we create a binding from
4070                  the mangled name (i.e., NAME) to the DECL.  But, for
4071                  an `extern "C"' function, the mangled name and the
4072                  ordinary name are the same so we need not do this.  */
4073               && !DECL_EXTERN_C_FUNCTION_P (x))
4074             {
4075               tree mangled_name;
4076
4077               if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
4078                   || TREE_CODE (x) == NAMESPACE_DECL)
4079                 mangled_name = name;
4080               else
4081                 mangled_name = DECL_ASSEMBLER_NAME (x);
4082
4083               if (TREE_CODE (x) == FUNCTION_DECL)
4084                 my_friendly_assert
4085                   ((IDENTIFIER_GLOBAL_VALUE (mangled_name) == NULL_TREE)
4086                   || (IDENTIFIER_GLOBAL_VALUE (mangled_name) == x), 378);
4087               SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name, x);
4088             }
4089
4090           /* Don't forget if the function was used via an implicit decl.  */
4091           if (IDENTIFIER_IMPLICIT_DECL (name)
4092               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4093             TREE_USED (x) = 1;
4094
4095           /* Don't forget if its address was taken in that way.  */
4096           if (IDENTIFIER_IMPLICIT_DECL (name)
4097               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4098             TREE_ADDRESSABLE (x) = 1;
4099
4100           /* Warn about mismatches against previous implicit decl.  */
4101           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4102               /* If this real decl matches the implicit, don't complain.  */
4103               && ! (TREE_CODE (x) == FUNCTION_DECL
4104                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4105             cp_warning
4106               ("`%D' was previously implicitly declared to return `int'", x);
4107
4108           /* If new decl is `static' and an `extern' was seen previously,
4109              warn about it.  */
4110           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4111             warn_extern_redeclared_static (x, t);
4112         }
4113       else
4114         {
4115           /* Here to install a non-global value.  */
4116           tree oldlocal = IDENTIFIER_VALUE (name);
4117           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4118
4119           if (need_new_binding)
4120             {
4121               push_local_binding (name, x, 0);
4122               /* Because push_local_binding will hook X on to the
4123                  current_binding_level's name list, we don't want to
4124                  do that again below.  */
4125               need_new_binding = 0;
4126             }
4127
4128           /* If this is a TYPE_DECL, push it into the type value slot.  */
4129           if (TREE_CODE (x) == TYPE_DECL)
4130             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4131                                                   current_binding_level);
4132
4133           /* Clear out any TYPE_DECL shadowed by a namespace so that
4134              we won't think this is a type.  The C struct hack doesn't
4135              go through namespaces.  */
4136           if (TREE_CODE (x) == NAMESPACE_DECL)
4137             set_identifier_type_value_with_scope (name, NULL_TREE,
4138                                                   current_binding_level);
4139
4140           if (oldlocal)
4141             {
4142               tree d = oldlocal;
4143
4144               while (oldlocal
4145                      && TREE_CODE (oldlocal) == VAR_DECL
4146                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4147                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4148
4149               if (oldlocal == NULL_TREE)
4150                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4151             }
4152
4153           /* If this is an extern function declaration, see if we
4154              have a global definition or declaration for the function.  */
4155           if (oldlocal == NULL_TREE
4156               && DECL_EXTERNAL (x)
4157               && oldglobal != NULL_TREE
4158               && TREE_CODE (x) == FUNCTION_DECL
4159               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4160             {
4161               /* We have one.  Their types must agree.  */
4162               if (decls_match (x, oldglobal))
4163                 /* OK */;
4164               else
4165                 {
4166                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4167                   cp_warning_at ("global declaration `%#D'", oldglobal);
4168                 }
4169             }
4170           /* If we have a local external declaration,
4171              and no file-scope declaration has yet been seen,
4172              then if we later have a file-scope decl it must not be static.  */
4173           if (oldlocal == NULL_TREE
4174               && oldglobal == NULL_TREE
4175               && DECL_EXTERNAL (x)
4176               && TREE_PUBLIC (x))
4177             TREE_PUBLIC (name) = 1;
4178
4179           /* Warn if shadowing an argument at the top level of the body.  */
4180           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4181               /* Inline decls shadow nothing.  */
4182               && !DECL_FROM_INLINE (x)
4183               && TREE_CODE (oldlocal) == PARM_DECL
4184               /* Don't complain if it's from an enclosing function.  */
4185               && DECL_CONTEXT (oldlocal) == current_function_decl
4186               && TREE_CODE (x) != PARM_DECL)
4187             {
4188               /* Go to where the parms should be and see if we
4189                  find them there.  */
4190               struct binding_level *b = current_binding_level->level_chain;
4191
4192               if (cleanup_label)
4193                 b = b->level_chain;
4194
4195               /* ARM $8.3 */
4196               if (b->parm_flag == 1)
4197                 cp_error ("declaration of `%#D' shadows a parameter", name);
4198             }
4199
4200           /* Maybe warn if shadowing something else.  */
4201           if (warn_shadow && !DECL_EXTERNAL (x)
4202               /* Inline decls shadow nothing.  */
4203               && !DECL_FROM_INLINE (x)
4204               /* No shadow warnings for internally generated vars.  */
4205               && ! DECL_ARTIFICIAL (x)
4206               /* No shadow warnings for vars made for inlining.  */
4207               && ! DECL_FROM_INLINE (x))
4208             {
4209               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4210                 warning ("declaration of `%s' shadows a parameter",
4211                         IDENTIFIER_POINTER (name));
4212               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4213                        && current_class_ptr
4214                        && !TREE_STATIC (name))
4215                 warning ("declaration of `%s' shadows a member of `this'",
4216                         IDENTIFIER_POINTER (name));
4217               else if (oldlocal != NULL_TREE)
4218                 warning ("declaration of `%s' shadows previous local",
4219                         IDENTIFIER_POINTER (name));
4220               else if (oldglobal != NULL_TREE)
4221                 /* XXX shadow warnings in outer-more namespaces */
4222                 warning ("declaration of `%s' shadows global declaration",
4223                         IDENTIFIER_POINTER (name));
4224             }
4225         }
4226
4227       if (TREE_CODE (x) == FUNCTION_DECL)
4228         check_default_args (x);
4229
4230       /* Keep count of variables in this level with incomplete type.  */
4231       if (TREE_CODE (x) == VAR_DECL
4232           && TREE_TYPE (x) != error_mark_node
4233           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4234                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4235               /* RTTI TD entries are created while defining the type_info.  */
4236               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4237                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4238         {
4239           if (namespace_bindings_p ())
4240             namespace_scope_incomplete
4241               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4242           else
4243             current_binding_level->incomplete
4244               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4245         }
4246     }
4247
4248   if (need_new_binding)
4249     add_decl_to_level (x,
4250                        DECL_NAMESPACE_SCOPE_P (x)
4251                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4252                        : current_binding_level);
4253
4254   return x;
4255 }
4256
4257 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4258    caller to set DECL_CONTEXT properly.  */
4259
4260 static tree
4261 pushdecl_with_scope (x, level)
4262      tree x;
4263      struct binding_level *level;
4264 {
4265   register struct binding_level *b;
4266   tree function_decl = current_function_decl;
4267
4268   current_function_decl = NULL_TREE;
4269   if (level->parm_flag == 2)
4270     {
4271       b = class_binding_level;
4272       class_binding_level = level;
4273       pushdecl_class_level (x);
4274       class_binding_level = b;
4275     }
4276   else
4277     {
4278       b = current_binding_level;
4279       current_binding_level = level;
4280       x = pushdecl (x);
4281       current_binding_level = b;
4282     }
4283   current_function_decl = function_decl;
4284   return x;
4285 }
4286
4287 /* Like pushdecl, only it places X in the current namespace,
4288    if appropriate.  */
4289
4290 tree
4291 pushdecl_namespace_level (x)
4292      tree x;
4293 {
4294   register struct binding_level *b = current_binding_level;
4295   register tree t;
4296
4297   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4298
4299   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4300      what we want.  */
4301   if (TREE_CODE (x) == TYPE_DECL)
4302     {
4303       tree name = DECL_NAME (x);
4304       tree newval;
4305       tree *ptr = (tree *)0;
4306       for (; b != global_binding_level; b = b->level_chain)
4307         {
4308           tree shadowed = b->type_shadowed;
4309           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4310             if (TREE_PURPOSE (shadowed) == name)
4311               {
4312                 ptr = &TREE_VALUE (shadowed);
4313                 /* Can't break out of the loop here because sometimes
4314                    a binding level will have duplicate bindings for
4315                    PT names.  It's gross, but I haven't time to fix it.  */
4316               }
4317         }
4318       newval = TREE_TYPE (x);
4319       if (ptr == (tree *)0)
4320         {
4321           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4322              up here if this is changed to an assertion.  --KR  */
4323           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4324         }
4325       else
4326         {
4327           *ptr = newval;
4328         }
4329     }
4330   return t;
4331 }
4332
4333 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4334    if appropriate.  */
4335
4336 tree
4337 pushdecl_top_level (x)
4338      tree x;
4339 {
4340   push_to_top_level ();
4341   x = pushdecl_namespace_level (x);
4342   pop_from_top_level ();
4343   return x;
4344 }
4345
4346 /* Make the declaration of X appear in CLASS scope.  */
4347
4348 void
4349 pushdecl_class_level (x)
4350      tree x;
4351 {
4352   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4353      scope looks for the pre-mangled name.  */
4354   register tree name;
4355
4356   if (TREE_CODE (x) == OVERLOAD)
4357     x = OVL_CURRENT (x);
4358   name = DECL_NAME (x);
4359
4360   if (name)
4361     {
4362       push_class_level_binding (name, x);
4363       if (TREE_CODE (x) == TYPE_DECL)
4364         set_identifier_type_value (name, TREE_TYPE (x));
4365     }
4366   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4367     {
4368       tree f;
4369
4370       for (f = TYPE_FIELDS (TREE_TYPE (x));
4371            f;
4372            f = TREE_CHAIN (f))
4373         pushdecl_class_level (f);
4374     }
4375 }
4376
4377 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4378    DECL, or a modified version thereof.  */
4379
4380 tree
4381 maybe_push_decl (decl)
4382      tree decl;
4383 {
4384   tree type = TREE_TYPE (decl);
4385
4386   /* Add this decl to the current binding level, but not if it comes
4387      from another scope, e.g. a static member variable.  TEM may equal
4388      DECL or it may be a previous decl of the same name.  */
4389   if (decl == error_mark_node
4390       || (TREE_CODE (decl) != PARM_DECL
4391           && DECL_CONTEXT (decl) != NULL_TREE
4392           /* Definitions of namespace members outside their namespace are
4393              possible. */
4394           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4395       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4396       || TREE_CODE (type) == UNKNOWN_TYPE
4397       /* The declaration of a template specialization does not affect
4398          the functions available for overload resolution, so we do not
4399          call pushdecl.  */
4400       || (TREE_CODE (decl) == FUNCTION_DECL
4401           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4402     return decl;
4403   else
4404     return pushdecl (decl);
4405 }
4406
4407 /* Make the declaration(s) of X appear in CLASS scope
4408    under the name NAME.  */
4409
4410 void
4411 push_class_level_binding (name, x)
4412      tree name;
4413      tree x;
4414 {
4415   tree binding;
4416   /* The class_binding_level will be NULL if x is a template
4417      parameter name in a member template.  */
4418   if (!class_binding_level)
4419     return;
4420
4421   /* Make sure that this new member does not have the same name
4422      as a template parameter.  */
4423   if (TYPE_BEING_DEFINED (current_class_type))
4424     check_template_shadow (x);
4425
4426   /* If this declaration shadows a declaration from an enclosing
4427      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4428      we leave this class.  Record the shadowed declaration here.  */
4429   binding = IDENTIFIER_BINDING (name);
4430   if (binding
4431       && ((TREE_CODE (x) == OVERLOAD
4432            && BINDING_VALUE (binding)
4433            && is_overloaded_fn (BINDING_VALUE (binding)))
4434           || INHERITED_VALUE_BINDING_P (binding)))
4435     {
4436       tree shadow;
4437       tree old_decl;
4438
4439       /* If the old binding was from a base class, and was for a tag
4440          name, slide it over to make room for the new binding.  The
4441          old binding is still visible if explicitly qualified with a
4442          class-key.  */
4443       if (INHERITED_VALUE_BINDING_P (binding)
4444           && BINDING_VALUE (binding)
4445           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4446           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4447           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4448         {
4449           old_decl = BINDING_TYPE (binding);
4450           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4451           BINDING_VALUE (binding) = NULL_TREE;
4452           INHERITED_VALUE_BINDING_P (binding) = 0;
4453         }
4454       else
4455         old_decl = BINDING_VALUE (binding);
4456
4457       /* There was already a binding for X containing fewer
4458          functions than are named in X.  Find the previous
4459          declaration of X on the class-shadowed list, and update it.  */
4460       for (shadow = class_binding_level->class_shadowed;
4461            shadow;
4462            shadow = TREE_CHAIN (shadow))
4463         if (TREE_PURPOSE (shadow) == name
4464             && TREE_TYPE (shadow) == old_decl)
4465           {
4466             BINDING_VALUE (binding) = x;
4467             INHERITED_VALUE_BINDING_P (binding) = 0;
4468             TREE_TYPE (shadow) = x;
4469             return;
4470           }
4471     }
4472
4473   /* If we didn't replace an existing binding, put the binding on the
4474      stack of bindings for the identifier, and update
4475      IDENTIFIER_CLASS_VALUE.  */
4476   if (push_class_binding (name, x))
4477     {
4478       class_binding_level->class_shadowed
4479         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4480                      class_binding_level->class_shadowed);
4481       /* Record the value we are binding NAME to so that we can know
4482          what to pop later.  */
4483       TREE_TYPE (class_binding_level->class_shadowed) = x;
4484     }
4485 }
4486
4487 /* Insert another USING_DECL into the current binding level, returning
4488    this declaration. If this is a redeclaration, do nothing, and
4489    return NULL_TREE if this not in namespace scope (in namespace
4490    scope, a using decl might extend any previous bindings).  */
4491
4492 tree
4493 push_using_decl (scope, name)
4494      tree scope;
4495      tree name;
4496 {
4497   tree decl;
4498
4499   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4500   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4501   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4502     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4503       break;
4504   if (decl)
4505     return namespace_bindings_p () ? decl : NULL_TREE;
4506   decl = build_lang_decl (USING_DECL, name, void_type_node);
4507   DECL_INITIAL (decl) = scope;
4508   TREE_CHAIN (decl) = current_binding_level->usings;
4509   current_binding_level->usings = decl;
4510   return decl;
4511 }
4512
4513 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4514    changed (i.e. there was already a directive), or the fresh
4515    TREE_LIST otherwise.  */
4516
4517 tree
4518 push_using_directive (used)
4519      tree used;
4520 {
4521   tree ud = current_binding_level->using_directives;
4522   tree iter, ancestor;
4523
4524   /* Check if we already have this. */
4525   if (purpose_member (used, ud) != NULL_TREE)
4526     return NULL_TREE;
4527
4528   /* Recursively add all namespaces used. */
4529   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4530     push_using_directive (TREE_PURPOSE (iter));
4531
4532   ancestor = namespace_ancestor (current_decl_namespace (), used);
4533   ud = current_binding_level->using_directives;
4534   ud = tree_cons (used, ancestor, ud);
4535   current_binding_level->using_directives = ud;
4536   return ud;
4537 }
4538
4539 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4540    other definitions already in place.  We get around this by making
4541    the value of the identifier point to a list of all the things that
4542    want to be referenced by that name.  It is then up to the users of
4543    that name to decide what to do with that list.
4544
4545    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4546    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4547
4548    FLAGS is a bitwise-or of the following values:
4549      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4550                  namespace scope.
4551      PUSH_USING: DECL is being pushed as the result of a using
4552                  declaration.
4553
4554    The value returned may be a previous declaration if we guessed wrong
4555    about what language DECL should belong to (C or C++).  Otherwise,
4556    it's always DECL (and never something that's not a _DECL).  */
4557
4558 tree
4559 push_overloaded_decl (decl, flags)
4560      tree decl;
4561      int flags;
4562 {
4563   tree name = DECL_NAME (decl);
4564   tree old;
4565   tree new_binding;
4566   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4567
4568   if (doing_global)
4569     old = namespace_binding (name, DECL_CONTEXT (decl));
4570   else
4571     old = lookup_name_current_level (name);
4572
4573   if (old)
4574     {
4575       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4576         {
4577           tree t = TREE_TYPE (old);
4578           if (IS_AGGR_TYPE (t) && warn_shadow
4579               && (! DECL_IN_SYSTEM_HEADER (decl)
4580                   || ! DECL_IN_SYSTEM_HEADER (old)))
4581             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4582           old = NULL_TREE;
4583         }
4584       else if (is_overloaded_fn (old))
4585         {
4586           tree tmp;
4587
4588           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4589             {
4590               tree fn = OVL_CURRENT (tmp);
4591
4592               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4593                   && !(flags & PUSH_USING)
4594                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4595                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4596                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4597                           decl, fn);
4598
4599               if (duplicate_decls (decl, fn))
4600                 return fn;
4601             }
4602         }
4603       else if (old == error_mark_node)
4604         /* Ignore the undefined symbol marker.  */
4605         old = NULL_TREE;
4606       else
4607         {
4608           cp_error_at ("previous non-function declaration `%#D'", old);
4609           cp_error ("conflicts with function declaration `%#D'", decl);
4610           return decl;
4611         }
4612     }
4613
4614   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4615     {
4616       if (old && TREE_CODE (old) != OVERLOAD)
4617         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4618       else
4619         new_binding = ovl_cons (decl, old);
4620       if (flags & PUSH_USING)
4621         OVL_USED (new_binding) = 1;
4622     }
4623   else
4624     /* NAME is not ambiguous.  */
4625     new_binding = decl;
4626
4627   if (doing_global)
4628     set_namespace_binding (name, current_namespace, new_binding);
4629   else
4630     {
4631       /* We only create an OVERLOAD if there was a previous binding at
4632          this level, or if decl is a template. In the former case, we
4633          need to remove the old binding and replace it with the new
4634          binding.  We must also run through the NAMES on the binding
4635          level where the name was bound to update the chain.  */
4636
4637       if (TREE_CODE (new_binding) == OVERLOAD && old)
4638         {
4639           tree *d;
4640
4641           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4642                *d;
4643                d = &TREE_CHAIN (*d))
4644             if (*d == old
4645                 || (TREE_CODE (*d) == TREE_LIST
4646                     && TREE_VALUE (*d) == old))
4647               {
4648                 if (TREE_CODE (*d) == TREE_LIST)
4649                   /* Just replace the old binding with the new.  */
4650                   TREE_VALUE (*d) = new_binding;
4651                 else
4652                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4653                   *d = tree_cons (NULL_TREE, new_binding,
4654                                   TREE_CHAIN (*d));
4655
4656                 /* And update the CPLUS_BINDING node.  */
4657                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4658                   = new_binding;
4659                 return decl;
4660               }
4661
4662           /* We should always find a previous binding in this case.  */
4663           my_friendly_abort (0);
4664         }
4665
4666       /* Install the new binding.  */
4667       push_local_binding (name, new_binding, flags);
4668     }
4669
4670   return decl;
4671 }
4672 \f
4673 /* Generate an implicit declaration for identifier FUNCTIONID
4674    as a function of type int ().  Print a warning if appropriate.  */
4675
4676 tree
4677 implicitly_declare (functionid)
4678      tree functionid;
4679 {
4680   register tree decl;
4681
4682   /* We used to reuse an old implicit decl here,
4683      but this loses with inline functions because it can clobber
4684      the saved decl chains.  */
4685   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4686
4687   DECL_EXTERNAL (decl) = 1;
4688   TREE_PUBLIC (decl) = 1;
4689
4690   /* ISO standard says implicit declarations are in the innermost block.
4691      So we record the decl in the standard fashion.  */
4692   pushdecl (decl);
4693   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4694
4695   if (warn_implicit
4696       /* Only one warning per identifier.  */
4697       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4698     {
4699       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4700     }
4701
4702   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4703
4704   return decl;
4705 }
4706
4707 /* Return zero if the declaration NEWDECL is valid
4708    when the declaration OLDDECL (assumed to be for the same name)
4709    has already been seen.
4710    Otherwise return an error message format string with a %s
4711    where the identifier should go.  */
4712
4713 static const char *
4714 redeclaration_error_message (newdecl, olddecl)
4715      tree newdecl, olddecl;
4716 {
4717   if (TREE_CODE (newdecl) == TYPE_DECL)
4718     {
4719       /* Because C++ can put things into name space for free,
4720          constructs like "typedef struct foo { ... } foo"
4721          would look like an erroneous redeclaration.  */
4722       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4723         return 0;
4724       else
4725         return "redefinition of `%#D'";
4726     }
4727   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4728     {
4729       /* If this is a pure function, its olddecl will actually be
4730          the original initialization to `0' (which we force to call
4731          abort()).  Don't complain about redefinition in this case.  */
4732       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4733         return 0;
4734
4735       /* If both functions come from different namespaces, this is not
4736          a redeclaration - this is a conflict with a used function. */
4737       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4738           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4739         return "`%D' conflicts with used function";
4740
4741       /* We'll complain about linkage mismatches in
4742          warn_extern_redeclared_static.  */
4743
4744       /* Defining the same name twice is no good.  */
4745       if (DECL_INITIAL (olddecl) != NULL_TREE
4746           && DECL_INITIAL (newdecl) != NULL_TREE)
4747         {
4748           if (DECL_NAME (olddecl) == NULL_TREE)
4749             return "`%#D' not declared in class";
4750           else
4751             return "redefinition of `%#D'";
4752         }
4753       return 0;
4754     }
4755   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4756     {
4757       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4758            && (DECL_TEMPLATE_RESULT (newdecl)
4759                != DECL_TEMPLATE_RESULT (olddecl))
4760            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4761            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4762           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4763               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4764               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4765         return "redefinition of `%#D'";
4766       return 0;
4767     }
4768   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4769     {
4770       /* Objects declared at top level:  */
4771       /* If at least one is a reference, it's ok.  */
4772       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4773         return 0;
4774       /* Reject two definitions.  */
4775       return "redefinition of `%#D'";
4776     }
4777   else
4778     {
4779       /* Objects declared with block scope:  */
4780       /* Reject two definitions, and reject a definition
4781          together with an external reference.  */
4782       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4783         return "redeclaration of `%#D'";
4784       return 0;
4785     }
4786 }
4787 \f
4788 /* Create a new label, named ID.  */
4789
4790 static tree
4791 make_label_decl (id, local_p)
4792      tree id;
4793      int local_p;
4794 {
4795   tree decl;
4796
4797   decl = build_decl (LABEL_DECL, id, void_type_node);
4798   if (expanding_p)
4799     /* Make sure every label has an rtx.  */
4800     label_rtx (decl);
4801
4802   DECL_CONTEXT (decl) = current_function_decl;
4803   DECL_MODE (decl) = VOIDmode;
4804   C_DECLARED_LABEL_FLAG (decl) = local_p;
4805
4806   /* Say where one reference is to the label, for the sake of the
4807      error if it is not defined.  */
4808   DECL_SOURCE_LINE (decl) = lineno;
4809   DECL_SOURCE_FILE (decl) = input_filename;
4810
4811   /* Record the fact that this identifier is bound to this label.  */
4812   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4813
4814   return decl;
4815 }
4816
4817 /* Record this label on the list of used labels so that we can check
4818    at the end of the function to see whether or not the label was
4819    actually defined, and so we can check when the label is defined whether
4820    this use is valid.  */
4821
4822 static void
4823 use_label (decl)
4824      tree decl;
4825 {
4826   if (named_label_uses == NULL
4827       || named_label_uses->names_in_scope != current_binding_level->names
4828       || named_label_uses->label_decl != decl)
4829     {
4830       struct named_label_use_list *new_ent;
4831       new_ent = ((struct named_label_use_list *)
4832                  ggc_alloc (sizeof (struct named_label_use_list)));
4833       new_ent->label_decl = decl;
4834       new_ent->names_in_scope = current_binding_level->names;
4835       new_ent->binding_level = current_binding_level;
4836       new_ent->lineno_o_goto = lineno;
4837       new_ent->filename_o_goto = input_filename;
4838       new_ent->next = named_label_uses;
4839       named_label_uses = new_ent;
4840     }
4841 }
4842
4843 /* Look for a label named ID in the current function.  If one cannot
4844    be found, create one.  (We keep track of used, but undefined,
4845    labels, and complain about them at the end of a function.)  */
4846
4847 tree
4848 lookup_label (id)
4849      tree id;
4850 {
4851   tree decl;
4852   struct named_label_list *ent;
4853
4854   /* You can't use labels at global scope.  */
4855   if (current_function_decl == NULL_TREE)
4856     {
4857       error ("label `%s' referenced outside of any function",
4858              IDENTIFIER_POINTER (id));
4859       return NULL_TREE;
4860     }
4861
4862   /* See if we've already got this label.  */
4863   decl = IDENTIFIER_LABEL_VALUE (id);
4864   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4865     return decl;
4866
4867   /* Record this label on the list of labels used in this function.
4868      We do this before calling make_label_decl so that we get the
4869      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4870   ent = ((struct named_label_list *)
4871          ggc_alloc_cleared (sizeof (struct named_label_list)));
4872   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4873   ent->next = named_labels;
4874   named_labels = ent;
4875
4876   /* We need a new label.  */
4877   decl = make_label_decl (id, /*local_p=*/0);
4878
4879   /* Now fill in the information we didn't have before.  */
4880   ent->label_decl = decl;
4881
4882   return decl;
4883 }
4884
4885 /* Declare a local label named ID.  */
4886
4887 tree
4888 declare_local_label (id)
4889      tree id;
4890 {
4891   tree decl;
4892
4893   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4894      this scope we can restore the old value of
4895      IDENTIFIER_TYPE_VALUE.  */
4896   current_binding_level->shadowed_labels
4897     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4898                  current_binding_level->shadowed_labels);
4899   /* Look for the label.  */
4900   decl = make_label_decl (id, /*local_p=*/1);
4901   /* Now fill in the information we didn't have before.  */
4902   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4903
4904   return decl;
4905 }
4906
4907 /* Returns nonzero if it is ill-formed to jump past the declaration of
4908    DECL.  Returns 2 if it's also a real problem.  */
4909
4910 static int
4911 decl_jump_unsafe (decl)
4912      tree decl;
4913 {
4914   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4915     return 0;
4916
4917   if (DECL_INITIAL (decl) == NULL_TREE
4918       && pod_type_p (TREE_TYPE (decl)))
4919     return 0;
4920
4921   /* This is really only important if we're crossing an initialization.
4922      The POD stuff is just pedantry; why should it matter if the class
4923      contains a field of pointer to member type?  */
4924   if (DECL_INITIAL (decl)
4925       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4926     return 2;
4927   return 1;
4928 }
4929
4930 /* Check that a single previously seen jump to a newly defined label
4931    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4932    the jump context; NAMES are the names in scope in LEVEL at the jump
4933    context; FILE and LINE are the source position of the jump or 0.  */
4934
4935 static void
4936 check_previous_goto_1 (decl, level, names, file, line)
4937      tree decl;
4938      struct binding_level *level;
4939      tree names;
4940      const char *file;
4941      int line;
4942 {
4943   int identified = 0;
4944   int saw_eh = 0;
4945   struct binding_level *b = current_binding_level;
4946   for (; b; b = b->level_chain)
4947     {
4948       tree new_decls = b->names;
4949       tree old_decls = (b == level ? names : NULL_TREE);
4950       for (; new_decls != old_decls;
4951            new_decls = TREE_CHAIN (new_decls))
4952         {
4953           int problem = decl_jump_unsafe (new_decls);
4954           if (! problem)
4955             continue;
4956
4957           if (! identified)
4958             {
4959               if (decl)
4960                 cp_pedwarn ("jump to label `%D'", decl);
4961               else
4962                 pedwarn ("jump to case label");
4963
4964               if (file)
4965                 pedwarn_with_file_and_line (file, line, "  from here");
4966               identified = 1;
4967             }
4968
4969           if (problem > 1 && DECL_ARTIFICIAL (new_decls))
4970             /* Can't skip init of __exception_info.  */
4971             cp_error_at ("  enters catch block", new_decls);
4972           else if (problem > 1)
4973             cp_error_at ("  crosses initialization of `%#D'",
4974                          new_decls);
4975           else
4976             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4977                            new_decls);
4978         }
4979
4980       if (b == level)
4981         break;
4982       if (b->eh_region && ! saw_eh)
4983         {
4984           if (! identified)
4985             {
4986               if (decl)
4987                 cp_pedwarn ("jump to label `%D'", decl);
4988               else
4989                 pedwarn ("jump to case label");
4990
4991               if (file)
4992                 pedwarn_with_file_and_line (file, line, "  from here");
4993               identified = 1;
4994             }
4995           error ("  enters try block");
4996           saw_eh = 1;
4997         }
4998     }
4999 }
5000
5001 static void
5002 check_previous_goto (use)
5003      struct named_label_use_list *use;
5004 {
5005   check_previous_goto_1 (use->label_decl, use->binding_level,
5006                          use->names_in_scope, use->filename_o_goto,
5007                          use->lineno_o_goto);
5008 }
5009
5010 static void
5011 check_switch_goto (level)
5012      struct binding_level *level;
5013 {
5014   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
5015 }
5016
5017 /* Check that any previously seen jumps to a newly defined label DECL
5018    are OK.  Called by define_label.  */
5019
5020 static void
5021 check_previous_gotos (decl)
5022      tree decl;
5023 {
5024   struct named_label_use_list **usep;
5025
5026   if (! TREE_USED (decl))
5027     return;
5028
5029   for (usep = &named_label_uses; *usep; )
5030     {
5031       struct named_label_use_list *use = *usep;
5032       if (use->label_decl == decl)
5033         {
5034           check_previous_goto (use);
5035           *usep = use->next;
5036         }
5037       else
5038         usep = &(use->next);
5039     }
5040 }
5041
5042 /* Check that a new jump to a label DECL is OK.  Called by
5043    finish_goto_stmt.  */
5044
5045 void
5046 check_goto (decl)
5047      tree decl;
5048 {
5049   int identified = 0;
5050   tree bad;
5051   struct named_label_list *lab;
5052
5053   /* We can't know where a computed goto is jumping.  So we assume
5054      that it's OK.  */
5055   if (! DECL_P (decl))
5056     return;
5057
5058   /* If the label hasn't been defined yet, defer checking.  */
5059   if (! DECL_INITIAL (decl))
5060     {
5061       use_label (decl);
5062       return;
5063     }
5064
5065   for (lab = named_labels; lab; lab = lab->next)
5066     if (decl == lab->label_decl)
5067       break;
5068
5069   /* If the label is not on named_labels it's a gcc local label, so
5070      it must be in an outer scope, so jumping to it is always OK.  */
5071   if (lab == 0)
5072     return;
5073
5074   if ((lab->eh_region || lab->bad_decls) && !identified)
5075     {
5076       cp_pedwarn_at ("jump to label `%D'", decl);
5077       pedwarn ("  from here");
5078       identified = 1;
5079     }
5080
5081   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5082     {
5083       tree b = TREE_VALUE (bad);
5084       int u = decl_jump_unsafe (b);
5085
5086       if (u > 1 && DECL_ARTIFICIAL (b))
5087         /* Can't skip init of __exception_info.  */
5088         cp_error_at ("  enters catch block", b);
5089       else if (u > 1)
5090         cp_error_at ("  skips initialization of `%#D'", b);
5091       else
5092         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5093     }
5094
5095   if (lab->eh_region)
5096     error ("  enters try block");
5097 }
5098
5099 /* Define a label, specifying the location in the source file.
5100    Return the LABEL_DECL node for the label, if the definition is valid.
5101    Otherwise return 0.  */
5102
5103 tree
5104 define_label (filename, line, name)
5105      const char *filename;
5106      int line;
5107      tree name;
5108 {
5109   tree decl = lookup_label (name);
5110   struct named_label_list *ent;
5111
5112   for (ent = named_labels; ent; ent = ent->next)
5113     if (ent->label_decl == decl)
5114       break;
5115
5116   /* After labels, make any new cleanups go into their
5117      own new (temporary) binding contour.  */
5118   current_binding_level->more_cleanups_ok = 0;
5119
5120   if (name == get_identifier ("wchar_t"))
5121     cp_pedwarn ("label named wchar_t");
5122
5123   if (DECL_INITIAL (decl) != NULL_TREE)
5124     {
5125       cp_error ("duplicate label `%D'", decl);
5126       return 0;
5127     }
5128   else
5129     {
5130       /* Mark label as having been defined.  */
5131       DECL_INITIAL (decl) = error_mark_node;
5132       /* Say where in the source.  */
5133       DECL_SOURCE_FILE (decl) = filename;
5134       DECL_SOURCE_LINE (decl) = line;
5135       if (ent)
5136         {
5137           ent->names_in_scope = current_binding_level->names;
5138           ent->binding_level = current_binding_level;
5139         }
5140       check_previous_gotos (decl);
5141       current_function_return_value = NULL_TREE;
5142       return decl;
5143     }
5144 }
5145
5146 struct cp_switch
5147 {
5148   struct binding_level *level;
5149   struct cp_switch *next;
5150 };
5151
5152 static struct cp_switch *switch_stack;
5153
5154 void
5155 push_switch ()
5156 {
5157   struct cp_switch *p
5158     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5159   p->level = current_binding_level;
5160   p->next = switch_stack;
5161   switch_stack = p;
5162 }
5163
5164 void
5165 pop_switch ()
5166 {
5167   struct cp_switch *cs;
5168
5169   cs = switch_stack;
5170   switch_stack = switch_stack->next;
5171   free (cs);
5172 }
5173
5174 /* Note that we've seen a definition of a case label, and complain if this
5175    is a bad place for one.  */
5176
5177 void
5178 define_case_label ()
5179 {
5180   tree cleanup = last_cleanup_this_contour ();
5181
5182   if (! switch_stack)
5183     /* Don't crash; we'll complain in do_case.  */
5184     return;
5185
5186   if (cleanup)
5187     {
5188       static int explained = 0;
5189       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
5190       warning ("where case label appears here");
5191       if (!explained)
5192         {
5193           warning ("(enclose actions of previous case statements requiring");
5194           warning ("destructors in their own binding contours.)");
5195           explained = 1;
5196         }
5197     }
5198
5199   check_switch_goto (switch_stack->level);
5200
5201   /* After labels, make any new cleanups go into their
5202      own new (temporary) binding contour.  */
5203
5204   current_binding_level->more_cleanups_ok = 0;
5205   current_function_return_value = NULL_TREE;
5206 }
5207 \f
5208 /* Return the list of declarations of the current level.
5209    Note that this list is in reverse order unless/until
5210    you nreverse it; and when you do nreverse it, you must
5211    store the result back using `storedecls' or you will lose.  */
5212
5213 tree
5214 getdecls ()
5215 {
5216   return current_binding_level->names;
5217 }
5218
5219 /* Return the list of type-tags (for structs, etc) of the current level.  */
5220
5221 tree
5222 gettags ()
5223 {
5224   return current_binding_level->tags;
5225 }
5226
5227 /* Store the list of declarations of the current level.
5228    This is done for the parameter declarations of a function being defined,
5229    after they are modified in the light of any missing parameters.  */
5230
5231 static void
5232 storedecls (decls)
5233      tree decls;
5234 {
5235   current_binding_level->names = decls;
5236 }
5237
5238 /* Similarly, store the list of tags of the current level.  */
5239
5240 void
5241 storetags (tags)
5242      tree tags;
5243 {
5244   current_binding_level->tags = tags;
5245 }
5246 \f
5247 /* Given NAME, an IDENTIFIER_NODE,
5248    return the structure (or union or enum) definition for that name.
5249    Searches binding levels from BINDING_LEVEL up to the global level.
5250    If THISLEVEL_ONLY is nonzero, searches only the specified context
5251    (but skips any tag-transparent contexts to find one that is
5252    meaningful for tags).
5253    FORM says which kind of type the caller wants;
5254    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5255    If the wrong kind of type is found, and it's not a template, an error is
5256    reported.  */
5257
5258 static tree
5259 lookup_tag (form, name, binding_level, thislevel_only)
5260      enum tree_code form;
5261      tree name;
5262      struct binding_level *binding_level;
5263      int thislevel_only;
5264 {
5265   register struct binding_level *level;
5266   /* Non-zero if, we should look past a template parameter level, even
5267      if THISLEVEL_ONLY.  */
5268   int allow_template_parms_p = 1;
5269
5270   for (level = binding_level; level; level = level->level_chain)
5271     {
5272       register tree tail;
5273       if (ANON_AGGRNAME_P (name))
5274         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5275           {
5276             /* There's no need for error checking here, because
5277                anon names are unique throughout the compilation.  */
5278             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5279               return TREE_VALUE (tail);
5280           }
5281       else if (level->namespace_p)
5282         /* Do namespace lookup. */
5283         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5284           {
5285             tree old = binding_for_name (name, tail);
5286
5287             /* If we just skipped past a template parameter level,
5288                even though THISLEVEL_ONLY, and we find a template
5289                class declaration, then we use the _TYPE node for the
5290                template.  See the example below.  */
5291             if (thislevel_only && !allow_template_parms_p
5292                 && old && BINDING_VALUE (old)
5293                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5294               old = TREE_TYPE (BINDING_VALUE (old));
5295             else
5296               old = BINDING_TYPE (old);
5297
5298             /* If it has an original type, it is a typedef, and we
5299                should not return it.  */
5300             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5301               old = NULL_TREE;
5302             if (old && TREE_CODE (old) != form
5303                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5304               {
5305                 cp_error ("`%#D' redeclared as %C", old, form);
5306                 return NULL_TREE;
5307               }
5308             if (old)
5309               return old;
5310             if (thislevel_only || tail == global_namespace)
5311               return NULL_TREE;
5312           }
5313       else
5314         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5315           {
5316             if (TREE_PURPOSE (tail) == name)
5317               {
5318                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5319                 /* Should tighten this up; it'll probably permit
5320                    UNION_TYPE and a struct template, for example.  */
5321                 if (code != form
5322                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5323                   {
5324                     /* Definition isn't the kind we were looking for.  */
5325                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5326                               form);
5327                     return NULL_TREE;
5328                   }
5329                 return TREE_VALUE (tail);
5330               }
5331           }
5332       if (thislevel_only && ! level->tag_transparent)
5333         {
5334           if (level->template_parms_p && allow_template_parms_p)
5335             {
5336               /* We must deal with cases like this:
5337
5338                    template <class T> struct S;
5339                    template <class T> struct S {};
5340
5341                  When looking up `S', for the second declaration, we
5342                  would like to find the first declaration.  But, we
5343                  are in the pseudo-global level created for the
5344                  template parameters, rather than the (surrounding)
5345                  namespace level.  Thus, we keep going one more level,
5346                  even though THISLEVEL_ONLY is non-zero.  */
5347               allow_template_parms_p = 0;
5348               continue;
5349             }
5350           else
5351             return NULL_TREE;
5352         }
5353     }
5354   return NULL_TREE;
5355 }
5356
5357 #if 0
5358 void
5359 set_current_level_tags_transparency (tags_transparent)
5360      int tags_transparent;
5361 {
5362   current_binding_level->tag_transparent = tags_transparent;
5363 }
5364 #endif
5365
5366 /* Given a type, find the tag that was defined for it and return the tag name.
5367    Otherwise return 0.  However, the value can never be 0
5368    in the cases in which this is used.
5369
5370    C++: If NAME is non-zero, this is the new name to install.  This is
5371    done when replacing anonymous tags with real tag names.  */
5372
5373 static tree
5374 lookup_tag_reverse (type, name)
5375      tree type;
5376      tree name;
5377 {
5378   register struct binding_level *level;
5379
5380   for (level = current_binding_level; level; level = level->level_chain)
5381     {
5382       register tree tail;
5383       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5384         {
5385           if (TREE_VALUE (tail) == type)
5386             {
5387               if (name)
5388                 TREE_PURPOSE (tail) = name;
5389               return TREE_PURPOSE (tail);
5390             }
5391         }
5392     }
5393   return NULL_TREE;
5394 }
5395 \f
5396 /* Look up NAME in the NAMESPACE.  */
5397
5398 tree
5399 lookup_namespace_name (namespace, name)
5400      tree namespace, name;
5401 {
5402   tree val;
5403   tree template_id = NULL_TREE;
5404
5405   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5406
5407   if (TREE_CODE (name) == NAMESPACE_DECL)
5408     /* This happens for A::B<int> when B is a namespace. */
5409     return name;
5410   else if (TREE_CODE (name) == TEMPLATE_DECL)
5411     {
5412       /* This happens for A::B where B is a template, and there are no
5413          template arguments.  */
5414       cp_error ("invalid use of `%D'", name);
5415       return error_mark_node;
5416     }
5417
5418   namespace = ORIGINAL_NAMESPACE (namespace);
5419
5420   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5421     {
5422       template_id = name;
5423       name = TREE_OPERAND (name, 0);
5424       if (TREE_CODE (name) == OVERLOAD)
5425         name = DECL_NAME (OVL_CURRENT (name));
5426       else if (DECL_P (name))
5427         name = DECL_NAME (name);
5428     }
5429
5430   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5431
5432   val = make_node (CPLUS_BINDING);
5433   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5434     return error_mark_node;
5435
5436   if (BINDING_VALUE (val))
5437     {
5438       val = BINDING_VALUE (val);
5439
5440       if (template_id)
5441         {
5442           if (DECL_CLASS_TEMPLATE_P (val))
5443             val = lookup_template_class (val,
5444                                          TREE_OPERAND (template_id, 1),
5445                                          /*in_decl=*/NULL_TREE,
5446                                          /*context=*/NULL_TREE,
5447                                          /*entering_scope=*/0);
5448           else if (DECL_FUNCTION_TEMPLATE_P (val)
5449                    || TREE_CODE (val) == OVERLOAD)
5450             val = lookup_template_function (val,
5451                                             TREE_OPERAND (template_id, 1));
5452           else
5453             {
5454               cp_error ("`%D::%D' is not a template",
5455                         namespace, name);
5456               return error_mark_node;
5457             }
5458         }
5459
5460       /* If we have a single function from a using decl, pull it out.  */
5461       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5462         val = OVL_FUNCTION (val);
5463       return val;
5464     }
5465
5466   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5467   return error_mark_node;
5468 }
5469
5470 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5471
5472 static unsigned long
5473 typename_hash (k)
5474      hash_table_key k;
5475 {
5476   unsigned long hash;
5477   tree t;
5478
5479   t = (tree) k;
5480   hash = (((unsigned long) TYPE_CONTEXT (t))
5481           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5482
5483   return hash;
5484 }
5485
5486 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5487
5488 static boolean
5489 typename_compare (k1, k2)
5490      hash_table_key k1;
5491      hash_table_key k2;
5492 {
5493   tree t1;
5494   tree t2;
5495   tree d1;
5496   tree d2;
5497
5498   t1 = (tree) k1;
5499   t2 = (tree) k2;
5500   d1 = TYPE_NAME (t1);
5501   d2 = TYPE_NAME (t2);
5502
5503   return (DECL_NAME (d1) == DECL_NAME (d2)
5504           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5505           && ((TREE_TYPE (t1) != NULL_TREE)
5506               == (TREE_TYPE (t2) != NULL_TREE))
5507           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5508           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5509 }
5510
5511 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5512    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5513    is non-NULL, this type is being created by the implicit typename
5514    extension, and BASE_TYPE is a type named `t' in some base class of
5515    `T' which depends on template parameters.
5516
5517    Returns the new TYPENAME_TYPE.  */
5518
5519 tree
5520 build_typename_type (context, name, fullname, base_type)
5521      tree context;
5522      tree name;
5523      tree fullname;
5524      tree base_type;
5525 {
5526   tree t;
5527   tree d;
5528   struct hash_entry* e;
5529
5530   static struct hash_table ht;
5531
5532   if (!ht.table)
5533     {
5534       static struct hash_table *h = &ht;
5535       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5536                             &typename_compare))
5537         fatal ("virtual memory exhausted");
5538       ggc_add_tree_hash_table_root (&h, 1);
5539     }
5540
5541   /* Build the TYPENAME_TYPE.  */
5542   t = make_aggr_type (TYPENAME_TYPE);
5543   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5544   TYPENAME_TYPE_FULLNAME (t) = fullname;
5545   TREE_TYPE (t) = base_type;
5546
5547   /* Build the corresponding TYPE_DECL.  */
5548   d = build_decl (TYPE_DECL, name, t);
5549   TYPE_NAME (TREE_TYPE (d)) = d;
5550   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5551   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5552   DECL_ARTIFICIAL (d) = 1;
5553
5554   /* See if we already have this type.  */
5555   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5556   if (e)
5557     t = (tree) e->key;
5558   else
5559     /* Insert the type into the table.  */
5560     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5561
5562   return t;
5563 }
5564
5565 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5566    unless an error occurs, in which case error_mark_node is returned.
5567    If COMPLAIN zero, don't complain about any errors that occur.  */
5568
5569 tree
5570 make_typename_type (context, name, complain)
5571      tree context, name;
5572      int complain;
5573 {
5574   tree fullname;
5575
5576   if (TYPE_P (name))
5577     {
5578       if (!(TYPE_LANG_SPECIFIC (name)
5579             && (CLASSTYPE_IS_TEMPLATE (name)
5580                 || CLASSTYPE_USE_TEMPLATE (name))))
5581         name = TYPE_IDENTIFIER (name);
5582       else
5583         /* Create a TEMPLATE_ID_EXPR for the type.  */
5584         name = build_nt (TEMPLATE_ID_EXPR,
5585                          CLASSTYPE_TI_TEMPLATE (name),
5586                          CLASSTYPE_TI_ARGS (name));
5587     }
5588   else if (TREE_CODE (name) == TYPE_DECL)
5589     name = DECL_NAME (name);
5590
5591   fullname = name;
5592
5593   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5594     {
5595       name = TREE_OPERAND (name, 0);
5596       if (TREE_CODE (name) == TEMPLATE_DECL)
5597         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5598     }
5599   if (TREE_CODE (name) != IDENTIFIER_NODE)
5600     my_friendly_abort (2000);
5601
5602   if (TREE_CODE (context) == NAMESPACE_DECL)
5603     {
5604       /* We can get here from typename_sub0 in the explicit_template_type
5605          expansion.  Just fail.  */
5606       if (complain)
5607         cp_error ("no class template named `%#T' in `%#T'",
5608                   name, context);
5609       return error_mark_node;
5610     }
5611
5612   if (! uses_template_parms (context)
5613       || currently_open_class (context))
5614     {
5615       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5616         {
5617           tree tmpl = NULL_TREE;
5618           if (IS_AGGR_TYPE (context))
5619             tmpl = lookup_field (context, name, 0, 0);
5620           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5621             {
5622               if (complain)
5623                 cp_error ("no class template named `%#T' in `%#T'",
5624                           name, context);
5625               return error_mark_node;
5626             }
5627
5628           return lookup_template_class (tmpl,
5629                                         TREE_OPERAND (fullname, 1),
5630                                         NULL_TREE, context,
5631                                         /*entering_scope=*/0);
5632         }
5633       else
5634         {
5635           tree t;
5636
5637           if (!IS_AGGR_TYPE (context))
5638             {
5639               if (complain)
5640                 cp_error ("no type named `%#T' in `%#T'", name, context);
5641               return error_mark_node;
5642             }
5643
5644           t = lookup_field (context, name, 0, 1);
5645           if (t)
5646             return TREE_TYPE (t);
5647         }
5648     }
5649
5650   /* If the CONTEXT is not a template type, then either the field is
5651      there now or its never going to be.  */
5652   if (!uses_template_parms (context))
5653     {
5654       if (complain)
5655         cp_error ("no type named `%#T' in `%#T'", name, context);
5656       return error_mark_node;
5657     }
5658
5659
5660   return build_typename_type (context, name, fullname,  NULL_TREE);
5661 }
5662
5663 /* Select the right _DECL from multiple choices. */
5664
5665 static tree
5666 select_decl (binding, flags)
5667      tree binding;
5668      int flags;
5669 {
5670   tree val;
5671   val = BINDING_VALUE (binding);
5672   if (LOOKUP_NAMESPACES_ONLY (flags))
5673     {
5674       /* We are not interested in types. */
5675       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5676         return val;
5677       return NULL_TREE;
5678     }
5679
5680   /* If we could have a type and
5681      we have nothing or we need a type and have none.  */
5682   if (BINDING_TYPE (binding)
5683       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5684                    && TREE_CODE (val) != TYPE_DECL)))
5685     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5686   /* Don't return non-types if we really prefer types. */
5687   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5688            && (TREE_CODE (val) != TEMPLATE_DECL
5689                || !DECL_CLASS_TEMPLATE_P (val)))
5690     val = NULL_TREE;
5691
5692   return val;
5693 }
5694
5695 /* Unscoped lookup of a global: iterate over current namespaces,
5696    considering using-directives.  If SPACESP is non-NULL, store a list
5697    of the namespaces we've considered in it.  */
5698
5699 tree
5700 unqualified_namespace_lookup (name, flags, spacesp)
5701      tree name;
5702      int flags;
5703      tree *spacesp;
5704 {
5705   tree b = make_node (CPLUS_BINDING);
5706   tree initial = current_decl_namespace();
5707   tree scope = initial;
5708   tree siter;
5709   struct binding_level *level;
5710   tree val = NULL_TREE;
5711
5712   if (spacesp)
5713     *spacesp = NULL_TREE;
5714
5715   for (; !val; scope = CP_DECL_CONTEXT (scope))
5716     {
5717       if (spacesp)
5718         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5719       val = binding_for_name (name, scope);
5720
5721       /* Initialize binding for this context. */
5722       BINDING_VALUE (b) = BINDING_VALUE (val);
5723       BINDING_TYPE (b) = BINDING_TYPE (val);
5724
5725       /* Add all _DECLs seen through local using-directives. */
5726       for (level = current_binding_level;
5727            !level->namespace_p;
5728            level = level->level_chain)
5729         if (!lookup_using_namespace (name, b, level->using_directives,
5730                                      scope, flags, spacesp))
5731           /* Give up because of error. */
5732           return error_mark_node;
5733
5734       /* Add all _DECLs seen through global using-directives. */
5735       /* XXX local and global using lists should work equally. */
5736       siter = initial;
5737       while (1)
5738         {
5739           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5740                                        scope, flags, spacesp))
5741             /* Give up because of error. */
5742             return error_mark_node;
5743           if (siter == scope) break;
5744           siter = CP_DECL_CONTEXT (siter);
5745         }
5746
5747       val = select_decl (b, flags);
5748       if (scope == global_namespace)
5749         break;
5750     }
5751   return val;
5752 }
5753
5754 /* Combine prefer_type and namespaces_only into flags.  */
5755
5756 static int
5757 lookup_flags (prefer_type, namespaces_only)
5758   int prefer_type, namespaces_only;
5759 {
5760   if (namespaces_only)
5761     return LOOKUP_PREFER_NAMESPACES;
5762   if (prefer_type > 1)
5763     return LOOKUP_PREFER_TYPES;
5764   if (prefer_type > 0)
5765     return LOOKUP_PREFER_BOTH;
5766   return 0;
5767 }
5768
5769 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5770    ignore it or not.  Subroutine of lookup_name_real.  */
5771
5772 static tree
5773 qualify_lookup (val, flags)
5774      tree val;
5775      int flags;
5776 {
5777   if (val == NULL_TREE)
5778     return val;
5779   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5780     return val;
5781   if ((flags & LOOKUP_PREFER_TYPES)
5782       && (TREE_CODE (val) == TYPE_DECL
5783           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5784               && DECL_CLASS_TEMPLATE_P (val))))
5785     return val;
5786   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5787     return NULL_TREE;
5788   return val;
5789 }
5790
5791 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5792    that.  */
5793
5794 static void
5795 warn_about_implicit_typename_lookup (typename, binding)
5796      tree typename;
5797      tree binding;
5798 {
5799   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5800   tree name = DECL_NAME (typename);
5801
5802   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5803          && CLASSTYPE_TEMPLATE_INFO (subtype)
5804          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5805       && ! (TREE_CODE (binding) == TYPE_DECL
5806             && same_type_p (TREE_TYPE (binding), subtype)))
5807     {
5808       cp_warning ("lookup of `%D' finds `%#D'",
5809                   name, binding);
5810       cp_warning ("  instead of `%D' from dependent base class",
5811                   typename);
5812       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5813                   constructor_name (current_class_type), name);
5814     }
5815 }
5816
5817 /* Look up NAME in the current binding level and its superiors in the
5818    namespace of variables, functions and typedefs.  Return a ..._DECL
5819    node of some kind representing its definition if there is only one
5820    such declaration, or return a TREE_LIST with all the overloaded
5821    definitions if there are many, or return 0 if it is undefined.
5822
5823    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5824    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5825    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5826    Otherwise we prefer non-TYPE_DECLs.
5827
5828    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5829    using IDENTIFIER_CLASS_VALUE.  */
5830
5831 static tree
5832 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5833      tree name;
5834      int prefer_type, nonclass, namespaces_only;
5835 {
5836   tree t;
5837   tree val = NULL_TREE;
5838   int yylex = 0;
5839   tree from_obj = NULL_TREE;
5840   int flags;
5841   int val_is_implicit_typename = 0;
5842
5843   /* Hack: copy flag set by parser, if set. */
5844   if (only_namespace_names)
5845     namespaces_only = 1;
5846
5847   if (prefer_type == -2)
5848     {
5849       extern int looking_for_typename;
5850       tree type = NULL_TREE;
5851
5852       yylex = 1;
5853       prefer_type = looking_for_typename;
5854
5855       flags = lookup_flags (prefer_type, namespaces_only);
5856       /* If the next thing is '<', class templates are types. */
5857       if (looking_for_template)
5858         flags |= LOOKUP_TEMPLATES_EXPECTED;
5859
5860       /* std:: becomes :: for now.  */
5861       if (got_scope == std_node)
5862         got_scope = void_type_node;
5863
5864       if (got_scope)
5865         type = got_scope;
5866       else if (got_object != error_mark_node)
5867         type = got_object;
5868
5869       if (type)
5870         {
5871           if (type == error_mark_node)
5872             return error_mark_node;
5873           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5874             type = TREE_TYPE (type);
5875
5876           if (TYPE_P (type))
5877             type = complete_type (type);
5878
5879           if (TREE_CODE (type) == VOID_TYPE)
5880             type = global_namespace;
5881           if (TREE_CODE (type) == NAMESPACE_DECL)
5882             {
5883               val = make_node (CPLUS_BINDING);
5884               flags |= LOOKUP_COMPLAIN;
5885               if (!qualified_lookup_using_namespace (name, type, val, flags))
5886                 return NULL_TREE;
5887               val = select_decl (val, flags);
5888             }
5889           else if (! IS_AGGR_TYPE (type)
5890                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5891                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5892                    || TREE_CODE (type) == TYPENAME_TYPE)
5893             /* Someone else will give an error about this if needed.  */
5894             val = NULL_TREE;
5895           else if (type == current_class_type)
5896             val = IDENTIFIER_CLASS_VALUE (name);
5897           else
5898             {
5899               val = lookup_member (type, name, 0, prefer_type);
5900               type_access_control (type, val);
5901
5902               /* Restore the containing TYPENAME_TYPE if we looked
5903                  through it before.  */
5904               if (got_scope && got_scope != type
5905                   && val && TREE_CODE (val) == TYPE_DECL
5906                   && TREE_CODE (TREE_TYPE (val)) == TYPENAME_TYPE)
5907                 TYPE_CONTEXT (TREE_TYPE (val)) = got_scope;
5908             }
5909         }
5910       else
5911         val = NULL_TREE;
5912
5913       if (got_scope)
5914         goto done;
5915       else if (got_object && val)
5916         from_obj = val;
5917     }
5918   else
5919     {
5920       flags = lookup_flags (prefer_type, namespaces_only);
5921       /* If we're not parsing, we need to complain. */
5922       flags |= LOOKUP_COMPLAIN;
5923     }
5924
5925   /* First, look in non-namespace scopes.  */
5926
5927   if (current_class_type == NULL_TREE)
5928     nonclass = 1;
5929
5930   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5931     {
5932       tree binding;
5933
5934       if (!LOCAL_BINDING_P (t) && nonclass)
5935         /* We're not looking for class-scoped bindings, so keep going.  */
5936         continue;
5937
5938       /* If this is the kind of thing we're looking for, we're done.  */
5939       if (qualify_lookup (BINDING_VALUE (t), flags))
5940         binding = BINDING_VALUE (t);
5941       else if ((flags & LOOKUP_PREFER_TYPES)
5942                && qualify_lookup (BINDING_TYPE (t), flags))
5943         binding = BINDING_TYPE (t);
5944       else
5945         binding = NULL_TREE;
5946
5947       /* Handle access control on types from enclosing or base classes.  */
5948       if (binding && ! yylex
5949           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5950         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5951
5952       if (binding
5953           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5954         {
5955           if (val_is_implicit_typename && !yylex)
5956             warn_about_implicit_typename_lookup (val, binding);
5957           val = binding;
5958           val_is_implicit_typename
5959             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5960           if (!val_is_implicit_typename)
5961             break;
5962         }
5963     }
5964
5965   /* Now lookup in namespace scopes.  */
5966   if (!val || val_is_implicit_typename)
5967     {
5968       t = unqualified_namespace_lookup (name, flags, 0);
5969       if (t)
5970         {
5971           if (val_is_implicit_typename && !yylex)
5972             warn_about_implicit_typename_lookup (val, t);
5973           val = t;
5974         }
5975     }
5976
5977  done:
5978   if (val)
5979     {
5980       /* This should only warn about types used in qualified-ids.  */
5981       if (from_obj && from_obj != val)
5982         {
5983           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5984               && TREE_CODE (val) == TYPE_DECL
5985               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5986             {
5987               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5988                           name, got_object, TREE_TYPE (from_obj));
5989               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5990                           TREE_TYPE (val));
5991             }
5992
5993           /* We don't change val to from_obj if got_object depends on
5994              template parms because that breaks implicit typename for
5995              destructor calls.  */
5996           if (! uses_template_parms (got_object))
5997             val = from_obj;
5998         }
5999
6000       /* If we have a single function from a using decl, pull it out.  */
6001       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6002         val = OVL_FUNCTION (val);
6003     }
6004   else if (from_obj)
6005     val = from_obj;
6006
6007   return val;
6008 }
6009
6010 tree
6011 lookup_name_nonclass (name)
6012      tree name;
6013 {
6014   return lookup_name_real (name, 0, 1, 0);
6015 }
6016
6017 tree
6018 lookup_function_nonclass (name, args)
6019      tree name;
6020      tree args;
6021 {
6022   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6023 }
6024
6025 tree
6026 lookup_name_namespace_only (name)
6027      tree name;
6028 {
6029   /* type-or-namespace, nonclass, namespace_only */
6030   return lookup_name_real (name, 1, 1, 1);
6031 }
6032
6033 tree
6034 lookup_name (name, prefer_type)
6035      tree name;
6036      int prefer_type;
6037 {
6038   return lookup_name_real (name, prefer_type, 0, 0);
6039 }
6040
6041 /* Similar to `lookup_name' but look only in the innermost non-class
6042    binding level.  */
6043
6044 tree
6045 lookup_name_current_level (name)
6046      tree name;
6047 {
6048   struct binding_level *b;
6049   tree t = NULL_TREE;
6050
6051   b = current_binding_level;
6052   while (b->parm_flag == 2)
6053     b = b->level_chain;
6054
6055   if (b->namespace_p)
6056     {
6057       t = IDENTIFIER_NAMESPACE_VALUE (name);
6058
6059       /* extern "C" function() */
6060       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6061         t = TREE_VALUE (t);
6062     }
6063   else if (IDENTIFIER_BINDING (name)
6064            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6065     {
6066       while (1)
6067         {
6068           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6069             return IDENTIFIER_VALUE (name);
6070
6071           if (b->keep == 2)
6072             b = b->level_chain;
6073           else
6074             break;
6075         }
6076     }
6077
6078   return t;
6079 }
6080
6081 /* Like lookup_name_current_level, but for types.  */
6082
6083 tree
6084 lookup_type_current_level (name)
6085      tree name;
6086 {
6087   register tree t = NULL_TREE;
6088
6089   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6090
6091   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6092       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6093     {
6094       struct binding_level *b = current_binding_level;
6095       while (1)
6096         {
6097           if (purpose_member (name, b->type_shadowed))
6098             return REAL_IDENTIFIER_TYPE_VALUE (name);
6099           if (b->keep == 2)
6100             b = b->level_chain;
6101           else
6102             break;
6103         }
6104     }
6105
6106   return t;
6107 }
6108
6109 void
6110 begin_only_namespace_names ()
6111 {
6112   only_namespace_names = 1;
6113 }
6114
6115 void
6116 end_only_namespace_names ()
6117 {
6118   only_namespace_names = 0;
6119 }
6120 \f
6121 /* Push the declarations of builtin types into the namespace.
6122    RID_INDEX, if < CP_RID_MAX is the index of the builtin type
6123    in the array RID_POINTERS.  NAME is the name used when looking
6124    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6125
6126 static void
6127 record_builtin_type (rid_index, name, type)
6128      enum rid rid_index;
6129      const char *name;
6130      tree type;
6131 {
6132   tree rname = NULL_TREE, tname = NULL_TREE;
6133   tree tdecl = NULL_TREE;
6134
6135   if ((int) rid_index < (int) CP_RID_MAX)
6136     rname = ridpointers[(int) rid_index];
6137   if (name)
6138     tname = get_identifier (name);
6139
6140   TYPE_BUILT_IN (type) = 1;
6141
6142   if (tname)
6143     {
6144       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6145       set_identifier_type_value (tname, NULL_TREE);
6146       if ((int) rid_index < (int) CP_RID_MAX)
6147         /* Built-in types live in the global namespace. */
6148         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6149     }
6150   if (rname != NULL_TREE)
6151     {
6152       if (tname != NULL_TREE)
6153         {
6154           set_identifier_type_value (rname, NULL_TREE);
6155           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6156         }
6157       else
6158         {
6159           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6160           set_identifier_type_value (rname, NULL_TREE);
6161         }
6162     }
6163 }
6164
6165 /* Record one of the standard Java types.
6166  * Declare it as having the given NAME.
6167  * If SIZE > 0, it is the size of one of the integral types;
6168  * otherwise it is the negative of the size of one of the other types.  */
6169
6170 static tree
6171 record_builtin_java_type (name, size)
6172      const char *name;
6173      int size;
6174 {
6175   tree type, decl;
6176   if (size > 0)
6177     type = make_signed_type (size);
6178   else if (size > -32)
6179     { /* "__java_char" or ""__java_boolean". */
6180       type = make_unsigned_type (-size);
6181       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6182     }
6183   else
6184     { /* "__java_float" or ""__java_double". */
6185       type = make_node (REAL_TYPE);
6186       TYPE_PRECISION (type) = - size;
6187       layout_type (type);
6188     }
6189   record_builtin_type (CP_RID_MAX, name, type);
6190   decl = TYPE_NAME (type);
6191
6192   /* Suppress generate debug symbol entries for these types,
6193      since for normal C++ they are just clutter.
6194      However, push_lang_context undoes this if extern "Java" is seen. */
6195   DECL_IGNORED_P (decl) = 1;
6196
6197   TYPE_FOR_JAVA (type) = 1;
6198   return type;
6199 }
6200
6201 /* Push a type into the namespace so that the back-ends ignore it. */
6202
6203 static void
6204 record_unknown_type (type, name)
6205      tree type;
6206      const char *name;
6207 {
6208   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6209   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6210   DECL_IGNORED_P (decl) = 1;
6211   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6212   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6213   TYPE_ALIGN (type) = 1;
6214   TYPE_USER_ALIGN (type) = 0;
6215   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6216 }
6217
6218 /* An string for which we should create an IDENTIFIER_NODE at
6219    startup.  */
6220
6221 typedef struct predefined_identifier
6222 {
6223   /* The name of the identifier.  */
6224   const char *name;
6225   /* The place where the IDENTIFIER_NODE should be stored.  */
6226   tree *node;
6227   /* Non-zero if this is the name of a constructor or destructor.  */
6228   int ctor_or_dtor_p;
6229 } predefined_identifier;
6230
6231 /* Create all the predefined identifiers.  */
6232
6233 static void
6234 initialize_predefined_identifiers ()
6235 {
6236   struct predefined_identifier *pid;
6237
6238   /* A table of identifiers to create at startup.  */
6239   static predefined_identifier predefined_identifiers[] = {
6240     { "C++", &lang_name_cplusplus, 0 },
6241     { "C", &lang_name_c, 0 },
6242     { "Java", &lang_name_java, 0 },
6243     { CTOR_NAME, &ctor_identifier, 1 },
6244     { "__base_ctor", &base_ctor_identifier, 1 },
6245     { "__comp_ctor", &complete_ctor_identifier, 1 },
6246     { DTOR_NAME, &dtor_identifier, 1 },
6247     { "__comp_dtor", &complete_dtor_identifier, 1 },
6248     { "__base_dtor", &base_dtor_identifier, 1 },
6249     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6250     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6251     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6252     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6253     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6254     { "nelts", &nelts_identifier, 0 },
6255     { THIS_NAME, &this_identifier, 0 },
6256     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6257     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6258     { "_vptr", &vptr_identifier, 0 },
6259     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6260     { "__vtt_parm", &vtt_parm_identifier, 0 },
6261     { "std", &std_identifier, 0 },
6262     { NULL, NULL, 0 }
6263   };
6264
6265   for (pid = predefined_identifiers; pid->name; ++pid)
6266     {
6267       *pid->node = get_identifier (pid->name);
6268       if (pid->ctor_or_dtor_p)
6269         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6270     }
6271 }
6272
6273 /* Create the predefined scalar types of C,
6274    and some nodes representing standard constants (0, 1, (void *)0).
6275    Initialize the global binding level.
6276    Make definitions for built-in primitive functions.  */
6277
6278 void
6279 init_decl_processing ()
6280 {
6281   tree fields[20];
6282   int wchar_type_size;
6283   tree array_domain_type;
6284
6285   /* Check to see that the user did not specify an invalid combination
6286      of command-line options.  */
6287   if (flag_new_abi && !flag_vtable_thunks)
6288     fatal ("the new ABI requires vtable thunks");
6289
6290   /* Create all the identifiers we need.  */
6291   initialize_predefined_identifiers ();
6292
6293   /* Let the back-end now how to save and restore language-specific
6294      per-function globals.  */
6295   init_lang_status = &push_cp_function_context;
6296   free_lang_status = &pop_cp_function_context;
6297   mark_lang_status = &mark_cp_function_context;
6298
6299   cp_parse_init ();
6300   init_decl2 ();
6301   init_pt ();
6302
6303   /* Create the global variables.  */
6304   push_to_top_level ();
6305
6306   /* Enter the global namespace. */
6307   my_friendly_assert (global_namespace == NULL_TREE, 375);
6308   push_namespace (get_identifier ("::"));
6309   global_namespace = current_namespace;
6310   current_lang_name = NULL_TREE;
6311
6312   /* Adjust various flags based on command-line settings.  */
6313   if (! flag_permissive && ! pedantic)
6314     flag_pedantic_errors = 1;
6315   if (!flag_no_inline)
6316     flag_inline_trees = 1;
6317
6318   /* Initially, C.  */
6319   current_lang_name = lang_name_c;
6320
6321   current_function_decl = NULL_TREE;
6322   current_binding_level = NULL_BINDING_LEVEL;
6323   free_binding_level = NULL_BINDING_LEVEL;
6324
6325   build_common_tree_nodes (flag_signed_char);
6326
6327   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6328   TREE_TYPE (error_mark_list) = error_mark_node;
6329
6330   /* Make the binding_level structure for global names.  */
6331   pushlevel (0);
6332   global_binding_level = current_binding_level;
6333   /* The global level is the namespace level of ::.  */
6334   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6335   declare_namespace_level ();
6336
6337   /* Define `int' and `char' first so that dbx will output them first.  */
6338   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6339   record_builtin_type (RID_CHAR, "char", char_type_node);
6340
6341   /* `signed' is the same as `int' */
6342   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6343   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6344   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6345   record_builtin_type (CP_RID_MAX, "long unsigned int",
6346                        long_unsigned_type_node);
6347   record_builtin_type (CP_RID_MAX, "unsigned long", long_unsigned_type_node);
6348   record_builtin_type (CP_RID_MAX, "long long int",
6349                        long_long_integer_type_node);
6350   record_builtin_type (CP_RID_MAX, "long long unsigned int",
6351                        long_long_unsigned_type_node);
6352   record_builtin_type (CP_RID_MAX, "long long unsigned",
6353                        long_long_unsigned_type_node);
6354   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6355   record_builtin_type (CP_RID_MAX, "short unsigned int",
6356                        short_unsigned_type_node);
6357   record_builtin_type (CP_RID_MAX, "unsigned short",
6358                        short_unsigned_type_node);
6359
6360   ptrdiff_type_node
6361     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6362
6363   /* Define both `signed char' and `unsigned char'.  */
6364   record_builtin_type (CP_RID_MAX, "signed char", signed_char_type_node);
6365   record_builtin_type (CP_RID_MAX, "unsigned char", unsigned_char_type_node);
6366
6367   /* `unsigned long' is the standard type for sizeof.
6368      Note that stddef.h uses `unsigned long',
6369      and this must agree, even if long and int are the same size.  */
6370   set_sizetype
6371     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6372
6373   /* Create the widest literal types. */
6374   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6375   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6376                         widest_integer_literal_type_node));
6377
6378   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6379   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6380                         widest_unsigned_literal_type_node));
6381
6382   /* These are types that type_for_size and type_for_mode use.  */
6383   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6384   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6385   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6386   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6387 #if HOST_BITS_PER_WIDE_INT >= 64
6388   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6389 #endif
6390   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6391   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6392   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6393   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6394 #if HOST_BITS_PER_WIDE_INT >= 64
6395   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6396 #endif
6397
6398   build_common_tree_nodes_2 (flag_short_double);
6399
6400   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6401   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6402   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6403   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6404   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6405   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6406   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6407   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6408
6409   integer_two_node = build_int_2 (2, 0);
6410   TREE_TYPE (integer_two_node) = integer_type_node;
6411   integer_three_node = build_int_2 (3, 0);
6412   TREE_TYPE (integer_three_node) = integer_type_node;
6413
6414   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6415   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6416   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6417   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6418   TYPE_PRECISION (boolean_type_node) = 1;
6419   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6420   boolean_false_node = build_int_2 (0, 0);
6421   TREE_TYPE (boolean_false_node) = boolean_type_node;
6422   boolean_true_node = build_int_2 (1, 0);
6423   TREE_TYPE (boolean_true_node) = boolean_type_node;
6424
6425   signed_size_zero_node = build_int_2 (0, 0);
6426   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6427   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6428   record_builtin_type (CP_RID_MAX, "long double", long_double_type_node);
6429
6430   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6431                         complex_integer_type_node));
6432   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6433                         complex_float_type_node));
6434   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6435                         complex_double_type_node));
6436   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6437                         complex_long_double_type_node));
6438
6439   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6440
6441   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6442   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6443   TREE_PARMLIST (void_list_node) = 1;
6444
6445   /* Used for expressions that do nothing, but are not errors.  */
6446   void_zero_node = build_int_2 (0, 0);
6447   TREE_TYPE (void_zero_node) = void_type_node;
6448
6449   string_type_node = build_pointer_type (char_type_node);
6450   const_string_type_node
6451     = build_pointer_type (build_qualified_type (char_type_node,
6452                                                 TYPE_QUAL_CONST));
6453   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6454 #if 0
6455   record_builtin_type (CP_RID_MAX, NULL_PTR, string_type_node);
6456 #endif
6457
6458   /* Make a type to be the domain of a few array types
6459      whose domains don't really matter.
6460      200 is small enough that it always fits in size_t.  */
6461   array_domain_type = build_index_type (build_int_2 (200, 0));
6462
6463   /* Make a type for arrays of characters.
6464      With luck nothing will ever really depend on the length of this
6465      array type.  */
6466   char_array_type_node
6467     = build_array_type (char_type_node, array_domain_type);
6468
6469   /* Likewise for arrays of ints.  */
6470   int_array_type_node
6471     = build_array_type (integer_type_node, array_domain_type);
6472
6473   if (flag_new_abi)
6474     delta_type_node = ptrdiff_type_node;
6475   else if (flag_huge_objects)
6476     delta_type_node = long_integer_type_node;
6477   else
6478     delta_type_node = short_integer_type_node;
6479
6480   if (flag_new_abi)
6481     vtable_index_type = ptrdiff_type_node;
6482   else
6483     vtable_index_type = delta_type_node;
6484
6485   default_function_type
6486     = build_function_type (integer_type_node, NULL_TREE);
6487
6488   ptr_type_node = build_pointer_type (void_type_node);
6489   const_ptr_type_node
6490     = build_pointer_type (build_qualified_type (void_type_node,
6491                                                 TYPE_QUAL_CONST));
6492   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6493   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6494   lang_type_promotes_to = convert_type_from_ellipsis;
6495
6496   void_ftype_ptr
6497     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6498
6499   /* C++ extensions */
6500
6501   unknown_type_node = make_node (UNKNOWN_TYPE);
6502   record_unknown_type (unknown_type_node, "unknown type");
6503
6504   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6505   TREE_TYPE (unknown_type_node) = unknown_type_node;
6506
6507   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6508
6509   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6510      result.  */
6511   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6512   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6513
6514   /* This is special for C++ so functions can be overloaded.  */
6515   wchar_type_node = get_identifier (flag_short_wchar
6516                                     ? "short unsigned int"
6517                                     : WCHAR_TYPE);
6518   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6519   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6520   if (TREE_UNSIGNED (wchar_type_node))
6521     wchar_type_node = make_signed_type (wchar_type_size);
6522   else
6523     wchar_type_node = make_unsigned_type (wchar_type_size);
6524   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6525
6526   /* Artificial declaration of wchar_t -- can be bashed */
6527   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6528                                 wchar_type_node);
6529   pushdecl (wchar_decl_node);
6530
6531   /* This is for wide string constants.  */
6532   wchar_array_type_node
6533     = build_array_type (wchar_type_node, array_domain_type);
6534
6535   if (flag_vtable_thunks)
6536     {
6537       /* Make sure we get a unique function type, so we can give
6538          its pointer type a name.  (This wins for gdb.) */
6539       tree vfunc_type = make_node (FUNCTION_TYPE);
6540       TREE_TYPE (vfunc_type) = integer_type_node;
6541       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6542       layout_type (vfunc_type);
6543
6544       vtable_entry_type = build_pointer_type (vfunc_type);
6545     }
6546   else
6547     {
6548       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6549       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6550                               delta_type_node);
6551       fields[1] = build_decl (FIELD_DECL, index_identifier,
6552                               delta_type_node);
6553       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6554                               ptr_type_node);
6555       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6556                            double_type_node);
6557
6558       /* Make this part of an invisible union.  */
6559       fields[3] = copy_node (fields[2]);
6560       TREE_TYPE (fields[3]) = delta_type_node;
6561       DECL_NAME (fields[3]) = delta2_identifier;
6562       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6563       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6564       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6565       TREE_UNSIGNED (fields[3]) = 0;
6566       TREE_CHAIN (fields[2]) = fields[3];
6567       vtable_entry_type = build_qualified_type (vtable_entry_type,
6568                                                 TYPE_QUAL_CONST);
6569     }
6570   record_builtin_type (CP_RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6571
6572   vtbl_type_node
6573     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6574   layout_type (vtbl_type_node);
6575   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6576   record_builtin_type (CP_RID_MAX, NULL_PTR, vtbl_type_node);
6577   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6578   layout_type (vtbl_ptr_type_node);
6579   record_builtin_type (CP_RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6580
6581   std_node = build_decl (NAMESPACE_DECL,
6582                          flag_honor_std
6583                          ? get_identifier ("fake std") : std_identifier,
6584                          void_type_node);
6585   pushdecl (std_node);
6586
6587   if (flag_new_abi)
6588     {
6589       push_namespace (get_identifier ("__cxxabiv1"));
6590       abi_node = current_namespace;
6591       pop_namespace ();
6592     }
6593
6594   global_type_node = make_node (LANG_TYPE);
6595   record_unknown_type (global_type_node, "global type");
6596
6597   /* Now, C++.  */
6598   current_lang_name = lang_name_cplusplus;
6599
6600   {
6601     tree bad_alloc_type_node, newtype, deltype;
6602     if (flag_honor_std)
6603       push_namespace (get_identifier ("std"));
6604     bad_alloc_type_node = xref_tag
6605       (class_type_node, get_identifier ("bad_alloc"), 1);
6606     if (flag_honor_std)
6607       pop_namespace ();
6608     newtype = build_exception_variant
6609       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6610     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6611     push_cp_library_fn (NEW_EXPR, newtype);
6612     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6613     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6614     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6615   }
6616
6617   abort_fndecl
6618     = build_library_fn_ptr ("__pure_virtual", void_ftype);
6619
6620   /* Perform other language dependent initializations.  */
6621   init_class_processing ();
6622   init_init_processing ();
6623   init_search_processing ();
6624   init_rtti_processing ();
6625
6626   if (flag_exceptions)
6627     init_exception_processing ();
6628   if (flag_no_inline)
6629     {
6630       flag_inline_functions = 0;
6631     }
6632
6633   if (! supports_one_only ())
6634     flag_weak = 0;
6635
6636   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6637   make_fname_decl = cp_make_fname_decl;
6638   declare_function_name ();
6639
6640   /* Prepare to check format strings against argument lists.  */
6641   init_function_format_info ();
6642
6643   /* Show we use EH for cleanups.  */
6644   using_eh_for_cleanups ();
6645
6646   print_error_function = lang_print_error_function;
6647   valid_lang_attribute = cp_valid_lang_attribute;
6648
6649   /* Maintain consistency.  Perhaps we should just complain if they
6650      say -fwritable-strings?  */
6651   if (flag_writable_strings)
6652     flag_const_strings = 0;
6653
6654   /* Add GC roots for all of our global variables.  */
6655   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6656   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6657   ggc_add_tree_root (&integer_three_node, 1);
6658   ggc_add_tree_root (&integer_two_node, 1);
6659   ggc_add_tree_root (&signed_size_zero_node, 1);
6660   ggc_add_tree_root (&size_one_node, 1);
6661   ggc_add_tree_root (&size_zero_node, 1);
6662   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6663                 mark_binding_level);
6664   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6665   ggc_add_tree_root (&static_ctors, 1);
6666   ggc_add_tree_root (&static_dtors, 1);
6667   ggc_add_tree_root (&lastiddecl, 1);
6668
6669   ggc_add_tree_root (&last_function_parm_tags, 1);
6670   ggc_add_tree_root (&current_function_return_value, 1);
6671   ggc_add_tree_root (&current_function_parms, 1);
6672   ggc_add_tree_root (&current_function_parm_tags, 1);
6673   ggc_add_tree_root (&last_function_parms, 1);
6674   ggc_add_tree_root (&error_mark_list, 1);
6675
6676   ggc_add_tree_root (&global_namespace, 1);
6677   ggc_add_tree_root (&global_type_node, 1);
6678   ggc_add_tree_root (&anonymous_namespace_name, 1);
6679
6680   ggc_add_tree_root (&got_object, 1);
6681   ggc_add_tree_root (&got_scope, 1);
6682
6683   ggc_add_tree_root (&current_lang_name, 1);
6684   ggc_add_tree_root (&static_aggregates, 1);
6685 }
6686
6687 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6688    decl, NAME is the initialization string and TYPE_DEP indicates whether
6689    NAME depended on the type of the function. We make use of that to detect
6690    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6691    the function before emitting any of it, we don't need to treat the
6692    VAR_DECL specially. We can decide whether to emit it later, if it was
6693    used.  */
6694
6695 static tree
6696 cp_make_fname_decl (id, name, type_dep)
6697      tree id;
6698      const char *name;
6699      int type_dep;
6700 {
6701   tree decl, type, init;
6702   size_t length = strlen (name);
6703   tree domain = NULL_TREE;
6704
6705   if (!processing_template_decl)
6706     type_dep = 0;
6707   if (!type_dep)
6708     domain = build_index_type (build_int_2 (length, 0));
6709
6710   type =  build_cplus_array_type
6711           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6712            domain);
6713
6714   decl = build_decl (VAR_DECL, id, type);
6715   TREE_STATIC (decl) = 1;
6716   TREE_READONLY (decl) = 1;
6717   DECL_SOURCE_LINE (decl) = 0;
6718   DECL_ARTIFICIAL (decl) = 1;
6719   DECL_IN_SYSTEM_HEADER (decl) = 1;
6720   pushdecl (decl);
6721   if (processing_template_decl)
6722     decl = push_template_decl (decl);
6723   if (type_dep)
6724     {
6725       init = build (FUNCTION_NAME, type);
6726       DECL_PRETTY_FUNCTION_P (decl) = 1;
6727     }
6728   else
6729     {
6730       init = build_string (length + 1, name);
6731       TREE_TYPE (init) = type;
6732     }
6733   DECL_INITIAL (decl) = init;
6734   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6735
6736   /* We will have to make sure we only emit this, if it is actually used. */
6737   return decl;
6738 }
6739
6740 /* Function to print any language-specific context for an error message.  */
6741
6742 static void
6743 lang_print_error_function (file)
6744      const char *file;
6745 {
6746   default_print_error_function (file);
6747   maybe_print_template_context ();
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   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6776      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6777      function in the namespace.  */
6778   pushdecl (decl);
6779   if (libname)
6780     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6781   make_function_rtl (decl);
6782
6783   /* Warn if a function in the namespace for users
6784      is used without an occasion to consider it declared.  */
6785   if (name[0] != '_' || name[1] != '_')
6786     DECL_ANTICIPATED (decl) = 1;
6787
6788   return decl;
6789 }
6790
6791 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6792    function.  Not called directly.  */
6793
6794 static tree
6795 build_library_fn_1 (name, operator_code, type)
6796      tree name;
6797      enum tree_code operator_code;
6798      tree type;
6799 {
6800   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6801   DECL_EXTERNAL (fn) = 1;
6802   TREE_PUBLIC (fn) = 1;
6803   DECL_ARTIFICIAL (fn) = 1;
6804   TREE_NOTHROW (fn) = 1;
6805   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6806   return fn;
6807 }
6808
6809 /* Returns the _DECL for a library function with C linkage.
6810    We assume that such functions never throw; if this is incorrect,
6811    callers should unset TREE_NOTHROW.  */
6812
6813 tree
6814 build_library_fn (name, type)
6815      tree name;
6816      tree type;
6817 {
6818   tree fn = build_library_fn_1 (name, ERROR_MARK, type);
6819   make_function_rtl (fn);
6820   return fn;
6821 }
6822
6823 /* Returns the _DECL for a library function with C++ linkage.  */
6824
6825 static tree
6826 build_cp_library_fn (name, operator_code, type)
6827      tree name;
6828      enum tree_code operator_code;
6829      tree type;
6830 {
6831   tree fn = build_library_fn_1 (name, operator_code, type);
6832   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6833   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6834   set_mangled_name_for_decl (fn);
6835   make_function_rtl (fn);
6836   return fn;
6837 }
6838
6839 /* Like build_library_fn, but takes a C string instead of an
6840    IDENTIFIER_NODE.  */
6841
6842 tree
6843 build_library_fn_ptr (name, type)
6844      const char *name;
6845      tree type;
6846 {
6847   return build_library_fn (get_identifier (name), type);
6848 }
6849
6850 /* Like build_cp_library_fn, but takes a C string instead of an
6851    IDENTIFIER_NODE.  */
6852
6853 tree
6854 build_cp_library_fn_ptr (name, type)
6855      const char *name;
6856      tree type;
6857 {
6858   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6859 }
6860
6861 /* Like build_library_fn, but also pushes the function so that we will
6862    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6863
6864 tree
6865 push_library_fn (name, type)
6866      tree name, type;
6867 {
6868   tree fn = build_library_fn (name, type);
6869   pushdecl_top_level (fn);
6870   return fn;
6871 }
6872
6873 /* Like build_cp_library_fn, but also pushes the function so that it
6874    will be found by normal lookup.  */
6875
6876 static tree
6877 push_cp_library_fn (operator_code, type)
6878      enum tree_code operator_code;
6879      tree type;
6880 {
6881   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6882                                  operator_code,
6883                                  type);
6884   pushdecl (fn);
6885   return fn;
6886 }
6887
6888 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6889    a FUNCTION_TYPE.  */
6890
6891 tree
6892 push_void_library_fn (name, parmtypes)
6893      tree name, parmtypes;
6894 {
6895   tree type = build_function_type (void_type_node, parmtypes);
6896   return push_library_fn (name, type);
6897 }
6898
6899 /* Like push_library_fn, but also note that this function throws
6900    and does not return.  Used for __throw_foo and the like.  */
6901
6902 tree
6903 push_throw_library_fn (name, type)
6904      tree name, type;
6905 {
6906   tree fn = push_library_fn (name, type);
6907   TREE_THIS_VOLATILE (fn) = 1;
6908   TREE_NOTHROW (fn) = 0;
6909   return fn;
6910 }
6911 \f
6912 /* When we call finish_struct for an anonymous union, we create
6913    default copy constructors and such.  But, an anonymous union
6914    shouldn't have such things; this function undoes the damage to the
6915    anonymous union type T.
6916
6917    (The reason that we create the synthesized methods is that we don't
6918    distinguish `union { int i; }' from `typedef union { int i; } U'.
6919    The first is an anonymous union; the second is just an ordinary
6920    union type.)  */
6921
6922 void
6923 fixup_anonymous_aggr (t)
6924      tree t;
6925 {
6926   tree *q;
6927
6928   /* Wipe out memory of synthesized methods */
6929   TYPE_HAS_CONSTRUCTOR (t) = 0;
6930   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6931   TYPE_HAS_INIT_REF (t) = 0;
6932   TYPE_HAS_CONST_INIT_REF (t) = 0;
6933   TYPE_HAS_ASSIGN_REF (t) = 0;
6934   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6935
6936   /* Splice the implicitly generated functions out of the TYPE_METHODS
6937      list.  */
6938   q = &TYPE_METHODS (t);
6939   while (*q)
6940     {
6941       if (DECL_ARTIFICIAL (*q))
6942         *q = TREE_CHAIN (*q);
6943       else
6944         q = &TREE_CHAIN (*q);
6945     }
6946
6947   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6948   if (TYPE_METHODS (t))
6949     error ("an anonymous union cannot have function members");
6950 }
6951
6952 /* Make sure that a declaration with no declarator is well-formed, i.e.
6953    just defines a tagged type or anonymous union.
6954
6955    Returns the type defined, if any.  */
6956
6957 tree
6958 check_tag_decl (declspecs)
6959      tree declspecs;
6960 {
6961   int found_type = 0;
6962   int saw_friend = 0;
6963   tree ob_modifier = NULL_TREE;
6964   register tree link;
6965   register tree t = NULL_TREE;
6966
6967   for (link = declspecs; link; link = TREE_CHAIN (link))
6968     {
6969       register tree value = TREE_VALUE (link);
6970
6971       if (TYPE_P (value)
6972           || (TREE_CODE (value) == IDENTIFIER_NODE
6973               && IDENTIFIER_GLOBAL_VALUE (value)
6974               && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
6975         {
6976           ++found_type;
6977
6978           if ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
6979               || TREE_CODE (value) == ENUMERAL_TYPE)
6980             {
6981               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6982               t = value;
6983             }
6984         }
6985       else if (value == ridpointers[(int) RID_FRIEND])
6986         {
6987           if (current_class_type == NULL_TREE
6988               || current_scope () != current_class_type)
6989             ob_modifier = value;
6990           else
6991             saw_friend = 1;
6992         }
6993       else if (value == ridpointers[(int) RID_STATIC]
6994                || value == ridpointers[(int) RID_EXTERN]
6995                || value == ridpointers[(int) RID_AUTO]
6996                || value == ridpointers[(int) RID_REGISTER]
6997                || value == ridpointers[(int) RID_INLINE]
6998                || value == ridpointers[(int) RID_VIRTUAL]
6999                || value == ridpointers[(int) RID_CONST]
7000                || value == ridpointers[(int) RID_VOLATILE]
7001                || value == ridpointers[(int) RID_EXPLICIT])
7002         ob_modifier = value;
7003     }
7004
7005   if (found_type > 1)
7006     error ("multiple types in one declaration");
7007
7008   if (t == NULL_TREE && ! saw_friend)
7009     pedwarn ("declaration does not declare anything");
7010
7011   /* Check for an anonymous union.  We're careful
7012      accessing TYPE_IDENTIFIER because some built-in types, like
7013      pointer-to-member types, do not have TYPE_NAME.  */
7014   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7015            && TYPE_NAME (t)
7016            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
7017     {
7018       /* Anonymous unions are objects, so they can have specifiers.  */;
7019       SET_ANON_AGGR_TYPE_P (t);
7020
7021       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7022         pedwarn ("ISO C++ prohibits anonymous structs");
7023     }
7024
7025   else if (ob_modifier)
7026     {
7027       if (ob_modifier == ridpointers[(int) RID_INLINE]
7028           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7029         cp_error ("`%D' can only be specified for functions", ob_modifier);
7030       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7031         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7032       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7033         cp_error ("`%D' can only be specified for constructors",
7034                   ob_modifier);
7035       else
7036         cp_error ("`%D' can only be specified for objects and functions",
7037                   ob_modifier);
7038     }
7039
7040   return t;
7041 }
7042
7043 /* Called when a declaration is seen that contains no names to declare.
7044    If its type is a reference to a structure, union or enum inherited
7045    from a containing scope, shadow that tag name for the current scope
7046    with a forward reference.
7047    If its type defines a new named structure or union
7048    or defines an enum, it is valid but we need not do anything here.
7049    Otherwise, it is an error.
7050
7051    C++: may have to grok the declspecs to learn about static,
7052    complain for anonymous unions.  */
7053
7054 void
7055 shadow_tag (declspecs)
7056      tree declspecs;
7057 {
7058   tree t = check_tag_decl (declspecs);
7059
7060   if (t)
7061     maybe_process_partial_specialization (t);
7062
7063   /* This is where the variables in an anonymous union are
7064      declared.  An anonymous union declaration looks like:
7065      union { ... } ;
7066      because there is no declarator after the union, the parser
7067      sends that declaration here.  */
7068   if (t && ANON_AGGR_TYPE_P (t))
7069     {
7070       fixup_anonymous_aggr (t);
7071
7072       if (TYPE_FIELDS (t))
7073         {
7074           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7075                                       NULL_TREE);
7076           finish_anon_union (decl);
7077         }
7078     }
7079 }
7080 \f
7081 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7082
7083 tree
7084 groktypename (typename)
7085      tree typename;
7086 {
7087   if (TREE_CODE (typename) != TREE_LIST)
7088     return typename;
7089   return grokdeclarator (TREE_VALUE (typename),
7090                          TREE_PURPOSE (typename),
7091                          TYPENAME, 0, NULL_TREE);
7092 }
7093
7094 /* Decode a declarator in an ordinary declaration or data definition.
7095    This is called as soon as the type information and variable name
7096    have been parsed, before parsing the initializer if any.
7097    Here we create the ..._DECL node, fill in its type,
7098    and put it on the list of decls for the current context.
7099    The ..._DECL node is returned as the value.
7100
7101    Exception: for arrays where the length is not specified,
7102    the type is left null, to be filled in by `cp_finish_decl'.
7103
7104    Function definitions do not come here; they go to start_function
7105    instead.  However, external and forward declarations of functions
7106    do go through here.  Structure field declarations are done by
7107    grokfield and not through here.  */
7108
7109 tree
7110 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7111      tree declarator, declspecs;
7112      int initialized;
7113      tree attributes, prefix_attributes;
7114 {
7115   register tree decl;
7116   register tree type, tem;
7117   tree context;
7118   extern int have_extern_spec;
7119   extern int used_extern_spec;
7120   tree attrlist;
7121
7122 #if 0
7123   /* See code below that used this.  */
7124   int init_written = initialized;
7125 #endif
7126
7127   /* This should only be done once on the top most decl.  */
7128   if (have_extern_spec && !used_extern_spec)
7129     {
7130       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
7131                                   declspecs);
7132       used_extern_spec = 1;
7133     }
7134
7135   if (attributes || prefix_attributes)
7136     attrlist = build_tree_list (attributes, prefix_attributes);
7137   else
7138     attrlist = NULL_TREE;
7139
7140   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7141                          attrlist);
7142
7143   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7144     return NULL_TREE;
7145
7146   type = TREE_TYPE (decl);
7147
7148   if (type == error_mark_node)
7149     return NULL_TREE;
7150
7151   context = DECL_CONTEXT (decl);
7152
7153   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7154       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7155     {
7156       /* When parsing the initializer, lookup should use the object's
7157          namespace. */
7158       push_decl_namespace (context);
7159     }
7160
7161   /* We are only interested in class contexts, later. */
7162   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7163     context = NULL_TREE;
7164
7165   if (initialized)
7166     /* Is it valid for this decl to have an initializer at all?
7167        If not, set INITIALIZED to zero, which will indirectly
7168        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7169     switch (TREE_CODE (decl))
7170       {
7171       case TYPE_DECL:
7172         /* typedef foo = bar  means give foo the same type as bar.
7173            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7174            Any other case of an initialization in a TYPE_DECL is an error.  */
7175         if (pedantic || list_length (declspecs) > 1)
7176           {
7177             cp_error ("typedef `%D' is initialized", decl);
7178             initialized = 0;
7179           }
7180         break;
7181
7182       case FUNCTION_DECL:
7183         cp_error ("function `%#D' is initialized like a variable", decl);
7184         initialized = 0;
7185         break;
7186
7187       default:
7188         break;
7189       }
7190
7191   if (initialized)
7192     {
7193       if (! toplevel_bindings_p ()
7194           && DECL_EXTERNAL (decl))
7195         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7196                     decl);
7197       DECL_EXTERNAL (decl) = 0;
7198       if (toplevel_bindings_p ())
7199         TREE_STATIC (decl) = 1;
7200
7201       /* Tell `pushdecl' this is an initialized decl
7202          even though we don't yet have the initializer expression.
7203          Also tell `cp_finish_decl' it may store the real initializer.  */
7204       DECL_INITIAL (decl) = error_mark_node;
7205     }
7206
7207 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7208   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7209 #endif
7210
7211   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7212   cplus_decl_attributes (decl, attributes, prefix_attributes);
7213
7214   if (context && COMPLETE_TYPE_P (complete_type (context)))
7215     {
7216       push_nested_class (context, 2);
7217
7218       if (TREE_CODE (decl) == VAR_DECL)
7219         {
7220           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7221           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7222             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7223           else
7224             {
7225               if (DECL_CONTEXT (field) != context)
7226                 {
7227                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7228                               DECL_CONTEXT (field), DECL_NAME (decl),
7229                               context, DECL_NAME (decl));
7230                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7231                 }
7232               /* Static data member are tricky; an in-class initialization
7233                  still doesn't provide a definition, so the in-class
7234                  declaration will have DECL_EXTERNAL set, but will have an
7235                  initialization.  Thus, duplicate_decls won't warn
7236                  about this situation, and so we check here.  */
7237               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7238                 cp_error ("duplicate initialization of %D", decl);
7239               if (duplicate_decls (decl, field))
7240                 decl = field;
7241             }
7242         }
7243       else
7244         {
7245           tree field = check_classfn (context, decl);
7246           if (field && duplicate_decls (decl, field))
7247             decl = field;
7248         }
7249
7250       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7251       DECL_IN_AGGR_P (decl) = 0;
7252       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7253           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7254         {
7255           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7256           /* [temp.expl.spec] An explicit specialization of a static data
7257              member of a template is a definition if the declaration
7258              includes an initializer; otherwise, it is a declaration.
7259
7260              We check for processing_specialization so this only applies
7261              to the new specialization syntax.  */
7262           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7263             DECL_EXTERNAL (decl) = 1;
7264         }
7265
7266       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7267         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7268                     decl);
7269     }
7270
7271   /* Enter this declaration into the symbol table.  */
7272   tem = maybe_push_decl (decl);
7273
7274   if (processing_template_decl)
7275     tem = push_template_decl (tem);
7276
7277 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7278   /* Tell the back-end to use or not use .common as appropriate.  If we say
7279      -fconserve-space, we want this to save .data space, at the expense of
7280      wrong semantics.  If we say -fno-conserve-space, we want this to
7281      produce errors about redefs; to do this we force variables into the
7282      data segment.  */
7283   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7284 #endif
7285
7286   if (! processing_template_decl)
7287     start_decl_1 (tem);
7288
7289   return tem;
7290 }
7291
7292 void
7293 start_decl_1 (decl)
7294      tree decl;
7295 {
7296   tree type = TREE_TYPE (decl);
7297   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7298
7299   if (type == error_mark_node)
7300     return;
7301
7302   /* If this type of object needs a cleanup, but we're not allowed to
7303      add any more objects with cleanups to the current scope, create a
7304      new binding level.  */
7305   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7306       && current_binding_level->more_cleanups_ok == 0)
7307     {
7308       keep_next_level (2);
7309       pushlevel (1);
7310       clear_last_expr ();
7311       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7312     }
7313
7314   if (initialized)
7315     /* Is it valid for this decl to have an initializer at all?
7316        If not, set INITIALIZED to zero, which will indirectly
7317        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7318     {
7319       /* Don't allow initializations for incomplete types except for
7320          arrays which might be completed by the initialization.  */
7321       if (COMPLETE_TYPE_P (complete_type (type)))
7322         ;                       /* A complete type is ok.  */
7323       else if (TREE_CODE (type) != ARRAY_TYPE)
7324         {
7325           cp_error ("variable `%#D' has initializer but incomplete type",
7326                     decl);
7327           initialized = 0;
7328           type = TREE_TYPE (decl) = error_mark_node;
7329         }
7330       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7331         {
7332           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7333             cp_error ("elements of array `%#D' have incomplete type", decl);
7334           /* else we already gave an error in start_decl.  */
7335           initialized = 0;
7336         }
7337     }
7338
7339   if (!initialized
7340       && TREE_CODE (decl) != TYPE_DECL
7341       && TREE_CODE (decl) != TEMPLATE_DECL
7342       && type != error_mark_node
7343       && IS_AGGR_TYPE (type)
7344       && ! DECL_EXTERNAL (decl))
7345     {
7346       if ((! processing_template_decl || ! uses_template_parms (type))
7347           && !COMPLETE_TYPE_P (complete_type (type)))
7348         {
7349           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7350                  decl);
7351           /* Change the type so that assemble_variable will give
7352              DECL an rtl we can live with: (mem (const_int 0)).  */
7353           type = TREE_TYPE (decl) = error_mark_node;
7354         }
7355       else
7356         {
7357           /* If any base type in the hierarchy of TYPE needs a constructor,
7358              then we set initialized to 1.  This way any nodes which are
7359              created for the purposes of initializing this aggregate
7360              will live as long as it does.  This is necessary for global
7361              aggregates which do not have their initializers processed until
7362              the end of the file.  */
7363           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7364         }
7365     }
7366
7367   if (! initialized)
7368     DECL_INITIAL (decl) = NULL_TREE;
7369 }
7370
7371 /* Handle initialization of references.
7372    These three arguments are from `cp_finish_decl', and have the
7373    same meaning here that they do there.
7374
7375    Quotes on semantics can be found in ARM 8.4.3.  */
7376
7377 static void
7378 grok_reference_init (decl, type, init)
7379      tree decl, type, init;
7380 {
7381   tree tmp;
7382
7383   if (init == NULL_TREE)
7384     {
7385       if ((DECL_LANG_SPECIFIC (decl) == 0
7386            || DECL_IN_AGGR_P (decl) == 0)
7387           && ! DECL_THIS_EXTERN (decl))
7388         cp_error ("`%D' declared as reference but not initialized", decl);
7389       return;
7390     }
7391
7392   if (init == error_mark_node)
7393     return;
7394
7395   if (TREE_CODE (init) == CONSTRUCTOR)
7396     {
7397       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7398       return;
7399     }
7400
7401   if (TREE_CODE (init) == TREE_LIST)
7402     init = build_compound_expr (init);
7403
7404   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7405     init = convert_from_reference (init);
7406
7407   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7408       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7409     {
7410       /* Note: default conversion is only called in very special cases.  */
7411       init = default_conversion (init);
7412     }
7413
7414   /* Convert INIT to the reference type TYPE.  This may involve the
7415      creation of a temporary, whose lifetime must be the same as that
7416      of the reference.  If so, a DECL_STMT for the temporary will be
7417      added just after the DECL_STMT for DECL.  That's why we don't set
7418      DECL_INITIAL for local references (instead assigning to them
7419      explicitly); we need to allow the temporary to be initialized
7420      first.  */
7421   tmp = convert_to_reference
7422     (type, init, CONV_IMPLICIT,
7423      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7424      decl);
7425
7426   if (tmp == error_mark_node)
7427     return;
7428   else if (tmp != NULL_TREE)
7429     {
7430       init = tmp;
7431       tmp = save_expr (tmp);
7432       if (building_stmt_tree ())
7433         {
7434           /* Initialize the declaration.  */
7435           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7436           finish_expr_stmt (tmp);
7437         }
7438       else
7439         DECL_INITIAL (decl) = tmp;
7440     }
7441   else
7442     {
7443       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7444       return;
7445     }
7446
7447   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7448     {
7449       expand_static_init (decl, DECL_INITIAL (decl));
7450       DECL_INITIAL (decl) = NULL_TREE;
7451     }
7452   return;
7453 }
7454
7455 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7456    mucking with forces it does not comprehend (i.e. initialization with a
7457    constructor).  If we are at global scope and won't go into COMMON, fill
7458    it in with a dummy CONSTRUCTOR to force the variable into .data;
7459    otherwise we can use error_mark_node.  */
7460
7461 static tree
7462 obscure_complex_init (decl, init)
7463      tree decl, init;
7464 {
7465   if (! flag_no_inline && TREE_STATIC (decl))
7466     {
7467       if (extract_init (decl, init))
7468         return NULL_TREE;
7469     }
7470
7471 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7472   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7473     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7474                                  NULL_TREE);
7475   else
7476 #endif
7477     DECL_INITIAL (decl) = error_mark_node;
7478
7479   return init;
7480 }
7481
7482 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7483    array until we finish parsing the initializer.  If that's the
7484    situation we're in, update DECL accordingly.  */
7485
7486 static void
7487 maybe_deduce_size_from_array_init (decl, init)
7488      tree decl;
7489      tree init;
7490 {
7491   tree type = TREE_TYPE (decl);
7492
7493   if (TREE_CODE (type) == ARRAY_TYPE
7494       && TYPE_DOMAIN (type) == NULL_TREE
7495       && TREE_CODE (decl) != TYPE_DECL)
7496     {
7497       int do_default
7498         = (TREE_STATIC (decl)
7499            /* Even if pedantic, an external linkage array
7500               may have incomplete type at first.  */
7501            ? pedantic && ! DECL_EXTERNAL (decl)
7502            : !DECL_EXTERNAL (decl));
7503       tree initializer = init ? init : DECL_INITIAL (decl);
7504       int failure = complete_array_type (type, initializer, do_default);
7505
7506       if (failure == 1)
7507         cp_error ("initializer fails to determine size of `%D'", decl);
7508
7509       if (failure == 2)
7510         {
7511           if (do_default)
7512             cp_error ("array size missing in `%D'", decl);
7513           /* If a `static' var's size isn't known, make it extern as
7514              well as static, so it does not get allocated.  If it's not
7515              `static', then don't mark it extern; finish_incomplete_decl
7516              will give it a default size and it will get allocated.  */
7517           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7518             DECL_EXTERNAL (decl) = 1;
7519         }
7520
7521       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7522           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7523                               integer_zero_node))
7524         cp_error ("zero-size array `%D'", decl);
7525
7526       layout_decl (decl, 0);
7527     }
7528 }
7529
7530 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7531    any appropriate error messages regarding the layout.  */
7532
7533 static void
7534 layout_var_decl (decl)
7535      tree decl;
7536 {
7537   tree type = TREE_TYPE (decl);
7538 #if 0
7539   tree ttype = target_type (type);
7540 #endif
7541
7542   /* If we haven't already layed out this declaration, do so now.
7543      Note that we must not call complete type for an external object
7544      because it's type might involve templates that we are not
7545      supposed to isntantiate yet.  (And it's perfectly legal to say
7546      `extern X x' for some incomplete type `X'.)  */
7547   if (!DECL_EXTERNAL (decl))
7548     complete_type (type);
7549   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7550     layout_decl (decl, 0);
7551
7552   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7553     {
7554       /* An automatic variable with an incomplete type: that is an error.
7555          Don't talk about array types here, since we took care of that
7556          message in grokdeclarator.  */
7557       cp_error ("storage size of `%D' isn't known", decl);
7558       TREE_TYPE (decl) = error_mark_node;
7559     }
7560 #if 0
7561   /* Keep this code around in case we later want to control debug info
7562      based on whether a type is "used".  (jason 1999-11-11) */
7563
7564   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7565     /* Let debugger know it should output info for this type.  */
7566     note_debug_info_needed (ttype);
7567
7568   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7569     note_debug_info_needed (DECL_CONTEXT (decl));
7570 #endif
7571
7572   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7573       && DECL_SIZE (decl) != NULL_TREE
7574       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7575     {
7576       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7577         constant_expression_warning (DECL_SIZE (decl));
7578       else
7579         cp_error ("storage size of `%D' isn't constant", decl);
7580     }
7581 }
7582
7583 /* If a local static variable is declared in an inline function, or if
7584    we have a weak definition, we must endeavor to create only one
7585    instance of the variable at link-time.  */
7586
7587 static void
7588 maybe_commonize_var (decl)
7589      tree decl;
7590 {
7591   /* Static data in a function with comdat linkage also has comdat
7592      linkage.  */
7593   if (TREE_STATIC (decl)
7594       /* Don't mess with __FUNCTION__.  */
7595       && ! DECL_ARTIFICIAL (decl)
7596       && current_function_decl
7597       && DECL_CONTEXT (decl) == current_function_decl
7598       && (DECL_THIS_INLINE (current_function_decl)
7599           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7600       && TREE_PUBLIC (current_function_decl))
7601     {
7602       /* Rather than try to get this right with inlining, we suppress
7603          inlining of such functions.  */
7604       current_function_cannot_inline
7605         = "function with static variable cannot be inline";
7606
7607       /* If flag_weak, we don't need to mess with this, as we can just
7608          make the function weak, and let it refer to its unique local
7609          copy.  This works because we don't allow the function to be
7610          inlined.  */
7611       if (! flag_weak)
7612         {
7613           if (DECL_INTERFACE_KNOWN (current_function_decl))
7614             {
7615               TREE_PUBLIC (decl) = 1;
7616               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7617             }
7618           else if (DECL_INITIAL (decl) == NULL_TREE
7619                    || DECL_INITIAL (decl) == error_mark_node)
7620             {
7621               TREE_PUBLIC (decl) = 1;
7622               DECL_COMMON (decl) = 1;
7623             }
7624           /* else we lose. We can only do this if we can use common,
7625              which we can't if it has been initialized.  */
7626
7627           if (TREE_PUBLIC (decl))
7628             DECL_ASSEMBLER_NAME (decl)
7629               = build_static_name (current_function_decl, DECL_NAME (decl));
7630           else
7631             {
7632               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7633               cp_warning_at ("  you can work around this by removing the initializer", decl);
7634             }
7635         }
7636     }
7637   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7638     /* Set it up again; we might have set DECL_INITIAL since the last
7639        time.  */
7640     comdat_linkage (decl);
7641 }
7642
7643 /* Issue an error message if DECL is an uninitialized const variable.  */
7644
7645 static void
7646 check_for_uninitialized_const_var (decl)
7647      tree decl;
7648 {
7649   tree type = TREE_TYPE (decl);
7650
7651   /* ``Unless explicitly declared extern, a const object does not have
7652      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7653      7.1.6 */
7654   if (TREE_CODE (decl) == VAR_DECL
7655       && TREE_CODE (type) != REFERENCE_TYPE
7656       && CP_TYPE_CONST_P (type)
7657       && !TYPE_NEEDS_CONSTRUCTING (type)
7658       && !DECL_INITIAL (decl))
7659     cp_error ("uninitialized const `%D'", decl);
7660 }
7661
7662 /* Verify INIT (the initializer for DECL), and record the
7663    initialization in DECL_INITIAL, if appropriate.  Returns a new
7664    value for INIT.  */
7665
7666 static tree
7667 check_initializer (decl, init)
7668      tree decl;
7669      tree init;
7670 {
7671   tree type;
7672
7673   if (TREE_CODE (decl) == FIELD_DECL)
7674     return init;
7675
7676   type = TREE_TYPE (decl);
7677
7678   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7679   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7680     init = NULL_TREE;
7681
7682   /* Check the initializer.  */
7683   if (init)
7684     {
7685       /* Things that are going to be initialized need to have complete
7686          type.  */
7687       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7688
7689       if (type == error_mark_node)
7690         /* We will have already complained.  */
7691         init = NULL_TREE;
7692       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7693         {
7694           cp_error ("variable-sized object `%D' may not be initialized", decl);
7695           init = NULL_TREE;
7696         }
7697       else if (TREE_CODE (type) == ARRAY_TYPE
7698                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7699         {
7700           cp_error ("elements of array `%#D' have incomplete type", decl);
7701           init = NULL_TREE;
7702         }
7703       else if (!COMPLETE_TYPE_P (type))
7704         {
7705           cp_error ("`%D' has incomplete type", decl);
7706           TREE_TYPE (decl) = error_mark_node;
7707           init = NULL_TREE;
7708         }
7709     }
7710
7711   if (TREE_CODE (decl) == CONST_DECL)
7712     {
7713       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7714
7715       DECL_INITIAL (decl) = init;
7716
7717       /* This will keep us from needing to worry about our obstacks.  */
7718       my_friendly_assert (init != NULL_TREE, 149);
7719       init = NULL_TREE;
7720     }
7721   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7722     {
7723       if (TREE_STATIC (decl))
7724         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7725       grok_reference_init (decl, type, init);
7726       init = NULL_TREE;
7727     }
7728   else if (init)
7729     {
7730       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7731         {
7732           if (TREE_CODE (type) == ARRAY_TYPE)
7733             init = digest_init (type, init, (tree *) 0);
7734           else if (TREE_CODE (init) == CONSTRUCTOR
7735                    && TREE_HAS_CONSTRUCTOR (init))
7736             {
7737               if (TYPE_NON_AGGREGATE_CLASS (type))
7738                 {
7739                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7740                             decl);
7741                   init = error_mark_node;
7742                 }
7743               else
7744                 goto dont_use_constructor;
7745             }
7746         }
7747       else
7748         {
7749         dont_use_constructor:
7750           if (TREE_CODE (init) != TREE_VEC)
7751             init = store_init_value (decl, init);
7752         }
7753
7754       if (init)
7755         /* We must hide the initializer so that expand_decl
7756            won't try to do something it does not understand.  */
7757         init = obscure_complex_init (decl, init);
7758     }
7759   else if (DECL_EXTERNAL (decl))
7760     ;
7761   else if (TYPE_P (type)
7762            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7763     {
7764       tree core_type = strip_array_types (type);
7765
7766       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7767         {
7768           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7769             cp_error ("structure `%D' with uninitialized const members", decl);
7770           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7771             cp_error ("structure `%D' with uninitialized reference members",
7772                       decl);
7773         }
7774
7775       check_for_uninitialized_const_var (decl);
7776
7777       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7778         init = obscure_complex_init (decl, NULL_TREE);
7779
7780     }
7781   else
7782     check_for_uninitialized_const_var (decl);
7783
7784   return init;
7785 }
7786
7787 /* If DECL is not a local variable, give it RTL.  */
7788
7789 static void
7790 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7791      tree decl;
7792      tree init;
7793      const char *asmspec;
7794 {
7795   int toplev = toplevel_bindings_p ();
7796   int defer_p;
7797
7798   /* Handle non-variables up front.  */
7799   if (TREE_CODE (decl) != VAR_DECL)
7800     {
7801       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7802       return;
7803     }
7804
7805   /* If we see a class member here, it should be a static data
7806      member.  */
7807   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7808     {
7809       my_friendly_assert (TREE_STATIC (decl), 19990828);
7810       /* An in-class declaration of a static data member should be
7811          external; it is only a declaration, and not a definition.  */
7812       if (init == NULL_TREE)
7813         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7814     }
7815
7816   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7817   if (asmspec)
7818     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7819
7820   /* We don't create any RTL for local variables.  */
7821   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7822     return;
7823
7824   /* We defer emission of local statics until the corresponding
7825      DECL_STMT is expanded.  */
7826   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7827
7828   /* We try to defer namespace-scope static constants so that they are
7829      not emitted into the object file unncessarily.  */
7830   if (!DECL_VIRTUAL_P (decl)
7831       && TREE_READONLY (decl)
7832       && DECL_INITIAL (decl) != NULL_TREE
7833       && DECL_INITIAL (decl) != error_mark_node
7834       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7835       && toplev
7836       && !TREE_PUBLIC (decl))
7837     {
7838       /* Fool with the linkage according to #pragma interface.  */
7839       if (!interface_unknown)
7840         {
7841           TREE_PUBLIC (decl) = 1;
7842           DECL_EXTERNAL (decl) = interface_only;
7843         }
7844
7845       defer_p = 1;
7846     }
7847
7848   /* If we're deferring the variable, just make RTL.  Do not actually
7849      emit the variable.  */
7850   if (defer_p)
7851     make_decl_rtl (decl, asmspec, toplev);
7852   /* If we're not deferring, go ahead and assemble the variable.  */
7853   else
7854     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7855 }
7856
7857 /* The old ARM scoping rules injected variables declared in the
7858    initialization statement of a for-statement into the surrounding
7859    scope.  We support this usage, in order to be backward-compatible.
7860    DECL is a just-declared VAR_DECL; if necessary inject its
7861    declaration into the surrounding scope.  */
7862
7863 void
7864 maybe_inject_for_scope_var (decl)
7865      tree decl;
7866 {
7867   if (!DECL_NAME (decl))
7868     return;
7869
7870   if (current_binding_level->is_for_scope)
7871     {
7872       struct binding_level *outer
7873         = current_binding_level->level_chain;
7874
7875       /* Check to see if the same name is already bound at the outer
7876          level, either because it was directly declared, or because a
7877          dead for-decl got preserved.  In either case, the code would
7878          not have been valid under the ARM scope rules, so clear
7879          is_for_scope for the current_binding_level.
7880
7881          Otherwise, we need to preserve the temp slot for decl to last
7882          into the outer binding level.  */
7883
7884       tree outer_binding
7885         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7886
7887       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7888           && (TREE_CODE (BINDING_VALUE (outer_binding))
7889               == VAR_DECL)
7890           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7891         {
7892           BINDING_VALUE (outer_binding)
7893             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7894           current_binding_level->is_for_scope = 0;
7895         }
7896       else if (DECL_IN_MEMORY_P (decl))
7897         preserve_temp_slots (DECL_RTL (decl));
7898     }
7899 }
7900
7901 /* Generate code to initialize DECL (a local variable).  */
7902
7903 void
7904 initialize_local_var (decl, init, flags)
7905      tree decl;
7906      tree init;
7907      int flags;
7908 {
7909   tree type = TREE_TYPE (decl);
7910
7911   /* If the type is bogus, don't bother initializing the variable.  */
7912   if (type == error_mark_node)
7913     return;
7914
7915   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7916     {
7917       /* If we used it already as memory, it must stay in memory.  */
7918       DECL_INITIAL (decl) = NULL_TREE;
7919       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7920     }
7921
7922   /* Local statics are handled differently from ordinary automatic
7923      variables.  */
7924   if (TREE_STATIC (decl))
7925     {
7926       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7927           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7928         expand_static_init (decl, init);
7929       return;
7930     }
7931
7932   if (DECL_SIZE (decl) && type != error_mark_node)
7933     {
7934       int already_used;
7935
7936       /* Compute and store the initial value.  */
7937       already_used = TREE_USED (decl) || TREE_USED (type);
7938
7939       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7940         {
7941           int saved_stmts_are_full_exprs_p;
7942
7943           emit_line_note (DECL_SOURCE_FILE (decl),
7944                           DECL_SOURCE_LINE (decl));
7945           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7946           current_stmt_tree->stmts_are_full_exprs_p = 1;
7947           if (building_stmt_tree ())
7948             finish_expr_stmt (build_aggr_init (decl, init, flags));
7949           else
7950             genrtl_expr_stmt (build_aggr_init (decl, init, flags));
7951           current_stmt_tree->stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7952         }
7953
7954       /* Set this to 0 so we can tell whether an aggregate which was
7955          initialized was ever used.  Don't do this if it has a
7956          destructor, so we don't complain about the 'resource
7957          allocation is initialization' idiom.  Now set
7958          attribute((unused)) on types so decls of that type will be
7959          marked used. (see TREE_USED, above.)  */
7960       if (TYPE_NEEDS_CONSTRUCTING (type)
7961           && ! already_used
7962           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7963           && DECL_NAME (decl))
7964         TREE_USED (decl) = 0;
7965       else if (already_used)
7966         TREE_USED (decl) = 1;
7967     }
7968 }
7969
7970 /* Generate code to destroy DECL (a local variable).  */
7971
7972 static void
7973 destroy_local_var (decl)
7974      tree decl;
7975 {
7976   tree type = TREE_TYPE (decl);
7977   tree cleanup;
7978
7979   /* Only variables get cleaned up.  */
7980   if (TREE_CODE (decl) != VAR_DECL)
7981     return;
7982
7983   /* And only things with destructors need cleaning up.  */
7984   if (type == error_mark_node
7985       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7986     return;
7987
7988   if (TREE_CODE (decl) == VAR_DECL &&
7989       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7990     /* We don't clean up things that aren't defined in this
7991        translation unit, or that need a static cleanup.  The latter
7992        are handled by finish_file.  */
7993     return;
7994
7995   /* Compute the cleanup.  */
7996   cleanup = maybe_build_cleanup (decl);
7997
7998   /* Record the cleanup required for this declaration.  */
7999   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
8000       && cleanup)
8001     finish_decl_cleanup (decl, cleanup);
8002 }
8003
8004 /* Finish processing of a declaration;
8005    install its line number and initial value.
8006    If the length of an array type is not known before,
8007    it must be determined now, from the initial value, or it is an error.
8008
8009    INIT holds the value of an initializer that should be allowed to escape
8010    the normal rules.
8011
8012    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8013    if the (init) syntax was used.  */
8014
8015 void
8016 cp_finish_decl (decl, init, asmspec_tree, flags)
8017      tree decl, init;
8018      tree asmspec_tree;
8019      int flags;
8020 {
8021   register tree type;
8022   tree ttype = NULL_TREE;
8023   const char *asmspec = NULL;
8024   int was_readonly = 0;
8025
8026   if (! decl)
8027     {
8028       if (init)
8029         error ("assignment (not initialization) in declaration");
8030       return;
8031     }
8032
8033   /* If a name was specified, get the string.  */
8034   if (asmspec_tree)
8035       asmspec = TREE_STRING_POINTER (asmspec_tree);
8036
8037   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8038     {
8039       cp_error ("cannot initialize `%D' to namespace `%D'",
8040                 decl, init);
8041       init = NULL_TREE;
8042     }
8043
8044   if (current_class_type
8045       && CP_DECL_CONTEXT (decl) == current_class_type
8046       && TYPE_BEING_DEFINED (current_class_type)
8047       && (DECL_INITIAL (decl) || init))
8048     DECL_DEFINED_IN_CLASS_P (decl) = 1;
8049
8050   if (TREE_CODE (decl) == VAR_DECL
8051       && DECL_CONTEXT (decl)
8052       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8053       && DECL_CONTEXT (decl) != current_namespace
8054       && init)
8055     {
8056       /* Leave the namespace of the object. */
8057       pop_decl_namespace ();
8058     }
8059
8060   type = TREE_TYPE (decl);
8061
8062   if (type == error_mark_node)
8063     return;
8064
8065   /* Add this declaration to the statement-tree.  */
8066   if (building_stmt_tree () && at_function_scope_p ())
8067     add_decl_stmt (decl);
8068
8069   if (TYPE_HAS_MUTABLE_P (type))
8070     TREE_READONLY (decl) = 0;
8071
8072   if (processing_template_decl)
8073     {
8074       if (init && DECL_INITIAL (decl))
8075         DECL_INITIAL (decl) = init;
8076       goto finish_end0;
8077     }
8078
8079   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8080   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8081
8082   /* Take care of TYPE_DECLs up front.  */
8083   if (TREE_CODE (decl) == TYPE_DECL)
8084     {
8085       if (init && DECL_INITIAL (decl))
8086         {
8087           /* typedef foo = bar; store the type of bar as the type of foo.  */
8088           TREE_TYPE (decl) = type = TREE_TYPE (init);
8089           DECL_INITIAL (decl) = init = NULL_TREE;
8090         }
8091       if (type != error_mark_node
8092           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8093         {
8094           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8095             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8096           set_identifier_type_value (DECL_NAME (decl), type);
8097           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8098         }
8099       GNU_xref_decl (current_function_decl, decl);
8100
8101       /* If we have installed this as the canonical typedef for this
8102          type, and that type has not been defined yet, delay emitting
8103          the debug information for it, as we will emit it later.  */
8104       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8105           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8106         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8107
8108       rest_of_decl_compilation (decl, NULL_PTR,
8109                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8110       goto finish_end;
8111     }
8112
8113   if (TREE_CODE (decl) != FUNCTION_DECL)
8114     ttype = target_type (type);
8115
8116   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8117       && TYPE_NEEDS_CONSTRUCTING (type))
8118     {
8119       /* Currently, GNU C++ puts constants in text space, making them
8120          impossible to initialize.  In the future, one would hope for
8121          an operating system which understood the difference between
8122          initialization and the running of a program.  */
8123       was_readonly = 1;
8124       TREE_READONLY (decl) = 0;
8125     }
8126
8127   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8128     {
8129       /* This must override the asm specifier which was placed by
8130          grokclassfn.  Lay this out fresh.  */
8131       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8132       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8133       make_decl_rtl (decl, asmspec, 0);
8134     }
8135
8136   /* Deduce size of array from initialization, if not already known.  */
8137   maybe_deduce_size_from_array_init (decl, init);
8138   init = check_initializer (decl, init);
8139
8140   GNU_xref_decl (current_function_decl, decl);
8141
8142   if (TREE_CODE (decl) == VAR_DECL)
8143     layout_var_decl (decl);
8144
8145   /* Output the assembler code and/or RTL code for variables and functions,
8146      unless the type is an undefined structure or union.
8147      If not, it will get done when the type is completed.  */
8148   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8149       || TREE_CODE (decl) == RESULT_DECL)
8150     {
8151       if (TREE_CODE (decl) == VAR_DECL)
8152         maybe_commonize_var (decl);
8153
8154       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8155
8156       if (TREE_CODE (type) == FUNCTION_TYPE
8157           || TREE_CODE (type) == METHOD_TYPE)
8158         abstract_virtuals_error (decl,
8159                                  strip_array_types (TREE_TYPE (type)));
8160       else
8161         abstract_virtuals_error (decl, strip_array_types (type));
8162
8163       if (TREE_CODE (decl) == FUNCTION_DECL)
8164         ;
8165       else if (DECL_EXTERNAL (decl)
8166                && ! (DECL_LANG_SPECIFIC (decl)
8167                      && DECL_NOT_REALLY_EXTERN (decl)))
8168         {
8169           if (init)
8170             DECL_INITIAL (decl) = init;
8171         }
8172       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8173         {
8174           /* This is a local declaration.  */
8175           if (doing_semantic_analysis_p ())
8176             maybe_inject_for_scope_var (decl);
8177           /* Initialize the local variable.  But, if we're building a
8178              statement-tree, we'll do the initialization when we
8179              expand the tree.  */
8180           if (processing_template_decl)
8181             {
8182               if (init || DECL_INITIAL (decl) == error_mark_node)
8183                 DECL_INITIAL (decl) = init;
8184             }
8185           else
8186             {
8187               /* If we're not building RTL, then we need to do so
8188                  now.  */
8189               if (!building_stmt_tree ())
8190                 emit_local_var (decl);
8191               /* Initialize the variable.  */
8192               initialize_local_var (decl, init, flags);
8193               /* Clean up the variable.  */
8194               destroy_local_var (decl);
8195             }
8196         }
8197       else if (TREE_STATIC (decl) && type != error_mark_node)
8198         {
8199           /* Cleanups for static variables are handled by `finish_file'.  */
8200           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8201               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8202             expand_static_init (decl, init);
8203         }
8204     finish_end0:
8205
8206       /* Undo call to `pushclass' that was done in `start_decl'
8207          due to initialization of qualified member variable.
8208          I.e., Foo::x = 10;  */
8209       {
8210         tree context = CP_DECL_CONTEXT (decl);
8211         if (context
8212             && TYPE_P (context)
8213             && (TREE_CODE (decl) == VAR_DECL
8214                 /* We also have a pushclass done that we need to undo here
8215                    if we're at top level and declare a method.  */
8216                 || TREE_CODE (decl) == FUNCTION_DECL)
8217             /* If size hasn't been set, we're still defining it,
8218                and therefore inside the class body; don't pop
8219                the binding level..  */
8220             && COMPLETE_TYPE_P (context)
8221             && context == current_class_type)
8222           pop_nested_class ();
8223       }
8224     }
8225
8226  finish_end:
8227
8228   if (was_readonly)
8229     TREE_READONLY (decl) = 1;
8230 }
8231
8232 /* This is here for a midend callback from c-common.c */
8233
8234 void
8235 finish_decl (decl, init, asmspec_tree)
8236      tree decl, init;
8237      tree asmspec_tree;
8238 {
8239   cp_finish_decl (decl, init, asmspec_tree, 0);
8240 }
8241
8242 /* Returns a declaration for a VAR_DECL as if:
8243
8244      extern "C" TYPE NAME;
8245
8246    had been seen.  Used to create compiler-generated global
8247    variables.  */
8248
8249 tree
8250 declare_global_var (name, type)
8251      tree name;
8252      tree type;
8253 {
8254   tree decl;
8255
8256   push_to_top_level ();
8257   decl = build_decl (VAR_DECL, name, type);
8258   TREE_PUBLIC (decl) = 1;
8259   DECL_EXTERNAL (decl) = 1;
8260   DECL_ARTIFICIAL (decl) = 1;
8261   pushdecl (decl);
8262   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8263   pop_from_top_level ();
8264
8265   return decl;
8266 }
8267
8268 /* Returns a pointer to the `atexit' function.  Note that if
8269    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8270    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8271
8272 static tree
8273 get_atexit_node ()
8274 {
8275   tree atexit_fndecl;
8276   tree arg_types;
8277   tree fn_type;
8278   tree fn_ptr_type;
8279   const char *name;
8280
8281   if (atexit_node)
8282     return atexit_node;
8283
8284   if (flag_use_cxa_atexit)
8285     {
8286       /* The declaration for `__cxa_atexit' is:
8287
8288            int __cxa_atexit (void (*)(void *), void *, void *)
8289
8290          We build up the argument types and then then function type
8291          itself.  */
8292
8293       /* First, build the pointer-to-function type for the first
8294          argument.  */
8295       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8296       fn_type = build_function_type (void_type_node, arg_types);
8297       fn_ptr_type = build_pointer_type (fn_type);
8298       /* Then, build the rest of the argument types.  */
8299       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8300       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8301       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8302       /* And the final __cxa_atexit type.  */
8303       fn_type = build_function_type (integer_type_node, arg_types);
8304       fn_ptr_type = build_pointer_type (fn_type);
8305       name = "__cxa_atexit";
8306     }
8307   else
8308     {
8309       /* The declaration for `atexit' is:
8310
8311            int atexit (void (*)());
8312
8313          We build up the argument types and then then function type
8314          itself.  */
8315       fn_type = build_function_type (void_type_node, void_list_node);
8316       fn_ptr_type = build_pointer_type (fn_type);
8317       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8318       /* Build the final atexit type.  */
8319       fn_type = build_function_type (integer_type_node, arg_types);
8320       name = "atexit";
8321     }
8322
8323   /* Now, build the function declaration.  */
8324   push_lang_context (lang_name_c);
8325   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8326   mark_used (atexit_fndecl);
8327   pop_lang_context ();
8328   atexit_node = default_conversion (atexit_fndecl);
8329
8330   return atexit_node;
8331 }
8332
8333 /* Returns the __dso_handle VAR_DECL.  */
8334
8335 static tree
8336 get_dso_handle_node ()
8337 {
8338   if (dso_handle_node)
8339     return dso_handle_node;
8340
8341   /* Declare the variable.  */
8342   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8343                                         ptr_type_node);
8344
8345   return dso_handle_node;
8346 }
8347
8348 /* Begin a new function with internal linkage whose job will be simply
8349    to destroy some particular variable.  */
8350
8351 static tree
8352 start_cleanup_fn ()
8353 {
8354   static int counter = 0;
8355   int old_interface_unknown = interface_unknown;
8356   char name[32];
8357   tree parmtypes;
8358   tree fntype;
8359   tree fndecl;
8360
8361   push_to_top_level ();
8362
8363   /* No need to mangle this.  */
8364   push_lang_context (lang_name_c);
8365
8366   interface_unknown = 1;
8367
8368   /* Build the parameter-types.  */
8369   parmtypes = void_list_node;
8370   /* Functions passed to __cxa_atexit take an additional parameter.
8371      We'll just ignore it.  After we implement the new calling
8372      convention for destructors, we can eliminate the use of
8373      additional cleanup functions entirely in the -fnew-abi case.  */
8374   if (flag_use_cxa_atexit)
8375     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8376   /* Build the function type itself.  */
8377   fntype = build_function_type (void_type_node, parmtypes);
8378   /* Build the name of the function.  */
8379   sprintf (name, "__tcf_%d", counter++);
8380   /* Build the function declaration.  */
8381   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8382   /* It's a function with internal linkage, generated by the
8383      compiler.  */
8384   TREE_PUBLIC (fndecl) = 0;
8385   DECL_ARTIFICIAL (fndecl) = 1;
8386   /* Make the function `inline' so that it is only emitted if it is
8387      actually needed.  It is unlikely that it will be inlined, since
8388      it is only called via a function pointer, but we avoid unncessary
8389      emissions this way.  */
8390   DECL_INLINE (fndecl) = 1;
8391   /* Build the parameter.  */
8392   if (flag_use_cxa_atexit)
8393     {
8394       tree parmdecl;
8395
8396       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8397       DECL_CONTEXT (parmdecl) = fndecl;
8398       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8399       TREE_USED (parmdecl) = 1;
8400       DECL_ARGUMENTS (fndecl) = parmdecl;
8401     }
8402
8403   pushdecl (fndecl);
8404   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8405   do_pushlevel ();
8406
8407   interface_unknown = old_interface_unknown;
8408
8409   pop_lang_context ();
8410
8411   return current_function_decl;
8412 }
8413
8414 /* Finish the cleanup function begun by start_cleanup_fn.  */
8415
8416 static void
8417 end_cleanup_fn ()
8418 {
8419   do_poplevel ();
8420
8421   expand_body (finish_function (0));
8422
8423   pop_from_top_level ();
8424 }
8425
8426 /* Generate code to handle the destruction of DECL, an object with
8427    static storage duration.  */
8428
8429 void
8430 register_dtor_fn (decl)
8431      tree decl;
8432 {
8433   tree cleanup;
8434   tree compound_stmt;
8435   tree args;
8436   tree fcall;
8437
8438   int saved_flag_access_control;
8439
8440   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8441     return;
8442
8443   /* Call build_cleanup before we enter the anonymous function so that
8444      any access checks will be done relative to the current scope,
8445      rather than the scope of the anonymous function.  */
8446   build_cleanup (decl);
8447
8448   /* Now start the function.  */
8449   cleanup = start_cleanup_fn ();
8450
8451   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8452      to the original function, rather than the anonymous one.  That
8453      will make the back-end think that nested functions are in use,
8454      which causes confusion.  */
8455   saved_flag_access_control = flag_access_control;
8456   flag_access_control = 0;
8457   fcall = build_cleanup (decl);
8458   flag_access_control = saved_flag_access_control;
8459
8460   /* Create the body of the anonymous function.  */
8461   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8462   finish_expr_stmt (fcall);
8463   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8464   end_cleanup_fn ();
8465
8466   /* Call atexit with the cleanup function.  */
8467   mark_addressable (cleanup);
8468   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8469   if (flag_use_cxa_atexit)
8470     {
8471       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8472       args = tree_cons (NULL_TREE, null_pointer_node, args);
8473       args = tree_cons (NULL_TREE, cleanup, args);
8474     }
8475   else
8476     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8477   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8478 }
8479
8480 void
8481 expand_static_init (decl, init)
8482      tree decl;
8483      tree init;
8484 {
8485   tree oldstatic = value_member (decl, static_aggregates);
8486
8487   if (oldstatic)
8488     {
8489       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8490         cp_error ("multiple initializations given for `%D'", decl);
8491     }
8492   else if (! toplevel_bindings_p ())
8493     {
8494       /* Emit code to perform this initialization but once.  */
8495       tree if_stmt;
8496       tree then_clause;
8497       tree assignment;
8498       tree guard;
8499       tree guard_init;
8500
8501       /* Emit code to perform this initialization but once.  This code
8502          looks like:
8503
8504            static int guard = 0;
8505            if (!guard) {
8506              // Do initialization.
8507              guard = 1;
8508              // Register variable for destruction at end of program.
8509            }
8510
8511          Note that the `temp' variable is only set to 1 *after* the
8512          initialization is complete.  This ensures that an exception,
8513          thrown during the construction, will cause the variable to
8514          reinitialized when we pass through this code again, as per:
8515
8516            [stmt.dcl]
8517
8518            If the initialization exits by throwing an exception, the
8519            initialization is not complete, so it will be tried again
8520            the next time control enters the declaration.
8521
8522          In theory, this process should be thread-safe, too; multiple
8523          threads should not be able to initialize the variable more
8524          than once.  We don't yet attempt to ensure thread-safety.  */
8525
8526       /* Create the guard variable.  */
8527       guard = get_guard (decl);
8528
8529       /* Begin the conditional initialization.  */
8530       if_stmt = begin_if_stmt ();
8531       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8532       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8533
8534       /* Do the initialization itself.  */
8535       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8536           || (init && TREE_CODE (init) == TREE_LIST))
8537         assignment = build_aggr_init (decl, init, 0);
8538       else if (init)
8539         /* The initialization we're doing here is just a bitwise
8540            copy.  */
8541         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8542       else
8543         assignment = NULL_TREE;
8544
8545       /* Once the assignment is complete, set TEMP to 1.  Since the
8546          construction of the static object is complete at this point,
8547          we want to make sure TEMP is set to 1 even if a temporary
8548          constructed during the initialization throws an exception
8549          when it is destroyed.  So, we combine the initialization and
8550          the assignment to TEMP into a single expression, ensuring
8551          that when we call finish_expr_stmt the cleanups will not be
8552          run until after TEMP is set to 1.  */
8553       guard_init = set_guard (guard);
8554       if (assignment)
8555         {
8556           assignment = tree_cons (NULL_TREE, assignment,
8557                                   build_tree_list (NULL_TREE,
8558                                                    guard_init));
8559           assignment = build_compound_expr (assignment);
8560         }
8561       else
8562         assignment = guard_init;
8563       finish_expr_stmt (assignment);
8564
8565       /* Use atexit to register a function for destroying this static
8566          variable.  */
8567       register_dtor_fn (decl);
8568
8569       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8570       finish_then_clause (if_stmt);
8571       finish_if_stmt ();
8572     }
8573   else
8574     static_aggregates = tree_cons (init, decl, static_aggregates);
8575 }
8576
8577 /* Finish the declaration of a catch-parameter.  */
8578
8579 tree
8580 start_handler_parms (declspecs, declarator)
8581      tree declspecs;
8582      tree declarator;
8583 {
8584   tree decl;
8585   if (declspecs)
8586     {
8587       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8588                              1, NULL_TREE);
8589       if (decl == NULL_TREE)
8590         error ("invalid catch parameter");
8591     }
8592   else
8593     decl = NULL_TREE;
8594
8595   return decl;
8596 }
8597
8598 \f
8599 /* Make TYPE a complete type based on INITIAL_VALUE.
8600    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8601    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8602
8603 int
8604 complete_array_type (type, initial_value, do_default)
8605      tree type, initial_value;
8606      int do_default;
8607 {
8608   register tree maxindex = NULL_TREE;
8609   int value = 0;
8610
8611   if (initial_value)
8612     {
8613       /* An array of character type can be initialized from a
8614          brace-enclosed string constant.  */
8615       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8616           && TREE_CODE (initial_value) == CONSTRUCTOR
8617           && CONSTRUCTOR_ELTS (initial_value)
8618           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8619               == STRING_CST)
8620           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8621         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8622
8623       /* Note MAXINDEX is really the maximum index, one less than the
8624          size.  */
8625       if (TREE_CODE (initial_value) == STRING_CST)
8626         {
8627           int eltsize
8628             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8629           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8630                                    / eltsize) - 1, 0);
8631         }
8632       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8633         {
8634           tree elts = CONSTRUCTOR_ELTS (initial_value);
8635
8636           maxindex = ssize_int (-1);
8637           for (; elts; elts = TREE_CHAIN (elts))
8638             {
8639               if (TREE_PURPOSE (elts))
8640                 maxindex = TREE_PURPOSE (elts);
8641               else
8642                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8643             }
8644           maxindex = copy_node (maxindex);
8645         }
8646       else
8647         {
8648           /* Make an error message unless that happened already.  */
8649           if (initial_value != error_mark_node)
8650             value = 1;
8651           else
8652             initial_value = NULL_TREE;
8653
8654           /* Prevent further error messages.  */
8655           maxindex = build_int_2 (0, 0);
8656         }
8657     }
8658
8659   if (!maxindex)
8660     {
8661       if (do_default)
8662         maxindex = build_int_2 (0, 0);
8663       value = 2;
8664     }
8665
8666   if (maxindex)
8667     {
8668       tree itype;
8669       tree domain;
8670
8671       domain = build_index_type (maxindex);
8672       TYPE_DOMAIN (type) = domain;
8673
8674       if (! TREE_TYPE (maxindex))
8675         TREE_TYPE (maxindex) = domain;
8676       if (initial_value)
8677         itype = TREE_TYPE (initial_value);
8678       else
8679         itype = NULL;
8680       if (itype && !TYPE_DOMAIN (itype))
8681         TYPE_DOMAIN (itype) = domain;
8682       /* The type of the main variant should never be used for arrays
8683          of different sizes.  It should only ever be completed with the
8684          size of the array.  */
8685       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8686         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8687     }
8688
8689   /* Lay out the type now that we can get the real answer.  */
8690
8691   layout_type (type);
8692
8693   return value;
8694 }
8695 \f
8696 /* Return zero if something is declared to be a member of type
8697    CTYPE when in the context of CUR_TYPE.  STRING is the error
8698    message to print in that case.  Otherwise, quietly return 1.  */
8699
8700 static int
8701 member_function_or_else (ctype, cur_type, flags)
8702      tree ctype, cur_type;
8703      enum overload_flags flags;
8704 {
8705   if (ctype && ctype != cur_type)
8706     {
8707       if (flags == DTOR_FLAG)
8708         error ("destructor for alien class `%s' cannot be a member",
8709                TYPE_NAME_STRING (ctype));
8710       else
8711         error ("constructor for alien class `%s' cannot be a member",
8712                TYPE_NAME_STRING (ctype));
8713       return 0;
8714     }
8715   return 1;
8716 }
8717 \f
8718 /* Subroutine of `grokdeclarator'.  */
8719
8720 /* Generate errors possibly applicable for a given set of specifiers.
8721    This is for ARM $7.1.2.  */
8722
8723 static void
8724 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8725      tree object;
8726      const char *type;
8727      int virtualp, quals, friendp, raises, inlinep;
8728 {
8729   if (virtualp)
8730     cp_error ("`%D' declared as a `virtual' %s", object, type);
8731   if (inlinep)
8732     cp_error ("`%D' declared as an `inline' %s", object, type);
8733   if (quals)
8734     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8735               object, type);
8736   if (friendp)
8737     cp_error_at ("`%D' declared as a friend", object);
8738   if (raises)
8739     cp_error_at ("`%D' declared with an exception specification", object);
8740 }
8741
8742 /* CTYPE is class type, or null if non-class.
8743    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8744    or METHOD_TYPE.
8745    DECLARATOR is the function's name.
8746    VIRTUALP is truthvalue of whether the function is virtual or not.
8747    FLAGS are to be passed through to `grokclassfn'.
8748    QUALS are qualifiers indicating whether the function is `const'
8749    or `volatile'.
8750    RAISES is a list of exceptions that this function can raise.
8751    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8752    not look, and -1 if we should not call `grokclassfn' at all.
8753
8754    Returns `NULL_TREE' if something goes wrong, after issuing
8755    applicable error messages.  */
8756
8757 static tree
8758 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8759             raises, check, friendp, publicp, inlinep, funcdef_flag,
8760             template_count, in_namespace)
8761      tree ctype, type;
8762      tree declarator;
8763      tree orig_declarator;
8764      int virtualp;
8765      enum overload_flags flags;
8766      tree quals, raises;
8767      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8768      tree in_namespace;
8769 {
8770   tree cname, decl;
8771   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8772   int has_default_arg = 0;
8773   tree t;
8774
8775   if (ctype)
8776     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8777       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8778   else
8779     cname = NULL_TREE;
8780
8781   if (raises)
8782     {
8783       type = build_exception_variant (type, raises);
8784     }
8785
8786   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8787   /* Propagate volatile out from type to decl. */
8788   if (TYPE_VOLATILE (type))
8789     TREE_THIS_VOLATILE (decl) = 1;
8790
8791   /* If this decl has namespace scope, set that up.  */
8792   if (in_namespace)
8793     set_decl_namespace (decl, in_namespace, friendp);
8794   else if (!ctype)
8795     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8796
8797   /* `main' and builtins have implicit 'C' linkage.  */
8798   if ((MAIN_NAME_P (declarator)
8799        || (IDENTIFIER_LENGTH (declarator) > 10
8800            && IDENTIFIER_POINTER (declarator)[0] == '_'
8801            && IDENTIFIER_POINTER (declarator)[1] == '_'
8802            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8803       && current_lang_name == lang_name_cplusplus
8804       && ctype == NULL_TREE
8805       /* NULL_TREE means global namespace.  */
8806       && DECL_CONTEXT (decl) == NULL_TREE)
8807     DECL_LANGUAGE (decl) = lang_c;
8808
8809   /* Should probably propagate const out from type to decl I bet (mrs).  */
8810   if (staticp)
8811     {
8812       DECL_STATIC_FUNCTION_P (decl) = 1;
8813       DECL_CONTEXT (decl) = ctype;
8814     }
8815
8816   if (ctype)
8817     DECL_CONTEXT (decl) = ctype;
8818
8819   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8820     {
8821       if (processing_template_decl)
8822         error ("cannot declare `::main' to be a template");
8823       if (inlinep)
8824         error ("cannot declare `::main' to be inline");
8825       else if (! publicp)
8826         error ("cannot declare `::main' to be static");
8827       inlinep = 0;
8828       publicp = 1;
8829     }
8830
8831   /* Members of anonymous types and local classes have no linkage; make
8832      them internal.  */
8833   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8834                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8835     publicp = 0;
8836
8837   if (publicp)
8838     {
8839       /* [basic.link]: A name with no linkage (notably, the name of a class
8840          or enumeration declared in a local scope) shall not be used to
8841          declare an entity with linkage.
8842
8843          Only check this for public decls for now.  */
8844       t = no_linkage_check (TREE_TYPE (decl));
8845       if (t)
8846         {
8847           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8848             {
8849               if (DECL_EXTERN_C_P (decl))
8850                 /* Allow this; it's pretty common in C.  */;
8851               else
8852                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8853                             decl);
8854             }
8855           else
8856             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8857                         decl, t);
8858         }
8859     }
8860
8861   TREE_PUBLIC (decl) = publicp;
8862   if (! publicp)
8863     {
8864       DECL_INTERFACE_KNOWN (decl) = 1;
8865       DECL_NOT_REALLY_EXTERN (decl) = 1;
8866     }
8867
8868   if (inlinep)
8869     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8870
8871   DECL_EXTERNAL (decl) = 1;
8872   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8873     {
8874       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8875                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8876       quals = NULL_TREE;
8877     }
8878
8879   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8880     grok_op_properties (decl, virtualp, check < 0);
8881
8882   if (ctype && decl_function_context (decl))
8883     DECL_NO_STATIC_CHAIN (decl) = 1;
8884
8885   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8886     if (TREE_PURPOSE (t)
8887         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8888       {
8889         has_default_arg = 1;
8890         break;
8891       }
8892
8893   if (friendp
8894       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8895     {
8896       if (funcdef_flag)
8897         cp_error
8898           ("defining explicit specialization `%D' in friend declaration",
8899            orig_declarator);
8900       else
8901         {
8902           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8903             {
8904               /* Something like `template <class T> friend void f<T>()'.  */
8905               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8906                         orig_declarator);
8907               return NULL_TREE;
8908             }
8909
8910
8911           /* A friend declaration of the form friend void f<>().  Record
8912              the information in the TEMPLATE_ID_EXPR.  */
8913           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8914           DECL_TEMPLATE_INFO (decl)
8915             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8916                          TREE_OPERAND (orig_declarator, 1),
8917                          NULL_TREE);
8918
8919           if (has_default_arg)
8920             {
8921               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8922                         decl);
8923               return NULL_TREE;
8924             }
8925
8926           if (inlinep)
8927             {
8928               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8929                         decl);
8930               return NULL_TREE;
8931             }
8932         }
8933     }
8934
8935   if (has_default_arg)
8936     add_defarg_fn (decl);
8937
8938   /* Plain overloading: will not be grok'd by grokclassfn.  */
8939   if (! ctype && ! processing_template_decl
8940       && !DECL_EXTERN_C_P (decl)
8941       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8942     set_mangled_name_for_decl (decl);
8943
8944   if (funcdef_flag)
8945     /* Make the init_value nonzero so pushdecl knows this is not
8946        tentative.  error_mark_node is replaced later with the BLOCK.  */
8947     DECL_INITIAL (decl) = error_mark_node;
8948
8949   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8950     TREE_NOTHROW (decl) = 1;
8951
8952   /* Caller will do the rest of this.  */
8953   if (check < 0)
8954     return decl;
8955
8956   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8957     DECL_CONSTRUCTOR_P (decl) = 1;
8958
8959   /* Function gets the ugly name, field gets the nice one.  This call
8960      may change the type of the function (because of default
8961      parameters)!  */
8962   if (ctype != NULL_TREE)
8963     grokclassfn (ctype, decl, flags, quals);
8964
8965   decl = check_explicit_specialization (orig_declarator, decl,
8966                                         template_count,
8967                                         2 * (funcdef_flag != 0) +
8968                                         4 * (friendp != 0));
8969   if (decl == error_mark_node)
8970     return NULL_TREE;
8971
8972   if (ctype != NULL_TREE
8973       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8974       && check)
8975     {
8976       tree old_decl;
8977
8978       old_decl = check_classfn (ctype, decl);
8979
8980       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
8981         /* Because grokfndecl is always supposed to return a
8982            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8983            here.  We depend on our callers to figure out that its
8984            really a template that's being returned.  */
8985         old_decl = DECL_TEMPLATE_RESULT (old_decl);
8986
8987       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
8988           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8989         {
8990           /* Remove the `this' parm added by grokclassfn.
8991              XXX Isn't this done in start_function, too?  */
8992           revert_static_member_fn (decl);
8993           last_function_parms = TREE_CHAIN (last_function_parms);
8994         }
8995       if (old_decl && DECL_ARTIFICIAL (old_decl))
8996         cp_error ("definition of implicitly-declared `%D'", old_decl);
8997
8998       if (old_decl)
8999         {
9000           /* Since we've smashed OLD_DECL to its
9001              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9002           if (TREE_CODE (decl) == TEMPLATE_DECL)
9003             decl = DECL_TEMPLATE_RESULT (decl);
9004
9005           /* Attempt to merge the declarations.  This can fail, in
9006              the case of some illegal specialization declarations.  */
9007           if (!duplicate_decls (decl, old_decl))
9008             cp_error ("no `%#D' member function declared in class `%T'",
9009                       decl, ctype);
9010           return old_decl;
9011         }
9012     }
9013
9014   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9015     return NULL_TREE;
9016
9017   if (ctype == NULL_TREE || check)
9018     return decl;
9019
9020   if (virtualp)
9021     {
9022       DECL_VIRTUAL_P (decl) = 1;
9023       if (DECL_VINDEX (decl) == NULL_TREE)
9024         DECL_VINDEX (decl) = error_mark_node;
9025       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
9026     }
9027
9028   return decl;
9029 }
9030
9031 static tree
9032 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9033      tree type;
9034      tree declarator;
9035      RID_BIT_TYPE *specbits_in;
9036      int initialized;
9037      int constp;
9038      tree in_namespace;
9039 {
9040   tree decl;
9041   RID_BIT_TYPE specbits;
9042
9043   specbits = *specbits_in;
9044
9045   if (TREE_CODE (type) == OFFSET_TYPE)
9046     {
9047       /* If you declare a static member so that it
9048          can be initialized, the code will reach here.  */
9049       tree basetype = TYPE_OFFSET_BASETYPE (type);
9050       type = TREE_TYPE (type);
9051       decl = build_lang_decl (VAR_DECL, declarator, type);
9052       DECL_CONTEXT (decl) = basetype;
9053       /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
9054          templates.  */
9055       if (!uses_template_parms (decl))
9056         {
9057           if (flag_new_abi)
9058             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9059           else
9060             DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype,
9061                                                             declarator);
9062         }
9063     }
9064   else
9065     {
9066       tree context;
9067
9068       if (in_namespace)
9069         context = in_namespace;
9070       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9071         context = current_namespace;
9072       else
9073         context = NULL_TREE;
9074
9075       if (processing_template_decl && context)
9076         /* For global variables, declared in a template, we need the
9077            full lang_decl.  */
9078         decl = build_lang_decl (VAR_DECL, declarator, type);
9079       else
9080         decl = build_decl (VAR_DECL, declarator, type);
9081
9082       if (context)
9083         set_decl_namespace (decl, context, 0);
9084
9085       context = DECL_CONTEXT (decl);
9086       if (declarator && context && current_lang_name != lang_name_c)
9087         {
9088           if (flag_new_abi)
9089             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9090           else
9091             DECL_ASSEMBLER_NAME (decl)
9092               = build_static_name (context, declarator);
9093         }
9094     }
9095
9096   if (in_namespace)
9097     set_decl_namespace (decl, in_namespace, 0);
9098
9099   if (RIDBIT_SETP (RID_EXTERN, specbits))
9100     {
9101       DECL_THIS_EXTERN (decl) = 1;
9102       DECL_EXTERNAL (decl) = !initialized;
9103     }
9104
9105   /* In class context, static means one per class,
9106      public access, and static storage.  */
9107   if (DECL_CLASS_SCOPE_P (decl))
9108     {
9109       TREE_PUBLIC (decl) = 1;
9110       TREE_STATIC (decl) = 1;
9111       DECL_EXTERNAL (decl) = 0;
9112     }
9113   /* At top level, either `static' or no s.c. makes a definition
9114      (perhaps tentative), and absence of `static' makes it public.  */
9115   else if (toplevel_bindings_p ())
9116     {
9117       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9118                             && (DECL_THIS_EXTERN (decl) || ! constp));
9119       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9120     }
9121   /* Not at top level, only `static' makes a static definition.  */
9122   else
9123     {
9124       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9125       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9126     }
9127
9128   if (TREE_PUBLIC (decl))
9129     {
9130       /* [basic.link]: A name with no linkage (notably, the name of a class
9131          or enumeration declared in a local scope) shall not be used to
9132          declare an entity with linkage.
9133
9134          Only check this for public decls for now.  */
9135       tree t = no_linkage_check (TREE_TYPE (decl));
9136       if (t)
9137         {
9138           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9139             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9140           else
9141             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9142                         decl, t);
9143         }
9144     }
9145
9146   return decl;
9147 }
9148
9149 /* Create and return a canonical pointer to member function type, for
9150    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9151
9152 tree
9153 build_ptrmemfunc_type (type)
9154      tree type;
9155 {
9156   tree fields[4];
9157   tree t;
9158   tree u;
9159   tree unqualified_variant = NULL_TREE;
9160
9161   /* If a canonical type already exists for this type, use it.  We use
9162      this method instead of type_hash_canon, because it only does a
9163      simple equality check on the list of field members.  */
9164
9165   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9166     return t;
9167
9168   /* Make sure that we always have the unqualified pointer-to-member
9169      type first.  */
9170   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9171     unqualified_variant
9172       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9173
9174   t = make_aggr_type (RECORD_TYPE);
9175   /* Let the front-end know this is a pointer to member function...  */
9176   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9177   /* ... and not really an aggregate.  */
9178   SET_IS_AGGR_TYPE (t, 0);
9179
9180   if (!flag_new_abi)
9181     {
9182       u = make_aggr_type (UNION_TYPE);
9183       SET_IS_AGGR_TYPE (u, 0);
9184       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9185       fields[1] = build_decl (FIELD_DECL, delta2_identifier,
9186                               delta_type_node);
9187       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9188       TYPE_NAME (u) = NULL_TREE;
9189
9190       fields[0] = build_decl (FIELD_DECL, delta_identifier,
9191                               delta_type_node);
9192       fields[1] = build_decl (FIELD_DECL, index_identifier,
9193                               delta_type_node);
9194       fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9195       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9196     }
9197   else
9198     {
9199       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9200       fields[1] = build_decl (FIELD_DECL, delta_identifier,
9201                               delta_type_node);
9202       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9203     }
9204
9205   /* Zap out the name so that the back-end will give us the debugging
9206      information for this anonymous RECORD_TYPE.  */
9207   TYPE_NAME (t) = NULL_TREE;
9208
9209   /* If this is not the unqualified form of this pointer-to-member
9210      type, set the TYPE_MAIN_VARIANT for this type to be the
9211      unqualified type.  Since they are actually RECORD_TYPEs that are
9212      not variants of each other, we must do this manually.  */
9213   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9214     {
9215       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9216       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9217       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9218       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9219     }
9220
9221   /* Cache this pointer-to-member type so that we can find it again
9222      later.  */
9223   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9224
9225   /* Seems to be wanted.  */
9226   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9227
9228   return t;
9229 }
9230
9231 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9232    Check to see that the definition is valid.  Issue appropriate error
9233    messages.  Return 1 if the definition is particularly bad, or 0
9234    otherwise.  */
9235
9236 int
9237 check_static_variable_definition (decl, type)
9238      tree decl;
9239      tree type;
9240 {
9241   /* Motion 10 at San Diego: If a static const integral data member is
9242      initialized with an integral constant expression, the initializer
9243      may appear either in the declaration (within the class), or in
9244      the definition, but not both.  If it appears in the class, the
9245      member is a member constant.  The file-scope definition is always
9246      required.  */
9247   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9248     {
9249       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9250                 type);
9251       /* If we just return the declaration, crashes will sometimes
9252          occur.  We therefore return void_type_node, as if this was a
9253          friend declaration, to cause callers to completely ignore
9254          this declaration.  */
9255       return 1;
9256     }
9257   else if (!CP_TYPE_CONST_P (type))
9258     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9259               decl);
9260   else if (pedantic && !INTEGRAL_TYPE_P (type))
9261     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9262
9263   return 0;
9264 }
9265
9266 /* Given the SIZE (i.e., number of elements) in an array, compute an
9267    appropriate index type for the array.  If non-NULL, NAME is the
9268    name of the thing being declared.  */
9269
9270 tree
9271 compute_array_index_type (name, size)
9272      tree name;
9273      tree size;
9274 {
9275   tree itype;
9276
9277   /* The size might be the result of a cast. */
9278   STRIP_TYPE_NOPS (size);
9279
9280   /* It might be a const variable or enumeration constant.  */
9281   size = decl_constant_value (size);
9282
9283   /* If this involves a template parameter, it will be a constant at
9284      instantiation time, but we don't know what the value is yet.
9285      Even if no template parameters are involved, we may an expression
9286      that is not a constant; we don't even simplify `1 + 2' when
9287      processing a template.  */
9288   if (processing_template_decl)
9289     {
9290       /* Resolve a qualified reference to an enumerator or static
9291          const data member of ours.  */
9292       if (TREE_CODE (size) == SCOPE_REF
9293           && TREE_OPERAND (size, 0) == current_class_type)
9294         {
9295           tree t = lookup_field (current_class_type,
9296                                  TREE_OPERAND (size, 1), 0, 0);
9297           if (t)
9298             size = t;
9299         }
9300
9301       return build_index_type (build_min (MINUS_EXPR, sizetype,
9302                                           size, integer_one_node));
9303     }
9304
9305   /* The array bound must be an integer type.  */
9306   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9307       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9308       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9309     {
9310       if (name)
9311         cp_error ("size of array `%D' has non-integer type", name);
9312       else
9313         cp_error ("size of array has non-integer type");
9314       size = integer_one_node;
9315     }
9316
9317   /* Normally, the array-bound will be a constant.  */
9318   if (TREE_CODE (size) == INTEGER_CST)
9319     {
9320       /* Check to see if the array bound overflowed.  Make that an
9321          error, no matter how generous we're being.  */
9322       int old_flag_pedantic_errors = flag_pedantic_errors;
9323       int old_pedantic = pedantic;
9324       pedantic = flag_pedantic_errors = 1;
9325       constant_expression_warning (size);
9326       pedantic = old_pedantic;
9327       flag_pedantic_errors = old_flag_pedantic_errors;
9328
9329       /* An array must have a positive number of elements.  */
9330       if (INT_CST_LT (size, integer_zero_node))
9331         {
9332           if (name)
9333             cp_error ("size of array `%D' is negative", name);
9334           else
9335             cp_error ("size of array is negative");
9336           size = integer_one_node;
9337         }
9338       /* Except that an extension we allow zero-sized arrays.  We
9339          always allow them in system headers because glibc uses
9340          them.  */
9341       else if (integer_zerop (size) && pedantic && !in_system_header)
9342         {
9343           if (name)
9344             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9345           else
9346             cp_pedwarn ("ISO C++ forbids zero-size array");
9347         }
9348     }
9349   else if (TREE_CONSTANT (size))
9350     {
9351       /* `(int) &fn' is not a valid array bound.  */
9352       if (name)
9353         cp_error ("size of array `%D' is not an integral constant-expression",
9354                   name);
9355       else
9356         cp_error ("size of array is not an integral constant-expression");
9357     }
9358
9359   /* Compute the index of the largest element in the array.  It is
9360      one less than the number of elements in the array.  */
9361   itype
9362     = fold (cp_build_binary_op (MINUS_EXPR,
9363                                 cp_convert (ssizetype, size),
9364                                 cp_convert (ssizetype,
9365                                             integer_one_node)));
9366
9367   /* Check for variable-sized arrays.  We allow such things as an
9368      extension, even though they are not allowed in ANSI/ISO C++.  */
9369   if (!TREE_CONSTANT (itype))
9370     {
9371       if (pedantic)
9372         {
9373           if (name)
9374             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9375                         name);
9376           else
9377             cp_pedwarn ("ISO C++ forbids variable-size array");
9378         }
9379
9380       /* Create a variable-sized array index type.  */
9381       itype = variable_size (itype);
9382     }
9383   /* Make sure that there was no overflow when creating to a signed
9384      index type.  (For example, on a 32-bit machine, an array with
9385      size 2^32 - 1 is too big.)  */
9386   else if (TREE_OVERFLOW (itype))
9387     {
9388       error ("overflow in array dimension");
9389       TREE_OVERFLOW (itype) = 0;
9390     }
9391
9392   /* Create and return the appropriate index type.  */
9393   return build_index_type (itype);
9394 }
9395
9396 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9397    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9398    with this type.  */
9399
9400 static tree
9401 create_array_type_for_decl (name, type, size)
9402      tree name;
9403      tree type;
9404      tree size;
9405 {
9406   tree itype = NULL_TREE;
9407   const char* error_msg;
9408
9409   /* If things have already gone awry, bail now.  */
9410   if (type == error_mark_node || size == error_mark_node)
9411     return error_mark_node;
9412
9413   /* Assume that everything will go OK.  */
9414   error_msg = NULL;
9415
9416   /* There are some types which cannot be array elements.  */
9417   switch (TREE_CODE (type))
9418     {
9419     case VOID_TYPE:
9420       error_msg = "array of void";
9421       break;
9422
9423     case FUNCTION_TYPE:
9424       error_msg = "array of functions";
9425       break;
9426
9427     case REFERENCE_TYPE:
9428       error_msg = "array of references";
9429       break;
9430
9431     case OFFSET_TYPE:
9432       error_msg = "array of data members";
9433       break;
9434
9435     case METHOD_TYPE:
9436       error_msg = "array of function members";
9437       break;
9438
9439     default:
9440       break;
9441     }
9442
9443   /* If something went wrong, issue an error-message and return.  */
9444   if (error_msg)
9445     {
9446       if (name)
9447         cp_error ("declaration of `%D' as %s", name, error_msg);
9448       else
9449         cp_error ("creating %s", error_msg);
9450
9451       return error_mark_node;
9452     }
9453
9454   /* [dcl.array]
9455
9456      The constant expressions that specify the bounds of the arrays
9457      can be omitted only for the first member of the sequence.  */
9458   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9459     {
9460       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9461                 name);
9462
9463       return error_mark_node;
9464     }
9465
9466   /* Figure out the index type for the array.  */
9467   if (size)
9468     itype = compute_array_index_type (name, size);
9469
9470   return build_cplus_array_type (type, itype);
9471 }
9472
9473 /* Check that it's OK to declare a function with the indicated TYPE.
9474    SFK indicates the kind of special function (if any) that this
9475    function is.  CTYPE is the class of which this function is a
9476    member.  OPTYPE is the type given in a conversion operator
9477    declaration.  Returns the actual return type of the function; that
9478    may be different than TYPE if an error occurs, or for certain
9479    special functions.  */
9480
9481 static tree
9482 check_special_function_return_type (sfk, type, ctype, optype)
9483      special_function_kind sfk;
9484      tree type;
9485      tree ctype;
9486      tree optype;
9487 {
9488   switch (sfk)
9489     {
9490     case sfk_constructor:
9491       if (type)
9492         cp_error ("return type specification for constructor invalid");
9493
9494       /* In the old ABI, we return `this'; in the new ABI we don't
9495          bother.  */
9496       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9497       break;
9498
9499     case sfk_destructor:
9500       if (type)
9501         cp_error ("return type specification for destructor invalid");
9502       type = void_type_node;
9503       break;
9504
9505     case sfk_conversion:
9506       if (type && !same_type_p (type, optype))
9507         cp_error ("operator `%T' declared to return `%T'", optype, type);
9508       else if (type)
9509         cp_pedwarn ("return type specified for `operator %T'",  optype);
9510       type = optype;
9511       break;
9512
9513     default:
9514       my_friendly_abort (20000408);
9515       break;
9516     }
9517
9518   return type;
9519 }
9520
9521 /* Given declspecs and a declarator,
9522    determine the name and type of the object declared
9523    and construct a ..._DECL node for it.
9524    (In one case we can return a ..._TYPE node instead.
9525     For invalid input we sometimes return 0.)
9526
9527    DECLSPECS is a chain of tree_list nodes whose value fields
9528     are the storage classes and type specifiers.
9529
9530    DECL_CONTEXT says which syntactic context this declaration is in:
9531      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9532      FUNCDEF for a function definition.  Like NORMAL but a few different
9533       error messages in each case.  Return value may be zero meaning
9534       this definition is too screwy to try to parse.
9535      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9536       handle member functions (which have FIELD context).
9537       Return value may be zero meaning this definition is too screwy to
9538       try to parse.
9539      PARM for a parameter declaration (either within a function prototype
9540       or before a function body).  Make a PARM_DECL, or return void_type_node.
9541      CATCHPARM for a parameter declaration before a catch clause.
9542      TYPENAME if for a typename (in a cast or sizeof).
9543       Don't make a DECL node; just return the ..._TYPE node.
9544      FIELD for a struct or union field; make a FIELD_DECL.
9545      BITFIELD for a field with specified width.
9546    INITIALIZED is 1 if the decl has an initializer.
9547
9548    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9549    normal attributes in TREE_PURPOSE, or NULL_TREE.
9550
9551    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9552    It may also be so in the PARM case, for a prototype where the
9553    argument type is specified but not the name.
9554
9555    This function is where the complicated C meanings of `static'
9556    and `extern' are interpreted.
9557
9558    For C++, if there is any monkey business to do, the function which
9559    calls this one must do it, i.e., prepending instance variables,
9560    renaming overloaded function names, etc.
9561
9562    Note that for this C++, it is an error to define a method within a class
9563    which does not belong to that class.
9564
9565    Except in the case where SCOPE_REFs are implicitly known (such as
9566    methods within a class being redundantly qualified),
9567    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9568    (class_name::decl_name).  The caller must also deal with this.
9569
9570    If a constructor or destructor is seen, and the context is FIELD,
9571    then the type gains the attribute TREE_HAS_x.  If such a declaration
9572    is erroneous, NULL_TREE is returned.
9573
9574    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9575    function, these are the qualifiers to give to the `this' pointer. We
9576    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9577
9578    May return void_type_node if the declarator turned out to be a friend.
9579    See grokfield for details.  */
9580
9581 tree
9582 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9583      tree declspecs;
9584      tree declarator;
9585      enum decl_context decl_context;
9586      int initialized;
9587      tree attrlist;
9588 {
9589   RID_BIT_TYPE specbits;
9590   int nclasses = 0;
9591   tree spec;
9592   tree type = NULL_TREE;
9593   int longlong = 0;
9594   int constp;
9595   int restrictp;
9596   int volatilep;
9597   int type_quals;
9598   int virtualp, explicitp, friendp, inlinep, staticp;
9599   int explicit_int = 0;
9600   int explicit_char = 0;
9601   int defaulted_int = 0;
9602   tree typedef_decl = NULL_TREE;
9603   const char *name;
9604   tree typedef_type = NULL_TREE;
9605   int funcdef_flag = 0;
9606   enum tree_code innermost_code = ERROR_MARK;
9607   int bitfield = 0;
9608 #if 0
9609   /* See the code below that used this.  */
9610   tree decl_machine_attr = NULL_TREE;
9611 #endif
9612   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9613      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9614   tree init = NULL_TREE;
9615
9616   /* Keep track of what sort of function is being processed
9617      so that we can warn about default return values, or explicit
9618      return values which do not match prescribed defaults.  */
9619   special_function_kind sfk = sfk_none;
9620
9621   tree dname = NULL_TREE;
9622   tree ctype = current_class_type;
9623   tree ctor_return_type = NULL_TREE;
9624   enum overload_flags flags = NO_SPECIAL;
9625   tree quals = NULL_TREE;
9626   tree raises = NULL_TREE;
9627   int template_count = 0;
9628   tree in_namespace = NULL_TREE;
9629   tree inner_attrs;
9630   int ignore_attrs;
9631
9632   RIDBIT_RESET_ALL (specbits);
9633   if (decl_context == FUNCDEF)
9634     funcdef_flag = 1, decl_context = NORMAL;
9635   else if (decl_context == MEMFUNCDEF)
9636     funcdef_flag = -1, decl_context = FIELD;
9637   else if (decl_context == BITFIELD)
9638     bitfield = 1, decl_context = FIELD;
9639
9640   /* Look inside a declarator for the name being declared
9641      and get it as a string, for an error message.  */
9642   {
9643     tree *next = &declarator;
9644     register tree decl;
9645     name = NULL;
9646
9647     while (next && *next)
9648       {
9649         decl = *next;
9650         switch (TREE_CODE (decl))
9651           {
9652           case TREE_LIST:
9653             /* For attributes.  */
9654             next = &TREE_VALUE (decl);
9655             break;
9656
9657           case COND_EXPR:
9658             ctype = NULL_TREE;
9659             next = &TREE_OPERAND (decl, 0);
9660             break;
9661
9662           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9663             {
9664               tree name = TREE_OPERAND (decl, 0);
9665               tree rename = NULL_TREE;
9666
9667               my_friendly_assert (flags == NO_SPECIAL, 152);
9668               flags = DTOR_FLAG;
9669               sfk = sfk_destructor;
9670               if (TREE_CODE (name) == TYPE_DECL)
9671                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9672               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9673               if (ctype == NULL_TREE)
9674                 {
9675                   if (current_class_type == NULL_TREE)
9676                     {
9677                       error ("destructors must be member functions");
9678                       flags = NO_SPECIAL;
9679                     }
9680                   else
9681                     {
9682                       tree t = constructor_name (current_class_name);
9683                       if (t != name)
9684                         rename = t;
9685                     }
9686                 }
9687               else
9688                 {
9689                   tree t = constructor_name (ctype);
9690                   if (t != name)
9691                     rename = t;
9692                 }
9693
9694               if (rename)
9695                 {
9696                   cp_error ("destructor `%T' must match class name `%T'",
9697                             name, rename);
9698                   TREE_OPERAND (decl, 0) = rename;
9699                 }
9700               next = &name;
9701             }
9702             break;
9703
9704           case ADDR_EXPR:       /* C++ reference declaration */
9705             /* Fall through. */
9706           case ARRAY_REF:
9707           case INDIRECT_REF:
9708             ctype = NULL_TREE;
9709             innermost_code = TREE_CODE (decl);
9710             next = &TREE_OPERAND (decl, 0);
9711             break;
9712
9713           case CALL_EXPR:
9714             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9715               {
9716                 /* This is actually a variable declaration using
9717                    constructor syntax.  We need to call start_decl and
9718                    cp_finish_decl so we can get the variable
9719                    initialized...  */
9720
9721                 tree attributes, prefix_attributes;
9722
9723                 *next = TREE_OPERAND (decl, 0);
9724                 init = CALL_DECLARATOR_PARMS (decl);
9725
9726                 if (attrlist)
9727                   {
9728                     attributes = TREE_PURPOSE (attrlist);
9729                     prefix_attributes = TREE_VALUE (attrlist);
9730                   }
9731                 else
9732                   {
9733                     attributes = NULL_TREE;
9734                     prefix_attributes = NULL_TREE;
9735                   }
9736
9737                 decl = start_decl (declarator, declspecs, 1,
9738                                    attributes, prefix_attributes);
9739                 decl_type_access_control (decl);
9740                 if (decl)
9741                   {
9742                     /* Look for __unused__ attribute */
9743                     if (TREE_USED (TREE_TYPE (decl)))
9744                       TREE_USED (decl) = 1;
9745                     finish_decl (decl, init, NULL_TREE);
9746                   }
9747                 else
9748                   cp_error ("invalid declarator");
9749                 return 0;
9750               }
9751             innermost_code = TREE_CODE (decl);
9752             if (decl_context == FIELD && ctype == NULL_TREE)
9753               ctype = current_class_type;
9754             if (ctype
9755                 && TREE_OPERAND (decl, 0)
9756                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9757                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9758                          == constructor_name_full (ctype))
9759                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9760                             == constructor_name (ctype)))))
9761               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9762             next = &TREE_OPERAND (decl, 0);
9763             decl = *next;
9764             if (ctype != NULL_TREE
9765                 && decl != NULL_TREE && flags != DTOR_FLAG
9766                 && decl == constructor_name (ctype))
9767               {
9768                 sfk = sfk_constructor;
9769                 ctor_return_type = ctype;
9770               }
9771             ctype = NULL_TREE;
9772             break;
9773
9774           case TEMPLATE_ID_EXPR:
9775               {
9776                 tree fns = TREE_OPERAND (decl, 0);
9777
9778                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9779                   fns = TREE_OPERAND (fns, 0);
9780
9781                 dname = fns;
9782                 if (TREE_CODE (dname) == COMPONENT_REF)
9783                   dname = TREE_OPERAND (dname, 1);
9784                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9785                   {
9786                     my_friendly_assert (is_overloaded_fn (dname),
9787                                         19990331);
9788                     dname = DECL_NAME (get_first_fn (dname));
9789                   }
9790               }
9791           /* Fall through. */
9792
9793           case IDENTIFIER_NODE:
9794             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9795               dname = decl;
9796
9797             next = 0;
9798
9799             if (is_rid (dname))
9800               {
9801                 cp_error ("declarator-id missing; using reserved word `%D'",
9802                           dname);
9803                 name = IDENTIFIER_POINTER (dname);
9804               }
9805             else if (!IDENTIFIER_TYPENAME_P (dname))
9806               name = IDENTIFIER_POINTER (dname);
9807             else
9808               {
9809                 my_friendly_assert (flags == NO_SPECIAL, 154);
9810                 flags = TYPENAME_FLAG;
9811                 ctor_return_type = TREE_TYPE (dname);
9812                 sfk = sfk_conversion;
9813                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9814                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9815                         == TYPE_DECL))
9816                   name = IDENTIFIER_POINTER (dname);
9817                 else
9818                   name = "<invalid operator>";
9819               }
9820             break;
9821
9822             /* C++ extension */
9823           case SCOPE_REF:
9824             {
9825               /* Perform error checking, and decide on a ctype.  */
9826               tree cname = TREE_OPERAND (decl, 0);
9827               if (cname == NULL_TREE)
9828                 ctype = NULL_TREE;
9829               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9830                 {
9831                   ctype = NULL_TREE;
9832                   in_namespace = TREE_OPERAND (decl, 0);
9833                   TREE_OPERAND (decl, 0) = NULL_TREE;
9834                 }
9835               else if (! is_aggr_type (cname, 1))
9836                 TREE_OPERAND (decl, 0) = NULL_TREE;
9837               /* Must test TREE_OPERAND (decl, 1), in case user gives
9838                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9839               else if (TREE_OPERAND (decl, 1)
9840                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9841                 ctype = cname;
9842               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9843                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9844                 {
9845                   cp_error ("`%T::%D' is not a valid declarator", cname,
9846                             TREE_OPERAND (decl, 1));
9847                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9848                             cname, TREE_OPERAND (decl, 1));
9849                   return void_type_node;
9850                 }
9851               else if (ctype == NULL_TREE)
9852                 ctype = cname;
9853               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9854                 TREE_OPERAND (decl, 0) = ctype;
9855               else
9856                 {
9857                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9858                     {
9859                       cp_error ("type `%T' is not derived from type `%T'",
9860                                 cname, ctype);
9861                       TREE_OPERAND (decl, 0) = NULL_TREE;
9862                     }
9863                   else
9864                     ctype = cname;
9865                 }
9866
9867               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9868                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9869                        == constructor_name_full (ctype))
9870                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9871                           == constructor_name (ctype))))
9872                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9873               next = &TREE_OPERAND (decl, 1);
9874               decl = *next;
9875               if (ctype)
9876                 {
9877                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9878                       && constructor_name (ctype) == decl)
9879                     {
9880                       sfk = sfk_constructor;
9881                       ctor_return_type = ctype;
9882                     }
9883                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9884                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9885                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9886                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9887                     {
9888                       sfk = sfk_destructor;
9889                       ctor_return_type = ctype;
9890                       flags = DTOR_FLAG;
9891                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9892                       next = &TREE_OPERAND (decl, 0);
9893                     }
9894                 }
9895             }
9896             break;
9897
9898           case ERROR_MARK:
9899             next = 0;
9900             break;
9901
9902           case TYPE_DECL:
9903             /* Parse error puts this typespec where
9904                a declarator should go.  */
9905             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9906             if (TREE_TYPE (decl) == current_class_type)
9907               cp_error ("  perhaps you want `%T' for a constructor",
9908                         current_class_name);
9909             dname = DECL_NAME (decl);
9910             name = IDENTIFIER_POINTER (dname);
9911
9912             /* Avoid giving two errors for this.  */
9913             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9914
9915             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9916             *next = dname;
9917             next = 0;
9918             break;
9919
9920           default:
9921             cp_compiler_error ("`%D' as declarator", decl);
9922             return 0; /* We used to do a 155 abort here.  */
9923           }
9924       }
9925   }
9926
9927   /* A function definition's declarator must have the form of
9928      a function declarator.  */
9929
9930   if (funcdef_flag && innermost_code != CALL_EXPR)
9931     return 0;
9932
9933   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9934       && innermost_code != CALL_EXPR
9935       && ! (ctype && declspecs == NULL_TREE))
9936     {
9937       cp_error ("declaration of `%D' as non-function", dname);
9938       return void_type_node;
9939     }
9940
9941   /* Anything declared one level down from the top level
9942      must be one of the parameters of a function
9943      (because the body is at least two levels down).  */
9944
9945   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9946      by not allowing C++ class definitions to specify their parameters
9947      with xdecls (must be spec.d in the parmlist).
9948
9949      Since we now wait to push a class scope until we are sure that
9950      we are in a legitimate method context, we must set oldcname
9951      explicitly (since current_class_name is not yet alive).
9952
9953      We also want to avoid calling this a PARM if it is in a namespace.  */
9954
9955   if (decl_context == NORMAL && !toplevel_bindings_p ())
9956     {
9957       struct binding_level *b = current_binding_level;
9958       current_binding_level = b->level_chain;
9959       if (current_binding_level != 0 && toplevel_bindings_p ())
9960         decl_context = PARM;
9961       current_binding_level = b;
9962     }
9963
9964   if (name == NULL)
9965     name = decl_context == PARM ? "parameter" : "type name";
9966
9967   /* Look through the decl specs and record which ones appear.
9968      Some typespecs are defined as built-in typenames.
9969      Others, the ones that are modifiers of other types,
9970      are represented by bits in SPECBITS: set the bits for
9971      the modifiers that appear.  Storage class keywords are also in SPECBITS.
9972
9973      If there is a typedef name or a type, store the type in TYPE.
9974      This includes builtin typedefs such as `int'.
9975
9976      Set EXPLICIT_INT if the type is `int' or `char' and did not
9977      come from a user typedef.
9978
9979      Set LONGLONG if `long' is mentioned twice.
9980
9981      For C++, constructors and destructors have their own fast treatment.  */
9982
9983   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9984     {
9985       register int i;
9986       register tree id;
9987
9988       /* Certain parse errors slip through.  For example,
9989          `int class;' is not caught by the parser. Try
9990          weakly to recover here.  */
9991       if (TREE_CODE (spec) != TREE_LIST)
9992         return 0;
9993
9994       id = TREE_VALUE (spec);
9995
9996       if (TREE_CODE (id) == IDENTIFIER_NODE)
9997         {
9998           if (id == ridpointers[(int) RID_INT]
9999               || id == ridpointers[(int) RID_CHAR]
10000               || id == ridpointers[(int) RID_BOOL]
10001               || id == ridpointers[(int) RID_WCHAR])
10002             {
10003               if (type)
10004                 {
10005                   if (id == ridpointers[(int) RID_BOOL])
10006                     error ("`bool' is now a keyword");
10007                   else
10008                     cp_error ("extraneous `%T' ignored", id);
10009                 }
10010               else
10011                 {
10012                   if (id == ridpointers[(int) RID_INT])
10013                     explicit_int = 1;
10014                   else if (id == ridpointers[(int) RID_CHAR])
10015                     explicit_char = 1;
10016                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10017                 }
10018               goto found;
10019             }
10020           /* C++ aggregate types.  */
10021           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10022             {
10023               if (type)
10024                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10025               else
10026                 type = IDENTIFIER_TYPE_VALUE (id);
10027               goto found;
10028             }
10029
10030           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10031             {
10032               if (ridpointers[i] == id)
10033                 {
10034                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10035                     {
10036                       if (pedantic && ! in_system_header && warn_long_long)
10037                         pedwarn ("ISO C++ does not support `long long'");
10038                       if (longlong)
10039                         error ("`long long long' is too long for GCC");
10040                       else
10041                         longlong = 1;
10042                     }
10043                   else if (RIDBIT_SETP (i, specbits))
10044                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10045                   RIDBIT_SET (i, specbits);
10046                   goto found;
10047                 }
10048             }
10049         }
10050       /* C++ aggregate types.  */
10051       else if (TREE_CODE (id) == TYPE_DECL)
10052         {
10053           if (type)
10054             cp_error ("multiple declarations `%T' and `%T'", type,
10055                       TREE_TYPE (id));
10056           else
10057             {
10058               type = TREE_TYPE (id);
10059               TREE_VALUE (spec) = type;
10060             }
10061           goto found;
10062         }
10063       if (type)
10064         error ("two or more data types in declaration of `%s'", name);
10065       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10066         {
10067           register tree t = lookup_name (id, 1);
10068           if (!t || TREE_CODE (t) != TYPE_DECL)
10069             error ("`%s' fails to be a typedef or built in type",
10070                    IDENTIFIER_POINTER (id));
10071           else
10072             {
10073               type = TREE_TYPE (t);
10074 #if 0
10075               /* See the code below that used this.  */
10076               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10077 #endif
10078               typedef_decl = t;
10079             }
10080         }
10081       else if (id != error_mark_node)
10082         /* Can't change CLASS nodes into RECORD nodes here!  */
10083         type = id;
10084
10085     found: ;
10086     }
10087
10088   typedef_type = type;
10089
10090   /* No type at all: default to `int', and set DEFAULTED_INT
10091      because it was not a user-defined typedef.  */
10092
10093   if (type == NULL_TREE
10094       && (RIDBIT_SETP (RID_SIGNED, specbits)
10095           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10096           || RIDBIT_SETP (RID_LONG, specbits)
10097           || RIDBIT_SETP (RID_SHORT, specbits)))
10098     {
10099       /* These imply 'int'.  */
10100       type = integer_type_node;
10101       defaulted_int = 1;
10102     }
10103
10104   if (sfk != sfk_none)
10105     type = check_special_function_return_type (sfk, type,
10106                                                ctor_return_type,
10107                                                ctor_return_type);
10108   else if (type == NULL_TREE)
10109     {
10110       int is_main;
10111
10112       explicit_int = -1;
10113
10114           /* We handle `main' specially here, because 'main () { }' is so
10115              common.  With no options, it is allowed.  With -Wreturn-type,
10116              it is a warning.  It is only an error with -pedantic-errors.  */
10117       is_main = (funcdef_flag
10118                  && MAIN_NAME_P (dname)
10119                  && ctype == NULL_TREE
10120                  && in_namespace == NULL_TREE
10121                  && current_namespace == global_namespace);
10122
10123       if (in_system_header || flag_ms_extensions)
10124         /* Allow it, sigh.  */;
10125       else if (pedantic || ! is_main)
10126         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10127                     name);
10128       else if (warn_return_type)
10129         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10130                     name);
10131
10132       type = integer_type_node;
10133     }
10134
10135   ctype = NULL_TREE;
10136
10137   /* Now process the modifiers that were specified
10138      and check for invalid combinations.  */
10139
10140   /* Long double is a special combination.  */
10141
10142   if (RIDBIT_SETP (RID_LONG, specbits)
10143       && TYPE_MAIN_VARIANT (type) == double_type_node)
10144     {
10145       RIDBIT_RESET (RID_LONG, specbits);
10146       type = build_qualified_type (long_double_type_node,
10147                                    CP_TYPE_QUALS (type));
10148     }
10149
10150   /* Check all other uses of type modifiers.  */
10151
10152   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10153       || RIDBIT_SETP (RID_SIGNED, specbits)
10154       || RIDBIT_SETP (RID_LONG, specbits)
10155       || RIDBIT_SETP (RID_SHORT, specbits))
10156     {
10157       int ok = 0;
10158
10159       if (TREE_CODE (type) == REAL_TYPE)
10160         error ("short, signed or unsigned invalid for `%s'", name);
10161       else if (TREE_CODE (type) != INTEGER_TYPE)
10162         error ("long, short, signed or unsigned invalid for `%s'", name);
10163       else if (RIDBIT_SETP (RID_LONG, specbits)
10164                && RIDBIT_SETP (RID_SHORT, specbits))
10165         error ("long and short specified together for `%s'", name);
10166       else if ((RIDBIT_SETP (RID_LONG, specbits)
10167                 || RIDBIT_SETP (RID_SHORT, specbits))
10168                && explicit_char)
10169         error ("long or short specified with char for `%s'", name);
10170       else if ((RIDBIT_SETP (RID_LONG, specbits)
10171                 || RIDBIT_SETP (RID_SHORT, specbits))
10172                && TREE_CODE (type) == REAL_TYPE)
10173         error ("long or short specified with floating type for `%s'", name);
10174       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10175                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10176         error ("signed and unsigned given together for `%s'", name);
10177       else
10178         {
10179           ok = 1;
10180           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10181             {
10182               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10183                        name);
10184               if (flag_pedantic_errors)
10185                 ok = 0;
10186             }
10187         }
10188
10189       /* Discard the type modifiers if they are invalid.  */
10190       if (! ok)
10191         {
10192           RIDBIT_RESET (RID_UNSIGNED, specbits);
10193           RIDBIT_RESET (RID_SIGNED, specbits);
10194           RIDBIT_RESET (RID_LONG, specbits);
10195           RIDBIT_RESET (RID_SHORT, specbits);
10196           longlong = 0;
10197         }
10198     }
10199
10200   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10201       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10202     {
10203       error ("complex invalid for `%s'", name);
10204       RIDBIT_RESET (RID_COMPLEX, specbits);
10205     }
10206
10207   /* Decide whether an integer type is signed or not.
10208      Optionally treat bitfields as signed by default.  */
10209   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10210       /* [class.bit]
10211
10212          It is implementation-defined whether a plain (neither
10213          explicitly signed or unsigned) char, short, int, or long
10214          bit-field is signed or unsigned.
10215
10216          Naturally, we extend this to long long as well.  Note that
10217          this does not include wchar_t.  */
10218       || (bitfield && !flag_signed_bitfields
10219           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10220           /* A typedef for plain `int' without `signed' can be
10221              controlled just like plain `int', but a typedef for
10222              `signed int' cannot be so controlled.  */
10223           && !(typedef_decl
10224                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10225           && (TREE_CODE (type) == INTEGER_TYPE
10226               || TREE_CODE (type) == CHAR_TYPE)
10227           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10228     {
10229       if (longlong)
10230         type = long_long_unsigned_type_node;
10231       else if (RIDBIT_SETP (RID_LONG, specbits))
10232         type = long_unsigned_type_node;
10233       else if (RIDBIT_SETP (RID_SHORT, specbits))
10234         type = short_unsigned_type_node;
10235       else if (type == char_type_node)
10236         type = unsigned_char_type_node;
10237       else if (typedef_decl)
10238         type = unsigned_type (type);
10239       else
10240         type = unsigned_type_node;
10241     }
10242   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10243            && type == char_type_node)
10244     type = signed_char_type_node;
10245   else if (longlong)
10246     type = long_long_integer_type_node;
10247   else if (RIDBIT_SETP (RID_LONG, specbits))
10248     type = long_integer_type_node;
10249   else if (RIDBIT_SETP (RID_SHORT, specbits))
10250     type = short_integer_type_node;
10251
10252   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10253     {
10254       /* If we just have "complex", it is equivalent to
10255          "complex double", but if any modifiers at all are specified it is
10256          the complex form of TYPE.  E.g, "complex short" is
10257          "complex short int".  */
10258
10259       if (defaulted_int && ! longlong
10260           && ! (RIDBIT_SETP (RID_LONG, specbits)
10261                 || RIDBIT_SETP (RID_SHORT, specbits)
10262                 || RIDBIT_SETP (RID_SIGNED, specbits)
10263                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10264         type = complex_double_type_node;
10265       else if (type == integer_type_node)
10266         type = complex_integer_type_node;
10267       else if (type == float_type_node)
10268         type = complex_float_type_node;
10269       else if (type == double_type_node)
10270         type = complex_double_type_node;
10271       else if (type == long_double_type_node)
10272         type = complex_long_double_type_node;
10273       else
10274         type = build_complex_type (type);
10275     }
10276
10277   if (sfk == sfk_conversion
10278       && (RIDBIT_SETP (RID_CONST, specbits)
10279           || RIDBIT_SETP (RID_VOLATILE, specbits)
10280           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10281     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10282               ctor_return_type);
10283
10284   /* Set CONSTP if this declaration is `const', whether by
10285      explicit specification or via a typedef.
10286      Likewise for VOLATILEP.  */
10287
10288   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10289   restrictp =
10290     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10291   volatilep =
10292     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10293   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10294                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10295                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10296   type = cp_build_qualified_type (type, type_quals);
10297   staticp = 0;
10298   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10299   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10300   RIDBIT_RESET (RID_VIRTUAL, specbits);
10301   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10302   RIDBIT_RESET (RID_EXPLICIT, specbits);
10303
10304   if (RIDBIT_SETP (RID_STATIC, specbits))
10305     staticp = 1 + (decl_context == FIELD);
10306
10307   if (virtualp && staticp == 2)
10308     {
10309       cp_error ("member `%D' cannot be declared both virtual and static",
10310                 dname);
10311       staticp = 0;
10312     }
10313   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10314   RIDBIT_RESET (RID_FRIEND, specbits);
10315
10316   /* Warn if two storage classes are given. Default to `auto'.  */
10317
10318   if (RIDBIT_ANY_SET (specbits))
10319     {
10320       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10321       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10322       if (decl_context == PARM && nclasses > 0)
10323         error ("storage class specifiers invalid in parameter declarations");
10324       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10325         {
10326           if (decl_context == PARM)
10327             error ("typedef declaration invalid in parameter declaration");
10328           nclasses++;
10329         }
10330       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10331       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10332     }
10333
10334   /* Give error if `virtual' is used outside of class declaration.  */
10335   if (virtualp
10336       && (current_class_name == NULL_TREE || decl_context != FIELD))
10337     {
10338       error ("virtual outside class declaration");
10339       virtualp = 0;
10340     }
10341
10342   /* Static anonymous unions are dealt with here.  */
10343   if (staticp && decl_context == TYPENAME
10344       && TREE_CODE (declspecs) == TREE_LIST
10345       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10346     decl_context = FIELD;
10347
10348   /* Warn about storage classes that are invalid for certain
10349      kinds of declarations (parameters, typenames, etc.).  */
10350
10351   if (nclasses > 1)
10352     error ("multiple storage classes in declaration of `%s'", name);
10353   else if (decl_context != NORMAL && nclasses > 0)
10354     {
10355       if ((decl_context == PARM || decl_context == CATCHPARM)
10356           && (RIDBIT_SETP (RID_REGISTER, specbits)
10357               || RIDBIT_SETP (RID_AUTO, specbits)))
10358         ;
10359       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10360         ;
10361       else if (decl_context == FIELD
10362                /* C++ allows static class elements  */
10363                && RIDBIT_SETP (RID_STATIC, specbits))
10364         /* C++ also allows inlines and signed and unsigned elements,
10365            but in those cases we don't come in here.  */
10366         ;
10367       else
10368         {
10369           if (decl_context == FIELD)
10370             {
10371               tree tmp = NULL_TREE;
10372               register int op = 0;
10373
10374               if (declarator)
10375                 {
10376                   /* Avoid trying to get an operand off an identifier node.  */
10377                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10378                     tmp = declarator;
10379                   else
10380                     tmp = TREE_OPERAND (declarator, 0);
10381                   op = IDENTIFIER_OPNAME_P (tmp);
10382                   if (IDENTIFIER_TYPENAME_P (tmp))
10383                     {
10384                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10385                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10386                               == TYPE_DECL))
10387                         name = IDENTIFIER_POINTER (tmp);
10388                       else
10389                         name = "<invalid operator>";
10390                     }
10391                 }
10392               error ("storage class specified for %s `%s'",
10393                      op ? "member operator" : "field",
10394                      name);
10395             }
10396           else
10397             {
10398               if (decl_context == PARM || decl_context == CATCHPARM)
10399                 error ("storage class specified for parameter `%s'", name);
10400               else
10401                 error ("storage class specified for typename");
10402             }
10403           RIDBIT_RESET (RID_REGISTER, specbits);
10404           RIDBIT_RESET (RID_AUTO, specbits);
10405           RIDBIT_RESET (RID_EXTERN, specbits);
10406         }
10407     }
10408   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10409     {
10410       if (toplevel_bindings_p ())
10411         {
10412           /* It's common practice (and completely valid) to have a const
10413              be initialized and declared extern.  */
10414           if (!(type_quals & TYPE_QUAL_CONST))
10415             warning ("`%s' initialized and declared `extern'", name);
10416         }
10417       else
10418         error ("`%s' has both `extern' and initializer", name);
10419     }
10420   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10421            && ! toplevel_bindings_p ())
10422     error ("nested function `%s' declared `extern'", name);
10423   else if (toplevel_bindings_p ())
10424     {
10425       if (RIDBIT_SETP (RID_AUTO, specbits))
10426         error ("top-level declaration of `%s' specifies `auto'", name);
10427     }
10428
10429   if (nclasses > 0 && friendp)
10430     error ("storage class specifiers invalid in friend function declarations");
10431
10432   /* Now figure out the structure of the declarator proper.
10433      Descend through it, creating more complex types, until we reach
10434      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10435
10436   inner_attrs = NULL_TREE;
10437   ignore_attrs = 0;
10438
10439   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10440          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10441     {
10442       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10443          an INDIRECT_REF (for *...),
10444          a CALL_EXPR (for ...(...)),
10445          an identifier (for the name being declared)
10446          or a null pointer (for the place in an absolute declarator
10447          where the name was omitted).
10448          For the last two cases, we have just exited the loop.
10449
10450          For C++ it could also be
10451          a SCOPE_REF (for class :: ...).  In this case, we have converted
10452          sensible names to types, and those are the values we use to
10453          qualify the member name.
10454          an ADDR_EXPR (for &...),
10455          a BIT_NOT_EXPR (for destructors)
10456
10457          At this point, TYPE is the type of elements of an array,
10458          or for a function to return, or for a pointer to point to.
10459          After this sequence of ifs, TYPE is the type of the
10460          array or function or pointer, and DECLARATOR has had its
10461          outermost layer removed.  */
10462
10463       if (type == error_mark_node)
10464         {
10465           if (TREE_CODE (declarator) == SCOPE_REF)
10466             declarator = TREE_OPERAND (declarator, 1);
10467           else
10468             declarator = TREE_OPERAND (declarator, 0);
10469           continue;
10470         }
10471       if (quals != NULL_TREE
10472           && (declarator == NULL_TREE
10473               || TREE_CODE (declarator) != SCOPE_REF))
10474         {
10475           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10476             ctype = TYPE_METHOD_BASETYPE (type);
10477           if (ctype != NULL_TREE)
10478             {
10479               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10480               grok_method_quals (ctype, dummy, quals);
10481               type = TREE_TYPE (dummy);
10482               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10483               quals = NULL_TREE;
10484             }
10485         }
10486
10487       /* See the comment for the TREE_LIST case, below.  */
10488       if (ignore_attrs)
10489         ignore_attrs = 0;
10490       else if (inner_attrs)
10491         {
10492           decl_attributes (type, inner_attrs, NULL_TREE);
10493           inner_attrs = NULL_TREE;
10494         }
10495
10496       switch (TREE_CODE (declarator))
10497         {
10498         case TREE_LIST:
10499           {
10500             /* We encode a declarator with embedded attributes using
10501                a TREE_LIST.  The attributes apply to the declarator
10502                directly inside them, so we have to skip an iteration
10503                before applying them to the type.  If the declarator just
10504                inside is the declarator-id, we apply the attrs to the
10505                decl itself.  */
10506             inner_attrs = TREE_PURPOSE (declarator);
10507             ignore_attrs = 1;
10508             declarator = TREE_VALUE (declarator);
10509           }
10510           break;
10511
10512         case ARRAY_REF:
10513           {
10514             register tree size;
10515
10516             size = TREE_OPERAND (declarator, 1);
10517
10518             /* VC++ spells a zero-sized array with [].  */
10519             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10520                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10521               size = integer_zero_node;
10522
10523             declarator = TREE_OPERAND (declarator, 0);
10524
10525             type = create_array_type_for_decl (dname, type, size);
10526
10527             /* VLAs never work as fields. */
10528             if (decl_context == FIELD && !processing_template_decl
10529                 && TREE_CODE (type) == ARRAY_TYPE
10530                 && TYPE_DOMAIN (type) != NULL_TREE
10531                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10532               {
10533                 cp_error ("size of member `%D' is not constant", dname);
10534                 /* Proceed with arbitrary constant size, so that offset
10535                    computations don't get confused. */
10536                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10537                                                    integer_one_node);
10538               }
10539
10540             ctype = NULL_TREE;
10541           }
10542           break;
10543
10544         case CALL_EXPR:
10545           {
10546             tree arg_types;
10547             int funcdecl_p;
10548             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10549             tree inner_decl = TREE_OPERAND (declarator, 0);
10550
10551             /* Declaring a function type.
10552                Make sure we have a valid type for the function to return.  */
10553
10554             /* We now know that the TYPE_QUALS don't apply to the
10555                decl, but to its return type.  */
10556             type_quals = TYPE_UNQUALIFIED;
10557
10558             /* Warn about some types functions can't return.  */
10559
10560             if (TREE_CODE (type) == FUNCTION_TYPE)
10561               {
10562                 error ("`%s' declared as function returning a function", name);
10563                 type = integer_type_node;
10564               }
10565             if (TREE_CODE (type) == ARRAY_TYPE)
10566               {
10567                 error ("`%s' declared as function returning an array", name);
10568                 type = integer_type_node;
10569               }
10570
10571             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10572               inner_decl = TREE_OPERAND (inner_decl, 1);
10573
10574             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10575               inner_decl = dname;
10576
10577             /* Pick up type qualifiers which should be applied to `this'.  */
10578             quals = CALL_DECLARATOR_QUALS (declarator);
10579
10580             /* Pick up the exception specifications.  */
10581             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10582
10583             /* Say it's a definition only for the CALL_EXPR
10584                closest to the identifier.  */
10585             funcdecl_p
10586               = inner_decl
10587               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10588                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10589                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10590
10591             if (ctype == NULL_TREE
10592                 && decl_context == FIELD
10593                 && funcdecl_p
10594                 && (friendp == 0 || dname == current_class_name))
10595               ctype = current_class_type;
10596
10597             if (ctype && sfk == sfk_conversion)
10598               TYPE_HAS_CONVERSION (ctype) = 1;
10599             if (ctype && constructor_name (ctype) == dname)
10600               {
10601                 /* We are within a class's scope. If our declarator name
10602                    is the same as the class name, and we are defining
10603                    a function, then it is a constructor/destructor, and
10604                    therefore returns a void type.  */
10605
10606                 if (flags == DTOR_FLAG)
10607                   {
10608                     /* ISO C++ 12.4/2.  A destructor may not be
10609                        declared const or volatile.  A destructor may
10610                        not be static.  */
10611                     if (staticp == 2)
10612                       error ("destructor cannot be static member function");
10613                     if (quals)
10614                       {
10615                         cp_error ("destructors may not be `%s'",
10616                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10617                         quals = NULL_TREE;
10618                       }
10619                     if (decl_context == FIELD)
10620                       {
10621                         if (! member_function_or_else (ctype,
10622                                                        current_class_type,
10623                                                        flags))
10624                           return void_type_node;
10625                       }
10626                   }
10627                 else            /* It's a constructor.  */
10628                   {
10629                     if (explicitp == 1)
10630                       explicitp = 2;
10631                     /* ISO C++ 12.1.  A constructor may not be
10632                        declared const or volatile.  A constructor may
10633                        not be virtual.  A constructor may not be
10634                        static.  */
10635                     if (staticp == 2)
10636                       error ("constructor cannot be static member function");
10637                     if (virtualp)
10638                       {
10639                         pedwarn ("constructors cannot be declared virtual");
10640                         virtualp = 0;
10641                       }
10642                     if (quals)
10643                       {
10644                         cp_error ("constructors may not be `%s'",
10645                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10646                         quals = NULL_TREE;
10647                       }
10648                     {
10649                       RID_BIT_TYPE tmp_bits;
10650                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10651                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10652                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10653                       if (RIDBIT_ANY_SET (tmp_bits))
10654                         error ("return value type specifier for constructor ignored");
10655                     }
10656                     if (decl_context == FIELD)
10657                       {
10658                         if (! member_function_or_else (ctype,
10659                                                        current_class_type,
10660                                                        flags))
10661                           return void_type_node;
10662                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10663                         if (sfk != sfk_constructor)
10664                           return NULL_TREE;
10665                       }
10666                   }
10667                 if (decl_context == FIELD)
10668                   staticp = 0;
10669               }
10670             else if (friendp)
10671               {
10672                 if (initialized)
10673                   error ("can't initialize friend function `%s'", name);
10674                 if (virtualp)
10675                   {
10676                     /* Cannot be both friend and virtual.  */
10677                     error ("virtual functions cannot be friends");
10678                     RIDBIT_RESET (RID_FRIEND, specbits);
10679                     friendp = 0;
10680                   }
10681                 if (decl_context == NORMAL)
10682                   error ("friend declaration not in class definition");
10683                 if (current_function_decl && funcdef_flag)
10684                   cp_error ("can't define friend function `%s' in a local class definition",
10685                             name);
10686               }
10687
10688             /* Construct the function type and go to the next
10689                inner layer of declarator.  */
10690
10691             declarator = TREE_OPERAND (declarator, 0);
10692
10693             /* FIXME: This is where default args should be fully
10694                processed.  */
10695
10696             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10697
10698             if (declarator && flags == DTOR_FLAG)
10699               {
10700                 /* A destructor declared in the body of a class will
10701                    be represented as a BIT_NOT_EXPR.  But, we just
10702                    want the underlying IDENTIFIER.  */
10703                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10704                   declarator = TREE_OPERAND (declarator, 0);
10705
10706                 if (arg_types != void_list_node)
10707                   {
10708                     cp_error ("destructors may not have parameters");
10709                     arg_types = void_list_node;
10710                     last_function_parms = NULL_TREE;
10711                   }
10712               }
10713
10714             /* ANSI says that `const int foo ();'
10715                does not make the function foo const.  */
10716             type = build_function_type (type, arg_types);
10717
10718             {
10719               tree t;
10720               for (t = arg_types; t; t = TREE_CHAIN (t))
10721                 if (TREE_PURPOSE (t)
10722                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10723                   {
10724                     add_defarg_fn (type);
10725                     break;
10726                   }
10727             }
10728           }
10729           break;
10730
10731         case ADDR_EXPR:
10732         case INDIRECT_REF:
10733           /* Filter out pointers-to-references and references-to-references.
10734              We can get these if a TYPE_DECL is used.  */
10735
10736           if (TREE_CODE (type) == REFERENCE_TYPE)
10737             {
10738               error ("cannot declare %s to references",
10739                      TREE_CODE (declarator) == ADDR_EXPR
10740                      ? "references" : "pointers");
10741               declarator = TREE_OPERAND (declarator, 0);
10742               continue;
10743             }
10744
10745           if (TREE_CODE (type) == OFFSET_TYPE
10746               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10747                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10748             {
10749               cp_error ("cannot declare pointer to `%#T' member",
10750                         TREE_TYPE (type));
10751               type = TREE_TYPE (type);
10752             }
10753
10754           /* Merge any constancy or volatility into the target type
10755              for the pointer.  */
10756
10757           /* We now know that the TYPE_QUALS don't apply to the decl,
10758              but to the target of the pointer.  */
10759           type_quals = TYPE_UNQUALIFIED;
10760
10761           if (TREE_CODE (declarator) == ADDR_EXPR)
10762             {
10763               if (TREE_CODE (type) == VOID_TYPE)
10764                 error ("invalid type: `void &'");
10765               else
10766                 type = build_reference_type (type);
10767             }
10768           else if (TREE_CODE (type) == METHOD_TYPE)
10769             type = build_ptrmemfunc_type (build_pointer_type (type));
10770           else
10771             type = build_pointer_type (type);
10772
10773           /* Process a list of type modifier keywords (such as
10774              const or volatile) that were given inside the `*' or `&'.  */
10775
10776           if (TREE_TYPE (declarator))
10777             {
10778               register tree typemodlist;
10779               int erred = 0;
10780
10781               constp = 0;
10782               volatilep = 0;
10783               restrictp = 0;
10784               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10785                    typemodlist = TREE_CHAIN (typemodlist))
10786                 {
10787                   tree qualifier = TREE_VALUE (typemodlist);
10788
10789                   if (qualifier == ridpointers[(int) RID_CONST])
10790                     constp++;
10791                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10792                     volatilep++;
10793                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10794                     restrictp++;
10795                   else if (!erred)
10796                     {
10797                       erred = 1;
10798                       error ("invalid type modifier within pointer declarator");
10799                     }
10800                 }
10801               if (constp > 1)
10802                 pedwarn ("duplicate `const'");
10803               if (volatilep > 1)
10804                 pedwarn ("duplicate `volatile'");
10805               if (restrictp > 1)
10806                 pedwarn ("duplicate `restrict'");
10807
10808               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10809                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10810                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10811               if (TREE_CODE (declarator) == ADDR_EXPR
10812                   && (constp || volatilep))
10813                 {
10814                   if (constp)
10815                     pedwarn ("discarding `const' applied to a reference");
10816                   if (volatilep)
10817                     pedwarn ("discarding `volatile' applied to a reference");
10818                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10819                 }
10820               type = cp_build_qualified_type (type, type_quals);
10821             }
10822           declarator = TREE_OPERAND (declarator, 0);
10823           ctype = NULL_TREE;
10824           break;
10825
10826         case SCOPE_REF:
10827           {
10828             /* We have converted type names to NULL_TREE if the
10829                name was bogus, or to a _TYPE node, if not.
10830
10831                The variable CTYPE holds the type we will ultimately
10832                resolve to.  The code here just needs to build
10833                up appropriate member types.  */
10834             tree sname = TREE_OPERAND (declarator, 1);
10835             tree t;
10836
10837             /* Destructors can have their visibilities changed as well.  */
10838             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10839               sname = TREE_OPERAND (sname, 0);
10840
10841             if (TREE_COMPLEXITY (declarator) == 0)
10842               /* This needs to be here, in case we are called
10843                  multiple times.  */ ;
10844             else if (TREE_COMPLEXITY (declarator) == -1)
10845               /* Namespace member. */
10846               pop_decl_namespace ();
10847             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10848               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10849             else if (! IS_AGGR_TYPE_CODE
10850                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10851               ;
10852             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10853               {
10854                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10855                    that refer to ctype.  They couldn't be resolved earlier
10856                    because we hadn't pushed into the class yet.
10857                    Example: resolve 'B<T>::type' in
10858                    'B<typename B<T>::type> B<T>::f () { }'.  */
10859                 if (current_template_parms
10860                     && uses_template_parms (type)
10861                     && uses_template_parms (current_class_type))
10862                   {
10863                     tree args = current_template_args ();
10864                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10865                   }
10866
10867                 /* This pop_nested_class corresponds to the
10868                    push_nested_class used to push into class scope for
10869                    parsing the argument list of a function decl, in
10870                    qualified_id.  */
10871                 pop_nested_class ();
10872                 TREE_COMPLEXITY (declarator) = current_class_depth;
10873               }
10874             else
10875               my_friendly_abort (16);
10876
10877             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10878               {
10879                 /* We had a reference to a global decl, or
10880                    perhaps we were given a non-aggregate typedef,
10881                    in which case we cleared this out, and should just
10882                    keep going as though it wasn't there.  */
10883                 declarator = sname;
10884                 continue;
10885               }
10886             ctype = TREE_OPERAND (declarator, 0);
10887
10888             t = ctype;
10889             while (t != NULL_TREE && CLASS_TYPE_P (t))
10890               {
10891                 /* You're supposed to have one `template <...>'
10892                    for every template class, but you don't need one
10893                    for a full specialization.  For example:
10894
10895                      template <class T> struct S{};
10896                      template <> struct S<int> { void f(); };
10897                      void S<int>::f () {}
10898
10899                    is correct; there shouldn't be a `template <>' for
10900                    the definition of `S<int>::f'.  */
10901                 if (CLASSTYPE_TEMPLATE_INFO (t)
10902                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10903                         || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
10904                   template_count += 1;
10905
10906                 t = TYPE_MAIN_DECL (t);
10907                 if (DECL_LANG_SPECIFIC (t))
10908                   t = DECL_CONTEXT (t);
10909                 else
10910                   t = NULL_TREE;
10911               }
10912
10913             if (sname == NULL_TREE)
10914               goto done_scoping;
10915
10916             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10917               {
10918                 /* This is the `standard' use of the scoping operator:
10919                    basetype :: member .  */
10920
10921                 if (ctype == current_class_type)
10922                   {
10923                     /* class A {
10924                          void A::f ();
10925                        };
10926
10927                        Is this ill-formed?  */
10928
10929                     if (pedantic)
10930                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10931                                   ctype, name);
10932                   }
10933                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10934                   {
10935                     if (current_class_type == NULL_TREE
10936                         || friendp)
10937                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10938                                                       TYPE_ARG_TYPES (type));
10939                     else
10940                       {
10941                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10942                                   ctype, name, current_class_type);
10943                         return void_type_node;
10944                       }
10945                   }
10946                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10947                          || COMPLETE_TYPE_P (complete_type (ctype)))
10948                   {
10949                     /* Have to move this code elsewhere in this function.
10950                        this code is used for i.e., typedef int A::M; M *pm;
10951
10952                        It is?  How? jason 10/2/94 */
10953
10954                     if (current_class_type)
10955                       {
10956                         cp_error ("cannot declare member `%T::%s' within `%T'",
10957                                   ctype, name, current_class_type);
10958                         return void_type_node;
10959                       }
10960                     type = build_offset_type (ctype, type);
10961                   }
10962                 else if (uses_template_parms (ctype))
10963                   {
10964                     if (TREE_CODE (type) == FUNCTION_TYPE)
10965                       type
10966                         = build_cplus_method_type (ctype, TREE_TYPE (type),
10967                                                    TYPE_ARG_TYPES (type));
10968                   }
10969                 else
10970                   {
10971                     cp_error ("structure `%T' not yet defined", ctype);
10972                     return error_mark_node;
10973                   }
10974
10975                 declarator = sname;
10976               }
10977             else if (TREE_CODE (sname) == SCOPE_REF)
10978               my_friendly_abort (17);
10979             else
10980               {
10981               done_scoping:
10982                 declarator = TREE_OPERAND (declarator, 1);
10983                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10984                   /* In this case, we will deal with it later.  */
10985                   ;
10986                 else
10987                   {
10988                     if (TREE_CODE (type) == FUNCTION_TYPE)
10989                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10990                                                       TYPE_ARG_TYPES (type));
10991                     else
10992                       type = build_offset_type (ctype, type);
10993                   }
10994               }
10995           }
10996           break;
10997
10998         case BIT_NOT_EXPR:
10999           declarator = TREE_OPERAND (declarator, 0);
11000           break;
11001
11002         case RECORD_TYPE:
11003         case UNION_TYPE:
11004         case ENUMERAL_TYPE:
11005           declarator = NULL_TREE;
11006           break;
11007
11008         case ERROR_MARK:
11009           declarator = NULL_TREE;
11010           break;
11011
11012         default:
11013           my_friendly_abort (158);
11014         }
11015     }
11016
11017   /* See the comment for the TREE_LIST case, above.  */
11018   if (inner_attrs)
11019     {
11020       if (! ignore_attrs)
11021         decl_attributes (type, inner_attrs, NULL_TREE);
11022       else if (attrlist)
11023         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
11024       else
11025         attrlist = build_decl_list (NULL_TREE, inner_attrs);
11026     }
11027
11028   /* Now TYPE has the actual type.  */
11029
11030   if (explicitp == 1 || (explicitp && friendp))
11031     {
11032       /* [dcl.fct.spec] The explicit specifier shall only be used in
11033          declarations of constructors within a class definition.  */
11034       error ("only declarations of constructors can be `explicit'");
11035       explicitp = 0;
11036     }
11037
11038   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11039     {
11040       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11041         {
11042           error ("non-member `%s' cannot be declared `mutable'", name);
11043           RIDBIT_RESET (RID_MUTABLE, specbits);
11044         }
11045       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11046         {
11047           error ("non-object member `%s' cannot be declared `mutable'", name);
11048           RIDBIT_RESET (RID_MUTABLE, specbits);
11049         }
11050       else if (TREE_CODE (type) == FUNCTION_TYPE
11051                || TREE_CODE (type) == METHOD_TYPE)
11052         {
11053           error ("function `%s' cannot be declared `mutable'", name);
11054           RIDBIT_RESET (RID_MUTABLE, specbits);
11055         }
11056       else if (staticp)
11057         {
11058           error ("static `%s' cannot be declared `mutable'", name);
11059           RIDBIT_RESET (RID_MUTABLE, specbits);
11060         }
11061       else if (type_quals & TYPE_QUAL_CONST)
11062         {
11063           error ("const `%s' cannot be declared `mutable'", name);
11064           RIDBIT_RESET (RID_MUTABLE, specbits);
11065         }
11066     }
11067
11068   if (declarator == NULL_TREE
11069       || TREE_CODE (declarator) == IDENTIFIER_NODE
11070       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11071           && (TREE_CODE (type) == FUNCTION_TYPE
11072               || TREE_CODE (type) == METHOD_TYPE)))
11073     /* OK */;
11074   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11075     {
11076       cp_error ("template-id `%D' used as a declarator", declarator);
11077       declarator = dname;
11078     }
11079   else
11080     /* Unexpected declarator format.  */
11081     my_friendly_abort (990210);
11082
11083   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11084
11085   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11086     {
11087       tree decl;
11088
11089       /* Note that the grammar rejects storage classes
11090          in typenames, fields or parameters.  */
11091       if (current_lang_name == lang_name_java)
11092         TYPE_FOR_JAVA (type) = 1;
11093
11094       if (decl_context == FIELD)
11095         {
11096           if (declarator == constructor_name (current_class_type))
11097             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11098                         declarator);
11099           decl = build_lang_decl (TYPE_DECL, declarator, type);
11100         }
11101       else
11102         decl = build_decl (TYPE_DECL, declarator, type);
11103
11104       /* If the user declares "typedef struct {...} foo" then the
11105          struct will have an anonymous name.  Fill that name in now.
11106          Nothing can refer to it, so nothing needs know about the name
11107          change.  */
11108       if (type != error_mark_node
11109           && declarator
11110           && TYPE_NAME (type)
11111           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11112           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
11113           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11114         {
11115           tree oldname = TYPE_NAME (type);
11116           tree t;
11117
11118           /* Replace the anonymous name with the real name everywhere.  */
11119           lookup_tag_reverse (type, declarator);
11120           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11121             if (TYPE_NAME (t) == oldname)
11122               TYPE_NAME (t) = decl;
11123
11124           if (TYPE_LANG_SPECIFIC (type))
11125             TYPE_WAS_ANONYMOUS (type) = 1;
11126
11127           /* If this is a typedef within a template class, the nested
11128              type is a (non-primary) template.  The name for the
11129              template needs updating as well.  */
11130           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11131             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11132               = TYPE_IDENTIFIER (type);
11133
11134           if (flag_new_abi)
11135             DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
11136           else
11137             {
11138               /* XXX Temporarily set the scope.
11139                  When returning, start_decl expects it as NULL_TREE,
11140                  and will then then set it using pushdecl. */
11141               my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
11142               if (current_class_type)
11143                 DECL_CONTEXT (decl) = current_class_type;
11144               else
11145                 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11146
11147               DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
11148               DECL_ASSEMBLER_NAME (decl)
11149                 = get_identifier (build_overload_name (type, 1, 1));
11150               DECL_CONTEXT (decl) = NULL_TREE;
11151             }
11152
11153           /* FIXME remangle member functions; member functions of a
11154              type with external linkage have external linkage.  */
11155         }
11156
11157       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11158         {
11159           cp_error_at ("typedef name may not be class-qualified", decl);
11160           return NULL_TREE;
11161         }
11162       else if (quals)
11163         {
11164           if (ctype == NULL_TREE)
11165             {
11166               if (TREE_CODE (type) != METHOD_TYPE)
11167                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11168               else
11169                 ctype = TYPE_METHOD_BASETYPE (type);
11170             }
11171           if (ctype != NULL_TREE)
11172             grok_method_quals (ctype, decl, quals);
11173         }
11174
11175       if (RIDBIT_SETP (RID_SIGNED, specbits)
11176           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11177         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11178
11179       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11180                       inlinep, friendp, raises != NULL_TREE);
11181
11182       if (initialized)
11183         error ("typedef declaration includes an initializer");
11184
11185       return decl;
11186     }
11187
11188   /* Detect the case of an array type of unspecified size
11189      which came, as such, direct from a typedef name.
11190      We must copy the type, so that each identifier gets
11191      a distinct type, so that each identifier's size can be
11192      controlled separately by its own initializer.  */
11193
11194   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11195       && TYPE_DOMAIN (type) == NULL_TREE)
11196     {
11197       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11198     }
11199
11200   /* If this is a type name (such as, in a cast or sizeof),
11201      compute the type and return it now.  */
11202
11203   if (decl_context == TYPENAME)
11204     {
11205       /* Note that the grammar rejects storage classes
11206          in typenames, fields or parameters.  */
11207       if (type_quals != TYPE_UNQUALIFIED)
11208         type_quals = TYPE_UNQUALIFIED;
11209
11210       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11211       if (friendp)
11212         {
11213           if (type_quals != TYPE_UNQUALIFIED)
11214             {
11215               cp_error ("type qualifiers specified for friend class declaration");
11216               type_quals = TYPE_UNQUALIFIED;
11217             }
11218           if (inlinep)
11219             {
11220               cp_error ("`inline' specified for friend class declaration");
11221               inlinep = 0;
11222             }
11223           if (!current_aggr && TREE_CODE (type) != TYPENAME_TYPE)
11224             {
11225               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11226                 cp_error ("template parameters cannot be friends");
11227               else
11228                 cp_error ("friend declaration requires `%#T'", type);
11229             }
11230
11231           /* Only try to do this stuff if we didn't already give up.  */
11232           if (type != integer_type_node)
11233             {
11234               /* A friendly class?  */
11235               if (current_class_type)
11236                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11237               else
11238                 error ("trying to make class `%s' a friend of global scope",
11239                        TYPE_NAME_STRING (type));
11240               type = void_type_node;
11241             }
11242         }
11243       else if (quals)
11244         {
11245           if (ctype == NULL_TREE)
11246             {
11247               if (TREE_CODE (type) != METHOD_TYPE)
11248                 cp_error ("invalid qualifiers on non-member function type");
11249               else
11250                 ctype = TYPE_METHOD_BASETYPE (type);
11251             }
11252           if (ctype)
11253             {
11254               tree dummy = build_decl (TYPE_DECL, declarator, type);
11255               grok_method_quals (ctype, dummy, quals);
11256               type = TREE_TYPE (dummy);
11257             }
11258         }
11259
11260       return type;
11261     }
11262   else if (declarator == NULL_TREE && decl_context != PARM
11263            && decl_context != CATCHPARM
11264            && TREE_CODE (type) != UNION_TYPE
11265            && ! bitfield)
11266     {
11267       cp_error ("abstract declarator `%T' used as declaration", type);
11268       declarator = make_anon_name ();
11269     }
11270
11271   /* `void' at top level (not within pointer)
11272      is allowed only in typedefs or type names.
11273      We don't complain about parms either, but that is because
11274      a better error message can be made later.  */
11275
11276   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11277     {
11278       if (! declarator)
11279         error ("unnamed variable or field declared void");
11280       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11281         {
11282           if (IDENTIFIER_OPNAME_P (declarator))
11283             my_friendly_abort (356);
11284           else
11285             error ("variable or field `%s' declared void", name);
11286         }
11287       else
11288         error ("variable or field declared void");
11289       type = integer_type_node;
11290     }
11291
11292   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11293      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11294
11295   if (decl_context == PARM || decl_context == CATCHPARM)
11296     {
11297       if (ctype || in_namespace)
11298         error ("cannot use `::' in parameter declaration");
11299
11300       /* A parameter declared as an array of T is really a pointer to T.
11301          One declared as a function is really a pointer to a function.
11302          One declared as a member is really a pointer to member.  */
11303
11304       if (TREE_CODE (type) == ARRAY_TYPE)
11305         {
11306           /* Transfer const-ness of array into that of type pointed to.  */
11307           type = build_pointer_type (TREE_TYPE (type));
11308           type_quals = TYPE_UNQUALIFIED;
11309         }
11310       else if (TREE_CODE (type) == FUNCTION_TYPE)
11311         type = build_pointer_type (type);
11312       else if (TREE_CODE (type) == OFFSET_TYPE)
11313         type = build_pointer_type (type);
11314       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11315         {
11316           error ("declaration of `%s' as void", name);
11317           return NULL_TREE;
11318         }
11319     }
11320
11321   {
11322     register tree decl;
11323
11324     if (decl_context == PARM)
11325       {
11326         decl = build_decl (PARM_DECL, declarator, type);
11327
11328         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11329                         inlinep, friendp, raises != NULL_TREE);
11330
11331         /* Compute the type actually passed in the parmlist,
11332            for the case where there is no prototype.
11333            (For example, shorts and chars are passed as ints.)
11334            When there is a prototype, this is overridden later.  */
11335
11336         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11337       }
11338     else if (decl_context == FIELD)
11339       {
11340         if (type == error_mark_node)
11341           {
11342             /* Happens when declaring arrays of sizes which
11343                are error_mark_node, for example.  */
11344             decl = NULL_TREE;
11345           }
11346         else if (in_namespace && !friendp)
11347           {
11348             /* Something like struct S { int N::j; };  */
11349             cp_error ("invalid use of `::'");
11350             decl = NULL_TREE;
11351           }
11352         else if (TREE_CODE (type) == FUNCTION_TYPE)
11353           {
11354             int publicp = 0;
11355             tree function_context;
11356
11357             /* We catch the others as conflicts with the builtin
11358                typedefs.  */
11359             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11360               {
11361                 cp_error ("function `%D' cannot be declared friend",
11362                           declarator);
11363                 friendp = 0;
11364               }
11365
11366             if (friendp == 0)
11367               {
11368                 if (ctype == NULL_TREE)
11369                   ctype = current_class_type;
11370
11371                 if (ctype == NULL_TREE)
11372                   {
11373                     cp_error ("can't make `%D' into a method -- not in a class",
11374                               declarator);
11375                     return void_type_node;
11376                   }
11377
11378                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11379                    ARM 9.5 */
11380                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11381                   {
11382                     cp_error ("function `%D' declared virtual inside a union",
11383                               declarator);
11384                     return void_type_node;
11385                   }
11386
11387                 if (declarator == ansi_opname (NEW_EXPR)
11388                     || declarator == ansi_opname (VEC_NEW_EXPR)
11389                     || declarator == ansi_opname (DELETE_EXPR)
11390                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11391                   {
11392                     if (virtualp)
11393                       {
11394                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11395                                   declarator);
11396                         virtualp = 0;
11397                       }
11398                   }
11399                 else if (staticp < 2)
11400                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11401                                                   TYPE_ARG_TYPES (type));
11402               }
11403
11404             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11405             function_context = (ctype != NULL_TREE) ?
11406               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11407             publicp = (! friendp || ! staticp)
11408               && function_context == NULL_TREE;
11409             decl = grokfndecl (ctype, type,
11410                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11411                                ? declarator : dname,
11412                                declarator,
11413                                virtualp, flags, quals, raises,
11414                                friendp ? -1 : 0, friendp, publicp, inlinep,
11415                                funcdef_flag, template_count, in_namespace);
11416             if (decl == NULL_TREE)
11417               return decl;
11418 #if 0
11419             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11420             /* The decl and setting of decl_machine_attr is also turned off.  */
11421             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11422 #endif
11423
11424             /* [class.conv.ctor]
11425
11426                A constructor declared without the function-specifier
11427                explicit that can be called with a single parameter
11428                specifies a conversion from the type of its first
11429                parameter to the type of its class.  Such a constructor
11430                is called a converting constructor.  */
11431             if (explicitp == 2)
11432               DECL_NONCONVERTING_P (decl) = 1;
11433             else if (DECL_CONSTRUCTOR_P (decl))
11434               {
11435                 /* The constructor can be called with exactly one
11436                    parameter if there is at least one parameter, and
11437                    any subsequent parameters have default arguments.
11438                    We don't look at the first parameter, which is
11439                    really just the `this' parameter for the new
11440                    object.  */
11441                 tree arg_types =
11442                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11443
11444                 /* Skip the `in_chrg' argument too, if present.  */
11445                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11446                   arg_types = TREE_CHAIN (arg_types);
11447
11448                 if (arg_types == void_list_node
11449                     || (arg_types
11450                         && TREE_CHAIN (arg_types)
11451                         && TREE_CHAIN (arg_types) != void_list_node
11452                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11453                   DECL_NONCONVERTING_P (decl) = 1;
11454               }
11455           }
11456         else if (TREE_CODE (type) == METHOD_TYPE)
11457           {
11458             /* We only get here for friend declarations of
11459                members of other classes.  */
11460             /* All method decls are public, so tell grokfndecl to set
11461                TREE_PUBLIC, also.  */
11462             decl = grokfndecl (ctype, type, declarator, declarator,
11463                                virtualp, flags, quals, raises,
11464                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11465                                template_count, in_namespace);
11466             if (decl == NULL_TREE)
11467               return NULL_TREE;
11468           }
11469         else if (!staticp && ! processing_template_decl
11470                  && !COMPLETE_TYPE_P (complete_type (type))
11471                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11472           {
11473             if (declarator)
11474               cp_error ("field `%D' has incomplete type", declarator);
11475             else
11476               cp_error ("name `%T' has incomplete type", type);
11477
11478             /* If we're instantiating a template, tell them which
11479                instantiation made the field's type be incomplete.  */
11480             if (current_class_type
11481                 && TYPE_NAME (current_class_type)
11482                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11483                 && declspecs && TREE_VALUE (declspecs)
11484                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11485               cp_error ("  in instantiation of template `%T'",
11486                         current_class_type);
11487
11488             type = error_mark_node;
11489             decl = NULL_TREE;
11490           }
11491         else
11492           {
11493             if (friendp)
11494               {
11495                 error ("`%s' is neither function nor member function; cannot be declared friend",
11496                        IDENTIFIER_POINTER (declarator));
11497                 friendp = 0;
11498               }
11499             decl = NULL_TREE;
11500           }
11501
11502         if (friendp)
11503           {
11504             /* Friends are treated specially.  */
11505             if (ctype == current_class_type)
11506               warning ("member functions are implicitly friends of their class");
11507             else
11508               {
11509                 tree t = NULL_TREE;
11510                 if (decl && DECL_NAME (decl))
11511                   {
11512                     if (template_class_depth (current_class_type) == 0)
11513                       {
11514                         decl
11515                           = check_explicit_specialization
11516                           (declarator, decl,
11517                            template_count, 2 * (funcdef_flag != 0) + 4);
11518                         if (decl == error_mark_node)
11519                           return error_mark_node;
11520                       }
11521
11522                     t = do_friend (ctype, declarator, decl,
11523                                    last_function_parms, attrlist, flags, quals,
11524                                    funcdef_flag);
11525                   }
11526                 if (t && funcdef_flag)
11527                   return t;
11528
11529                 return void_type_node;
11530               }
11531           }
11532
11533         /* Structure field.  It may not be a function, except for C++ */
11534
11535         if (decl == NULL_TREE)
11536           {
11537             if (initialized)
11538               {
11539                 if (!staticp)
11540                   {
11541                     /* An attempt is being made to initialize a non-static
11542                        member.  But, from [class.mem]:
11543
11544                        4 A member-declarator can contain a
11545                        constant-initializer only if it declares a static
11546                        member (_class.static_) of integral or enumeration
11547                        type, see _class.static.data_.
11548
11549                        This used to be relatively common practice, but
11550                        the rest of the compiler does not correctly
11551                        handle the initialization unless the member is
11552                        static so we make it static below.  */
11553                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11554                                 declarator);
11555                     cp_pedwarn ("making `%D' static", declarator);
11556                     staticp = 1;
11557                   }
11558
11559                 if (uses_template_parms (type))
11560                   /* We'll check at instantiation time.  */
11561                   ;
11562                 else if (check_static_variable_definition (declarator,
11563                                                            type))
11564                   /* If we just return the declaration, crashes
11565                      will sometimes occur.  We therefore return
11566                      void_type_node, as if this was a friend
11567                      declaration, to cause callers to completely
11568                      ignore this declaration.  */
11569                   return void_type_node;
11570               }
11571
11572             /* 9.2p13 [class.mem] */
11573             if (declarator == constructor_name (current_class_type)
11574                 /* The standard does not allow non-static data members
11575                    here either, but we agreed at the 10/99 meeting
11576                    to change that in TC 1 so that they are allowed in
11577                    classes with no user-defined constructors.  */
11578                 && staticp)
11579               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11580                           declarator);
11581
11582             if (staticp)
11583               {
11584                 /* C++ allows static class members.  All other work
11585                    for this is done by grokfield.  */
11586                 decl = build_lang_decl (VAR_DECL, declarator, type);
11587                 TREE_STATIC (decl) = 1;
11588                 /* In class context, 'static' means public access.  */
11589                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11590               }
11591             else
11592               {
11593                 decl = build_decl (FIELD_DECL, declarator, type);
11594                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11595                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11596                   {
11597                     DECL_MUTABLE_P (decl) = 1;
11598                     RIDBIT_RESET (RID_MUTABLE, specbits);
11599                   }
11600               }
11601
11602             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11603                             inlinep, friendp, raises != NULL_TREE);
11604           }
11605       }
11606     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11607       {
11608         tree original_name;
11609         int publicp = 0;
11610
11611         if (! declarator)
11612           return NULL_TREE;
11613
11614         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11615           original_name = dname;
11616         else
11617           original_name = declarator;
11618
11619         if (RIDBIT_SETP (RID_AUTO, specbits))
11620           error ("storage class `auto' invalid for function `%s'", name);
11621         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11622           error ("storage class `register' invalid for function `%s'", name);
11623
11624         /* Function declaration not at top level.
11625            Storage classes other than `extern' are not allowed
11626            and `extern' makes no difference.  */
11627         if (! toplevel_bindings_p ()
11628             && (RIDBIT_SETP (RID_STATIC, specbits)
11629                 || RIDBIT_SETP (RID_INLINE, specbits))
11630             && pedantic)
11631           {
11632             if (RIDBIT_SETP (RID_STATIC, specbits))
11633               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11634             else
11635               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11636           }
11637
11638         if (ctype == NULL_TREE)
11639           {
11640             if (virtualp)
11641               {
11642                 error ("virtual non-class function `%s'", name);
11643                 virtualp = 0;
11644               }
11645           }
11646         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11647           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11648                                           TYPE_ARG_TYPES (type));
11649
11650         /* Record presence of `static'.  */
11651         publicp = (ctype != NULL_TREE
11652                    || RIDBIT_SETP (RID_EXTERN, specbits)
11653                    || !RIDBIT_SETP (RID_STATIC, specbits));
11654
11655         decl = grokfndecl (ctype, type, original_name, declarator,
11656                            virtualp, flags, quals, raises,
11657                            1, friendp,
11658                            publicp, inlinep, funcdef_flag,
11659                            template_count, in_namespace);
11660         if (decl == NULL_TREE)
11661           return NULL_TREE;
11662
11663         if (staticp == 1)
11664           {
11665             int illegal_static = 0;
11666
11667             /* Don't allow a static member function in a class, and forbid
11668                declaring main to be static.  */
11669             if (TREE_CODE (type) == METHOD_TYPE)
11670               {
11671                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11672                 illegal_static = 1;
11673               }
11674             else if (current_function_decl)
11675               {
11676                 /* FIXME need arm citation */
11677                 error ("cannot declare static function inside another function");
11678                 illegal_static = 1;
11679               }
11680
11681             if (illegal_static)
11682               {
11683                 staticp = 0;
11684                 RIDBIT_RESET (RID_STATIC, specbits);
11685               }
11686           }
11687       }
11688     else
11689       {
11690         /* It's a variable.  */
11691
11692         /* An uninitialized decl with `extern' is a reference.  */
11693         decl = grokvardecl (type, declarator, &specbits,
11694                             initialized,
11695                             (type_quals & TYPE_QUAL_CONST) != 0,
11696                             in_namespace);
11697         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11698                         inlinep, friendp, raises != NULL_TREE);
11699
11700         if (ctype)
11701           {
11702             DECL_CONTEXT (decl) = ctype;
11703             if (staticp == 1)
11704               {
11705                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11706                 staticp = 0;
11707                 RIDBIT_RESET (RID_STATIC, specbits);
11708               }
11709             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11710               {
11711                 cp_error ("static member `%D' declared `register'", decl);
11712                 RIDBIT_RESET (RID_REGISTER, specbits);
11713               }
11714             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11715               {
11716                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11717                             decl);
11718                 RIDBIT_RESET (RID_EXTERN, specbits);
11719               }
11720           }
11721       }
11722
11723     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11724
11725     /* Record `register' declaration for warnings on &
11726        and in case doing stupid register allocation.  */
11727
11728     if (RIDBIT_SETP (RID_REGISTER, specbits))
11729       DECL_REGISTER (decl) = 1;
11730
11731     if (RIDBIT_SETP (RID_EXTERN, specbits))
11732       DECL_THIS_EXTERN (decl) = 1;
11733
11734     if (RIDBIT_SETP (RID_STATIC, specbits))
11735       DECL_THIS_STATIC (decl) = 1;
11736
11737     /* Record constancy and volatility.  There's no need to do this
11738        when processing a template; we'll do this for the instantiated
11739        declaration based on the type of DECL.  */
11740     if (!processing_template_decl)
11741       c_apply_type_quals_to_decl (type_quals, decl);
11742
11743     return decl;
11744   }
11745 }
11746 \f
11747 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11748    An empty exprlist is a parmlist.  An exprlist which
11749    contains only identifiers at the global level
11750    is a parmlist.  Otherwise, it is an exprlist.  */
11751
11752 int
11753 parmlist_is_exprlist (exprs)
11754      tree exprs;
11755 {
11756   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11757     return 0;
11758
11759   if (toplevel_bindings_p ())
11760     {
11761       /* At the global level, if these are all identifiers,
11762          then it is a parmlist.  */
11763       while (exprs)
11764         {
11765           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11766             return 1;
11767           exprs = TREE_CHAIN (exprs);
11768         }
11769       return 0;
11770     }
11771   return 1;
11772 }
11773
11774 /* Subroutine of start_function.  Ensure that each of the parameter
11775    types (as listed in PARMS) is complete, as is required for a
11776    function definition.  */
11777
11778 static void
11779 require_complete_types_for_parms (parms)
11780      tree parms;
11781 {
11782   for (; parms; parms = TREE_CHAIN (parms))
11783     {
11784       tree type = TREE_TYPE (parms);
11785
11786       /* Try to complete the TYPE.  */
11787       type = complete_type (type);
11788
11789       if (type == error_mark_node)
11790         continue;
11791
11792       if (!COMPLETE_TYPE_P (type))
11793         {
11794           if (DECL_NAME (parms))
11795             error ("parameter `%s' has incomplete type",
11796                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11797           else
11798             error ("parameter has incomplete type");
11799           TREE_TYPE (parms) = error_mark_node;
11800         }
11801       else
11802         layout_decl (parms, 0);
11803     }
11804 }
11805
11806 /* Returns non-zero if T is a local variable.  */
11807
11808 int
11809 local_variable_p (t)
11810      tree t;
11811 {
11812   if ((TREE_CODE (t) == VAR_DECL
11813        /* A VAR_DECL with a context that is a _TYPE is a static data
11814           member.  */
11815        && !TYPE_P (CP_DECL_CONTEXT (t))
11816        /* Any other non-local variable must be at namespace scope.  */
11817        && !DECL_NAMESPACE_SCOPE_P (t))
11818       || (TREE_CODE (t) == PARM_DECL))
11819     return 1;
11820
11821   return 0;
11822 }
11823
11824 /* Returns non-zero if T is an automatic local variable or a label.
11825    (These are the declarations that need to be remapped when the code
11826    containing them is duplicated.)  */
11827
11828 int
11829 nonstatic_local_decl_p (t)
11830      tree t;
11831 {
11832   return ((local_variable_p (t) && !TREE_STATIC (t))
11833           || TREE_CODE (t) == LABEL_DECL
11834           || TREE_CODE (t) == RESULT_DECL);
11835 }
11836
11837 /* Like local_variable_p, but suitable for use as a tree-walking
11838    function.  */
11839
11840 static tree
11841 local_variable_p_walkfn (tp, walk_subtrees, data)
11842      tree *tp;
11843      int *walk_subtrees ATTRIBUTE_UNUSED;
11844      void *data ATTRIBUTE_UNUSED;
11845 {
11846   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11847           ? *tp : NULL_TREE);
11848 }
11849
11850 /* Check that ARG, which is a default-argument expression for a
11851    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11852    something goes wrong.  DECL may also be a _TYPE node, rather than a
11853    DECL, if there is no DECL available.  */
11854
11855 tree
11856 check_default_argument (decl, arg)
11857      tree decl;
11858      tree arg;
11859 {
11860   tree var;
11861   tree decl_type;
11862
11863   if (TREE_CODE (arg) == DEFAULT_ARG)
11864     /* We get a DEFAULT_ARG when looking at an in-class declaration
11865        with a default argument.  Ignore the argument for now; we'll
11866        deal with it after the class is complete.  */
11867     return arg;
11868
11869   if (processing_template_decl || uses_template_parms (arg))
11870     /* We don't do anything checking until instantiation-time.  Note
11871        that there may be uninstantiated arguments even for an
11872        instantiated function, since default arguments are not
11873        instantiated until they are needed.  */
11874     return arg;
11875
11876   if (TYPE_P (decl))
11877     {
11878       decl_type = decl;
11879       decl = NULL_TREE;
11880     }
11881   else
11882     decl_type = TREE_TYPE (decl);
11883
11884   if (arg == error_mark_node
11885       || decl == error_mark_node
11886       || TREE_TYPE (arg) == error_mark_node
11887       || decl_type == error_mark_node)
11888     /* Something already went wrong.  There's no need to check
11889        further.  */
11890     return error_mark_node;
11891
11892   /* [dcl.fct.default]
11893
11894      A default argument expression is implicitly converted to the
11895      parameter type.  */
11896   if (!TREE_TYPE (arg)
11897       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11898     {
11899       if (decl)
11900         cp_error ("default argument for `%#D' has type `%T'",
11901                   decl, TREE_TYPE (arg));
11902       else
11903         cp_error ("default argument for parameter of type `%T' has type `%T'",
11904                   decl_type, TREE_TYPE (arg));
11905
11906       return error_mark_node;
11907     }
11908
11909   /* [dcl.fct.default]
11910
11911      Local variables shall not be used in default argument
11912      expressions.
11913
11914      The keyword `this' shall not be used in a default argument of a
11915      member function.  */
11916   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11917   if (var)
11918     {
11919       cp_error ("default argument `%E' uses local variable `%D'",
11920                 arg, var);
11921       return error_mark_node;
11922     }
11923
11924   /* All is well.  */
11925   return arg;
11926 }
11927
11928 /* Decode the list of parameter types for a function type.
11929    Given the list of things declared inside the parens,
11930    return a list of types.
11931
11932    The list we receive can have three kinds of elements:
11933    an IDENTIFIER_NODE for names given without types,
11934    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11935    or void_type_node, to mark the end of an argument list
11936    when additional arguments are not permitted (... was not used).
11937
11938    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11939    a mere declaration.  A nonempty identifier-list gets an error message
11940    when FUNCDEF_FLAG is zero.
11941    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11942    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11943
11944    If all elements of the input list contain types,
11945    we return a list of the types.
11946    If all elements contain no type (except perhaps a void_type_node
11947    at the end), we return a null list.
11948    If some have types and some do not, it is an error, and we
11949    return a null list.
11950
11951    Also set last_function_parms to either
11952    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11953    A list of names is converted to a chain of PARM_DECLs
11954    by store_parm_decls so that ultimately it is always a chain of decls.
11955
11956    Note that in C++, parameters can take default values.  These default
11957    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
11958    an error to specify default values which are followed by parameters
11959    that have no default values, or an ELLIPSES.  For simplicities sake,
11960    only parameters which are specified with their types can take on
11961    default values.  */
11962
11963 static tree
11964 grokparms (first_parm, funcdef_flag)
11965      tree first_parm;
11966      int funcdef_flag;
11967 {
11968   tree result = NULL_TREE;
11969   tree decls = NULL_TREE;
11970
11971   if (first_parm != NULL_TREE
11972       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11973     {
11974       if (! funcdef_flag)
11975         pedwarn ("parameter names (without types) in function declaration");
11976       last_function_parms = first_parm;
11977       return NULL_TREE;
11978     }
11979   else if (first_parm != NULL_TREE
11980            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
11981            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
11982     my_friendly_abort (145);
11983   else
11984     {
11985       /* Types were specified.  This is a list of declarators
11986          each represented as a TREE_LIST node.  */
11987       register tree parm, chain;
11988       int any_init = 0, any_error = 0;
11989
11990       if (first_parm != NULL_TREE)
11991         {
11992           tree last_result = NULL_TREE;
11993           tree last_decl = NULL_TREE;
11994
11995           for (parm = first_parm; parm != NULL_TREE; parm = chain)
11996             {
11997               tree type = NULL_TREE, list_node = parm;
11998               register tree decl = TREE_VALUE (parm);
11999               tree init = TREE_PURPOSE (parm);
12000
12001               chain = TREE_CHAIN (parm);
12002               /* @@ weak defense against parse errors.  */
12003               if (TREE_CODE (decl) != VOID_TYPE
12004                   && TREE_CODE (decl) != TREE_LIST)
12005                 {
12006                   /* Give various messages as the need arises.  */
12007                   if (TREE_CODE (decl) == STRING_CST)
12008                     cp_error ("invalid string constant `%E'", decl);
12009                   else if (TREE_CODE (decl) == INTEGER_CST)
12010                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12011                   continue;
12012                 }
12013
12014               if (TREE_CODE (decl) != VOID_TYPE)
12015                 {
12016                   decl = grokdeclarator (TREE_VALUE (decl),
12017                                          TREE_PURPOSE (decl),
12018                                          PARM, init != NULL_TREE,
12019                                          NULL_TREE);
12020                   if (! decl || TREE_TYPE (decl) == error_mark_node)
12021                     continue;
12022
12023                   /* Top-level qualifiers on the parameters are
12024                      ignored for function types.  */
12025                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
12026
12027                   if (TREE_CODE (type) == VOID_TYPE)
12028                     decl = void_type_node;
12029                   else if (TREE_CODE (type) == METHOD_TYPE)
12030                     {
12031                       if (DECL_NAME (decl))
12032                         /* Cannot use the decl here because
12033                            we don't have DECL_CONTEXT set up yet.  */
12034                         cp_error ("parameter `%D' invalidly declared method type",
12035                                   DECL_NAME (decl));
12036                       else
12037                         error ("parameter invalidly declared method type");
12038                       type = build_pointer_type (type);
12039                       TREE_TYPE (decl) = type;
12040                     }
12041                   else if (TREE_CODE (type) == OFFSET_TYPE)
12042                     {
12043                       if (DECL_NAME (decl))
12044                         cp_error ("parameter `%D' invalidly declared offset type",
12045                                   DECL_NAME (decl));
12046                       else
12047                         error ("parameter invalidly declared offset type");
12048                       type = build_pointer_type (type);
12049                       TREE_TYPE (decl) = type;
12050                     }
12051                   else if (abstract_virtuals_error (decl, type))
12052                     any_error = 1;  /* Seems like a good idea. */
12053                   else if (POINTER_TYPE_P (type))
12054                     {
12055                       tree t = type;
12056                       while (POINTER_TYPE_P (t)
12057                              || (TREE_CODE (t) == ARRAY_TYPE
12058                                  && TYPE_DOMAIN (t) != NULL_TREE))
12059                         t = TREE_TYPE (t);
12060                       if (TREE_CODE (t) == ARRAY_TYPE)
12061                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
12062                                   type,
12063                                   TYPE_PTR_P (type) ? "pointer" : "reference");
12064                     }
12065                 }
12066
12067               if (TREE_CODE (decl) == VOID_TYPE)
12068                 {
12069                   if (result == NULL_TREE)
12070                     {
12071                       result = void_list_node;
12072                       last_result = result;
12073                     }
12074                   else
12075                     {
12076                       TREE_CHAIN (last_result) = void_list_node;
12077                       last_result = void_list_node;
12078                     }
12079                   if (chain
12080                       && (chain != void_list_node || TREE_CHAIN (chain)))
12081                     error ("`void' in parameter list must be entire list");
12082                   break;
12083                 }
12084
12085               /* Since there is a prototype, args are passed in their own types.  */
12086               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12087               if (PROMOTE_PROTOTYPES
12088                   && (TREE_CODE (type) == INTEGER_TYPE
12089                       || TREE_CODE (type) == ENUMERAL_TYPE)
12090                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12091                 DECL_ARG_TYPE (decl) = integer_type_node;
12092               if (!any_error && init)
12093                 {
12094                   any_init++;
12095                   init = check_default_argument (decl, init);
12096                 }
12097               else
12098                 init = NULL_TREE;
12099
12100               if (decls == NULL_TREE)
12101                 {
12102                   decls = decl;
12103                   last_decl = decls;
12104                 }
12105               else
12106                 {
12107                   TREE_CHAIN (last_decl) = decl;
12108                   last_decl = decl;
12109                 }
12110               list_node = tree_cons (init, type, NULL_TREE);
12111               if (result == NULL_TREE)
12112                 {
12113                   result = list_node;
12114                   last_result = result;
12115                 }
12116               else
12117                 {
12118                   TREE_CHAIN (last_result) = list_node;
12119                   last_result = list_node;
12120                 }
12121             }
12122           if (last_result)
12123             TREE_CHAIN (last_result) = NULL_TREE;
12124           /* If there are no parameters, and the function does not end
12125              with `...', then last_decl will be NULL_TREE.  */
12126           if (last_decl != NULL_TREE)
12127             TREE_CHAIN (last_decl) = NULL_TREE;
12128         }
12129     }
12130
12131   last_function_parms = decls;
12132
12133   return result;
12134 }
12135
12136 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12137    FUNCTION_TYPE with the newly parsed version of its default argument, which
12138    was previously digested as text.  See snarf_defarg et al in lex.c.  */
12139
12140 void
12141 replace_defarg (arg, init)
12142      tree arg, init;
12143 {
12144   if (! processing_template_decl
12145       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
12146     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12147                 TREE_TYPE (init), TREE_VALUE (arg));
12148   TREE_PURPOSE (arg) = init;
12149 }
12150 \f
12151 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12152    D's arguments allow it to be a copy constructor, or copy assignment
12153    operator.  */
12154
12155 int
12156 copy_args_p (d)
12157      tree d;
12158 {
12159   tree t;
12160
12161   if (!DECL_FUNCTION_MEMBER_P (d))
12162     return 0;
12163
12164   t = FUNCTION_ARG_CHAIN (d);
12165   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
12166     t = TREE_CHAIN (t);
12167   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12168       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12169           == DECL_CONTEXT (d))
12170       && (TREE_CHAIN (t) == NULL_TREE
12171           || TREE_CHAIN (t) == void_list_node
12172           || TREE_PURPOSE (TREE_CHAIN (t))))
12173     return 1;
12174   return 0;
12175 }
12176
12177 /* These memoizing functions keep track of special properties which
12178    a class may have.  `grok_ctor_properties' notices whether a class
12179    has a constructor of the form X(X&), and also complains
12180    if the class has a constructor of the form X(X).
12181    `grok_op_properties' takes notice of the various forms of
12182    operator= which are defined, as well as what sorts of type conversion
12183    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12184
12185 int
12186 grok_ctor_properties (ctype, decl)
12187      tree ctype, decl;
12188 {
12189   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
12190   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12191
12192   /* When a type has virtual baseclasses, a magical first int argument is
12193      added to any ctor so we can tell if the class has been initialized
12194      yet.  This could screw things up in this function, so we deliberately
12195      ignore the leading int if we're in that situation.  */
12196   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
12197     {
12198       my_friendly_assert (parmtypes
12199                           && TREE_VALUE (parmtypes) == integer_type_node,
12200                           980529);
12201       parmtypes = TREE_CHAIN (parmtypes);
12202       parmtype = TREE_VALUE (parmtypes);
12203     }
12204
12205   /* [class.copy]
12206
12207      A non-template constructor for class X is a copy constructor if
12208      its first parameter is of type X&, const X&, volatile X& or const
12209      volatile X&, and either there are no other parameters or else all
12210      other parameters have default arguments.  */
12211   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12212       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12213       && (TREE_CHAIN (parmtypes) == NULL_TREE
12214           || TREE_CHAIN (parmtypes) == void_list_node
12215           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12216       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12217            && is_member_template (DECL_TI_TEMPLATE (decl))))
12218     {
12219       TYPE_HAS_INIT_REF (ctype) = 1;
12220       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12221         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12222     }
12223   /* [class.copy]
12224
12225      A declaration of a constructor for a class X is ill-formed if its
12226      first parameter is of type (optionally cv-qualified) X and either
12227      there are no other parameters or else all other parameters have
12228      default arguments.
12229
12230      We *don't* complain about member template instantiations that
12231      have this form, though; they can occur as we try to decide what
12232      constructor to use during overload resolution.  Since overload
12233      resolution will never prefer such a constructor to the
12234      non-template copy constructor (which is either explicitly or
12235      implicitly defined), there's no need to worry about their
12236      existence.  Theoretically, they should never even be
12237      instantiated, but that's hard to forestall.  */
12238   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12239            && (TREE_CHAIN (parmtypes) == NULL_TREE
12240                || TREE_CHAIN (parmtypes) == void_list_node
12241                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12242            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12243                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12244     {
12245       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12246                 ctype, ctype);
12247       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12248       return 0;
12249     }
12250   else if (TREE_CODE (parmtype) == VOID_TYPE
12251            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12252     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12253
12254   return 1;
12255 }
12256
12257 /* An operator with this code is unary, but can also be binary.  */
12258
12259 static int
12260 ambi_op_p (code)
12261      enum tree_code code;
12262 {
12263   return (code == INDIRECT_REF
12264           || code == ADDR_EXPR
12265           || code == CONVERT_EXPR
12266           || code == NEGATE_EXPR
12267           || code == PREINCREMENT_EXPR
12268           || code == PREDECREMENT_EXPR);
12269 }
12270
12271 /* An operator with this name can only be unary.  */
12272
12273 static int
12274 unary_op_p (code)
12275      enum tree_code code;
12276 {
12277   return (code == TRUTH_NOT_EXPR
12278           || code == BIT_NOT_EXPR
12279           || code == COMPONENT_REF
12280           || code == TYPE_EXPR);
12281 }
12282
12283 /* Do a little sanity-checking on how they declared their operator.  */
12284
12285 void
12286 grok_op_properties (decl, virtualp, friendp)
12287      tree decl;
12288      int virtualp, friendp;
12289 {
12290   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12291   tree argtype;
12292   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12293   tree name = DECL_NAME (decl);
12294   enum tree_code operator_code;
12295   int arity;
12296
12297   /* Count the number of arguments.  */
12298   for (argtype = argtypes, arity = 0;
12299        argtype && argtype != void_list_node;
12300        argtype = TREE_CHAIN (argtype))
12301     ++arity;
12302
12303   if (current_class_type == NULL_TREE)
12304     friendp = 1;
12305
12306   if (DECL_CONV_FN_P (decl))
12307     operator_code = TYPE_EXPR;
12308   else
12309     do
12310       {
12311 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P)  \
12312         if (ansi_opname (CODE) == name)                                     \
12313           {                                                                 \
12314             operator_code = CODE;                                           \
12315             break;                                                          \
12316           }                                                                 \
12317         else if (ansi_assopname (CODE) == name)                             \
12318           {                                                                 \
12319             operator_code = CODE;                                           \
12320             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;                          \
12321             break;                                                          \
12322           }
12323
12324 #include "operators.def"
12325 #undef DEF_OPERATOR
12326
12327         my_friendly_abort (20000527);
12328       }
12329     while (0);
12330   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12331   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12332
12333   if (! friendp)
12334     {
12335       switch (operator_code)
12336         {
12337         case CALL_EXPR:
12338           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12339           break;
12340
12341         case ARRAY_REF:
12342           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12343           break;
12344
12345         case COMPONENT_REF:
12346         case MEMBER_REF:
12347           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12348           break;
12349
12350         case NEW_EXPR:
12351           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12352           break;
12353
12354         case DELETE_EXPR:
12355           TYPE_GETS_DELETE (current_class_type) |= 1;
12356           break;
12357
12358         case VEC_NEW_EXPR:
12359           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12360           break;
12361
12362         case VEC_DELETE_EXPR:
12363           TYPE_GETS_DELETE (current_class_type) |= 2;
12364           break;
12365
12366         default:
12367           break;
12368         }
12369     }
12370
12371   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12372     {
12373       /* When the compiler encounters the definition of A::operator new, it
12374          doesn't look at the class declaration to find out if it's static.  */
12375       if (methodp)
12376         revert_static_member_fn (decl);
12377
12378       /* Take care of function decl if we had syntax errors.  */
12379       if (argtypes == NULL_TREE)
12380         TREE_TYPE (decl)
12381           = build_function_type (ptr_type_node,
12382                                  hash_tree_chain (integer_type_node,
12383                                                   void_list_node));
12384       else
12385         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12386     }
12387   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12388     {
12389       if (methodp)
12390         revert_static_member_fn (decl);
12391
12392       if (argtypes == NULL_TREE)
12393         TREE_TYPE (decl)
12394           = build_function_type (void_type_node,
12395                                  hash_tree_chain (ptr_type_node,
12396                                                   void_list_node));
12397       else
12398         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12399     }
12400   else
12401     {
12402       /* An operator function must either be a non-static member function
12403          or have at least one parameter of a class, a reference to a class,
12404          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12405       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12406         {
12407           if (operator_code == TYPE_EXPR
12408               || operator_code == CALL_EXPR
12409               || operator_code == COMPONENT_REF
12410               || operator_code == ARRAY_REF
12411               || operator_code == NOP_EXPR)
12412             cp_error ("`%D' must be a nonstatic member function", decl);
12413           else
12414             {
12415               tree p = argtypes;
12416
12417               if (DECL_STATIC_FUNCTION_P (decl))
12418                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12419
12420               if (p)
12421                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12422                   {
12423                     tree arg = TREE_VALUE (p);
12424                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12425                       arg = TREE_TYPE (arg);
12426
12427                     /* This lets bad template code slip through.  */
12428                     if (IS_AGGR_TYPE (arg)
12429                         || TREE_CODE (arg) == ENUMERAL_TYPE
12430                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12431                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12432                       goto foundaggr;
12433                   }
12434               cp_error
12435                 ("`%D' must have an argument of class or enumerated type",
12436                  decl);
12437             foundaggr:
12438               ;
12439             }
12440         }
12441
12442       if (operator_code == CALL_EXPR)
12443         return;                 /* No restrictions on args. */
12444
12445       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12446         {
12447           tree t = TREE_TYPE (name);
12448           if (! friendp)
12449             {
12450               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12451               const char *what = 0;
12452
12453               if (ref)
12454                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12455
12456               if (TREE_CODE (t) == VOID_TYPE)
12457                 what = "void";
12458               else if (t == current_class_type)
12459                 what = "the same type";
12460               /* Don't force t to be complete here.  */
12461               else if (IS_AGGR_TYPE (t)
12462                        && COMPLETE_TYPE_P (t)
12463                        && DERIVED_FROM_P (t, current_class_type))
12464                 what = "a base class";
12465
12466               if (what)
12467                 warning ("conversion to %s%s will never use a type conversion operator",
12468                          ref ? "a reference to " : "", what);
12469             }
12470         }
12471
12472       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12473           && operator_code == NOP_EXPR)
12474         {
12475           tree parmtype;
12476
12477           if (arity != 2 && methodp)
12478             {
12479               cp_error ("`%D' must take exactly one argument", decl);
12480               return;
12481             }
12482           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12483
12484           /* [class.copy]
12485
12486              A user-declared copy assignment operator X::operator= is
12487              a non-static non-template member function of class X with
12488              exactly one parameter of type X, X&, const X&, volatile
12489              X& or const volatile X&.  */
12490           if (copy_assignment_arg_p (parmtype, virtualp)
12491               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12492                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12493               && ! friendp)
12494             {
12495               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12496               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12497                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12498                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12499             }
12500         }
12501       else if (operator_code == COND_EXPR)
12502         {
12503           /* 13.4.0.3 */
12504           cp_error ("ISO C++ prohibits overloading operator ?:");
12505         }
12506       else if (ambi_op_p (operator_code))
12507         {
12508           if (arity == 1)
12509             /* We pick the one-argument operator codes by default, so
12510                we don't have to change anything.  */
12511             ;
12512           else if (arity == 2)
12513             {
12514               /* If we thought this was a unary operator, we now know
12515                  it to be a binary operator.  */
12516               switch (operator_code)
12517                 {
12518                 case INDIRECT_REF:
12519                   operator_code = MULT_EXPR;
12520                   break;
12521
12522                 case ADDR_EXPR:
12523                   operator_code = BIT_AND_EXPR;
12524                   break;
12525
12526                 case CONVERT_EXPR:
12527                   operator_code = PLUS_EXPR;
12528                   break;
12529
12530                 case NEGATE_EXPR:
12531                   operator_code = MINUS_EXPR;
12532                   break;
12533
12534                 case PREINCREMENT_EXPR:
12535                   operator_code = POSTINCREMENT_EXPR;
12536                   break;
12537
12538                 case PREDECREMENT_EXPR:
12539                   operator_code = POSTDECREMENT_EXPR;
12540                   break;
12541
12542                 default:
12543                   my_friendly_abort (20000527);
12544                 }
12545
12546               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12547
12548               if ((operator_code == POSTINCREMENT_EXPR
12549                    || operator_code == POSTDECREMENT_EXPR)
12550                   && ! processing_template_decl
12551                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12552                 {
12553                   if (methodp)
12554                     cp_error ("postfix `%D' must take `int' as its argument",
12555                               decl);
12556                   else
12557                     cp_error
12558                       ("postfix `%D' must take `int' as its second argument",
12559                        decl);
12560                 }
12561             }
12562           else
12563             {
12564               if (methodp)
12565                 cp_error ("`%D' must take either zero or one argument", decl);
12566               else
12567                 cp_error ("`%D' must take either one or two arguments", decl);
12568             }
12569
12570           /* More Effective C++ rule 6.  */
12571           if (warn_ecpp
12572               && (operator_code == POSTINCREMENT_EXPR
12573                   || operator_code == POSTDECREMENT_EXPR
12574                   || operator_code == PREINCREMENT_EXPR
12575                   || operator_code == PREDECREMENT_EXPR))
12576             {
12577               tree arg = TREE_VALUE (argtypes);
12578               tree ret = TREE_TYPE (TREE_TYPE (decl));
12579               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12580                 arg = TREE_TYPE (arg);
12581               arg = TYPE_MAIN_VARIANT (arg);
12582               if (operator_code == PREINCREMENT_EXPR
12583                   || operator_code == PREDECREMENT_EXPR)
12584                 {
12585                   if (TREE_CODE (ret) != REFERENCE_TYPE
12586                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12587                                        arg))
12588                     cp_warning ("prefix `%D' should return `%T'", decl,
12589                                 build_reference_type (arg));
12590                 }
12591               else
12592                 {
12593                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12594                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12595                 }
12596             }
12597         }
12598       else if (unary_op_p (operator_code))
12599         {
12600           if (arity != 1)
12601             {
12602               if (methodp)
12603                 cp_error ("`%D' must take `void'", decl);
12604               else
12605                 cp_error ("`%D' must take exactly one argument", decl);
12606             }
12607         }
12608       else /* if (binary_op_p (operator_code)) */
12609         {
12610           if (arity != 2)
12611             {
12612               if (methodp)
12613                 cp_error ("`%D' must take exactly one argument", decl);
12614               else
12615                 cp_error ("`%D' must take exactly two arguments", decl);
12616             }
12617
12618           /* More Effective C++ rule 7.  */
12619           if (warn_ecpp
12620               && (operator_code == TRUTH_ANDIF_EXPR
12621                   || operator_code == TRUTH_ORIF_EXPR
12622                   || operator_code == COMPOUND_EXPR))
12623             cp_warning ("user-defined `%D' always evaluates both arguments",
12624                         decl);
12625         }
12626
12627       /* Effective C++ rule 23.  */
12628       if (warn_ecpp
12629           && arity == 2
12630           && (operator_code == PLUS_EXPR
12631               || operator_code == MINUS_EXPR
12632               || operator_code == TRUNC_DIV_EXPR
12633               || operator_code == MULT_EXPR)
12634           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12635         cp_warning ("`%D' should return by value", decl);
12636
12637       /* 13.4.0.8 */
12638       for (; argtypes && argtypes != void_list_node;
12639           argtypes = TREE_CHAIN (argtypes))
12640         if (TREE_PURPOSE (argtypes))
12641           {
12642             TREE_PURPOSE (argtypes) = NULL_TREE;
12643             if (operator_code == POSTINCREMENT_EXPR
12644                 || operator_code == POSTDECREMENT_EXPR)
12645               {
12646                 if (pedantic)
12647                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12648               }
12649             else
12650               cp_error ("`%D' cannot have default arguments", decl);
12651           }
12652
12653     }
12654 }
12655 \f
12656 static const char *
12657 tag_name (code)
12658      enum tag_types code;
12659 {
12660   switch (code)
12661     {
12662     case record_type:
12663       return "struct";
12664     case class_type:
12665       return "class";
12666     case union_type:
12667       return "union ";
12668     case enum_type:
12669       return "enum";
12670     default:
12671       my_friendly_abort (981122);
12672     }
12673 }
12674
12675 /* Get the struct, enum or union (CODE says which) with tag NAME.
12676    Define the tag as a forward-reference if it is not defined.
12677
12678    C++: If a class derivation is given, process it here, and report
12679    an error if multiple derivation declarations are not identical.
12680
12681    If this is a definition, come in through xref_tag and only look in
12682    the current frame for the name (since C++ allows new names in any
12683    scope.)  */
12684
12685 tree
12686 xref_tag (code_type_node, name, globalize)
12687      tree code_type_node;
12688      tree name;
12689      int globalize;
12690 {
12691   enum tag_types tag_code;
12692   enum tree_code code;
12693   register tree ref, t;
12694   struct binding_level *b = current_binding_level;
12695   int got_type = 0;
12696   tree attributes = NULL_TREE;
12697   tree context = NULL_TREE;
12698
12699   /* If we are called from the parser, code_type_node will sometimes be a
12700      TREE_LIST.  This indicates that the user wrote
12701      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12702      use them later.  */
12703   if (TREE_CODE (code_type_node) == TREE_LIST)
12704     {
12705       attributes = TREE_PURPOSE (code_type_node);
12706       code_type_node = TREE_VALUE (code_type_node);
12707     }
12708
12709   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12710   switch (tag_code)
12711     {
12712     case record_type:
12713     case class_type:
12714       code = RECORD_TYPE;
12715       break;
12716     case union_type:
12717       code = UNION_TYPE;
12718       break;
12719     case enum_type:
12720       code = ENUMERAL_TYPE;
12721       break;
12722     default:
12723       my_friendly_abort (18);
12724     }
12725
12726   /* If a cross reference is requested, look up the type
12727      already defined for this tag and return it.  */
12728   if (TYPE_P (name))
12729     {
12730       t = name;
12731       name = TYPE_IDENTIFIER (t);
12732       got_type = 1;
12733     }
12734   else
12735     t = IDENTIFIER_TYPE_VALUE (name);
12736
12737   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12738       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12739     t = NULL_TREE;
12740
12741   if (! globalize)
12742     {
12743       /* If we know we are defining this tag, only look it up in
12744          this scope and don't try to find it as a type.  */
12745       ref = lookup_tag (code, name, b, 1);
12746     }
12747   else
12748     {
12749       if (t)
12750         {
12751           /* [dcl.type.elab] If the identifier resolves to a
12752              typedef-name or a template type-parameter, the
12753              elaborated-type-specifier is ill-formed.  */
12754           if (t != TYPE_MAIN_VARIANT (t)
12755               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12756             cp_pedwarn ("using typedef-name `%D' after `%s'",
12757                         TYPE_NAME (t), tag_name (tag_code));
12758           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12759             cp_error ("using template type parameter `%T' after `%s'",
12760                       t, tag_name (tag_code));
12761
12762           ref = t;
12763         }
12764       else
12765         ref = lookup_tag (code, name, b, 0);
12766
12767       if (! ref)
12768         {
12769           /* Try finding it as a type declaration.  If that wins,
12770              use it.  */
12771           ref = lookup_name (name, 1);
12772
12773           if (ref != NULL_TREE
12774               && processing_template_decl
12775               && DECL_CLASS_TEMPLATE_P (ref)
12776               && template_class_depth (current_class_type) == 0)
12777             /* Since GLOBALIZE is true, we're declaring a global
12778                template, so we want this type.  */
12779             ref = DECL_TEMPLATE_RESULT (ref);
12780
12781           if (ref && TREE_CODE (ref) == TYPE_DECL
12782               && TREE_CODE (TREE_TYPE (ref)) == code)
12783             ref = TREE_TYPE (ref);
12784           else
12785             ref = NULL_TREE;
12786         }
12787
12788       if (ref && current_class_type
12789           && template_class_depth (current_class_type)
12790           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12791         {
12792           /* Since GLOBALIZE is non-zero, we are not looking at a
12793              definition of this tag.  Since, in addition, we are currently
12794              processing a (member) template declaration of a template
12795              class, we must be very careful; consider:
12796
12797                template <class X>
12798                struct S1
12799
12800                template <class U>
12801                struct S2
12802                { template <class V>
12803                friend struct S1; };
12804
12805              Here, the S2::S1 declaration should not be confused with the
12806              outer declaration.  In particular, the inner version should
12807              have a template parameter of level 2, not level 1.  This
12808              would be particularly important if the member declaration
12809              were instead:
12810
12811                template <class V = U> friend struct S1;
12812
12813              say, when we should tsubst into `U' when instantiating
12814              S2.  On the other hand, when presented with:
12815
12816                  template <class T>
12817                  struct S1 {
12818                    template <class U>
12819                    struct S2 {};
12820                    template <class U>
12821                    friend struct S2;
12822                  };
12823
12824               we must find the inner binding eventually.  We
12825               accomplish this by making sure that the new type we
12826               create to represent this declaration has the right
12827               TYPE_CONTEXT.  */
12828           context = TYPE_CONTEXT (ref);
12829           ref = NULL_TREE;
12830         }
12831     }
12832
12833   if (! ref)
12834     {
12835       /* If no such tag is yet defined, create a forward-reference node
12836          and record it as the "definition".
12837          When a real declaration of this type is found,
12838          the forward-reference will be altered into a real type.  */
12839       if (code == ENUMERAL_TYPE)
12840         {
12841           cp_error ("use of enum `%#D' without previous declaration", name);
12842
12843           ref = make_node (ENUMERAL_TYPE);
12844
12845           /* Give the type a default layout like unsigned int
12846              to avoid crashing if it does not get defined.  */
12847           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12848           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12849           TYPE_USER_ALIGN (ref) = 0;
12850           TREE_UNSIGNED (ref) = 1;
12851           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12852           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12853           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12854
12855           /* Enable us to recognize when a type is created in class context.
12856              To do nested classes correctly, this should probably be cleared
12857              out when we leave this classes scope.  Currently this in only
12858              done in `start_enum'.  */
12859
12860           pushtag (name, ref, globalize);
12861         }
12862       else
12863         {
12864           struct binding_level *old_b = class_binding_level;
12865
12866           ref = make_aggr_type (code);
12867           TYPE_CONTEXT (ref) = context;
12868
12869 #ifdef NONNESTED_CLASSES
12870           /* Class types don't nest the way enums do.  */
12871           class_binding_level = (struct binding_level *)0;
12872 #endif
12873           pushtag (name, ref, globalize);
12874           class_binding_level = old_b;
12875         }
12876     }
12877   else
12878     {
12879       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12880         redeclare_class_template (ref, current_template_parms);
12881     }
12882
12883   /* Until the type is defined, tentatively accept whatever
12884      structure tag the user hands us.  */
12885   if (!COMPLETE_TYPE_P (ref)
12886       && ref != current_class_type
12887       /* Have to check this, in case we have contradictory tag info.  */
12888       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12889     {
12890       if (tag_code == class_type)
12891         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12892       else if (tag_code == record_type)
12893         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12894     }
12895
12896   TREE_TYPE (ref) = attributes;
12897
12898   return ref;
12899 }
12900
12901 tree
12902 xref_tag_from_type (old, id, globalize)
12903      tree old, id;
12904      int globalize;
12905 {
12906   tree code_type_node;
12907
12908   if (TREE_CODE (old) == RECORD_TYPE)
12909     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12910                       ? class_type_node : record_type_node);
12911   else
12912     code_type_node = union_type_node;
12913
12914   if (id == NULL_TREE)
12915     id = TYPE_IDENTIFIER (old);
12916
12917   return xref_tag (code_type_node, id, globalize);
12918 }
12919
12920 /* REF is a type (named NAME), for which we have just seen some
12921    baseclasses.  BINFO is a list of those baseclasses; the
12922    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12923    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12924    struct, or union.  */
12925
12926 void
12927 xref_basetypes (code_type_node, name, ref, binfo)
12928      tree code_type_node;
12929      tree name, ref;
12930      tree binfo;
12931 {
12932   /* In the declaration `A : X, Y, ... Z' we mark all the types
12933      (A, X, Y, ..., Z) so we can check for duplicates.  */
12934   tree binfos;
12935   tree base;
12936
12937   int i, len;
12938   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12939
12940   if (tag_code == union_type)
12941     {
12942       cp_error ("derived union `%T' invalid", ref);
12943       return;
12944     }
12945
12946   len = list_length (binfo);
12947
12948   /* First, make sure that any templates in base-classes are
12949      instantiated.  This ensures that if we call ourselves recursively
12950      we do not get confused about which classes are marked and which
12951      are not.  */
12952   for (base = binfo; base; base = TREE_CHAIN (base))
12953     complete_type (TREE_VALUE (base));
12954
12955   SET_CLASSTYPE_MARKED (ref);
12956   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12957
12958   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12959     {
12960       /* The base of a derived struct is public by default.  */
12961       int via_public
12962         = (TREE_PURPOSE (binfo) == access_public_node
12963            || TREE_PURPOSE (binfo) == access_public_virtual_node
12964            || (tag_code != class_type
12965                && (TREE_PURPOSE (binfo) == access_default_node
12966                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12967       int via_protected
12968         = (TREE_PURPOSE (binfo) == access_protected_node
12969            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12970       int via_virtual
12971         = (TREE_PURPOSE (binfo) == access_private_virtual_node
12972            || TREE_PURPOSE (binfo) == access_protected_virtual_node
12973            || TREE_PURPOSE (binfo) == access_public_virtual_node
12974            || TREE_PURPOSE (binfo) == access_default_virtual_node);
12975       tree basetype = TREE_VALUE (binfo);
12976       tree base_binfo;
12977
12978       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12979         basetype = TREE_TYPE (basetype);
12980       if (!basetype
12981           || (TREE_CODE (basetype) != RECORD_TYPE
12982               && TREE_CODE (basetype) != TYPENAME_TYPE
12983               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12984               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
12985         {
12986           cp_error ("base type `%T' fails to be a struct or class type",
12987                     TREE_VALUE (binfo));
12988           continue;
12989         }
12990
12991       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12992
12993       /* This code replaces similar code in layout_basetypes.
12994          We put the complete_type first for implicit `typename'.  */
12995       if (!COMPLETE_TYPE_P (basetype)
12996           && ! (current_template_parms && uses_template_parms (basetype)))
12997         {
12998           cp_error ("base class `%T' has incomplete type", basetype);
12999           continue;
13000         }
13001       else
13002         {
13003           if (CLASSTYPE_MARKED (basetype))
13004             {
13005               if (basetype == ref)
13006                 cp_error ("recursive type `%T' undefined", basetype);
13007               else
13008                 cp_error ("duplicate base type `%T' invalid", basetype);
13009               continue;
13010             }
13011
13012           if (TYPE_FOR_JAVA (basetype)
13013               && (current_lang_stack
13014                   == &VARRAY_TREE (current_lang_base, 0)))
13015             TYPE_FOR_JAVA (ref) = 1;
13016
13017           /* Note that the BINFO records which describe individual
13018              inheritances are *not* shared in the lattice!  They
13019              cannot be shared because a given baseclass may be
13020              inherited with different `accessibility' by different
13021              derived classes.  (Each BINFO record describing an
13022              individual inheritance contains flags which say what
13023              the `accessibility' of that particular inheritance is.)  */
13024
13025           base_binfo
13026             = make_binfo (size_zero_node, basetype,
13027                           CLASS_TYPE_P (basetype)
13028                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13029                           CLASS_TYPE_P (basetype)
13030                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13031
13032           TREE_VEC_ELT (binfos, i) = base_binfo;
13033           TREE_VIA_PUBLIC (base_binfo) = via_public;
13034           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13035           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13036           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13037
13038           /* We need to unshare the binfos now so that lookups during class
13039              definition work.  */
13040           unshare_base_binfos (base_binfo);
13041
13042           SET_CLASSTYPE_MARKED (basetype);
13043
13044           /* We are free to modify these bits because they are meaningless
13045              at top level, and BASETYPE is a top-level type.  */
13046           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13047             {
13048               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13049               /* Converting to a virtual base class requires looking
13050                  up the offset of the virtual base.  */
13051               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13052             }
13053
13054           if (CLASS_TYPE_P (basetype))
13055             {
13056               TYPE_HAS_NEW_OPERATOR (ref)
13057                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13058               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13059                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13060               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13061               /* If the base-class uses multiple inheritance, so do we.  */
13062               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13063                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13064               /* Likewise, if converting to a base of the base may require
13065                  code, then we may need to generate code to convert to a
13066                  base as well.  */
13067               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13068                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13069             }
13070
13071           i += 1;
13072         }
13073     }
13074   if (i)
13075     TREE_VEC_LENGTH (binfos) = i;
13076   else
13077     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13078
13079   if (i > 1)
13080     {
13081       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13082       /* If there is more than one non-empty they cannot be at the same
13083          address.  */
13084       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13085     }
13086
13087   /* Unmark all the types.  */
13088   while (--i >= 0)
13089     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13090   CLEAR_CLASSTYPE_MARKED (ref);
13091
13092   /* Now that we know all the base-classes, set up the list of virtual
13093      bases.  */
13094   get_vbase_types (ref);
13095 }
13096
13097 \f
13098 /* Begin compiling the definition of an enumeration type.
13099    NAME is its name (or null if anonymous).
13100    Returns the type object, as yet incomplete.
13101    Also records info about it so that build_enumerator
13102    may be used to declare the individual values as they are read.  */
13103
13104 tree
13105 start_enum (name)
13106      tree name;
13107 {
13108   register tree enumtype = NULL_TREE;
13109   struct binding_level *b = current_binding_level;
13110
13111   /* If this is the real definition for a previous forward reference,
13112      fill in the contents in the same object that used to be the
13113      forward reference.  */
13114
13115   if (name != NULL_TREE)
13116     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13117
13118   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13119     {
13120       cp_error ("multiple definition of `%#T'", enumtype);
13121       cp_error_at ("previous definition here", enumtype);
13122       /* Clear out TYPE_VALUES, and start again.  */
13123       TYPE_VALUES (enumtype) = NULL_TREE;
13124     }
13125   else
13126     {
13127       enumtype = make_node (ENUMERAL_TYPE);
13128       pushtag (name, enumtype, 0);
13129     }
13130
13131   if (current_class_type)
13132     TREE_ADDRESSABLE (b->tags) = 1;
13133
13134   GNU_xref_decl (current_function_decl, enumtype);
13135   return enumtype;
13136 }
13137
13138 /* After processing and defining all the values of an enumeration type,
13139    install their decls in the enumeration type and finish it off.
13140    ENUMTYPE is the type object and VALUES a list of name-value pairs.
13141    Returns ENUMTYPE.  */
13142
13143 tree
13144 finish_enum (enumtype)
13145      tree enumtype;
13146 {
13147   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
13148   /* Calculate the maximum value of any enumerator in this type.  */
13149
13150   tree values = TYPE_VALUES (enumtype);
13151   if (values)
13152     {
13153       tree pair;
13154
13155       for (pair = values; pair; pair = TREE_CHAIN (pair))
13156         {
13157           tree decl;
13158           tree value;
13159
13160           /* The TREE_VALUE is a CONST_DECL for this enumeration
13161              constant.  */
13162           decl = TREE_VALUE (pair);
13163
13164           /* [dcl.enum]
13165
13166              Following the closing brace of an enum-specifier, each
13167              enumerator has the type of its enumeration.  Prior to the
13168              closing brace, the type of each enumerator is the type of
13169              its initializing value.  */
13170           TREE_TYPE (decl) = enumtype;
13171
13172           /* The DECL_INITIAL will be NULL if we are processing a
13173              template declaration and this enumeration constant had no
13174              explicit initializer.  */
13175           value = DECL_INITIAL (decl);
13176           if (value && !processing_template_decl)
13177             {
13178               /* Set the TREE_TYPE for the VALUE as well.  That's so
13179                  that when we call decl_constant_value we get an
13180                  entity of the right type (but with the constant
13181                  value).  Since we shouldn't ever call
13182                  decl_constant_value on a template type, there's no
13183                  reason to do that when processing_template_decl.
13184                  And, if the expression is something like a
13185                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13186                  wreak havoc on the intended type of the expression.
13187
13188                  Of course, there's also no point in trying to compute
13189                  minimum or maximum values if we're in a template.  */
13190               TREE_TYPE (value) = enumtype;
13191
13192               if (!minnode)
13193                 minnode = maxnode = value;
13194               else if (tree_int_cst_lt (maxnode, value))
13195                 maxnode = value;
13196               else if (tree_int_cst_lt (value, minnode))
13197                 minnode = value;
13198             }
13199
13200           if (processing_template_decl)
13201             /* If this is just a template, leave the CONST_DECL
13202                alone.  That way tsubst_copy will find CONST_DECLs for
13203                CONST_DECLs, and not INTEGER_CSTs.  */
13204             ;
13205           else
13206             /* In the list we're building up, we want the enumeration
13207                values, not the CONST_DECLs.  */
13208             TREE_VALUE (pair) = value;
13209         }
13210     }
13211   else
13212     maxnode = minnode = integer_zero_node;
13213
13214   TYPE_VALUES (enumtype) = nreverse (values);
13215
13216   if (processing_template_decl)
13217     {
13218       tree scope = current_scope ();
13219       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13220         add_tree (build_min (TAG_DEFN, enumtype));
13221     }
13222   else
13223     {
13224       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
13225       int lowprec = min_precision (minnode, unsignedp);
13226       int highprec = min_precision (maxnode, unsignedp);
13227       int precision = MAX (lowprec, highprec);
13228       tree tem;
13229
13230       TYPE_SIZE (enumtype) = NULL_TREE;
13231
13232       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13233
13234       TYPE_PRECISION (enumtype) = precision;
13235       if (unsignedp)
13236         fixup_unsigned_type (enumtype);
13237       else
13238         fixup_signed_type (enumtype);
13239
13240       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13241         /* Use the width of the narrowest normal C type which is wide
13242            enough.  */
13243         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13244                                                     (precision, 1));
13245       else
13246         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13247
13248       TYPE_SIZE (enumtype) = 0;
13249       layout_type (enumtype);
13250
13251       /* Fix up all variant types of this enum type.  */
13252       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
13253            tem = TYPE_NEXT_VARIANT (tem))
13254         {
13255           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
13256           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
13257           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
13258           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
13259           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
13260           TYPE_MODE (tem) = TYPE_MODE (enumtype);
13261           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
13262           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
13263           TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
13264           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
13265         }
13266
13267       /* Finish debugging output for this type.  */
13268       rest_of_type_compilation (enumtype, namespace_bindings_p ());
13269     }
13270
13271   return enumtype;
13272 }
13273
13274 /* Build and install a CONST_DECL for an enumeration constant of the
13275    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13276    Assignment of sequential values by default is handled here.  */
13277
13278 void
13279 build_enumerator (name, value, enumtype)
13280      tree name;
13281      tree value;
13282      tree enumtype;
13283 {
13284   tree decl;
13285   tree context;
13286   tree type;
13287   tree values;
13288
13289   /* Remove no-op casts from the value.  */
13290   if (value)
13291     STRIP_TYPE_NOPS (value);
13292
13293   if (! processing_template_decl)
13294     {
13295       /* Validate and default VALUE.  */
13296       if (value != NULL_TREE)
13297         {
13298           value = decl_constant_value (value);
13299
13300           if (TREE_CODE (value) == INTEGER_CST)
13301             {
13302               value = default_conversion (value);
13303               constant_expression_warning (value);
13304             }
13305           else
13306             {
13307               cp_error ("enumerator value for `%D' not integer constant", name);
13308               value = NULL_TREE;
13309             }
13310         }
13311
13312       /* Default based on previous value.  */
13313       if (value == NULL_TREE && ! processing_template_decl)
13314         {
13315           tree prev_value;
13316
13317           if (TYPE_VALUES (enumtype))
13318             {
13319               /* The next value is the previous value ... */
13320               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13321               /* ... plus one.  */
13322               value = cp_build_binary_op (PLUS_EXPR,
13323                                           prev_value,
13324                                           integer_one_node);
13325
13326               if (tree_int_cst_lt (value, prev_value))
13327                 cp_error ("overflow in enumeration values at `%D'", name);
13328             }
13329           else
13330             value = integer_zero_node;
13331         }
13332
13333       /* Remove no-op casts from the value.  */
13334       if (value)
13335         STRIP_TYPE_NOPS (value);
13336 #if 0
13337       /* To fix MAX_VAL enum consts. (bkoz)  */
13338       TREE_TYPE (value) = integer_type_node;
13339 #endif
13340     }
13341
13342   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13343      Even in other cases, we will later (in finish_enum) be setting
13344      the type of VALUE.  But, we don't need to make a copy if this
13345      VALUE is one of the enumeration constants for this same
13346      enumeration type.  */
13347   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13348     if (TREE_VALUE (values) == value)
13349       break;
13350   /* If we didn't break out of the loop, then we do need a copy.  */
13351   if (!values && value)
13352     value = copy_node (value);
13353
13354   /* C++ associates enums with global, function, or class declarations.  */
13355   context = current_scope ();
13356
13357   /* Build the actual enumeration constant.  Note that the enumeration
13358     constants have the type of their initializers until the
13359     enumeration is complete:
13360
13361       [ dcl.enum ]
13362
13363       Following the closing brace of an enum-specifier, each enumer-
13364       ator has the type of its enumeration.  Prior to the closing
13365       brace, the type of each enumerator is the type of its
13366       initializing value.
13367
13368     In finish_enum we will reset the type.  Of course, if we're
13369     processing a template, there may be no value.   */
13370   type = value ? TREE_TYPE (value) : NULL_TREE;
13371
13372   if (context && context == current_class_type)
13373     /* This enum declaration is local to the class.  We need the full
13374       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13375     decl = build_lang_decl (CONST_DECL, name, type);
13376   else
13377     /* It's a global enum, or it's local to a function.  (Note local to
13378       a function could mean local to a class method.  */
13379     decl = build_decl (CONST_DECL, name, type);
13380
13381   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13382   DECL_INITIAL (decl) = value;
13383   TREE_READONLY (decl) = 1;
13384
13385   if (context && context == current_class_type)
13386     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13387       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13388       things like `S::i' later.)  */
13389     finish_member_declaration (decl);
13390   else
13391     {
13392       pushdecl (decl);
13393       GNU_xref_decl (current_function_decl, decl);
13394     }
13395
13396   /* Add this enumeration constant to the list for this type.  */
13397   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13398 }
13399
13400 \f
13401 /* We're defining DECL.  Make sure that it's type is OK.  */
13402
13403 static void
13404 check_function_type (decl)
13405      tree decl;
13406 {
13407   tree fntype = TREE_TYPE (decl);
13408   tree return_type = complete_type (TREE_TYPE (fntype));
13409
13410   /* In a function definition, arg types must be complete.  */
13411   require_complete_types_for_parms (current_function_parms);
13412
13413   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13414     {
13415       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13416
13417       /* Make it return void instead, but don't change the
13418          type of the DECL_RESULT, in case we have a named return value.  */
13419       if (TREE_CODE (fntype) == METHOD_TYPE)
13420         {
13421           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13422           TREE_TYPE (decl)
13423             = build_cplus_method_type (ctype,
13424                                        void_type_node,
13425                                        FUNCTION_ARG_CHAIN (decl));
13426         }
13427       else
13428         TREE_TYPE (decl)
13429           = build_function_type (void_type_node,
13430                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13431       TREE_TYPE (decl)
13432         = build_exception_variant (fntype,
13433                                    TYPE_RAISES_EXCEPTIONS (fntype));
13434     }
13435   else
13436     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13437 }
13438
13439 /* Create the FUNCTION_DECL for a function definition.
13440    DECLSPECS and DECLARATOR are the parts of the declaration;
13441    they describe the function's name and the type it returns,
13442    but twisted together in a fashion that parallels the syntax of C.
13443
13444    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13445    DECLARATOR is really the DECL for the function we are about to
13446    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13447    indicating that the function is an inline defined in-class, and
13448    SF_EXPAND indicating that we should generate RTL for this
13449    function.
13450
13451    This function creates a binding context for the function body
13452    as well as setting up the FUNCTION_DECL in current_function_decl.
13453
13454    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13455    (it defines a datum instead), we return 0, which tells
13456    yyparse to report a parse error.
13457
13458    For C++, we must first check whether that datum makes any sense.
13459    For example, "class A local_a(1,2);" means that variable local_a
13460    is an aggregate of type A, which should have a constructor
13461    applied to it with the argument list [1, 2].  */
13462
13463 int
13464 start_function (declspecs, declarator, attrs, flags)
13465      tree declspecs, declarator, attrs;
13466      int flags;
13467 {
13468   tree decl1;
13469   tree ctype = NULL_TREE;
13470   tree fntype;
13471   tree restype;
13472   extern int have_extern_spec;
13473   extern int used_extern_spec;
13474   int doing_friend = 0;
13475   struct binding_level *bl;
13476
13477   /* Sanity check.  */
13478   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13479   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13480
13481   /* This should only be done once on the top most decl.  */
13482   if (have_extern_spec && !used_extern_spec)
13483     {
13484       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13485       used_extern_spec = 1;
13486     }
13487
13488   if (flags & SF_PRE_PARSED)
13489     {
13490       decl1 = declarator;
13491
13492       fntype = TREE_TYPE (decl1);
13493       if (TREE_CODE (fntype) == METHOD_TYPE)
13494         ctype = TYPE_METHOD_BASETYPE (fntype);
13495
13496       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13497          the (lexical) scope of the class in which it is defined.  */
13498       if (!ctype && DECL_FRIEND_P (decl1))
13499         {
13500           ctype = DECL_FRIEND_CONTEXT (decl1);
13501
13502           /* CTYPE could be null here if we're dealing with a template;
13503              for example, `inline friend float foo()' inside a template
13504              will have no CTYPE set.  */
13505           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13506             ctype = NULL_TREE;
13507           else
13508             doing_friend = 1;
13509         }
13510
13511       last_function_parms = DECL_ARGUMENTS (decl1);
13512       last_function_parm_tags = NULL_TREE;
13513     }
13514   else
13515     {
13516       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13517       /* If the declarator is not suitable for a function definition,
13518          cause a syntax error.  */
13519       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13520
13521       fntype = TREE_TYPE (decl1);
13522
13523       restype = TREE_TYPE (fntype);
13524       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13525         {
13526           cp_error ("semicolon missing after declaration of `%#T'", restype);
13527           shadow_tag (build_tree_list (NULL_TREE, restype));
13528           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13529           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13530             fntype = build_function_type (integer_type_node,
13531                                           TYPE_ARG_TYPES (fntype));
13532           else
13533             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13534                                               integer_type_node,
13535                                               TYPE_ARG_TYPES (fntype));
13536           TREE_TYPE (decl1) = fntype;
13537         }
13538
13539       if (TREE_CODE (fntype) == METHOD_TYPE)
13540         ctype = TYPE_METHOD_BASETYPE (fntype);
13541       else if (DECL_MAIN_P (decl1))
13542         {
13543           /* If this doesn't return integer_type, complain.  */
13544           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13545             {
13546               if (pedantic || warn_return_type)
13547                 pedwarn ("return type for `main' changed to `int'");
13548               TREE_TYPE (decl1) = fntype = default_function_type;
13549             }
13550         }
13551     }
13552
13553   /* Sometimes we don't notice that a function is a static member, and
13554      build a METHOD_TYPE for it.  Fix that up now.  */
13555   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13556       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13557     {
13558       revert_static_member_fn (decl1);
13559       last_function_parms = TREE_CHAIN (last_function_parms);
13560       ctype = NULL_TREE;
13561     }
13562
13563   /* Warn if function was previously implicitly declared
13564      (but not if we warned then).  */
13565   if (! warn_implicit
13566       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13567     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13568
13569   /* Set up current_class_type, and enter the scope of the class, if
13570      appropriate.  */
13571   if (ctype)
13572     push_nested_class (ctype, 1);
13573   else if (DECL_STATIC_FUNCTION_P (decl1))
13574     push_nested_class (DECL_CONTEXT (decl1), 2);
13575
13576   /* Now that we have entered the scope of the class, we must restore
13577      the bindings for any template parameters surrounding DECL1, if it
13578      is an inline member template.  (Order is important; consider the
13579      case where a template parameter has the same name as a field of
13580      the class.)  It is not until after this point that
13581      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13582   if (flags & SF_INCLASS_INLINE)
13583     maybe_begin_member_template_processing (decl1);
13584
13585   /* Effective C++ rule 15.  See also c_expand_return.  */
13586   if (warn_ecpp
13587       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13588       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13589     cp_warning ("`operator=' should return a reference to `*this'");
13590
13591   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13592      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13593   if (!DECL_INITIAL (decl1))
13594     DECL_INITIAL (decl1) = error_mark_node;
13595
13596 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13597   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13598 #endif
13599
13600   /* This function exists in static storage.
13601      (This does not mean `static' in the C sense!)  */
13602   TREE_STATIC (decl1) = 1;
13603
13604   /* We must call push_template_decl after current_class_type is set
13605      up.  (If we are processing inline definitions after exiting a
13606      class scope, current_class_type will be NULL_TREE until set above
13607      by push_nested_class.)  */
13608   if (processing_template_decl)
13609     decl1 = push_template_decl (decl1);
13610
13611   /* We are now in the scope of the function being defined.  */
13612   current_function_decl = decl1;
13613
13614   /* Save the parm names or decls from this function's declarator
13615      where store_parm_decls will find them.  */
13616   current_function_parms = last_function_parms;
13617   current_function_parm_tags = last_function_parm_tags;
13618
13619   /* Make sure the parameter and return types are reasonable.  When
13620      you declare a function, these types can be incomplete, but they
13621      must be complete when you define the function.  */
13622   if (! processing_template_decl)
13623     check_function_type (decl1);
13624
13625   /* Build the return declaration for the function.  */
13626   restype = TREE_TYPE (fntype);
13627   if (!processing_template_decl)
13628     {
13629       if (!DECL_RESULT (decl1))
13630         {
13631           DECL_RESULT (decl1)
13632             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13633           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13634                                       DECL_RESULT (decl1));
13635         }
13636     }
13637   else
13638     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13639     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13640
13641   /* Initialize RTL machinery.  We cannot do this until
13642      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13643      even when processing a template; this is how we get
13644      CFUN set up, and our per-function variables initialized.  */
13645   bl = current_binding_level;
13646   init_function_start (decl1, input_filename, lineno);
13647   current_binding_level = bl;
13648   expanding_p = (flags & SF_EXPAND) != 0;
13649
13650   /* Even though we're inside a function body, we still don't want to
13651      call expand_expr to calculate the size of a variable-sized array.
13652      We haven't necessarily assigned RTL to all variables yet, so it's
13653      not safe to try to expand expressions involving them.  */
13654   immediate_size_expand = 0;
13655   cfun->x_dont_save_pending_sizes_p = 1;
13656
13657   /* If we're building a statement-tree, start the tree now.  */
13658   if (processing_template_decl || !expanding_p)
13659     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13660
13661   /* Let the user know we're compiling this function.  */
13662   announce_function (decl1);
13663
13664   /* Record the decl so that the function name is defined.
13665      If we already have a decl for this name, and it is a FUNCTION_DECL,
13666      use the old decl.  */
13667   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13668     {
13669       /* A specialization is not used to guide overload resolution.  */
13670       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13671           && ! DECL_FUNCTION_MEMBER_P (decl1))
13672         decl1 = pushdecl (decl1);
13673       else
13674         {
13675           /* We need to set the DECL_CONTEXT. */
13676           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13677             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13678           /* And make sure we have enough default args.  */
13679           check_default_args (decl1);
13680         }
13681       fntype = TREE_TYPE (decl1);
13682     }
13683
13684   /* Reset these in case the call to pushdecl changed them.  */
13685   current_function_decl = decl1;
13686   cfun->decl = decl1;
13687
13688   /* Initialize the per-function data.  */
13689   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13690     {
13691       /* If we already parsed this function, and we're just expanding it
13692          now, restore saved state.  */
13693       struct binding_level *bl = current_binding_level;
13694       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13695       current_binding_level = bl;
13696
13697       /* This function is being processed in whole-function mode; we
13698          already did semantic analysis.  */
13699       cfun->x_whole_function_mode_p = 1;
13700
13701       /* If we decided that we didn't want to inline this function,
13702          make sure the back-end knows that.  */
13703       if (!current_function_cannot_inline)
13704         current_function_cannot_inline = cp_function_chain->cannot_inline;
13705
13706       /* We don't need the saved data anymore.  */
13707       free (DECL_SAVED_FUNCTION_DATA (decl1));
13708       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13709     }
13710   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13711     {
13712       /* We know that this was set up by `grokclassfn'.  We do not
13713          wait until `store_parm_decls', since evil parse errors may
13714          never get us to that point.  Here we keep the consistency
13715          between `current_class_type' and `current_class_ptr'.  */
13716       tree t = DECL_ARGUMENTS (decl1);
13717
13718       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13719                           162);
13720       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13721                           19990811);
13722
13723       cp_function_chain->x_current_class_ref
13724         = build_indirect_ref (t, NULL_PTR);
13725       cp_function_chain->x_current_class_ptr = t;
13726
13727       /* Constructors and destructors need to know whether they're "in
13728          charge" of initializing virtual base classes.  */
13729       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13730         current_in_charge_parm = TREE_CHAIN (t);
13731     }
13732
13733   if (DECL_INTERFACE_KNOWN (decl1))
13734     {
13735       tree ctx = decl_function_context (decl1);
13736
13737       if (DECL_NOT_REALLY_EXTERN (decl1))
13738         DECL_EXTERNAL (decl1) = 0;
13739
13740       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13741           && TREE_PUBLIC (ctx))
13742         /* This is a function in a local class in an extern inline
13743            function.  */
13744         comdat_linkage (decl1);
13745     }
13746   /* If this function belongs to an interface, it is public.
13747      If it belongs to someone else's interface, it is also external.
13748      This only affects inlines and template instantiations.  */
13749   else if (interface_unknown == 0
13750            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13751                || flag_alt_external_templates))
13752     {
13753       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13754           || processing_template_decl)
13755         {
13756           DECL_EXTERNAL (decl1)
13757             = (interface_only
13758                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13759                    && !DECL_VINDEX (decl1)));
13760
13761           /* For WIN32 we also want to put these in linkonce sections.  */
13762           maybe_make_one_only (decl1);
13763         }
13764       else
13765         DECL_EXTERNAL (decl1) = 0;
13766       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13767       DECL_INTERFACE_KNOWN (decl1) = 1;
13768     }
13769   else if (interface_unknown && interface_only
13770            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13771                || flag_alt_external_templates))
13772     {
13773       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13774          interface, we will have interface_only set but not
13775          interface_known.  In that case, we don't want to use the normal
13776          heuristics because someone will supply a #pragma implementation
13777          elsewhere, and deducing it here would produce a conflict.  */
13778       comdat_linkage (decl1);
13779       DECL_EXTERNAL (decl1) = 0;
13780       DECL_INTERFACE_KNOWN (decl1) = 1;
13781       DECL_DEFER_OUTPUT (decl1) = 1;
13782     }
13783   else
13784     {
13785       /* This is a definition, not a reference.
13786          So clear DECL_EXTERNAL.  */
13787       DECL_EXTERNAL (decl1) = 0;
13788
13789       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13790           && ! DECL_INTERFACE_KNOWN (decl1)
13791           /* Don't try to defer nested functions for now.  */
13792           && ! decl_function_context (decl1))
13793         DECL_DEFER_OUTPUT (decl1) = 1;
13794       else
13795         DECL_INTERFACE_KNOWN (decl1) = 1;
13796     }
13797
13798   if (doing_semantic_analysis_p ())
13799     {
13800       pushlevel (0);
13801       current_binding_level->parm_flag = 1;
13802     }
13803
13804   if (attrs)
13805     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13806
13807   if (!building_stmt_tree ())
13808     {
13809       GNU_xref_function (decl1, current_function_parms);
13810       make_function_rtl (decl1);
13811     }
13812
13813   /* Promote the value to int before returning it.  */
13814   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13815     restype = type_promotes_to (restype);
13816
13817   /* If this fcn was already referenced via a block-scope `extern' decl
13818      (or an implicit decl), propagate certain information about the usage.  */
13819   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13820     TREE_ADDRESSABLE (decl1) = 1;
13821
13822   if (DECL_RESULT (decl1) == NULL_TREE)
13823     {
13824       DECL_RESULT (decl1)
13825         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13826       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13827       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13828     }
13829
13830   ++function_depth;
13831
13832   if (DECL_DESTRUCTOR_P (decl1))
13833     {
13834       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13835       DECL_CONTEXT (dtor_label) = current_function_decl;
13836     }
13837   /* Under the old ABI we return `this' from constructors, so we make
13838      ordinary `return' statements in constructors jump to CTOR_LABEL;
13839      from there we return `this'.  Under the new ABI, we don't bother
13840      with any of this.  By not setting CTOR_LABEL the remainder of the
13841      machinery is automatically disabled.  */
13842   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13843     {
13844       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13845       DECL_CONTEXT (ctor_label) = current_function_decl;
13846     }
13847
13848   return 1;
13849 }
13850 \f
13851 /* Called after store_parm_decls for a function-try-block.  */
13852
13853 void
13854 expand_start_early_try_stmts ()
13855 {
13856   expand_start_try_stmts ();
13857 }
13858
13859 /* Store the parameter declarations into the current function declaration.
13860    This is called after parsing the parameter declarations, before
13861    digesting the body of the function.
13862
13863    Also install to binding contour return value identifier, if any.  */
13864
13865 void
13866 store_parm_decls ()
13867 {
13868   register tree fndecl = current_function_decl;
13869   register tree parm;
13870   int parms_have_cleanups = 0;
13871   tree cleanups = NULL_TREE;
13872
13873   /* This is a list of types declared among parms in a prototype.  */
13874   tree parmtags = current_function_parm_tags;
13875
13876   /* This is a chain of any other decls that came in among the parm
13877      declarations.  If a parm is declared with  enum {foo, bar} x;
13878      then CONST_DECLs for foo and bar are put here.  */
13879   tree nonparms = NULL_TREE;
13880
13881   /* Create a binding level for the parms.  */
13882   if (!building_stmt_tree ())
13883     expand_start_bindings (2);
13884
13885   if (current_function_parms)
13886     {
13887       /* This case is when the function was defined with an ANSI prototype.
13888          The parms already have decls, so we need not do anything here
13889          except record them as in effect
13890          and complain if any redundant old-style parm decls were written.  */
13891
13892       tree specparms = current_function_parms;
13893       tree next;
13894
13895       if (doing_semantic_analysis_p ())
13896         {
13897           /* Must clear this because it might contain TYPE_DECLs declared
13898              at class level.  */
13899           storedecls (NULL_TREE);
13900
13901           /* If we're doing semantic analysis, then we'll call pushdecl
13902              for each of these.  We must do them in reverse order so that
13903              they end in the correct forward order.  */
13904           specparms = nreverse (specparms);
13905         }
13906
13907       for (parm = specparms; parm; parm = next)
13908         {
13909           next = TREE_CHAIN (parm);
13910           if (TREE_CODE (parm) == PARM_DECL)
13911             {
13912               tree type = TREE_TYPE (parm);
13913
13914               if (doing_semantic_analysis_p ())
13915                 {
13916                   tree cleanup;
13917
13918                   if (DECL_NAME (parm) == NULL_TREE
13919                       || TREE_CODE (parm) != VOID_TYPE)
13920                     pushdecl (parm);
13921                   else
13922                     cp_error ("parameter `%D' declared void", parm);
13923
13924                   cleanup = (processing_template_decl
13925                              ? NULL_TREE
13926                              : maybe_build_cleanup (parm));
13927
13928                   if (cleanup)
13929                     cleanups = tree_cons (parm, cleanup, cleanups);
13930                 }
13931               else if (type != error_mark_node
13932                        && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13933                 parms_have_cleanups = 1;
13934             }
13935           else
13936             {
13937               /* If we find an enum constant or a type tag,
13938                  put it aside for the moment.  */
13939               TREE_CHAIN (parm) = NULL_TREE;
13940               nonparms = chainon (nonparms, parm);
13941             }
13942         }
13943
13944       if (doing_semantic_analysis_p ())
13945         {
13946           /* Get the decls in their original chain order
13947              and record in the function.  This is all and only the
13948              PARM_DECLs that were pushed into scope by the loop above.  */
13949           DECL_ARGUMENTS (fndecl) = getdecls ();
13950           storetags (chainon (parmtags, gettags ()));
13951         }
13952     }
13953   else
13954     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13955
13956   /* Now store the final chain of decls for the arguments
13957      as the decl-chain of the current lexical scope.
13958      Put the enumerators in as well, at the front so that
13959      DECL_ARGUMENTS is not modified.  */
13960   if (doing_semantic_analysis_p ())
13961     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13962
13963   /* Initialize the RTL code for the function.  */
13964   DECL_SAVED_INSNS (fndecl) = 0;
13965   if (! building_stmt_tree ())
13966     expand_function_start (fndecl, parms_have_cleanups);
13967
13968   current_function_parms_stored = 1;
13969
13970   /* If this function is `main', emit a call to `__main'
13971      to run global initializers, etc.  */
13972   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
13973     expand_main_function ();
13974
13975   /* Now that we have initialized the parms, we can start their
13976      cleanups.  We cannot do this before, since expand_decl_cleanup
13977      should not be called before the parm can be used.  */
13978   while (cleanups)
13979     {
13980       finish_decl_cleanup (TREE_PURPOSE (cleanups),
13981                            TREE_VALUE (cleanups));
13982       cleanups = TREE_CHAIN (cleanups);
13983     }
13984
13985   /* Create a binding contour which can be used to catch
13986      cleanup-generated temporaries.  Also, if the return value needs or
13987      has initialization, deal with that now.  */
13988   if (parms_have_cleanups)
13989     {
13990       pushlevel (0);
13991       if (!building_stmt_tree ())
13992         expand_start_bindings (2);
13993     }
13994
13995   /* Do the starting of the exception specifications, if we have any.  */
13996   if (flag_exceptions && !processing_template_decl
13997       && flag_enforce_eh_specs
13998       && building_stmt_tree ()
13999       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14000     current_eh_spec_try_block = expand_start_eh_spec ();
14001 }
14002
14003 /* Bind a name and initialization to the return value of
14004    the current function.  */
14005
14006 void
14007 store_return_init (decl)
14008      tree decl;
14009 {
14010   /* If this named return value comes in a register, put it in a
14011      pseudo-register.  */
14012   if (DECL_REGISTER (decl))
14013     {
14014       original_result_rtx = DECL_RTL (decl);
14015       /* Note that the mode of the old DECL_RTL may be wider than the
14016          mode of DECL_RESULT, depending on the calling conventions for
14017          the processor.  For example, on the Alpha, a 32-bit integer
14018          is returned in a DImode register -- the DECL_RESULT has
14019          SImode but the DECL_RTL for the DECL_RESULT has DImode.  So,
14020          here, we use the mode the back-end has already assigned for
14021          the return value.  */
14022       DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
14023       if (TREE_ADDRESSABLE (decl))
14024         put_var_into_stack (decl);
14025     }
14026 }
14027
14028 \f
14029 /* We have finished doing semantic analysis on DECL, but have not yet
14030    generated RTL for its body.  Save away our current state, so that
14031    when we want to generate RTL later we know what to do.  */
14032
14033 static void
14034 save_function_data (decl)
14035      tree decl;
14036 {
14037   struct language_function *f;
14038
14039   /* Save the language-specific per-function data so that we can
14040      get it back when we really expand this function.  */
14041   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14042                       19990908);
14043
14044   /* Make a copy.  */
14045   f = ((struct language_function *)
14046        xmalloc (sizeof (struct language_function)));
14047   bcopy ((char *) cp_function_chain, (char *) f,
14048          sizeof (struct language_function));
14049   DECL_SAVED_FUNCTION_DATA (decl) = f;
14050
14051   /* Clear out the bits we don't need.  */
14052   f->x_stmt_tree.x_last_stmt = NULL_TREE;
14053   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
14054   f->x_result_rtx = NULL_RTX;
14055   f->x_named_label_uses = NULL;
14056   f->bindings = NULL;
14057
14058   /* When we get back here again, we will be expanding.  */
14059   f->x_expanding_p = 1;
14060
14061   /* If we've already decided that we cannot inline this function, we
14062      must remember that fact when we actually go to expand the
14063      function.  */
14064   f->cannot_inline = current_function_cannot_inline;
14065 }
14066
14067 /* At the end of every constructor we generate to code to return
14068    `this'.  Do that now.  */
14069
14070 static void
14071 finish_constructor_body ()
14072 {
14073   /* Any return from a constructor will end up here.  */
14074   if (ctor_label)
14075     add_tree (build_stmt (LABEL_STMT, ctor_label));
14076
14077   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
14078      generate the return, rather than a goto to CTOR_LABEL.  */
14079   ctor_label = NULL_TREE;
14080   /* In check_return_expr we translate an empty return from a
14081      constructor to a return of `this'.  */
14082   finish_return_stmt (NULL_TREE);
14083   /* Mark the end of the constructor.  */
14084   add_tree (build_stmt (CTOR_STMT));
14085 }
14086
14087 /* At the end of every destructor we generate code to restore virtual
14088    function tables to the values desired by base classes and to call
14089    to base class destructors.  Do that now.  */
14090
14091 static void
14092 finish_destructor_body ()
14093 {
14094   tree compound_stmt;
14095   tree virtual_size;
14096   tree exprstmt;
14097   tree if_stmt;
14098
14099   /* Create a block to contain all the extra code.  */
14100   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14101
14102   /* Any return from a destructor will end up here.  */
14103   add_tree (build_stmt (LABEL_STMT, dtor_label));
14104
14105   /* Generate the code to call destructor on base class.  If this
14106      destructor belongs to a class with virtual functions, then set
14107      the virtual function table pointer to represent the type of our
14108      base class.  */
14109
14110   /* This side-effect makes call to `build_delete' generate the code
14111      we have to have at the end of this destructor.  `build_delete'
14112      will set the flag again.  */
14113   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
14114
14115   exprstmt = build_delete (current_class_type,
14116                            current_class_ref,
14117                            sfk_base_destructor,
14118                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
14119                            0);
14120
14121   if (exprstmt != error_mark_node
14122       && (TREE_CODE (exprstmt) != NOP_EXPR
14123           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
14124           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
14125     {
14126       if (exprstmt != void_zero_node)
14127         /* Don't call `expand_expr_stmt' if we're not going to do
14128            anything, since -Wall will give a diagnostic.  */
14129         finish_expr_stmt (exprstmt);
14130
14131       /* Run destructors for all virtual baseclasses.  */
14132       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
14133         {
14134           tree vbases;
14135           tree if_stmt;
14136
14137           if_stmt = begin_if_stmt ();
14138           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14139                                       current_in_charge_parm,
14140                                       integer_two_node),
14141                                if_stmt);
14142
14143           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
14144           /* The CLASSTYPE_VBASECLASSES list is in initialization
14145              order, so we have to march through it in reverse order.  */
14146           for (vbases = nreverse (copy_list (vbases));
14147                vbases;
14148                vbases = TREE_CHAIN (vbases))
14149             {
14150               tree vbase = TREE_VALUE (vbases);
14151
14152               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase)))
14153                 {
14154                   tree vb = get_vbase
14155                     (BINFO_TYPE (vbase),
14156                      TYPE_BINFO (current_class_type));
14157                   finish_expr_stmt
14158                     (build_scoped_method_call
14159                      (current_class_ref, vb, base_dtor_identifier,
14160                       NULL_TREE));
14161                 }
14162             }
14163
14164           finish_then_clause (if_stmt);
14165           finish_if_stmt ();
14166         }
14167     }
14168
14169   virtual_size = c_sizeof (current_class_type);
14170
14171   /* At the end, call delete if that's what's requested.  */
14172
14173   /* FDIS sez: At the point of definition of a virtual destructor
14174      (including an implicit definition), non-placement operator delete
14175      shall be looked up in the scope of the destructor's class and if
14176      found shall be accessible and unambiguous.
14177
14178      This is somewhat unclear, but I take it to mean that if the class
14179      only defines placement deletes we don't do anything here.  So we
14180      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14181      they ever try to delete one of these.  */
14182   exprstmt = build_op_delete_call
14183     (DELETE_EXPR, current_class_ptr, virtual_size,
14184      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14185
14186   if_stmt = begin_if_stmt ();
14187   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14188                               current_in_charge_parm,
14189                               integer_one_node),
14190                        if_stmt);
14191   finish_expr_stmt (exprstmt);
14192   finish_then_clause (if_stmt);
14193   finish_if_stmt ();
14194
14195   /* Close the block we started above.  */
14196   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14197 }
14198
14199 /* Finish up a function declaration and compile that function
14200    all the way to assembler language output.  The free the storage
14201    for the function definition.
14202
14203    FLAGS is a bitwise or of the following values:
14204      1 - CALL_POPLEVEL
14205        An extra call to poplevel (and expand_end_bindings) must be
14206        made to take care of the binding contour for the base
14207        initializers.  This is only relevant for constructors.
14208      2 - INCLASS_INLINE
14209        We just finished processing the body of an in-class inline
14210        function definition.  (This processing will have taken place
14211        after the class definition is complete.)  */
14212
14213 tree
14214 finish_function (flags)
14215      int flags;
14216 {
14217   register tree fndecl = current_function_decl;
14218   tree fntype, ctype = NULL_TREE;
14219   /* Label to use if this function is supposed to return a value.  */
14220   tree no_return_label = NULL_TREE;
14221   int call_poplevel = (flags & 1) != 0;
14222   int inclass_inline = (flags & 2) != 0;
14223   int expand_p;
14224   int nested;
14225   int current_line = lineno;
14226
14227   /* When we get some parse errors, we can end up without a
14228      current_function_decl, so cope.  */
14229   if (fndecl == NULL_TREE)
14230     return error_mark_node;
14231
14232   nested = function_depth > 1;
14233   fntype = TREE_TYPE (fndecl);
14234
14235   /*  TREE_READONLY (fndecl) = 1;
14236       This caused &foo to be of type ptr-to-const-function
14237       which then got a warning when stored in a ptr-to-function variable.  */
14238
14239   /* This happens on strange parse errors.  */
14240   if (! current_function_parms_stored)
14241     {
14242       call_poplevel = 0;
14243       store_parm_decls ();
14244     }
14245
14246   /* For a cloned function, we've already got all the code we need;
14247      there's no need to add any extra bits.  */
14248   if (building_stmt_tree () && DECL_CLONED_FUNCTION_P (fndecl))
14249     ;
14250   else if (building_stmt_tree ())
14251     {
14252       if (DECL_CONSTRUCTOR_P (fndecl))
14253         {
14254           finish_constructor_body ();
14255           if (call_poplevel)
14256             do_poplevel ();
14257         }
14258       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14259         finish_destructor_body ();
14260       else if (DECL_MAIN_P (fndecl))
14261         {
14262           /* Make it so that `main' always returns 0 by default.  */
14263 #ifdef VMS
14264           finish_return_stmt (integer_one_node);
14265 #else
14266           finish_return_stmt (integer_zero_node);
14267 #endif
14268         }
14269
14270       /* Finish dealing with exception specifiers.  */
14271       if (flag_exceptions && !processing_template_decl
14272           && flag_enforce_eh_specs
14273           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14274         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14275                             (TREE_TYPE (current_function_decl)),
14276                             current_eh_spec_try_block);
14277     }
14278   else
14279     {
14280 #if 0
14281       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
14282         {
14283           /* Keep this code around in case we later want to control debug info
14284              based on whether a type is "used".  (jason 1999-11-11) */
14285
14286           tree ttype = target_type (fntype);
14287           tree parmdecl;
14288
14289           if (IS_AGGR_TYPE (ttype))
14290             /* Let debugger know it should output info for this type.  */
14291             note_debug_info_needed (ttype);
14292
14293           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
14294             {
14295               ttype = target_type (TREE_TYPE (parmdecl));
14296               if (IS_AGGR_TYPE (ttype))
14297                 /* Let debugger know it should output info for this type.  */
14298                 note_debug_info_needed (ttype);
14299             }
14300         }
14301 #endif
14302
14303       /* Clean house because we will need to reorder insns here.  */
14304       do_pending_stack_adjust ();
14305
14306       if (dtor_label)
14307         ;
14308       else if (DECL_CONSTRUCTOR_P (fndecl))
14309         {
14310           if (call_poplevel)
14311             do_poplevel ();
14312         }
14313       else if (return_label != NULL_RTX
14314                && flag_this_is_variable <= 0
14315                && current_function_return_value == NULL_TREE
14316                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
14317         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14318
14319       if (flag_exceptions)
14320         expand_exception_blocks ();
14321
14322       /* If this function is supposed to return a value, ensure that
14323          we do not fall into the cleanups by mistake.  The end of our
14324          function will look like this:
14325
14326          user code (may have return stmt somewhere)
14327          goto no_return_label
14328          cleanup_label:
14329          cleanups
14330          goto return_label
14331          no_return_label:
14332          NOTE_INSN_FUNCTION_END
14333          return_label:
14334          things for return
14335
14336          If the user omits a return stmt in the USER CODE section, we
14337          will have a control path which reaches NOTE_INSN_FUNCTION_END.
14338          Otherwise, we won't.  */
14339       if (no_return_label)
14340         {
14341           DECL_CONTEXT (no_return_label) = fndecl;
14342           DECL_INITIAL (no_return_label) = error_mark_node;
14343           DECL_SOURCE_FILE (no_return_label) = input_filename;
14344           DECL_SOURCE_LINE (no_return_label) = current_line;
14345           expand_goto (no_return_label);
14346         }
14347
14348       if (cleanup_label)
14349         {
14350           /* Remove the binding contour which is used
14351              to catch cleanup-generated temporaries.  */
14352           expand_end_bindings (0, 0, 0);
14353           poplevel (0, 0, 0);
14354
14355           /* Emit label at beginning of cleanup code for parameters.  */
14356           emit_label (cleanup_label);
14357         }
14358
14359       /* Get return value into register if that's where it's supposed
14360          to be.  */
14361       if (original_result_rtx)
14362         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
14363
14364       /* Finish building code that will trigger warnings if users forget
14365          to make their functions return values.  */
14366       if (no_return_label || cleanup_label)
14367         emit_jump (return_label);
14368       if (no_return_label)
14369         {
14370           /* We don't need to call `expand_*_return' here because we
14371              don't need any cleanups here--this path of code is only
14372              for error checking purposes.  */
14373           expand_label (no_return_label);
14374         }
14375
14376       /* We hard-wired immediate_size_expand to zero in
14377          start_function.  Expand_function_end will decrement this
14378          variable.  So, we set the variable to one here, so that after
14379          the decrement it will remain zero.  */
14380       immediate_size_expand = 1;
14381
14382       /* Generate rtl for function exit.  */
14383       expand_function_end (input_filename, current_line, 1);
14384     }
14385
14386   /* We have to save this value here in case
14387      maybe_end_member_template_processing decides to pop all the
14388      template parameters.  */
14389   expand_p = !building_stmt_tree ();
14390
14391   /* If we're saving up tree structure, tie off the function now.  */
14392   if (!expand_p)
14393     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14394
14395   /* This must come after expand_function_end because cleanups might
14396      have declarations (from inline functions) that need to go into
14397      this function's blocks.  */
14398   if (doing_semantic_analysis_p ())
14399     {
14400       if (current_binding_level->parm_flag != 1)
14401         my_friendly_abort (122);
14402       poplevel (1, 0, 1);
14403     }
14404
14405   /* Remember that we were in class scope.  */
14406   if (current_class_name)
14407     ctype = current_class_type;
14408
14409   /* Must mark the RESULT_DECL as being in this function.  */
14410   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14411
14412   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14413      to the FUNCTION_DECL node itself.  */
14414   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14415
14416   /* Save away current state, if appropriate.  */
14417   if (!expanding_p && !processing_template_decl)
14418     save_function_data (fndecl);
14419
14420   /* If this function calls `setjmp' it cannot be inlined.  When
14421      `longjmp' is called it is not guaranteed to restore the value of
14422      local variables that have been modified since the call to
14423      `setjmp'.  So, if were to inline this function into some caller
14424      `c', then when we `longjmp', we might not restore all variables
14425      in `c'.  (It might seem, at first blush, that there's no way for
14426      this function to modify local variables in `c', but their
14427      addresses may have been stored somewhere accessible to this
14428      function.)  */
14429   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
14430     DECL_UNINLINABLE (fndecl) = 1;
14431
14432   if (expand_p)
14433     {
14434       int returns_null;
14435       int returns_value;
14436
14437       /* So we can tell if jump_optimize sets it to 1.  */
14438       can_reach_end = 0;
14439
14440       /* Before we call rest_of_compilation (which will pop the
14441          CURRENT_FUNCTION), we must save these values.  */
14442       returns_null = current_function_returns_null;
14443       returns_value = current_function_returns_value;
14444
14445       /* If this is a nested function (like a template instantiation
14446          that we're compiling in the midst of compiling something
14447          else), push a new GC context.  That will keep local variables
14448          on the stack from being collected while we're doing the
14449          compilation of this function.  */
14450       if (function_depth > 1)
14451         ggc_push_context ();
14452
14453       /* Run the optimizers and output the assembler code for this
14454          function.  */
14455       rest_of_compilation (fndecl);
14456
14457       /* Undo the call to ggc_push_context above.  */
14458       if (function_depth > 1)
14459         ggc_pop_context ();
14460
14461       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
14462         {
14463           /* Set DECL_EXTERNAL so that assemble_external will be called as
14464              necessary.  We'll clear it again in finish_file.  */
14465           if (! DECL_EXTERNAL (fndecl))
14466             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
14467           DECL_EXTERNAL (fndecl) = 1;
14468           defer_fn (fndecl);
14469         }
14470
14471 #if 0
14472       /* Keep this code around in case we later want to control debug info
14473          based on whether a type is "used".  (jason 1999-11-11) */
14474
14475       if (ctype && TREE_ASM_WRITTEN (fndecl))
14476         note_debug_info_needed (ctype);
14477 #endif
14478
14479       if (DECL_NAME (DECL_RESULT (fndecl)))
14480         returns_value |= can_reach_end;
14481       else
14482         returns_null |= can_reach_end;
14483
14484       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
14485         warning ("`noreturn' function does return");
14486       else if (returns_null
14487                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14488         {
14489           /* Always complain if there's just no return statement.  */
14490           if (!returns_value)
14491             warning ("no return statement in function returning non-void");
14492           else if (warn_return_type || pedantic)
14493             /* If this function returns non-void and control can drop through,
14494                complain.  */
14495             warning ("control reaches end of non-void function");
14496         }
14497     }
14498   else
14499     {
14500       /* Clear out memory we no longer need.  */
14501       free_after_parsing (cfun);
14502       /* Since we never call rest_of_compilation, we never clear
14503          CFUN.  Do so explicitly.  */
14504       free_after_compilation (cfun);
14505       cfun = NULL;
14506     }
14507
14508   /* If this is a in-class inline definition, we may have to pop the
14509      bindings for the template parameters that we added in
14510      maybe_begin_member_template_processing when start_function was
14511      called.  */
14512   if (inclass_inline)
14513     maybe_end_member_template_processing ();
14514
14515   /* Leave the scope of the class.  */
14516   if (ctype)
14517     pop_nested_class ();
14518
14519   --function_depth;
14520
14521   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14522       && !(flag_inline_trees && DECL_INLINE (fndecl)))
14523     {
14524       tree t;
14525
14526       /* Stop pointing to the local nodes about to be freed.  */
14527       /* But DECL_INITIAL must remain nonzero so we know this
14528          was an actual function definition.  */
14529       DECL_INITIAL (fndecl) = error_mark_node;
14530       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14531         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14532     }
14533
14534   if (DECL_STATIC_CONSTRUCTOR (fndecl))
14535     static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14536   if (DECL_STATIC_DESTRUCTOR (fndecl))
14537     static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14538
14539   /* Clean up.  */
14540   if (! nested)
14541     {
14542       /* Let the error reporting routines know that we're outside a
14543          function.  For a nested function, this value is used in
14544          pop_cp_function_context and then reset via pop_function_context.  */
14545       current_function_decl = NULL_TREE;
14546       /* We don't really care about obstacks, but the middle-end
14547          sometimes cares on what obstck things are located.  */
14548       permanent_allocation (1);
14549     }
14550
14551   return fndecl;
14552 }
14553 \f
14554 /* Create the FUNCTION_DECL for a function definition.
14555    DECLSPECS and DECLARATOR are the parts of the declaration;
14556    they describe the return type and the name of the function,
14557    but twisted together in a fashion that parallels the syntax of C.
14558
14559    This function creates a binding context for the function body
14560    as well as setting up the FUNCTION_DECL in current_function_decl.
14561
14562    Returns a FUNCTION_DECL on success.
14563
14564    If the DECLARATOR is not suitable for a function (it defines a datum
14565    instead), we return 0, which tells yyparse to report a parse error.
14566
14567    May return void_type_node indicating that this method is actually
14568    a friend.  See grokfield for more details.
14569
14570    Came here with a `.pushlevel' .
14571
14572    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14573    CHANGES TO CODE IN `grokfield'.  */
14574
14575 tree
14576 start_method (declspecs, declarator, attrlist)
14577      tree declarator, declspecs, attrlist;
14578 {
14579   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14580                                 attrlist);
14581
14582   /* Something too ugly to handle.  */
14583   if (fndecl == NULL_TREE)
14584     return NULL_TREE;
14585
14586   /* Pass friends other than inline friend functions back.  */
14587   if (fndecl == void_type_node)
14588     return fndecl;
14589
14590   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14591     /* Not a function, tell parser to report parse error.  */
14592     return NULL_TREE;
14593
14594   if (DECL_IN_AGGR_P (fndecl))
14595     {
14596       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14597         {
14598           if (DECL_CONTEXT (fndecl)
14599               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14600             cp_error ("`%D' is already defined in class %s", fndecl,
14601                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14602         }
14603       return void_type_node;
14604     }
14605
14606   check_template_shadow (fndecl);
14607
14608   DECL_THIS_INLINE (fndecl) = 1;
14609
14610   if (flag_default_inline)
14611     DECL_INLINE (fndecl) = 1;
14612
14613   /* We process method specializations in finish_struct_1.  */
14614   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14615     fndecl = push_template_decl (fndecl);
14616
14617   if (! DECL_FRIEND_P (fndecl))
14618     {
14619       if (TREE_CHAIN (fndecl))
14620         {
14621           fndecl = copy_node (fndecl);
14622           TREE_CHAIN (fndecl) = NULL_TREE;
14623         }
14624
14625       if (DECL_CONSTRUCTOR_P (fndecl))
14626         {
14627           if (! grok_ctor_properties (current_class_type, fndecl))
14628             return void_type_node;
14629         }
14630       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14631         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14632     }
14633
14634   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14635
14636   /* Make a place for the parms */
14637   pushlevel (0);
14638   current_binding_level->parm_flag = 1;
14639
14640   DECL_IN_AGGR_P (fndecl) = 1;
14641   return fndecl;
14642 }
14643
14644 /* Go through the motions of finishing a function definition.
14645    We don't compile this method until after the whole class has
14646    been processed.
14647
14648    FINISH_METHOD must return something that looks as though it
14649    came from GROKFIELD (since we are defining a method, after all).
14650
14651    This is called after parsing the body of the function definition.
14652    STMTS is the chain of statements that makes up the function body.
14653
14654    DECL is the ..._DECL that `start_method' provided.  */
14655
14656 tree
14657 finish_method (decl)
14658      tree decl;
14659 {
14660   register tree fndecl = decl;
14661   tree old_initial;
14662
14663   register tree link;
14664
14665   if (decl == void_type_node)
14666     return decl;
14667
14668   old_initial = DECL_INITIAL (fndecl);
14669
14670   /* Undo the level for the parms (from start_method).
14671      This is like poplevel, but it causes nothing to be
14672      saved.  Saving information here confuses symbol-table
14673      output routines.  Besides, this information will
14674      be correctly output when this method is actually
14675      compiled.  */
14676
14677   /* Clear out the meanings of the local variables of this level;
14678      also record in each decl which block it belongs to.  */
14679
14680   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14681     {
14682       if (DECL_NAME (link) != NULL_TREE)
14683         pop_binding (DECL_NAME (link), link);
14684       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14685       DECL_CONTEXT (link) = NULL_TREE;
14686     }
14687
14688   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14689                       (HOST_WIDE_INT) current_binding_level->level_chain,
14690                       current_binding_level->parm_flag,
14691                       current_binding_level->keep);
14692
14693   poplevel (0, 0, 0);
14694
14695   DECL_INITIAL (fndecl) = old_initial;
14696
14697   /* We used to check if the context of FNDECL was different from
14698      current_class_type as another way to get inside here.  This didn't work
14699      for String.cc in libg++.  */
14700   if (DECL_FRIEND_P (fndecl))
14701     {
14702       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14703         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14704       decl = void_type_node;
14705     }
14706
14707   return decl;
14708 }
14709 \f
14710 /* Called when a new struct TYPE is defined.
14711    If this structure or union completes the type of any previous
14712    variable declaration, lay it out and output its rtl.  */
14713
14714 void
14715 hack_incomplete_structures (type)
14716      tree type;
14717 {
14718   tree *list;
14719   struct binding_level *level;
14720
14721   if (!type) /* Don't do this for class templates.  */
14722     return;
14723
14724   if (namespace_bindings_p ())
14725     {
14726       level = 0;
14727       list = &namespace_scope_incomplete;
14728     }
14729   else
14730     {
14731       level = innermost_nonclass_level ();
14732       list = &level->incomplete;
14733     }
14734
14735   while (1)
14736     {
14737       while (*list)
14738         {
14739           tree decl = TREE_VALUE (*list);
14740           if ((decl && TREE_TYPE (decl) == type)
14741               || (TREE_TYPE (decl)
14742                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14743                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14744             {
14745               int toplevel = toplevel_bindings_p ();
14746               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14747                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14748                 layout_type (TREE_TYPE (decl));
14749               layout_decl (decl, 0);
14750               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14751               if (! toplevel)
14752                 {
14753                   tree cleanup;
14754                   expand_decl (decl);
14755                   cleanup = maybe_build_cleanup (decl);
14756                   expand_decl_init (decl);
14757                   if (! expand_decl_cleanup (decl, cleanup))
14758                     cp_error ("parser lost in parsing declaration of `%D'",
14759                               decl);
14760                 }
14761               *list = TREE_CHAIN (*list);
14762             }
14763           else
14764             list = &TREE_CHAIN (*list);
14765         }
14766
14767       /* Keep looking through artificial binding levels generated
14768          for local variables.  */
14769       if (level && level->keep == 2)
14770         {
14771           level = level->level_chain;
14772           list = &level->incomplete;
14773         }
14774       else
14775         break;
14776     }
14777 }
14778
14779 /* If DECL is of a type which needs a cleanup, build that cleanup
14780    here.  */
14781
14782 tree
14783 maybe_build_cleanup (decl)
14784      tree decl;
14785 {
14786   tree type = TREE_TYPE (decl);
14787
14788   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14789     {
14790       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14791       tree rval;
14792
14793       if (TREE_CODE (type) == ARRAY_TYPE)
14794         rval = decl;
14795       else
14796         {
14797           mark_addressable (decl);
14798           rval = build_unary_op (ADDR_EXPR, decl, 0);
14799         }
14800
14801       /* Optimize for space over speed here.  */
14802       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14803           || flag_expensive_optimizations)
14804         flags |= LOOKUP_NONVIRTUAL;
14805
14806       rval = build_delete (TREE_TYPE (rval), rval,
14807                            sfk_complete_destructor, flags, 0);
14808
14809       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14810           && ! TYPE_HAS_DESTRUCTOR (type))
14811         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14812                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14813
14814       return rval;
14815     }
14816   return 0;
14817 }
14818 \f
14819 /* Expand a C++ expression at the statement level.
14820    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14821    The C++ type checker should get all of these out when
14822    expressions are combined with other, type-providing, expressions,
14823    leaving only orphan expressions, such as:
14824
14825    &class::bar;         / / takes its address, but does nothing with it.  */
14826
14827 void
14828 cplus_expand_expr_stmt (exp)
14829      tree exp;
14830 {
14831 #if 0
14832   /* We should do this eventually, but right now this causes regex.o from
14833      libg++ to miscompile, and tString to core dump.  */
14834   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14835 #endif
14836
14837   /* If we don't do this, we end up down inside expand_expr
14838      trying to do TYPE_MODE on the ERROR_MARK, and really
14839      go outside the bounds of the type.  */
14840   if (exp != error_mark_node)
14841     expand_expr_stmt (exp);
14842 }
14843
14844 /* When a stmt has been parsed, this function is called.  */
14845
14846 void
14847 finish_stmt ()
14848 {
14849   /* Always assume this statement was not an expression statement.  If
14850      it actually was an expression statement, its our callers
14851      responsibility to fix this up.  */
14852   last_expr_type = NULL_TREE;
14853 }
14854
14855 /* DECL was originally constructed as a non-static member function,
14856    but turned out to be static.  Update it accordingly.  */
14857
14858 void
14859 revert_static_member_fn (decl)
14860      tree decl;
14861 {
14862   tree tmp;
14863   tree function = TREE_TYPE (decl);
14864   tree args = TYPE_ARG_TYPES (function);
14865
14866   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14867       != TYPE_UNQUALIFIED)
14868     cp_error ("static member function `%#D' declared with type qualifiers",
14869               *decl);
14870
14871   args = TREE_CHAIN (args);
14872   tmp = build_function_type (TREE_TYPE (function), args);
14873   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14874   tmp = build_exception_variant (tmp,
14875                                  TYPE_RAISES_EXCEPTIONS (function));
14876   TREE_TYPE (decl) = tmp;
14877   if (DECL_ARGUMENTS (decl))
14878     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14879   DECL_STATIC_FUNCTION_P (decl) = 1;
14880 }
14881
14882 /* Initialize the variables used during compilation of a C++
14883    function.  */
14884
14885 static void
14886 push_cp_function_context (f)
14887      struct function *f;
14888 {
14889   struct language_function *p
14890     = ((struct language_function *)
14891        xcalloc (1, sizeof (struct language_function)));
14892   f->language = p;
14893
14894   /* It takes an explicit call to expand_body to generate RTL for a
14895      function.  */
14896   expanding_p = 0;
14897
14898   /* Whenever we start a new function, we destroy temporaries in the
14899      usual way.  */
14900   current_stmt_tree->stmts_are_full_exprs_p = 1;
14901 }
14902
14903 /* Free the language-specific parts of F, now that we've finished
14904    compiling the function.  */
14905
14906 static void
14907 pop_cp_function_context (f)
14908      struct function *f;
14909 {
14910   if (f->language)
14911     free (f->language);
14912   f->language = 0;
14913 }
14914
14915 /* Mark P for GC.  */
14916
14917 static void
14918 mark_lang_function (p)
14919      struct language_function *p;
14920 {
14921   if (!p)
14922     return;
14923
14924   ggc_mark_tree (p->x_ctor_label);
14925   ggc_mark_tree (p->x_dtor_label);
14926   ggc_mark_tree (p->x_current_class_ptr);
14927   ggc_mark_tree (p->x_current_class_ref);
14928   ggc_mark_tree (p->x_eh_spec_try_block);
14929   ggc_mark_tree (p->x_scope_stmt_stack);
14930
14931   ggc_mark_rtx (p->x_result_rtx);
14932
14933   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14934   mark_stmt_tree (&p->x_stmt_tree);
14935   mark_binding_level (&p->bindings);
14936 }
14937
14938 /* Mark the language-specific data in F for GC.  */
14939
14940 static void
14941 mark_cp_function_context (f)
14942      struct function *f;
14943 {
14944   mark_lang_function (f->language);
14945 }
14946
14947 void
14948 lang_mark_false_label_stack (l)
14949      struct label_node *l;
14950 {
14951   /* C++ doesn't use false_label_stack.  It better be NULL.  */
14952   my_friendly_assert (l == NULL, 19990904);
14953 }
14954
14955 void
14956 lang_mark_tree (t)
14957      tree t;
14958 {
14959   enum tree_code code = TREE_CODE (t);
14960   if (code == IDENTIFIER_NODE)
14961     {
14962       struct lang_identifier *li = (struct lang_identifier *) t;
14963       struct lang_id2 *li2 = li->x;
14964       ggc_mark_tree (li->namespace_bindings);
14965       ggc_mark_tree (li->bindings);
14966       ggc_mark_tree (li->class_value);
14967       ggc_mark_tree (li->class_template_info);
14968
14969       if (li2)
14970         {
14971           ggc_mark_tree (li2->label_value);
14972           ggc_mark_tree (li2->implicit_decl);
14973           ggc_mark_tree (li2->error_locus);
14974         }
14975     }
14976   else if (code == CPLUS_BINDING)
14977     {
14978       if (BINDING_HAS_LEVEL_P (t))
14979         mark_binding_level (&BINDING_LEVEL (t));
14980       else
14981         ggc_mark_tree (BINDING_SCOPE (t));
14982       ggc_mark_tree (BINDING_VALUE (t));
14983     }
14984   else if (code == OVERLOAD)
14985     ggc_mark_tree (OVL_FUNCTION (t));
14986   else if (code == TEMPLATE_PARM_INDEX)
14987     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14988   else if (TREE_CODE_CLASS (code) == 'd')
14989     {
14990       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14991
14992       if (ld)
14993         {
14994           ggc_mark (ld);
14995           if (!DECL_GLOBAL_CTOR_P (t)
14996               && !DECL_GLOBAL_DTOR_P (t)
14997               && !DECL_THUNK_P (t))
14998             ggc_mark_tree (ld->decl_flags.u2.access);
14999           else if (DECL_THUNK_P (t))
15000             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
15001           ggc_mark_tree (ld->decl_flags.context);
15002           if (TREE_CODE (t) != NAMESPACE_DECL)
15003             ggc_mark_tree (ld->decl_flags.u.template_info);
15004           else
15005             mark_binding_level (&NAMESPACE_LEVEL (t));
15006           if (CAN_HAVE_FULL_LANG_DECL_P (t))
15007             {
15008               ggc_mark_tree (ld->befriending_classes);
15009               ggc_mark_tree (ld->saved_tree);
15010               ggc_mark_tree (ld->cloned_function);
15011               if (!DECL_OVERLOADED_OPERATOR_P (t))
15012                 ggc_mark_tree (ld->u2.vtt_parm);
15013               if (TREE_CODE (t) == TYPE_DECL)
15014                 ggc_mark_tree (ld->u.sorted_fields);
15015               else if (TREE_CODE (t) == FUNCTION_DECL
15016                        && !DECL_PENDING_INLINE_P (t))
15017                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
15018             }
15019         }
15020     }
15021   else if (TREE_CODE_CLASS (code) == 't')
15022     {
15023       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
15024
15025       if (lt && !(TREE_CODE (t) == POINTER_TYPE
15026                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
15027         {
15028           ggc_mark (lt);
15029           ggc_mark_tree (lt->primary_base);
15030           ggc_mark_tree (lt->vfields);
15031           ggc_mark_tree (lt->vbases);
15032           ggc_mark_tree (lt->tags);
15033           ggc_mark_tree (lt->size);
15034           ggc_mark_tree (lt->pure_virtuals);
15035           ggc_mark_tree (lt->friend_classes);
15036           ggc_mark_tree (lt->rtti);
15037           ggc_mark_tree (lt->methods);
15038           ggc_mark_tree (lt->template_info);
15039           ggc_mark_tree (lt->befriending_classes);
15040         }
15041       else if (lt)
15042         /* In the case of pointer-to-member function types, the
15043            TYPE_LANG_SPECIFIC is really just a tree.  */
15044         ggc_mark_tree ((tree) lt);
15045     }
15046 }