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 <signal.h>
  41 #include "defaults.h"
  42 #include "output.h"
  43 #include "except.h"
  44 #include "toplev.h"
  45 #include "../hash.h"
  46 #include "defaults.h"
  47 #include "ggc.h"
  48
  49 extern int current_class_depth;
  50
  51 extern tree static_ctors, static_dtors;
  52
  53 extern tree global_namespace;
  54
  55 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
  56
  57 /* Use garbage collection.  */
  58
  59 int ggc_p = 1;
  60
  61 #ifndef WCHAR_UNSIGNED
  62 #define WCHAR_UNSIGNED 0
  63 #endif
  64
  65 #ifndef CHAR_TYPE_SIZE
  66 #define CHAR_TYPE_SIZE BITS_PER_UNIT
  67 #endif
  68
  69 #ifndef BOOL_TYPE_SIZE
  70 #ifdef SLOW_BYTE_ACCESS
  71 /* In the new ABI, `bool' has size and alignment `1', on all
  72    platforms.  */
  73 #define BOOL_TYPE_SIZE \
  74   ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
  75 #else
  76 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  77 #endif
  78 #endif
  79
  80 /* We let tm.h override the types used here, to handle trivial differences
  81    such as the choice of unsigned int or long unsigned int for size_t.
  82    When machines start needing nontrivial differences in the size type,
  83    it would be best to do something here to figure out automatically
  84    from other information what type to use.  */
  85
  86 #ifndef SIZE_TYPE
  87 #define SIZE_TYPE "long unsigned int"
  88 #endif
  89
  90 #ifndef PTRDIFF_TYPE
  91 #define PTRDIFF_TYPE "long int"
  92 #endif
  93
  94 #ifndef WCHAR_TYPE
  95 #define WCHAR_TYPE "int"
  96 #endif
  97
  98 static tree grokparms                           PARAMS ((tree, int));
  99 static const char *redeclaration_error_message  PARAMS ((tree, tree));
 100
 101 static void push_binding_level PARAMS ((struct binding_level *, int,
 102                                       int));
 103 static void pop_binding_level PARAMS ((void));
 104 static void suspend_binding_level PARAMS ((void));
 105 static void resume_binding_level PARAMS ((struct binding_level *));
 106 static struct binding_level *make_binding_level PARAMS ((void));
 107 static void declare_namespace_level PARAMS ((void));
 108 static void signal_catch PARAMS ((int)) ATTRIBUTE_NORETURN;
 109 static int decl_jump_unsafe PARAMS ((tree));
 110 static void storedecls PARAMS ((tree));
 111 static void require_complete_types_for_parms PARAMS ((tree));
 112 static int ambi_op_p PARAMS ((enum tree_code));
 113 static int unary_op_p PARAMS ((enum tree_code));
 114 static tree store_bindings PARAMS ((tree, tree));
 115 static tree lookup_tag_reverse PARAMS ((tree, tree));
 116 static tree obscure_complex_init PARAMS ((tree, tree));
 117 static tree lookup_name_real PARAMS ((tree, int, int, int));
 118 static void warn_extern_redeclared_static PARAMS ((tree, tree));
 119 static void grok_reference_init PARAMS ((tree, tree, tree));
 120 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
 121                               enum overload_flags, tree,
 122                               tree, int, int, int, int, int, int, tree));
 123 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
 124 static tree lookup_tag PARAMS ((enum tree_code, tree,
 125                               struct binding_level *, int));
 126 static void set_identifier_type_value_with_scope
 127         PARAMS ((tree, tree, struct binding_level *));
 128 static void record_builtin_type PARAMS ((enum rid, const char *, tree));
 129 static void record_unknown_type PARAMS ((tree, const char *));
 130 static tree build_library_fn_1 PARAMS ((tree, enum tree_code, tree));
 131 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
 132 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
 133                                   int));
 134 static void lang_print_error_function PARAMS ((const char *));
 135 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
 136 static void check_for_uninitialized_const_var PARAMS ((tree));
 137 static unsigned long typename_hash PARAMS ((hash_table_key));
 138 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
 139 static void push_binding PARAMS ((tree, tree, struct binding_level*));
 140 static int add_binding PARAMS ((tree, tree));
 141 static void pop_binding PARAMS ((tree, tree));
 142 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
 143 static tree find_binding PARAMS ((tree, tree));
 144 static tree select_decl PARAMS ((tree, int));
 145 static int lookup_flags PARAMS ((int, int));
 146 static tree qualify_lookup PARAMS ((tree, int));
 147 static tree record_builtin_java_type PARAMS ((const char *, int));
 148 static const char *tag_name PARAMS ((enum tag_types code));
 149 static void find_class_binding_level PARAMS ((void));
 150 static struct binding_level *innermost_nonclass_level PARAMS ((void));
 151 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
 152 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
 153 static int walk_globals_r PARAMS ((tree, void *));
 154 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
 155 static tree make_label_decl PARAMS ((tree, int));
 156 static void use_label PARAMS ((tree));
 157 static void check_previous_goto_1 PARAMS ((tree, struct binding_level *, tree,
 158                                            const char *, int));
 159 static void check_previous_goto PARAMS ((struct named_label_use_list *));
 160 static void check_switch_goto PARAMS ((struct binding_level *));
 161 static void check_previous_gotos PARAMS ((tree));
 162 static void pop_label PARAMS ((tree, tree));
 163 static void pop_labels PARAMS ((tree));
 164 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
 165 static void layout_var_decl PARAMS ((tree));
 166 static void maybe_commonize_var PARAMS ((tree));
 167 static tree check_initializer PARAMS ((tree, tree));
 168 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
 169 static void push_cp_function_context PARAMS ((struct function *));
 170 static void pop_cp_function_context PARAMS ((struct function *));
 171 static void mark_binding_level PARAMS ((void *));
 172 static void mark_named_label_lists PARAMS ((void *, void *));
 173 static void mark_cp_function_context PARAMS ((struct function *));
 174 static void mark_saved_scope PARAMS ((void *));
 175 static void mark_lang_function PARAMS ((struct language_function *));
 176 static void mark_stmt_tree PARAMS ((struct stmt_tree *));
 177 static void save_function_data PARAMS ((tree));
 178 static void check_function_type PARAMS ((tree));
 179 static void destroy_local_var PARAMS ((tree));
 180 static void finish_constructor_body PARAMS ((void));
 181 static void finish_destructor_body PARAMS ((void));
 182 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
 183 static tree get_atexit_node PARAMS ((void));
 184 static tree get_dso_handle_node PARAMS ((void));
 185 static tree start_cleanup_fn PARAMS ((void));
 186 static void end_cleanup_fn PARAMS ((void));
 187 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
 188 static void initialize_predefined_identifiers PARAMS ((void));
 189 static tree check_special_function_return_type
 190   PARAMS ((special_function_kind, tree, tree, tree));
 191 static tree push_cp_library_fn PARAMS ((enum tree_code, tree));
 192 static tree build_cp_library_fn PARAMS ((tree, enum tree_code, tree));
 193
 194 #if defined (DEBUG_CP_BINDING_LEVELS)
 195 static void indent PARAMS ((void));
 196 #endif
 197
 198 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 199 tree error_mark_list;
 200
 201 /* The following symbols are subsumed in the cp_global_trees array, and
 202    listed here individually for documentation purposes.
 203
 204    C++ extensions
 205         tree wchar_decl_node;
 206         tree void_zero_node;
 207
 208         tree vtable_entry_type;
 209         tree delta_type_node;
 210 #if 0
 211    Old rtti stuff.
 212         tree __baselist_desc_type_node;
 213         tree __i_desc_type_node, __m_desc_type_node;
 214         tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
 215 #endif
 216         tree __t_desc_type_node;
 217 #if 0
 218         tree __tp_desc_type_node;
 219 #endif
 220         tree ti_desc_type_node;
 221         tree bltn_desc_type_node, ptr_desc_type_node;
 222         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 223         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 224         tree ptm_desc_type_node;
 225         tree base_desc_type_node;
 226 #if 0
 227    Not needed yet?  May be needed one day?
 228         tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
 229         tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
 230         tree __ptmf_desc_array_type, __ptmd_desc_array_type;
 231 #endif
 232
 233         tree class_type_node, record_type_node, union_type_node, enum_type_node;
 234         tree unknown_type_node;
 235
 236    Array type `vtable_entry_type[]'
 237
 238         tree vtbl_type_node;
 239         tree vtbl_ptr_type_node;
 240
 241    Namespaces,
 242
 243         tree std_node;
 244         tree abi_node;
 245
 246    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 247    one that the user will declare, but sufficient to be called
 248    by routines that want to abort the program.
 249
 250         tree abort_fndecl;
 251
 252    The FUNCTION_DECL for the default `::operator delete'.
 253
 254         tree global_delete_fndecl;
 255
 256    Used by RTTI
 257         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 258         tree tinfo_var_id;
 259
 260 */
 261
 262 tree cp_global_trees[CPTI_MAX];
 263
 264 /* Indicates that there is a type value in some namespace, although
 265    that is not necessarily in scope at the moment.  */
 266
 267 static tree global_type_node;
 268
 269 /* Namespace std.  */
 270 int in_std;
 271
 272 /* Expect only namespace names now. */
 273 static int only_namespace_names;
 274
 275 /* If original DECL_RESULT of current function was a register,
 276    but due to being an addressable named return value, would up
 277    on the stack, this variable holds the named return value's
 278    original location.  */
 279
 280 #define original_result_rtx cp_function_chain->x_result_rtx
 281
 282 /* Used only for jumps to as-yet undefined labels, since jumps to
 283    defined labels can have their validity checked immediately.  */
 284
 285 struct named_label_use_list
 286 {
 287   struct binding_level *binding_level;
 288   tree names_in_scope;
 289   tree label_decl;
 290   const char *filename_o_goto;
 291   int lineno_o_goto;
 292   struct named_label_use_list *next;
 293 };
 294
 295 #define named_label_uses cp_function_chain->x_named_label_uses
 296
 297 /* A list of objects which have constructors or destructors
 298    which reside in the global scope.  The decl is stored in
 299    the TREE_VALUE slot and the initializer is stored
 300    in the TREE_PURPOSE slot.  */
 301 tree static_aggregates;
 302
 303 /* -- end of C++ */
 304
 305 /* A node for the integer constants 2, and 3.  */
 306
 307 tree integer_two_node, integer_three_node;
 308
 309 /* Parsing a function declarator leaves here a chain of structure
 310    and enum types declared in the parmlist.  */
 311
 312 static tree last_function_parm_tags;
 313
 314 /* Similar, for last_function_parm_tags.  */
 315 tree last_function_parms;
 316 static tree current_function_parm_tags;
 317
 318 /* A list of all LABEL_DECLs in the function that have names.  Here so
 319    we can clear out their names' definitions at the end of the
 320    function, and so we can check the validity of jumps to these labels.  */
 321
 322 struct named_label_list
 323 {
 324   struct binding_level *binding_level;
 325   tree names_in_scope;
 326   tree old_value;
 327   tree label_decl;
 328   tree bad_decls;
 329   int eh_region;
 330   struct named_label_list *next;
 331 };
 332
 333 #define named_labels cp_function_chain->x_named_labels
 334
 335 /* Set to 0 at beginning of a function definition, and whenever
 336    a label (case or named) is defined.  Set to value of expression
 337    returned from function when that value can be transformed into
 338    a named return value.  */
 339
 340 tree current_function_return_value;
 341
 342 /* Nonzero means use the ISO C99 dialect of C.  */
 343
 344 int flag_isoc99;
 345
 346 /* Nonzero means give `double' the same size as `float'.  */
 347
 348 extern int flag_short_double;
 349
 350 /* Nonzero means don't recognize any builtin functions.  */
 351
 352 extern int flag_no_builtin;
 353
 354 /* Nonzero means don't recognize the non-ANSI builtin functions.
 355    -ansi sets this.  */
 356
 357 extern int flag_no_nonansi_builtin;
 358
 359 /* Nonzero if we want to conserve space in the .o files.  We do this
 360    by putting uninitialized data and runtime initialized data into
 361    .common instead of .data at the expense of not flagging multiple
 362    definitions.  */
 363 extern int flag_conserve_space;
 364 \f
 365 /* C and C++ flags are in decl2.c.  */
 366
 367 /* Flag used when debugging spew.c */
 368
 369 extern int spew_debug;
 370
 371 /* A expression of value 0 with the same precision as a sizetype
 372    node, but signed.  */
 373 tree signed_size_zero_node;
 374
 375 /* The name of the anonymous namespace, throughout this translation
 376    unit.  */
 377 tree anonymous_namespace_name;
 378
 379 \f
 380 /* For each binding contour we allocate a binding_level structure
 381    which records the names defined in that contour.
 382    Contours include:
 383     0) the global one
 384     1) one for each function definition,
 385        where internal declarations of the parameters appear.
 386     2) one for each compound statement,
 387        to record its declarations.
 388
 389    The current meaning of a name can be found by searching the levels
 390    from the current one out to the global one.
 391
 392    Off to the side, may be the class_binding_level.  This exists only
 393    to catch class-local declarations.  It is otherwise nonexistent.
 394
 395    Also there may be binding levels that catch cleanups that must be
 396    run when exceptions occur.  Thus, to see whether a name is bound in
 397    the current scope, it is not enough to look in the
 398    CURRENT_BINDING_LEVEL.  You should use lookup_name_current_level
 399    instead.  */
 400
 401 /* Note that the information in the `names' component of the global contour
 402    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
 403
 404 struct binding_level
 405   {
 406     /* A chain of _DECL nodes for all variables, constants, functions,
 407        and typedef types.  These are in the reverse of the order
 408        supplied.  There may be OVERLOADs on this list, too, but they
 409        are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD.  */
 410     tree names;
 411
 412     /* A list of structure, union and enum definitions, for looking up
 413        tag names.
 414        It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
 415        or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
 416        or ENUMERAL_TYPE node.
 417
 418        C++: the TREE_VALUE nodes can be simple types for
 419        component_bindings.  */
 420     tree tags;
 421
 422     /* A list of USING_DECL nodes. */
 423     tree usings;
 424
 425     /* A list of used namespaces. PURPOSE is the namespace,
 426        VALUE the common ancestor with this binding_level's namespace. */
 427     tree using_directives;
 428
 429     /* If this binding level is the binding level for a class, then
 430        class_shadowed is a TREE_LIST.  The TREE_PURPOSE of each node
 431        is the name of an entity bound in the class; the TREE_VALUE is
 432        the IDENTIFIER_CLASS_VALUE before we entered the class.  Thus,
 433        when leaving class scope, we can restore the
 434        IDENTIFIER_CLASS_VALUE by walking this list.  The TREE_TYPE is
 435        the DECL bound by this name in the class.  */
 436     tree class_shadowed;
 437
 438     /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
 439        is used for all binding levels.  */
 440     tree type_shadowed;
 441
 442     /* A TREE_LIST.  Each TREE_VALUE is the LABEL_DECL for a local
 443        label in this scope.  The TREE_PURPOSE is the previous value of
 444        the IDENTIFIER_LABEL VALUE.  */
 445     tree shadowed_labels;
 446
 447     /* For each level (except not the global one),
 448        a chain of BLOCK nodes for all the levels
 449        that were entered and exited one level down.  */
 450     tree blocks;
 451
 452     /* The BLOCK node for this level, if one has been preallocated.
 453        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
 454     tree this_block;
 455
 456     /* The _TYPE node for this level, if parm_flag == 2.  */
 457     tree this_class;
 458
 459     /* The binding level which this one is contained in (inherits from).  */
 460     struct binding_level *level_chain;
 461
 462     /* List of decls in `names' that have incomplete
 463        structure or union types.  */
 464     tree incomplete;
 465
 466     /* List of VAR_DECLS saved from a previous for statement.
 467        These would be dead in ISO-conforming code, but might
 468        be referenced in ARM-era code.  These are stored in a
 469        TREE_LIST; the TREE_VALUE is the actual declaration.  */
 470     tree dead_vars_from_for;
 471
 472     /* 1 for the level that holds the parameters of a function.
 473        2 for the level that holds a class declaration.  */
 474     unsigned parm_flag : 2;
 475
 476     /* 1 means make a BLOCK for this level regardless of all else.
 477        2 for temporary binding contours created by the compiler.  */
 478     unsigned keep : 2;
 479
 480     /* Nonzero if this level "doesn't exist" for tags.  */
 481     unsigned tag_transparent : 1;
 482
 483     /* Nonzero if this level can safely have additional
 484        cleanup-needing variables added to it.  */
 485     unsigned more_cleanups_ok : 1;
 486     unsigned have_cleanups : 1;
 487
 488     /* Nonzero if this scope is for storing the decls for template
 489        parameters and generic decls; these decls will be discarded and
 490        replaced with a TEMPLATE_DECL.  */
 491     unsigned template_parms_p : 1;
 492
 493     /* Nonzero if this scope corresponds to the `<>' in a
 494        `template <>' clause.  Whenever this flag is set,
 495        TEMPLATE_PARMS_P will be set as well.  */
 496     unsigned template_spec_p : 1;
 497
 498     /* This is set for a namespace binding level.  */
 499     unsigned namespace_p : 1;
 500
 501     /* True if this level is that of a for-statement where we need to
 502        worry about ambiguous (ARM or ISO) scope rules.  */
 503     unsigned is_for_scope : 1;
 504
 505     /* True if this level corresponds to an EH region, as for a try block.
 506        Currently this information is only available while building the
 507        tree structure.  */
 508     unsigned eh_region : 1;
 509
 510     /* Four bits left for this word.  */
 511
 512 #if defined(DEBUG_CP_BINDING_LEVELS)
 513     /* Binding depth at which this level began.  */
 514     unsigned binding_depth;
 515 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 516   };
 517
 518 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
 519
 520 /* The binding level currently in effect.  */
 521
 522 #define current_binding_level                   \
 523   (cfun                                         \
 524    ? cp_function_chain->bindings                \
 525    : scope_chain->bindings)
 526
 527 /* The binding level of the current class, if any.  */
 528
 529 #define class_binding_level scope_chain->class_bindings
 530
 531 /* A chain of binding_level structures awaiting reuse.  */
 532
 533 static struct binding_level *free_binding_level;
 534
 535 /* The outermost binding level, for names of file scope.
 536    This is created when the compiler is started and exists
 537    through the entire run.  */
 538
 539 static struct binding_level *global_binding_level;
 540
 541 /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
 542
 543 static int keep_next_level_flag;
 544
 545 #if defined(DEBUG_CP_BINDING_LEVELS)
 546 static int binding_depth = 0;
 547 static int is_class_level = 0;
 548
 549 static void
 550 indent ()
 551 {
 552   register unsigned i;
 553
 554   for (i = 0; i < binding_depth*2; i++)
 555     putc (' ', stderr);
 556 }
 557 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 558
 559 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
 560
 561 static void
 562 push_binding_level (newlevel, tag_transparent, keep)
 563      struct binding_level *newlevel;
 564      int tag_transparent, keep;
 565 {
 566   /* Add this level to the front of the chain (stack) of levels that
 567      are active.  */
 568   bzero ((char*) newlevel, sizeof (struct binding_level));
 569   newlevel->level_chain = current_binding_level;
 570   current_binding_level = newlevel;
 571   newlevel->tag_transparent = tag_transparent;
 572   newlevel->more_cleanups_ok = 1;
 573
 574   newlevel->keep = keep;
 575 #if defined(DEBUG_CP_BINDING_LEVELS)
 576   newlevel->binding_depth = binding_depth;
 577   indent ();
 578   fprintf (stderr, "push %s level 0x%08x line %d\n",
 579            (is_class_level) ? "class" : "block", newlevel, lineno);
 580   is_class_level = 0;
 581   binding_depth++;
 582 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 583 }
 584
 585 /* Find the innermost enclosing class scope, and reset
 586    CLASS_BINDING_LEVEL appropriately.  */
 587
 588 static void
 589 find_class_binding_level ()
 590 {
 591   struct binding_level *level = current_binding_level;
 592
 593   while (level && level->parm_flag != 2)
 594     level = level->level_chain;
 595   if (level && level->parm_flag == 2)
 596     class_binding_level = level;
 597   else
 598     class_binding_level = 0;
 599 }
 600
 601 static void
 602 pop_binding_level ()
 603 {
 604   if (global_binding_level)
 605     {
 606       /* Cannot pop a level, if there are none left to pop.  */
 607       if (current_binding_level == global_binding_level)
 608         my_friendly_abort (123);
 609     }
 610   /* Pop the current level, and free the structure for reuse.  */
 611 #if defined(DEBUG_CP_BINDING_LEVELS)
 612   binding_depth--;
 613   indent ();
 614   fprintf (stderr, "pop  %s level 0x%08x line %d\n",
 615           (is_class_level) ? "class" : "block",
 616           current_binding_level, lineno);
 617   if (is_class_level != (current_binding_level == class_binding_level))
 618     {
 619       indent ();
 620       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 621     }
 622   is_class_level = 0;
 623 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 624   {
 625     register struct binding_level *level = current_binding_level;
 626     current_binding_level = current_binding_level->level_chain;
 627     level->level_chain = free_binding_level;
 628 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
 629     if (level->binding_depth != binding_depth)
 630       abort ();
 631 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 632     free_binding_level = level;
 633     find_class_binding_level ();
 634   }
 635 }
 636
 637 static void
 638 suspend_binding_level ()
 639 {
 640   if (class_binding_level)
 641     current_binding_level = class_binding_level;
 642
 643   if (global_binding_level)
 644     {
 645       /* Cannot suspend a level, if there are none left to suspend.  */
 646       if (current_binding_level == global_binding_level)
 647         my_friendly_abort (123);
 648     }
 649   /* Suspend the current level.  */
 650 #if defined(DEBUG_CP_BINDING_LEVELS)
 651   binding_depth--;
 652   indent ();
 653   fprintf (stderr, "suspend  %s level 0x%08x line %d\n",
 654           (is_class_level) ? "class" : "block",
 655           current_binding_level, lineno);
 656   if (is_class_level != (current_binding_level == class_binding_level))
 657     {
 658       indent ();
 659       fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
 660     }
 661   is_class_level = 0;
 662 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 663   current_binding_level = current_binding_level->level_chain;
 664   find_class_binding_level ();
 665 }
 666
 667 static void
 668 resume_binding_level (b)
 669      struct binding_level *b;
 670 {
 671   /* Resuming binding levels is meant only for namespaces,
 672      and those cannot nest into classes. */
 673   my_friendly_assert(!class_binding_level, 386);
 674   /* Also, resuming a non-directly nested namespace is a no-no.  */
 675   my_friendly_assert(b->level_chain == current_binding_level, 386);
 676   current_binding_level = b;
 677 #if defined(DEBUG_CP_BINDING_LEVELS)
 678   b->binding_depth = binding_depth;
 679   indent ();
 680   fprintf (stderr, "resume %s level 0x%08x line %d\n",
 681            (is_class_level) ? "class" : "block", b, lineno);
 682   is_class_level = 0;
 683   binding_depth++;
 684 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
 685 }
 686 \f
 687 /* Create a new `struct binding_level'.  */
 688
 689 static
 690 struct binding_level *
 691 make_binding_level ()
 692 {
 693   /* NOSTRICT */
 694   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
 695 }
 696
 697 /* Nonzero if we are currently in the global binding level.  */
 698
 699 int
 700 global_bindings_p ()
 701 {
 702   return current_binding_level == global_binding_level;
 703 }
 704
 705 /* Return the innermost binding level that is not for a class scope.  */
 706
 707 static struct binding_level *
 708 innermost_nonclass_level ()
 709 {
 710   struct binding_level *b;
 711
 712   b = current_binding_level;
 713   while (b->parm_flag == 2)
 714     b = b->level_chain;
 715
 716   return b;
 717 }
 718
 719 /* Nonzero if we are currently in a toplevel binding level.  This
 720    means either the global binding level or a namespace in a toplevel
 721    binding level.  Since there are no non-toplevel namespace levels,
 722    this really means any namespace or template parameter level.  We
 723    also include a class whose context is toplevel.  */
 724
 725 int
 726 toplevel_bindings_p ()
 727 {
 728   struct binding_level *b = innermost_nonclass_level ();
 729
 730   return b->namespace_p || b->template_parms_p;
 731 }
 732
 733 /* Nonzero if this is a namespace scope, or if we are defining a class
 734    which is itself at namespace scope, or whose enclosing class is
 735    such a class, etc.  */
 736
 737 int
 738 namespace_bindings_p ()
 739 {
 740   struct binding_level *b = innermost_nonclass_level ();
 741
 742   return b->namespace_p;
 743 }
 744
 745 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
 746    unconditionally.  Otherwise, use the normal logic to decide whether
 747    or not to create a BLOCK.  */
 748
 749 void
 750 keep_next_level (keep)
 751      int keep;
 752 {
 753   keep_next_level_flag = keep;
 754 }
 755
 756 /* Nonzero if the current level needs to have a BLOCK made.  */
 757
 758 int
 759 kept_level_p ()
 760 {
 761   return (current_binding_level->blocks != NULL_TREE
 762           || current_binding_level->keep
 763           || current_binding_level->names != NULL_TREE
 764           || (current_binding_level->tags != NULL_TREE
 765               && !current_binding_level->tag_transparent));
 766 }
 767
 768 static void
 769 declare_namespace_level ()
 770 {
 771   current_binding_level->namespace_p = 1;
 772 }
 773
 774 /* Returns non-zero if this scope was created to store template
 775    parameters.  */
 776
 777 int
 778 template_parm_scope_p ()
 779 {
 780   return current_binding_level->template_parms_p;
 781 }
 782
 783 /* Returns the kind of template specialization we are currently
 784    processing, given that it's declaration contained N_CLASS_SCOPES
 785    explicit scope qualifications.  */
 786
 787 tmpl_spec_kind
 788 current_tmpl_spec_kind (n_class_scopes)
 789      int n_class_scopes;
 790 {
 791   int n_template_parm_scopes = 0;
 792   int seen_specialization_p = 0;
 793   int innermost_specialization_p = 0;
 794   struct binding_level *b;
 795
 796   /* Scan through the template parameter scopes.  */
 797   for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
 798     {
 799       /* If we see a specialization scope inside a parameter scope,
 800          then something is wrong.  That corresponds to a declaration
 801          like:
 802
 803             template <class T> template <> ...
 804
 805          which is always illegal since [temp.expl.spec] forbids the
 806          specialization of a class member template if the enclosing
 807          class templates are not explicitly specialized as well.  */
 808       if (b->template_spec_p)
 809         {
 810           if (n_template_parm_scopes == 0)
 811             innermost_specialization_p = 1;
 812           else
 813             seen_specialization_p = 1;
 814         }
 815       else if (seen_specialization_p == 1)
 816         return tsk_invalid_member_spec;
 817
 818       ++n_template_parm_scopes;
 819     }
 820
 821   /* Handle explicit instantiations.  */
 822   if (processing_explicit_instantiation)
 823     {
 824       if (n_template_parm_scopes != 0)
 825         /* We've seen a template parameter list during an explicit
 826            instantiation.  For example:
 827
 828              template <class T> template void f(int);
 829
 830            This is erroneous.  */
 831         return tsk_invalid_expl_inst;
 832       else
 833         return tsk_expl_inst;
 834     }
 835
 836   if (n_template_parm_scopes < n_class_scopes)
 837     /* We've not seen enough template headers to match all the
 838        specialized classes present.  For example:
 839
 840          template <class T> void R<T>::S<T>::f(int);
 841
 842        This is illegal; there needs to be one set of template
 843        parameters for each class.  */
 844     return tsk_insufficient_parms;
 845   else if (n_template_parm_scopes == n_class_scopes)
 846     /* We're processing a non-template declaration (even though it may
 847        be a member of a template class.)  For example:
 848
 849          template <class T> void S<T>::f(int);
 850
 851        The `class T' maches the `S<T>', leaving no template headers
 852        corresponding to the `f'.  */
 853     return tsk_none;
 854   else if (n_template_parm_scopes > n_class_scopes + 1)
 855     /* We've got too many template headers.  For example:
 856
 857          template <> template <class T> void f (T);
 858
 859        There need to be more enclosing classes.  */
 860     return tsk_excessive_parms;
 861   else
 862     /* This must be a template.  It's of the form:
 863
 864          template <class T> template <class U> void S<T>::f(U);
 865
 866        This is a specialization if the innermost level was a
 867        specialization; otherwise it's just a definition of the
 868        template.  */
 869     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 870 }
 871
 872 void
 873 set_class_shadows (shadows)
 874      tree shadows;
 875 {
 876   class_binding_level->class_shadowed = shadows;
 877 }
 878
 879 /* Enter a new binding level.
 880    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
 881    not for that of tags.  */
 882
 883 void
 884 pushlevel (tag_transparent)
 885      int tag_transparent;
 886 {
 887   struct binding_level *newlevel;
 888
 889   if (cfun && !doing_semantic_analysis_p ())
 890     return;
 891
 892   /* Reuse or create a struct for this binding level.  */
 893 #if defined(DEBUG_CP_BINDING_LEVELS)
 894   if (0)
 895 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
 896   if (free_binding_level)
 897 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
 898     {
 899       newlevel = free_binding_level;
 900       free_binding_level = free_binding_level->level_chain;
 901     }
 902   else
 903     newlevel = make_binding_level ();
 904
 905   push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
 906   GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
 907   keep_next_level_flag = 0;
 908 }
 909
 910 /* Enter a new scope.  The KIND indicates what kind of scope is being
 911    created.  */
 912
 913 void
 914 begin_scope (sk)
 915      scope_kind sk;
 916 {
 917   pushlevel (0);
 918
 919   switch (sk)
 920     {
 921     case sk_template_spec:
 922       current_binding_level->template_spec_p = 1;
 923       /* Fall through.  */
 924
 925     case sk_template_parms:
 926       current_binding_level->template_parms_p = 1;
 927       break;
 928
 929     default:
 930       my_friendly_abort (20000309);
 931     }
 932 }
 933
 934 /* Exit the current scope.  */
 935
 936 void
 937 finish_scope ()
 938 {
 939   poplevel (0, 0, 0);
 940 }
 941
 942 void
 943 note_level_for_for ()
 944 {
 945   current_binding_level->is_for_scope = 1;
 946 }
 947
 948 /* Record that the current binding level represents a try block.  */
 949
 950 void
 951 note_level_for_eh ()
 952 {
 953   current_binding_level->eh_region = 1;
 954 }
 955
 956 /* For a binding between a name and an entity at a block scope,
 957    this is the `struct binding_level' for the block.  */
 958 #define BINDING_LEVEL(NODE) \
 959    (((struct tree_binding*)NODE)->scope.level)
 960
 961 /* Make DECL the innermost binding for ID.  The LEVEL is the binding
 962    level at which this declaration is being bound.  */
 963
 964 static void
 965 push_binding (id, decl, level)
 966      tree id;
 967      tree decl;
 968      struct binding_level* level;
 969 {
 970   tree binding;
 971
 972   binding = make_node (CPLUS_BINDING);
 973
 974   /* Now, fill in the binding information.  */
 975   BINDING_VALUE (binding) = decl;
 976   BINDING_TYPE (binding) = NULL_TREE;
 977   BINDING_LEVEL (binding) = level;
 978   INHERITED_VALUE_BINDING_P (binding) = 0;
 979   LOCAL_BINDING_P (binding) = (level != class_binding_level);
 980   BINDING_HAS_LEVEL_P (binding) = 1;
 981
 982   /* And put it on the front of the list of bindings for ID.  */
 983   TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
 984   IDENTIFIER_BINDING (id) = binding;
 985 }
 986
 987 /* ID is already bound in the current scope.  But, DECL is an
 988    additional binding for ID in the same scope.  This is the `struct
 989    stat' hack whereby a non-typedef class-name or enum-name can be
 990    bound at the same level as some other kind of entity.  It's the
 991    responsibility of the caller to check that inserting this name is
 992    legal here.  Returns nonzero if the new binding was successful.  */
 993 static int
 994 add_binding (id, decl)
 995      tree id;
 996      tree decl;
 997 {
 998   tree binding = IDENTIFIER_BINDING (id);
 999   int ok = 1;
1000
1001   if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
1002     /* The new name is the type name.  */
1003     BINDING_TYPE (binding) = decl;
1004   else if (!BINDING_VALUE (binding))
1005     /* This situation arises when push_class_level_binding moves an
1006        inherited type-binding out of the way to make room for a new
1007        value binding.  */
1008     BINDING_VALUE (binding) = decl;
1009   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1010            && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
1011     {
1012       /* The old binding was a type name.  It was placed in
1013          BINDING_VALUE because it was thought, at the point it was
1014          declared, to be the only entity with such a name.  Move the
1015          type name into the type slot; it is now hidden by the new
1016          binding.  */
1017       BINDING_TYPE (binding) = BINDING_VALUE (binding);
1018       BINDING_VALUE (binding) = decl;
1019       INHERITED_VALUE_BINDING_P (binding) = 0;
1020     }
1021   else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1022            && TREE_CODE (decl) == TYPE_DECL
1023            && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1024            && same_type_p (TREE_TYPE (decl),
1025                            TREE_TYPE (BINDING_VALUE (binding))))
1026     /* We have two typedef-names, both naming the same type to have
1027        the same name.  This is OK because of:
1028
1029          [dcl.typedef]
1030
1031          In a given scope, a typedef specifier can be used to redefine
1032          the name of any type declared in that scope to refer to the
1033          type to which it already refers.  */
1034     ok = 0;
1035   /* There can be two block-scope declarations of the same variable,
1036      so long as they are `extern' declarations.  */
1037   else if (TREE_CODE (decl) == VAR_DECL
1038            && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
1039            && DECL_EXTERNAL (decl)
1040            && DECL_EXTERNAL (BINDING_VALUE (binding)))
1041     {
1042       duplicate_decls (decl, BINDING_VALUE (binding));
1043       ok = 0;
1044     }
1045   else
1046     {
1047       cp_error ("declaration of `%#D'", decl);
1048       cp_error_at ("conflicts with previous declaration `%#D'",
1049                    BINDING_VALUE (binding));
1050       ok = 0;
1051     }
1052
1053   return ok;
1054 }
1055
1056 /* Add DECL to the list of things declared in B.  */
1057
1058 static void
1059 add_decl_to_level (decl, b)
1060      tree decl;
1061      struct binding_level *b;
1062 {
1063   /* We build up the list in reverse order, and reverse it later if
1064      necessary.  */
1065   TREE_CHAIN (decl) = b->names;
1066   b->names = decl;
1067 }
1068
1069 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1070    binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1071    doesn't really belong to this binding level, that it got here
1072    through a using-declaration.  */
1073
1074 void
1075 push_local_binding (id, decl, flags)
1076      tree id;
1077      tree decl;
1078      int flags;
1079 {
1080   struct binding_level *b;
1081
1082   /* Skip over any local classes.  This makes sense if we call
1083      push_local_binding with a friend decl of a local class.  */
1084   b = current_binding_level;
1085   while (b->parm_flag == 2)
1086     b = b->level_chain;
1087
1088   if (lookup_name_current_level (id))
1089     {
1090       /* Supplement the existing binding.  */
1091       if (!add_binding (id, decl))
1092         /* It didn't work.  Something else must be bound at this
1093            level.  Do not add DECL to the list of things to pop
1094            later.  */
1095         return;
1096     }
1097   else
1098     /* Create a new binding.  */
1099     push_binding (id, decl, b);
1100
1101   if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1102     /* We must put the OVERLOAD into a TREE_LIST since the
1103        TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1104        decls that got here through a using-declaration.  */
1105     decl = build_tree_list (NULL_TREE, decl);
1106
1107   /* And put DECL on the list of things declared by the current
1108      binding level.  */
1109   add_decl_to_level (decl, b);
1110 }
1111
1112 /* Bind DECL to ID in the class_binding_level.  Returns nonzero if the
1113    binding was successful.  */
1114
1115 int
1116 push_class_binding (id, decl)
1117      tree id;
1118      tree decl;
1119 {
1120   int result = 1;
1121   tree binding = IDENTIFIER_BINDING (id);
1122   tree context;
1123
1124   /* Note that we declared this value so that we can issue an error if
1125      this an illegal redeclaration of a name already used for some
1126      other purpose.  */
1127   note_name_declared_in_class (id, decl);
1128
1129   if (binding && BINDING_LEVEL (binding) == class_binding_level)
1130     /* Supplement the existing binding.  */
1131     result = add_binding (id, decl);
1132   else
1133     /* Create a new binding.  */
1134     push_binding (id, decl, class_binding_level);
1135
1136   /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1137      class-level declaration.  Note that we do not use DECL here
1138      because of the possibility of the `struct stat' hack; if DECL is
1139      a class-name or enum-name we might prefer a field-name, or some
1140      such.  */
1141   IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1142
1143   /* If this is a binding from a base class, mark it as such.  */
1144   binding = IDENTIFIER_BINDING (id);
1145   if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1146     {
1147       /* Any implicit typename must be from a base-class.  The
1148          context for an implicit typename declaration is always
1149          the derived class in which the lookup was done, so the checks
1150          based on the context of DECL below will not trigger.  */
1151       if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1152         INHERITED_VALUE_BINDING_P (binding) = 1;
1153       else
1154         {
1155           if (TREE_CODE (decl) == OVERLOAD)
1156             context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1157           else
1158             {
1159               my_friendly_assert (DECL_P (decl), 0);
1160               context = CP_DECL_CONTEXT (decl);
1161             }
1162
1163           if (is_properly_derived_from (current_class_type, context))
1164             INHERITED_VALUE_BINDING_P (binding) = 1;
1165           else
1166             INHERITED_VALUE_BINDING_P (binding) = 0;
1167         }
1168     }
1169   else if (BINDING_VALUE (binding) == decl)
1170     /* We only encounter a TREE_LIST when push_class_decls detects an
1171        ambiguity.  Such an ambiguity can be overridden by a definition
1172        in this class.  */
1173     INHERITED_VALUE_BINDING_P (binding) = 1;
1174
1175   return result;
1176 }
1177
1178 /* Remove the binding for DECL which should be the innermost binding
1179    for ID.  */
1180
1181 static void
1182 pop_binding (id, decl)
1183      tree id;
1184      tree decl;
1185 {
1186   tree binding;
1187
1188   if (id == NULL_TREE)
1189     /* It's easiest to write the loops that call this function without
1190        checking whether or not the entities involved have names.  We
1191        get here for such an entity.  */
1192     return;
1193
1194   /* Get the innermost binding for ID.  */
1195   binding = IDENTIFIER_BINDING (id);
1196
1197   /* The name should be bound.  */
1198   my_friendly_assert (binding != NULL_TREE, 0);
1199
1200   /* The DECL will be either the ordinary binding or the type
1201      binding for this identifier.  Remove that binding.  */
1202   if (BINDING_VALUE (binding) == decl)
1203     BINDING_VALUE (binding) = NULL_TREE;
1204   else if (BINDING_TYPE (binding) == decl)
1205     BINDING_TYPE (binding) = NULL_TREE;
1206   else
1207     my_friendly_abort (0);
1208
1209   if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1210     /* We're completely done with the innermost binding for this
1211        identifier.  Unhook it from the list of bindings.  */
1212     IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1213 }
1214
1215 /* When a label goes out of scope, check to see if that label was used
1216    in a valid manner, and issue any appropriate warnings or errors.  */
1217
1218 static void
1219 pop_label (label, old_value)
1220      tree label;
1221      tree old_value;
1222 {
1223   if (!processing_template_decl && doing_semantic_analysis_p ())
1224     {
1225       if (DECL_INITIAL (label) == NULL_TREE)
1226         {
1227           cp_error_at ("label `%D' used but not defined", label);
1228           /* Avoid crashing later.  */
1229           define_label (input_filename, 1, DECL_NAME (label));
1230         }
1231       else if (warn_unused_label && !TREE_USED (label))
1232         cp_warning_at ("label `%D' defined but not used", label);
1233     }
1234
1235   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1236 }
1237
1238 /* At the end of a function, all labels declared within the fucntion
1239    go out of scope.  BLOCK is the top-level block for the
1240    function.  */
1241
1242 static void
1243 pop_labels (block)
1244      tree block;
1245 {
1246   struct named_label_list *link;
1247
1248   /* Clear out the definitions of all label names, since their scopes
1249      end here.  */
1250   for (link = named_labels; link; link = link->next)
1251     {
1252       pop_label (link->label_decl, link->old_value);
1253       /* Put the labels into the "variables" of the top-level block,
1254          so debugger can see them.  */
1255       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1256       BLOCK_VARS (block) = link->label_decl;
1257     }
1258
1259   named_labels = NULL;
1260 }
1261
1262 /* Exit a binding level.
1263    Pop the level off, and restore the state of the identifier-decl mappings
1264    that were in effect when this level was entered.
1265
1266    If KEEP == 1, this level had explicit declarations, so
1267    and create a "block" (a BLOCK node) for the level
1268    to record its declarations and subblocks for symbol table output.
1269
1270    If FUNCTIONBODY is nonzero, this level is the body of a function,
1271    so create a block as if KEEP were set and also clear out all
1272    label names.
1273
1274    If REVERSE is nonzero, reverse the order of decls before putting
1275    them into the BLOCK.  */
1276
1277 tree
1278 poplevel (keep, reverse, functionbody)
1279      int keep;
1280      int reverse;
1281      int functionbody;
1282 {
1283   register tree link;
1284   /* The chain of decls was accumulated in reverse order.
1285      Put it into forward order, just for cleanliness.  */
1286   tree decls;
1287   int tmp = functionbody;
1288   int real_functionbody;
1289   tree tags;
1290   tree subblocks;
1291   tree block = NULL_TREE;
1292   tree decl;
1293   int block_previously_created;
1294   int leaving_for_scope;
1295
1296   if (cfun && !doing_semantic_analysis_p ())
1297     return NULL_TREE;
1298
1299   my_friendly_assert (current_binding_level->parm_flag != 2,
1300                       19990916);
1301
1302   real_functionbody = (current_binding_level->keep == 2
1303                        ? ((functionbody = 0), tmp) : functionbody);
1304   tags = functionbody >= 0 ? current_binding_level->tags : 0;
1305   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1306
1307   my_friendly_assert (!current_binding_level->class_shadowed,
1308                       19990414);
1309
1310   /* We used to use KEEP == 2 to indicate that the new block should go
1311      at the beginning of the list of blocks at this binding level,
1312      rather than the end.  This hack is no longer used.  */
1313   my_friendly_assert (keep == 0 || keep == 1, 0);
1314
1315   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1316                       (HOST_WIDE_INT) current_binding_level->level_chain,
1317                       current_binding_level->parm_flag,
1318                       current_binding_level->keep);
1319
1320   if (current_binding_level->keep == 1)
1321     keep = 1;
1322
1323   /* Any uses of undefined labels, and any defined labels, now operate
1324      under constraints of next binding contour.  */
1325   if (cfun && !functionbody)
1326     {
1327       struct binding_level *level_chain;
1328       level_chain = current_binding_level->level_chain;
1329       if (level_chain)
1330         {
1331           struct named_label_use_list *uses;
1332           struct named_label_list *labels;
1333           for (labels = named_labels; labels; labels = labels->next)
1334             if (labels->binding_level == current_binding_level)
1335               {
1336                 tree decl;
1337                 if (current_binding_level->eh_region)
1338                   labels->eh_region = 1;
1339                 for (decl = labels->names_in_scope; decl;
1340                      decl = TREE_CHAIN (decl))
1341                   if (decl_jump_unsafe (decl))
1342                     labels->bad_decls = tree_cons (NULL_TREE, decl,
1343                                                    labels->bad_decls);
1344                 labels->binding_level = level_chain;
1345                 labels->names_in_scope = level_chain->names;
1346               }
1347
1348           for (uses = named_label_uses; uses; uses = uses->next)
1349             if (uses->binding_level == current_binding_level)
1350               {
1351                 uses->binding_level = level_chain;
1352                 uses->names_in_scope = level_chain->names;
1353               }
1354         }
1355     }
1356
1357   /* Get the decls in the order they were written.
1358      Usually current_binding_level->names is in reverse order.
1359      But parameter decls were previously put in forward order.  */
1360
1361   if (reverse)
1362     current_binding_level->names
1363       = decls = nreverse (current_binding_level->names);
1364   else
1365     decls = current_binding_level->names;
1366
1367   /* Output any nested inline functions within this block
1368      if they weren't already output.  */
1369   for (decl = decls; decl; decl = TREE_CHAIN (decl))
1370     if (TREE_CODE (decl) == FUNCTION_DECL
1371         && ! TREE_ASM_WRITTEN (decl)
1372         && DECL_INITIAL (decl) != NULL_TREE
1373         && TREE_ADDRESSABLE (decl)
1374         && decl_function_context (decl) == current_function_decl)
1375       {
1376         /* If this decl was copied from a file-scope decl
1377            on account of a block-scope extern decl,
1378            propagate TREE_ADDRESSABLE to the file-scope decl.  */
1379         if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1380           TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1381         else
1382           {
1383             push_function_context ();
1384             output_inline_function (decl);
1385             pop_function_context ();
1386           }
1387       }
1388
1389   /* When not in function-at-a-time mode, expand_end_bindings will
1390      warn about unused variables.  But, in function-at-a-time mode
1391      expand_end_bindings is not passed the list of variables in the
1392      current scope, and therefore no warning is emitted.  So, we
1393      explicitly warn here.  */
1394   if (!processing_template_decl)
1395     warn_about_unused_variables (getdecls ());
1396
1397   /* If there were any declarations or structure tags in that level,
1398      or if this level is a function body,
1399      create a BLOCK to record them for the life of this function.  */
1400   block = NULL_TREE;
1401   block_previously_created = (current_binding_level->this_block != NULL_TREE);
1402   if (block_previously_created)
1403     block = current_binding_level->this_block;
1404   else if (keep == 1 || functionbody)
1405     block = make_node (BLOCK);
1406   if (block != NULL_TREE)
1407     {
1408       if (block_previously_created)
1409         {
1410           if (decls || tags || subblocks)
1411             {
1412               if (BLOCK_VARS (block))
1413                 warning ("internal compiler error: debugging info corrupted");
1414
1415               BLOCK_VARS (block) = decls;
1416
1417               /* We can have previous subblocks and new subblocks when
1418                  doing fixup_gotos with complex cleanups.  We chain the new
1419                  subblocks onto the end of any pre-existing subblocks.  */
1420               BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1421                                                  subblocks);
1422             }
1423         }
1424       else
1425         {
1426           BLOCK_VARS (block) = decls;
1427           BLOCK_SUBBLOCKS (block) = subblocks;
1428         }
1429     }
1430
1431   /* In each subblock, record that this is its superior.  */
1432   if (keep >= 0)
1433     for (link = subblocks; link; link = TREE_CHAIN (link))
1434       BLOCK_SUPERCONTEXT (link) = block;
1435
1436   /* We still support the old for-scope rules, whereby the variables
1437      in a for-init statement were in scope after the for-statement
1438      ended.  We only use the new rules in flag_new_for_scope is
1439      nonzero.  */
1440   leaving_for_scope
1441     = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1442
1443   /* Remove declarations for all the DECLs in this level.  */
1444   for (link = decls; link; link = TREE_CHAIN (link))
1445     {
1446       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL)
1447         {
1448           tree outer_binding
1449             = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1450           tree ns_binding;
1451
1452           if (!outer_binding)
1453             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1454           else
1455             ns_binding = NULL_TREE;
1456
1457           if (outer_binding
1458               && (BINDING_LEVEL (outer_binding)
1459                   == current_binding_level->level_chain))
1460             /* We have something like:
1461
1462                  int i;
1463                  for (int i; ;);
1464
1465                and we are leaving the `for' scope.  There's no reason to
1466                keep the binding of the inner `i' in this case.  */
1467             pop_binding (DECL_NAME (link), link);
1468           else if ((outer_binding
1469                     && (TREE_CODE (BINDING_VALUE (outer_binding))
1470                         == TYPE_DECL))
1471                    || (ns_binding
1472                        && TREE_CODE (ns_binding) == TYPE_DECL))
1473             /* Here, we have something like:
1474
1475                  typedef int I;
1476
1477                  void f () {
1478                    for (int I; ;);
1479                  }
1480
1481                We must pop the for-scope binding so we know what's a
1482                type and what isn't.  */
1483             pop_binding (DECL_NAME (link), link);
1484           else
1485             {
1486               /* Mark this VAR_DECL as dead so that we can tell we left it
1487                  there only for backward compatibility.  */
1488               DECL_DEAD_FOR_LOCAL (link) = 1;
1489
1490               /* Keep track of what should of have happenned when we
1491                  popped the binding.  */
1492               if (outer_binding && BINDING_VALUE (outer_binding))
1493                 DECL_SHADOWED_FOR_VAR (link)
1494                   = BINDING_VALUE (outer_binding);
1495
1496               /* Add it to the list of dead variables in the next
1497                  outermost binding to that we can remove these when we
1498                  leave that binding.  */
1499               current_binding_level->level_chain->dead_vars_from_for
1500                 = tree_cons (NULL_TREE, link,
1501                              current_binding_level->level_chain->
1502                              dead_vars_from_for);
1503
1504               /* Although we don't pop the CPLUS_BINDING, we do clear
1505                  its BINDING_LEVEL since the level is going away now.  */
1506               BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1507                 = 0;
1508             }
1509         }
1510       else
1511         {
1512           /* Remove the binding.  */
1513           decl = link;
1514           if (TREE_CODE (decl) == TREE_LIST)
1515             decl = TREE_VALUE (decl);
1516           if (DECL_P (decl))
1517             pop_binding (DECL_NAME (decl), decl);
1518           else if (TREE_CODE (decl) == OVERLOAD)
1519             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1520           else
1521             my_friendly_abort (0);
1522         }
1523     }
1524
1525   /* Remove declarations for any `for' variables from inner scopes
1526      that we kept around.  */
1527   for (link = current_binding_level->dead_vars_from_for;
1528        link; link = TREE_CHAIN (link))
1529     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1530
1531   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
1532   for (link = current_binding_level->type_shadowed;
1533        link; link = TREE_CHAIN (link))
1534     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1535
1536   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
1537   for (link = current_binding_level->shadowed_labels;
1538        link;
1539        link = TREE_CHAIN (link))
1540     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1541
1542   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1543      list if a `using' declaration put them there.  The debugging
1544      back-ends won't understand OVERLOAD, so we remove them here.
1545      Because the BLOCK_VARS are (temporarily) shared with
1546      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1547      popped all the bindings.  */
1548   if (block)
1549     {
1550       tree* d;
1551
1552       for (d = &BLOCK_VARS (block); *d; )
1553         {
1554           if (TREE_CODE (*d) == TREE_LIST)
1555             *d = TREE_CHAIN (*d);
1556           else
1557             d = &TREE_CHAIN (*d);
1558         }
1559     }
1560
1561   /* If the level being exited is the top level of a function,
1562      check over all the labels.  */
1563   if (functionbody)
1564     {
1565       /* Since this is the top level block of a function, the vars are
1566          the function's parameters.  Don't leave them in the BLOCK
1567          because they are found in the FUNCTION_DECL instead.  */
1568       BLOCK_VARS (block) = 0;
1569       pop_labels (block);
1570     }
1571
1572   tmp = current_binding_level->keep;
1573
1574   pop_binding_level ();
1575   if (functionbody)
1576     DECL_INITIAL (current_function_decl) = block;
1577   else if (block)
1578     {
1579       if (!block_previously_created)
1580         current_binding_level->blocks
1581           = chainon (current_binding_level->blocks, block);
1582     }
1583   /* If we did not make a block for the level just exited,
1584      any blocks made for inner levels
1585      (since they cannot be recorded as subblocks in that level)
1586      must be carried forward so they will later become subblocks
1587      of something else.  */
1588   else if (subblocks)
1589     current_binding_level->blocks
1590       = chainon (current_binding_level->blocks, subblocks);
1591
1592   /* Each and every BLOCK node created here in `poplevel' is important
1593      (e.g. for proper debugging information) so if we created one
1594      earlier, mark it as "used".  */
1595   if (block)
1596     TREE_USED (block) = 1;
1597
1598   /* Take care of compiler's internal binding structures.  */
1599   if (tmp == 2)
1600     {
1601       tree scope_stmts;
1602
1603       scope_stmts
1604         = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1605       if (block)
1606         {
1607           SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1608           SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1609         }
1610
1611       block = poplevel (keep, reverse, functionbody);
1612     }
1613
1614   return block;
1615 }
1616
1617 /* Delete the node BLOCK from the current binding level.
1618    This is used for the block inside a stmt expr ({...})
1619    so that the block can be reinserted where appropriate.  */
1620
1621 void
1622 delete_block (block)
1623      tree block;
1624 {
1625   tree t;
1626   if (current_binding_level->blocks == block)
1627     current_binding_level->blocks = TREE_CHAIN (block);
1628   for (t = current_binding_level->blocks; t;)
1629     {
1630       if (TREE_CHAIN (t) == block)
1631         TREE_CHAIN (t) = TREE_CHAIN (block);
1632       else
1633         t = TREE_CHAIN (t);
1634     }
1635   TREE_CHAIN (block) = NULL_TREE;
1636   /* Clear TREE_USED which is always set by poplevel.
1637      The flag is set again if insert_block is called.  */
1638   TREE_USED (block) = 0;
1639 }
1640
1641 /* Insert BLOCK at the end of the list of subblocks of the
1642    current binding level.  This is used when a BIND_EXPR is expanded,
1643    to handle the BLOCK node inside the BIND_EXPR.  */
1644
1645 void
1646 insert_block (block)
1647      tree block;
1648 {
1649   TREE_USED (block) = 1;
1650   current_binding_level->blocks
1651     = chainon (current_binding_level->blocks, block);
1652 }
1653
1654 /* Set the BLOCK node for the innermost scope
1655    (the one we are currently in).  */
1656
1657 void
1658 set_block (block)
1659     register tree block;
1660 {
1661   current_binding_level->this_block = block;
1662 }
1663
1664 /* Do a pushlevel for class declarations.  */
1665
1666 void
1667 pushlevel_class ()
1668 {
1669   register struct binding_level *newlevel;
1670
1671   /* Reuse or create a struct for this binding level.  */
1672 #if defined(DEBUG_CP_BINDING_LEVELS)
1673   if (0)
1674 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1675   if (free_binding_level)
1676 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1677     {
1678       newlevel = free_binding_level;
1679       free_binding_level = free_binding_level->level_chain;
1680     }
1681   else
1682     newlevel = make_binding_level ();
1683
1684 #if defined(DEBUG_CP_BINDING_LEVELS)
1685   is_class_level = 1;
1686 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1687
1688   push_binding_level (newlevel, 0, 0);
1689
1690   class_binding_level = current_binding_level;
1691   class_binding_level->parm_flag = 2;
1692   class_binding_level->this_class = current_class_type;
1693 }
1694
1695 /* ...and a poplevel for class declarations.  */
1696
1697 void
1698 poplevel_class ()
1699 {
1700   register struct binding_level *level = class_binding_level;
1701   tree shadowed;
1702
1703   my_friendly_assert (level != 0, 354);
1704
1705   /* If we're leaving a toplevel class, don't bother to do the setting
1706      of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1707      shouldn't even be used when current_class_type isn't set, and second,
1708      if we don't touch it here, we're able to use the cache effect if the
1709      next time we're entering a class scope, it is the same class.  */
1710   if (current_class_depth != 1)
1711     {
1712       struct binding_level* b;
1713
1714       /* Clear out our IDENTIFIER_CLASS_VALUEs.  */
1715       for (shadowed = level->class_shadowed;
1716            shadowed;
1717            shadowed = TREE_CHAIN (shadowed))
1718         IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1719
1720       /* Find the next enclosing class, and recreate
1721          IDENTIFIER_CLASS_VALUEs appropriate for that class.  */
1722       b = level->level_chain;
1723       while (b && b->parm_flag != 2)
1724         b = b->level_chain;
1725
1726       if (b)
1727         for (shadowed = b->class_shadowed;
1728              shadowed;
1729              shadowed = TREE_CHAIN (shadowed))
1730           {
1731             tree t;
1732
1733             t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1734             while (t && BINDING_LEVEL (t) != b)
1735               t = TREE_CHAIN (t);
1736
1737             if (t)
1738               IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1739                 = BINDING_VALUE (t);
1740           }
1741     }
1742   else
1743     /* Remember to save what IDENTIFIER's were bound in this scope so we
1744        can recover from cache misses.  */
1745     {
1746       previous_class_type = current_class_type;
1747       previous_class_values = class_binding_level->class_shadowed;
1748     }
1749   for (shadowed = level->type_shadowed;
1750        shadowed;
1751        shadowed = TREE_CHAIN (shadowed))
1752     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1753
1754   /* Remove the bindings for all of the class-level declarations.  */
1755   for (shadowed = level->class_shadowed;
1756        shadowed;
1757        shadowed = TREE_CHAIN (shadowed))
1758     pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1759
1760   GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1761                       (HOST_WIDE_INT) class_binding_level->level_chain,
1762                       class_binding_level->parm_flag,
1763                       class_binding_level->keep);
1764
1765   /* Now, pop out of the binding level which we created up in the
1766      `pushlevel_class' routine.  */
1767 #if defined(DEBUG_CP_BINDING_LEVELS)
1768   is_class_level = 1;
1769 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1770
1771   pop_binding_level ();
1772 }
1773
1774 /* We are entering the scope of a class.  Clear IDENTIFIER_CLASS_VALUE
1775    for any names in enclosing classes.  */
1776
1777 void
1778 clear_identifier_class_values ()
1779 {
1780   tree t;
1781
1782   if (!class_binding_level)
1783     return;
1784
1785   for (t = class_binding_level->class_shadowed;
1786        t;
1787        t = TREE_CHAIN (t))
1788     IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1789 }
1790
1791 /* Returns non-zero if T is a virtual function table.  */
1792
1793 int
1794 vtable_decl_p (t, data)
1795      tree t;
1796      void *data ATTRIBUTE_UNUSED;
1797 {
1798   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1799 }
1800
1801 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1802    functions.  */
1803
1804 int
1805 vtype_decl_p (t, data)
1806      tree t;
1807      void *data ATTRIBUTE_UNUSED;
1808 {
1809   return (TREE_CODE (t) == TYPE_DECL
1810           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1811           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1812 }
1813
1814 /* Return the declarations that are members of the namespace NS.  */
1815
1816 tree
1817 cp_namespace_decls (ns)
1818      tree ns;
1819 {
1820   return NAMESPACE_LEVEL (ns)->names;
1821 }
1822
1823 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1824    itself, calling F for each.  The DATA is passed to F as well.  */
1825
1826 static int
1827 walk_namespaces_r (namespace, f, data)
1828      tree namespace;
1829      walk_namespaces_fn f;
1830      void *data;
1831 {
1832   tree current;
1833   int result = 0;
1834
1835   result |= (*f) (namespace, data);
1836
1837   for (current = cp_namespace_decls (namespace);
1838        current;
1839        current = TREE_CHAIN (current))
1840     {
1841       if (TREE_CODE (current) != NAMESPACE_DECL
1842           || DECL_NAMESPACE_ALIAS (current))
1843         continue;
1844       if (!DECL_LANG_SPECIFIC (current))
1845         {
1846           /* Hmm. std. */
1847           my_friendly_assert (current == std_node, 393);
1848           continue;
1849         }
1850
1851       /* We found a namespace.  */
1852       result |= walk_namespaces_r (current, f, data);
1853     }
1854
1855   return result;
1856 }
1857
1858 /* Walk all the namespaces, calling F for each.  The DATA is passed to
1859    F as well.  */
1860
1861 int
1862 walk_namespaces (f, data)
1863      walk_namespaces_fn f;
1864      void *data;
1865 {
1866   return walk_namespaces_r (global_namespace, f, data);
1867 }
1868
1869 struct walk_globals_data {
1870   walk_globals_pred p;
1871   walk_globals_fn f;
1872   void *data;
1873 };
1874
1875 /* Walk the global declarations in NAMESPACE.  Whenever one is found
1876    for which P returns non-zero, call F with its address.  If any call
1877    to F returns a non-zero value, return a non-zero value.  */
1878
1879 static int
1880 walk_globals_r (namespace, data)
1881      tree namespace;
1882      void *data;
1883 {
1884   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1885   walk_globals_pred p = wgd->p;
1886   walk_globals_fn f = wgd->f;
1887   void *d = wgd->data;
1888   tree *t;
1889   int result = 0;
1890
1891   t = &NAMESPACE_LEVEL (namespace)->names;
1892
1893   while (*t)
1894     {
1895       tree glbl = *t;
1896
1897       if ((*p) (glbl, d))
1898         result |= (*f) (t, d);
1899
1900       /* If F changed *T, then *T still points at the next item to
1901          examine.  */
1902       if (*t == glbl)
1903         t = &TREE_CHAIN (*t);
1904     }
1905
1906   return result;
1907 }
1908
1909 /* Walk the global declarations.  Whenever one is found for which P
1910    returns non-zero, call F with its address.  If any call to F
1911    returns a non-zero value, return a non-zero value.  */
1912
1913 int
1914 walk_globals (p, f, data)
1915      walk_globals_pred p;
1916      walk_globals_fn f;
1917      void *data;
1918 {
1919   struct walk_globals_data wgd;
1920   wgd.p = p;
1921   wgd.f = f;
1922   wgd.data = data;
1923
1924   return walk_namespaces (walk_globals_r, &wgd);
1925 }
1926
1927 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
1928    DATA is non-NULL, this is the last time we will call
1929    wrapup_global_declarations for this NAMESPACE.  */
1930
1931 int
1932 wrapup_globals_for_namespace (namespace, data)
1933      tree namespace;
1934      void *data;
1935 {
1936   tree globals = cp_namespace_decls (namespace);
1937   int len = list_length (globals);
1938   tree *vec = (tree *) alloca (sizeof (tree) * len);
1939   int i;
1940   int result;
1941   tree decl;
1942   int last_time = (data != 0);
1943
1944   if (last_time && namespace == global_namespace)
1945     /* Let compile_file handle the global namespace.  */
1946     return 0;
1947
1948   /* Process the decls in reverse order--earliest first.
1949      Put them into VEC from back to front, then take out from front.  */
1950
1951   for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1952     {
1953       /* Pretend we've output an unused static variable.  This ensures
1954          that the toplevel __FUNCTION__ etc won't be emitted, unless
1955          needed. */
1956       if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)
1957           && !TREE_PUBLIC (decl) && !TREE_USED (decl))
1958         {
1959           TREE_ASM_WRITTEN (decl) = 1;
1960           DECL_IGNORED_P (decl) = 1;
1961         }
1962       vec[len - i - 1] = decl;
1963     }
1964
1965   if (last_time)
1966     {
1967       check_global_declarations (vec, len);
1968       return 0;
1969     }
1970
1971   /* Temporarily mark vtables as external.  That prevents
1972      wrapup_global_declarations from writing them out; we must process
1973      them ourselves in finish_vtable_vardecl.  */
1974   for (i = 0; i < len; ++i)
1975     if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1976       {
1977         DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1978         DECL_EXTERNAL (vec[i]) = 1;
1979       }
1980
1981   /* Write out any globals that need to be output.  */
1982   result = wrapup_global_declarations (vec, len);
1983
1984   /* Undo the hack to DECL_EXTERNAL above.  */
1985   for (i = 0; i < len; ++i)
1986     if (vtable_decl_p (vec[i], /*data=*/0)
1987         && DECL_NOT_REALLY_EXTERN (vec[i]))
1988       {
1989         DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1990         DECL_EXTERNAL (vec[i]) = 0;
1991       }
1992
1993   return result;
1994 }
1995
1996 \f
1997 /* Mark ARG (which is really a struct binding_level **) for GC.  */
1998
1999 static void
2000 mark_binding_level (arg)
2001      void *arg;
2002 {
2003   struct binding_level *lvl = *(struct binding_level **)arg;
2004
2005   for (; lvl; lvl = lvl->level_chain)
2006     {
2007       ggc_mark_tree (lvl->names);
2008       ggc_mark_tree (lvl->tags);
2009       ggc_mark_tree (lvl->usings);
2010       ggc_mark_tree (lvl->using_directives);
2011       ggc_mark_tree (lvl->class_shadowed);
2012       ggc_mark_tree (lvl->type_shadowed);
2013       ggc_mark_tree (lvl->shadowed_labels);
2014       ggc_mark_tree (lvl->blocks);
2015       ggc_mark_tree (lvl->this_block);
2016       ggc_mark_tree (lvl->this_class);
2017       ggc_mark_tree (lvl->incomplete);
2018       ggc_mark_tree (lvl->dead_vars_from_for);
2019     }
2020 }
2021
2022 static void
2023 mark_named_label_lists (labs, uses)
2024      void *labs;
2025      void *uses;
2026 {
2027   struct named_label_list *l = *(struct named_label_list **)labs;
2028   struct named_label_use_list *u = *(struct named_label_use_list **)uses;
2029
2030   for (; l; l = l->next)
2031     {
2032       ggc_mark (l);
2033       mark_binding_level (l->binding_level);
2034       ggc_mark_tree (l->old_value);
2035       ggc_mark_tree (l->label_decl);
2036       ggc_mark_tree (l->bad_decls);
2037     }
2038
2039   for (; u; u = u->next)
2040     ggc_mark (u);
2041 }
2042 \f
2043 /* For debugging.  */
2044 static int no_print_functions = 0;
2045 static int no_print_builtins = 0;
2046
2047 void
2048 print_binding_level (lvl)
2049      struct binding_level *lvl;
2050 {
2051   tree t;
2052   int i = 0, len;
2053   fprintf (stderr, " blocks=");
2054   fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
2055   fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
2056            list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
2057   if (lvl->tag_transparent)
2058     fprintf (stderr, " tag-transparent");
2059   if (lvl->more_cleanups_ok)
2060     fprintf (stderr, " more-cleanups-ok");
2061   if (lvl->have_cleanups)
2062     fprintf (stderr, " have-cleanups");
2063   fprintf (stderr, "\n");
2064   if (lvl->names)
2065     {
2066       fprintf (stderr, " names:\t");
2067       /* We can probably fit 3 names to a line?  */
2068       for (t = lvl->names; t; t = TREE_CHAIN (t))
2069         {
2070           if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2071             continue;
2072           if (no_print_builtins
2073               && (TREE_CODE (t) == TYPE_DECL)
2074               && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2075             continue;
2076
2077           /* Function decls tend to have longer names.  */
2078           if (TREE_CODE (t) == FUNCTION_DECL)
2079             len = 3;
2080           else
2081             len = 2;
2082           i += len;
2083           if (i > 6)
2084             {
2085               fprintf (stderr, "\n\t");
2086               i = len;
2087             }
2088           print_node_brief (stderr, "", t, 0);
2089           if (t == error_mark_node)
2090             break;
2091         }
2092       if (i)
2093         fprintf (stderr, "\n");
2094     }
2095   if (lvl->tags)
2096     {
2097       fprintf (stderr, " tags:\t");
2098       i = 0;
2099       for (t = lvl->tags; t; t = TREE_CHAIN (t))
2100         {
2101           if (TREE_PURPOSE (t) == NULL_TREE)
2102             len = 3;
2103           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2104             len = 2;
2105           else
2106             len = 4;
2107           i += len;
2108           if (i > 5)
2109             {
2110               fprintf (stderr, "\n\t");
2111               i = len;
2112             }
2113           if (TREE_PURPOSE (t) == NULL_TREE)
2114             {
2115               print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2116               fprintf (stderr, ">");
2117             }
2118           else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2119             print_node_brief (stderr, "", TREE_VALUE (t), 0);
2120           else
2121             {
2122               print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2123               print_node_brief (stderr, "", TREE_VALUE (t), 0);
2124               fprintf (stderr, ">");
2125             }
2126         }
2127       if (i)
2128         fprintf (stderr, "\n");
2129     }
2130   if (lvl->class_shadowed)
2131     {
2132       fprintf (stderr, " class-shadowed:");
2133       for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2134         {
2135           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2136         }
2137       fprintf (stderr, "\n");
2138     }
2139   if (lvl->type_shadowed)
2140     {
2141       fprintf (stderr, " type-shadowed:");
2142       for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2143         {
2144           fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2145         }
2146       fprintf (stderr, "\n");
2147     }
2148 }
2149
2150 void
2151 print_other_binding_stack (stack)
2152      struct binding_level *stack;
2153 {
2154   struct binding_level *level;
2155   for (level = stack; level != global_binding_level; level = level->level_chain)
2156     {
2157       fprintf (stderr, "binding level ");
2158       fprintf (stderr, HOST_PTR_PRINTF, level);
2159       fprintf (stderr, "\n");
2160       print_binding_level (level);
2161     }
2162 }
2163
2164 void
2165 print_binding_stack ()
2166 {
2167   struct binding_level *b;
2168   fprintf (stderr, "current_binding_level=");
2169   fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2170   fprintf (stderr, "\nclass_binding_level=");
2171   fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2172   fprintf (stderr, "\nglobal_binding_level=");
2173   fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2174   fprintf (stderr, "\n");
2175   if (class_binding_level)
2176     {
2177       for (b = class_binding_level; b; b = b->level_chain)
2178         if (b == current_binding_level)
2179           break;
2180       if (b)
2181         b = class_binding_level;
2182       else
2183         b = current_binding_level;
2184     }
2185   else
2186     b = current_binding_level;
2187   print_other_binding_stack (b);
2188   fprintf (stderr, "global:\n");
2189   print_binding_level (global_binding_level);
2190 }
2191
2192 /* Namespace binding access routines: The namespace_bindings field of
2193    the identifier is polymorphic, with three possible values:
2194    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2195    indicating the BINDING_VALUE of global_namespace. */
2196
2197 /* Check whether the a binding for the name to scope is known.
2198    Assumes that the bindings of the name are already a list
2199    of bindings. Returns the binding found, or NULL_TREE. */
2200
2201 static tree
2202 find_binding (name, scope)
2203      tree name;
2204      tree scope;
2205 {
2206   tree iter, prev = NULL_TREE;
2207
2208   scope = ORIGINAL_NAMESPACE (scope);
2209
2210   for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2211        iter = TREE_CHAIN (iter))
2212     {
2213       my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2214       if (BINDING_SCOPE (iter) == scope)
2215         {
2216           /* Move binding found to the front of the list, so
2217              subsequent lookups will find it faster. */
2218           if (prev)
2219             {
2220               TREE_CHAIN (prev) = TREE_CHAIN (iter);
2221               TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2222               IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2223             }
2224           return iter;
2225         }
2226       prev = iter;
2227     }
2228   return NULL_TREE;
2229 }
2230
2231 /* Always returns a binding for name in scope. If the
2232    namespace_bindings is not a list, convert it to one first.
2233    If no binding is found, make a new one. */
2234
2235 tree
2236 binding_for_name (name, scope)
2237      tree name;
2238      tree scope;
2239 {
2240   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2241   tree result;
2242
2243   scope = ORIGINAL_NAMESPACE (scope);
2244
2245   if (b && TREE_CODE (b) != CPLUS_BINDING)
2246     {
2247       /* Get rid of optimization for global scope. */
2248       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2249       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2250       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2251     }
2252   if (b && (result = find_binding (name, scope)))
2253     return result;
2254   /* Not found, make a new one. */
2255   result = make_node (CPLUS_BINDING);
2256   TREE_CHAIN (result) = b;
2257   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2258   BINDING_SCOPE (result) = scope;
2259   BINDING_TYPE (result) = NULL_TREE;
2260   BINDING_VALUE (result) = NULL_TREE;
2261   return result;
2262 }
2263
2264 /* Return the binding value for name in scope, considering that
2265    namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2266
2267 tree
2268 namespace_binding (name, scope)
2269      tree name;
2270      tree scope;
2271 {
2272   tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2273   if (b == NULL_TREE)
2274     return NULL_TREE;
2275   if (scope == NULL_TREE)
2276     scope = global_namespace;
2277   if (TREE_CODE (b) != CPLUS_BINDING)
2278     return (scope == global_namespace) ? b : NULL_TREE;
2279   name = find_binding (name,scope);
2280   if (name == NULL_TREE)
2281     return name;
2282   return BINDING_VALUE (name);
2283 }
2284
2285 /* Set the binding value for name in scope. If modifying the binding
2286    of global_namespace is attempted, try to optimize it. */
2287
2288 void
2289 set_namespace_binding (name, scope, val)
2290      tree name;
2291      tree scope;
2292      tree val;
2293 {
2294   tree b;
2295
2296   if (scope == NULL_TREE)
2297     scope = global_namespace;
2298
2299   if (scope == global_namespace)
2300     {
2301       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2302       if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2303         {
2304           IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2305           return;
2306         }
2307     }
2308   b = binding_for_name (name, scope);
2309   BINDING_VALUE (b) = val;
2310 }
2311
2312 /* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
2313    select a name that is unique to this compilation unit.  */
2314
2315 void
2316 push_namespace (name)
2317      tree name;
2318 {
2319   tree d = NULL_TREE;
2320   int need_new = 1;
2321   int implicit_use = 0;
2322   int global = 0;
2323   if (!global_namespace)
2324     {
2325       /* This must be ::. */
2326       my_friendly_assert (name == get_identifier ("::"), 377);
2327       global = 1;
2328     }
2329   else if (!name)
2330     {
2331       /* The name of anonymous namespace is unique for the translation
2332          unit.  */
2333       if (!anonymous_namespace_name)
2334         anonymous_namespace_name = get_file_function_name ('N');
2335       name = anonymous_namespace_name;
2336       d = IDENTIFIER_NAMESPACE_VALUE (name);
2337       if (d)
2338         /* Reopening anonymous namespace.  */
2339         need_new = 0;
2340       implicit_use = 1;
2341     }
2342   else if (current_namespace == global_namespace
2343            && name == DECL_NAME (std_node))
2344     {
2345       in_std++;
2346       return;
2347     }
2348   else
2349     {
2350       /* Check whether this is an extended namespace definition. */
2351       d = IDENTIFIER_NAMESPACE_VALUE (name);
2352       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2353         {
2354           need_new = 0;
2355           if (DECL_NAMESPACE_ALIAS (d))
2356             {
2357               cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2358                         d, DECL_NAMESPACE_ALIAS (d));
2359               d = DECL_NAMESPACE_ALIAS (d);
2360             }
2361         }
2362     }
2363
2364   if (need_new)
2365     {
2366       /* Make a new namespace, binding the name to it. */
2367       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2368       /* The global namespace is not pushed, and the global binding
2369          level is set elsewhere.  */
2370       if (!global)
2371         {
2372           DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2373           d = pushdecl (d);
2374           pushlevel (0);
2375           declare_namespace_level ();
2376           NAMESPACE_LEVEL (d) = current_binding_level;
2377         }
2378     }
2379   else
2380     resume_binding_level (NAMESPACE_LEVEL (d));
2381
2382   if (implicit_use)
2383     do_using_directive (d);
2384   /* Enter the name space. */
2385   current_namespace = d;
2386 }
2387
2388 /* Pop from the scope of the current namespace.  */
2389
2390 void
2391 pop_namespace ()
2392 {
2393   if (current_namespace == global_namespace)
2394     {
2395       my_friendly_assert (in_std>0, 980421);
2396       in_std--;
2397       return;
2398     }
2399   current_namespace = CP_DECL_CONTEXT (current_namespace);
2400   /* The binding level is not popped, as it might be re-opened later.  */
2401   suspend_binding_level ();
2402 }
2403
2404 /* Push into the scope of the namespace NS, even if it is deeply
2405    nested within another namespace.  */
2406
2407 void
2408 push_nested_namespace (ns)
2409      tree ns;
2410 {
2411   if (ns == global_namespace)
2412     push_to_top_level ();
2413   else
2414     {
2415       push_nested_namespace (CP_DECL_CONTEXT (ns));
2416       push_namespace (DECL_NAME (ns));
2417     }
2418 }
2419
2420 /* Pop back from the scope of the namespace NS, which was previously
2421    entered with push_nested_namespace.  */
2422
2423 void
2424 pop_nested_namespace (ns)
2425      tree ns;
2426 {
2427   while (ns != global_namespace)
2428     {
2429       pop_namespace ();
2430       ns = CP_DECL_CONTEXT (ns);
2431     }
2432
2433   pop_from_top_level ();
2434 }
2435
2436 \f
2437 /* Subroutines for reverting temporarily to top-level for instantiation
2438    of templates and such.  We actually need to clear out the class- and
2439    local-value slots of all identifiers, so that only the global values
2440    are at all visible.  Simply setting current_binding_level to the global
2441    scope isn't enough, because more binding levels may be pushed.  */
2442 struct saved_scope *scope_chain;
2443
2444 /* Mark ST for GC.  */
2445
2446 static void
2447 mark_stmt_tree (st)
2448      struct stmt_tree *st;
2449 {
2450   ggc_mark_tree (st->x_last_stmt);
2451   ggc_mark_tree (st->x_last_expr_type);
2452 }
2453
2454 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2455
2456 static void
2457 mark_saved_scope (arg)
2458      void *arg;
2459 {
2460   struct saved_scope *t = *(struct saved_scope **)arg;
2461   while (t)
2462     {
2463       mark_binding_level (&t->class_bindings);
2464       ggc_mark_tree (t->old_bindings);
2465       ggc_mark_tree (t->old_namespace);
2466       ggc_mark_tree (t->class_name);
2467       ggc_mark_tree (t->class_type);
2468       ggc_mark_tree (t->access_specifier);
2469       ggc_mark_tree (t->function_decl);
2470       if (t->lang_base)
2471         ggc_mark_tree_varray (t->lang_base);
2472       ggc_mark_tree (t->lang_name);
2473       ggc_mark_tree (t->x_function_parms);
2474       ggc_mark_tree (t->template_parms);
2475       ggc_mark_tree (t->x_previous_class_type);
2476       ggc_mark_tree (t->x_previous_class_values);
2477       ggc_mark_tree (t->x_saved_tree);
2478       ggc_mark_tree (t->incomplete);
2479       ggc_mark_tree (t->lookups);
2480
2481       mark_stmt_tree (&t->x_stmt_tree);
2482       mark_binding_level (&t->bindings);
2483       t = t->prev;
2484     }
2485 }
2486
2487 static tree
2488 store_bindings (names, old_bindings)
2489      tree names, old_bindings;
2490 {
2491   tree t;
2492   for (t = names; t; t = TREE_CHAIN (t))
2493     {
2494       tree binding, t1, id;
2495
2496       if (TREE_CODE (t) == TREE_LIST)
2497         id = TREE_PURPOSE (t);
2498       else
2499         id = DECL_NAME (t);
2500
2501       if (!id
2502           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2503              we have no IDENTIFIER_BINDING if we have left the class
2504              scope, but cached the class-level declarations.  */
2505           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2506         continue;
2507
2508       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2509         if (TREE_VEC_ELT (t1, 0) == id)
2510           goto skip_it;
2511
2512       binding = make_tree_vec (4);
2513
2514       if (id)
2515         {
2516           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2517           TREE_VEC_ELT (binding, 0) = id;
2518           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2519           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2520           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2521           IDENTIFIER_BINDING (id) = NULL_TREE;
2522           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2523         }
2524       TREE_CHAIN (binding) = old_bindings;
2525       old_bindings = binding;
2526     skip_it:
2527       ;
2528     }
2529   return old_bindings;
2530 }
2531
2532 void
2533 maybe_push_to_top_level (pseudo)
2534      int pseudo;
2535 {
2536   struct saved_scope *s;
2537   struct binding_level *b;
2538   tree old_bindings;
2539   int need_pop;
2540
2541   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2542
2543   b = scope_chain ? current_binding_level : 0;
2544
2545   /* If we're in the middle of some function, save our state.  */
2546   if (cfun)
2547     {
2548       need_pop = 1;
2549       push_function_context_to (NULL_TREE);
2550     }
2551   else
2552     need_pop = 0;
2553
2554   old_bindings = NULL_TREE;
2555   if (scope_chain && previous_class_type)
2556     old_bindings = store_bindings (previous_class_values, old_bindings);
2557
2558   /* Have to include global_binding_level, because class-level decls
2559      aren't listed anywhere useful.  */
2560   for (; b; b = b->level_chain)
2561     {
2562       tree t;
2563
2564       /* Template IDs are inserted into the global level. If they were
2565          inserted into namespace level, finish_file wouldn't find them
2566          when doing pending instantiations. Therefore, don't stop at
2567          namespace level, but continue until :: .  */
2568       if (b == global_binding_level || (pseudo && b->template_parms_p))
2569         break;
2570
2571       old_bindings = store_bindings (b->names, old_bindings);
2572       /* We also need to check class_shadowed to save class-level type
2573          bindings, since pushclass doesn't fill in b->names.  */
2574       if (b->parm_flag == 2)
2575         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2576
2577       /* Unwind type-value slots back to top level.  */
2578       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2579         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2580     }
2581   s->prev = scope_chain;
2582   s->old_bindings = old_bindings;
2583   s->bindings = b;
2584   s->need_pop_function_context = need_pop;
2585   s->function_decl = current_function_decl;
2586
2587   scope_chain = s;
2588   current_function_decl = NULL_TREE;
2589   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2590   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2591   current_lang_name = lang_name_cplusplus;
2592   strict_prototype = strict_prototypes_lang_cplusplus;
2593   current_namespace = global_namespace;
2594 }
2595
2596 void
2597 push_to_top_level ()
2598 {
2599   maybe_push_to_top_level (0);
2600 }
2601
2602 void
2603 pop_from_top_level ()
2604 {
2605   struct saved_scope *s = scope_chain;
2606   tree t;
2607
2608   /* Clear out class-level bindings cache.  */
2609   if (previous_class_type)
2610     invalidate_class_lookup_cache ();
2611
2612   VARRAY_FREE (current_lang_base);
2613
2614   scope_chain = s->prev;
2615   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2616     {
2617       tree id = TREE_VEC_ELT (t, 0);
2618       if (id)
2619         {
2620           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2621           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2622           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2623         }
2624     }
2625
2626   if (current_lang_name == lang_name_cplusplus)
2627     strict_prototype = strict_prototypes_lang_cplusplus;
2628   else if (current_lang_name == lang_name_c)
2629     strict_prototype = strict_prototypes_lang_c;
2630
2631   /* If we were in the middle of compiling a function, restore our
2632      state.  */
2633   if (s->need_pop_function_context)
2634     pop_function_context_from (NULL_TREE);
2635   current_function_decl = s->function_decl;
2636
2637   free (s);
2638 }
2639 \f
2640 /* Push a definition of struct, union or enum tag "name".
2641    into binding_level "b".   "type" should be the type node,
2642    We assume that the tag "name" is not already defined.
2643
2644    Note that the definition may really be just a forward reference.
2645    In that case, the TYPE_SIZE will be a NULL_TREE.
2646
2647    C++ gratuitously puts all these tags in the name space.  */
2648
2649 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2650    record the shadowed value for this binding contour.  TYPE is
2651    the type that ID maps to.  */
2652
2653 static void
2654 set_identifier_type_value_with_scope (id, type, b)
2655      tree id;
2656      tree type;
2657      struct binding_level *b;
2658 {
2659   if (!b->namespace_p)
2660     {
2661       /* Shadow the marker, not the real thing, so that the marker
2662          gets restored later. */
2663       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2664       b->type_shadowed
2665         = tree_cons (id, old_type_value, b->type_shadowed);
2666     }
2667   else
2668     {
2669       tree binding = binding_for_name (id, current_namespace);
2670       BINDING_TYPE (binding) = type;
2671       /* Store marker instead of real type. */
2672       type = global_type_node;
2673     }
2674   SET_IDENTIFIER_TYPE_VALUE (id, type);
2675 }
2676
2677 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2678
2679 void
2680 set_identifier_type_value (id, type)
2681      tree id;
2682      tree type;
2683 {
2684   set_identifier_type_value_with_scope (id, type, current_binding_level);
2685 }
2686
2687 /* Return the type associated with id. */
2688
2689 tree
2690 identifier_type_value (id)
2691      tree id;
2692 {
2693   /* There is no type with that name, anywhere. */
2694   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2695     return NULL_TREE;
2696   /* This is not the type marker, but the real thing. */
2697   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2698     return REAL_IDENTIFIER_TYPE_VALUE (id);
2699   /* Have to search for it. It must be on the global level, now.
2700      Ask lookup_name not to return non-types. */
2701   id = lookup_name_real (id, 2, 1, 0);
2702   if (id)
2703     return TREE_TYPE (id);
2704   return NULL_TREE;
2705 }
2706
2707 /* Pop off extraneous binding levels left over due to syntax errors.
2708
2709    We don't pop past namespaces, as they might be valid.  */
2710
2711 void
2712 pop_everything ()
2713 {
2714 #ifdef DEBUG_CP_BINDING_LEVELS
2715   fprintf (stderr, "XXX entering pop_everything ()\n");
2716 #endif
2717   while (!toplevel_bindings_p ())
2718     {
2719       if (current_binding_level->parm_flag == 2)
2720         pop_nested_class ();
2721       else
2722         poplevel (0, 0, 0);
2723     }
2724 #ifdef DEBUG_CP_BINDING_LEVELS
2725   fprintf (stderr, "XXX leaving pop_everything ()\n");
2726 #endif
2727 }
2728
2729 /* The type TYPE is being declared.  If it is a class template, or a
2730    specialization of a class template, do any processing required and
2731    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2732    being declared a friend.  B is the binding level at which this TYPE
2733    should be bound.
2734
2735    Returns the TYPE_DECL for TYPE, which may have been altered by this
2736    processing.  */
2737
2738 static tree
2739 maybe_process_template_type_declaration (type, globalize, b)
2740      tree type;
2741      int globalize;
2742      struct binding_level* b;
2743 {
2744   tree decl = TYPE_NAME (type);
2745
2746   if (processing_template_parmlist)
2747     /* You can't declare a new template type in a template parameter
2748        list.  But, you can declare a non-template type:
2749
2750          template <class A*> struct S;
2751
2752        is a forward-declaration of `A'.  */
2753     ;
2754   else
2755     {
2756       maybe_check_template_type (type);
2757
2758       my_friendly_assert (IS_AGGR_TYPE (type)
2759                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2760
2761
2762       if (processing_template_decl)
2763         {
2764           /* This may change after the call to
2765              push_template_decl_real, but we want the original value.  */
2766           tree name = DECL_NAME (decl);
2767
2768           decl = push_template_decl_real (decl, globalize);
2769           /* If the current binding level is the binding level for the
2770              template parameters (see the comment in
2771              begin_template_parm_list) and the enclosing level is a class
2772              scope, and we're not looking at a friend, push the
2773              declaration of the member class into the class scope.  In the
2774              friend case, push_template_decl will already have put the
2775              friend into global scope, if appropriate.  */
2776           if (TREE_CODE (type) != ENUMERAL_TYPE
2777               && !globalize && b->template_parms_p
2778               && b->level_chain->parm_flag == 2)
2779             {
2780               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2781               /* Put this tag on the list of tags for the class, since
2782                  that won't happen below because B is not the class
2783                  binding level, but is instead the pseudo-global level.  */
2784               b->level_chain->tags =
2785                 tree_cons (name, type, b->level_chain->tags);
2786               if (!COMPLETE_TYPE_P (current_class_type))
2787                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2788             }
2789         }
2790     }
2791
2792   return decl;
2793 }
2794
2795 /* In C++, you don't have to write `struct S' to refer to `S'; you
2796    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2797    if the user had written `typedef struct S S'.  Create and return
2798    the TYPE_DECL for TYPE.  */
2799
2800 tree
2801 create_implicit_typedef (name, type)
2802      tree name;
2803      tree type;
2804 {
2805   tree decl;
2806
2807   decl = build_decl (TYPE_DECL, name, type);
2808   SET_DECL_ARTIFICIAL (decl);
2809   /* There are other implicit type declarations, like the one *within*
2810      a class that allows you to write `S::S'.  We must distinguish
2811      amongst these.  */
2812   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2813   TYPE_NAME (type) = decl;
2814
2815   return decl;
2816 }
2817
2818 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2819    Normally put it into the inner-most non-tag-transparent scope,
2820    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2821    The latter is needed for implicit declarations.  */
2822
2823 void
2824 pushtag (name, type, globalize)
2825      tree name, type;
2826      int globalize;
2827 {
2828   register struct binding_level *b;
2829
2830   b = current_binding_level;
2831   while (b->tag_transparent
2832          || (globalize && b->parm_flag == 2))
2833     b = b->level_chain;
2834
2835   b->tags = tree_cons (name, type, b->tags);
2836
2837   if (name)
2838     {
2839       /* Do C++ gratuitous typedefing.  */
2840       if (IDENTIFIER_TYPE_VALUE (name) != type)
2841         {
2842           register tree d = NULL_TREE;
2843           int in_class = 0;
2844           tree context = TYPE_CONTEXT (type);
2845
2846           if (! context)
2847             {
2848               tree cs = current_scope ();
2849
2850               if (! globalize)
2851                 context = cs;
2852               else if (cs != NULL_TREE && TYPE_P (cs))
2853                 /* When declaring a friend class of a local class, we want
2854                    to inject the newly named class into the scope
2855                    containing the local class, not the namespace scope.  */
2856                 context = decl_function_context (get_type_decl (cs));
2857             }
2858           if (!context)
2859             context = current_namespace;
2860
2861           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2862               || b->parm_flag == 2)
2863             in_class = 1;
2864
2865           if (current_lang_name == lang_name_java)
2866             TYPE_FOR_JAVA (type) = 1;
2867
2868           d = create_implicit_typedef (name, type);
2869           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2870           if (! in_class)
2871             set_identifier_type_value_with_scope (name, type, b);
2872
2873           d = maybe_process_template_type_declaration (type,
2874                                                        globalize, b);
2875
2876           if (b->parm_flag == 2)
2877             {
2878               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2879                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2880                    class.  But if it's a member template class, we
2881                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2882                    is done later.  */
2883                 finish_member_declaration (d);
2884               else
2885                 pushdecl_class_level (d);
2886             }
2887           else
2888             d = pushdecl_with_scope (d, b);
2889
2890           if (ANON_AGGRNAME_P (name))
2891             DECL_IGNORED_P (d) = 1;
2892
2893           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2894           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2895
2896           /* If this is a local class, keep track of it.  We need this
2897              information for name-mangling, and so that it is possible to find
2898              all function definitions in a translation unit in a convenient
2899              way.  (It's otherwise tricky to find a member function definition
2900              it's only pointed to from within a local class.)  */
2901           if (TYPE_CONTEXT (type)
2902               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
2903             VARRAY_PUSH_TREE (local_classes, type);
2904
2905           if (!uses_template_parms (type))
2906             {
2907               if (flag_new_abi)
2908                 DECL_ASSEMBLER_NAME (d) = mangle_type (type);
2909               else
2910                 DECL_ASSEMBLER_NAME (d)
2911                   = get_identifier (build_overload_name (type, 1, 1));
2912             }
2913         }
2914       if (b->parm_flag == 2)
2915         {
2916           if (!COMPLETE_TYPE_P (current_class_type))
2917             CLASSTYPE_TAGS (current_class_type) = b->tags;
2918         }
2919     }
2920
2921   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2922     /* Use the canonical TYPE_DECL for this node.  */
2923     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2924   else
2925     {
2926       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2927          will be the tagged type we just added to the current
2928          binding level.  This fake NULL-named TYPE_DECL node helps
2929          dwarfout.c to know when it needs to output a
2930          representation of a tagged type, and it also gives us a
2931          convenient place to record the "scope start" address for
2932          the tagged type.  */
2933
2934       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2935       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2936     }
2937 }
2938
2939 /* Counter used to create anonymous type names.  */
2940
2941 static int anon_cnt = 0;
2942
2943 /* Return an IDENTIFIER which can be used as a name for
2944    anonymous structs and unions.  */
2945
2946 tree
2947 make_anon_name ()
2948 {
2949   char buf[32];
2950
2951   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2952   return get_identifier (buf);
2953 }
2954
2955 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2956    This keeps dbxout from getting confused.  */
2957
2958 void
2959 clear_anon_tags ()
2960 {
2961   register struct binding_level *b;
2962   register tree tags;
2963   static int last_cnt = 0;
2964
2965   /* Fast out if no new anon names were declared.  */
2966   if (last_cnt == anon_cnt)
2967     return;
2968
2969   b = current_binding_level;
2970   while (b->tag_transparent)
2971     b = b->level_chain;
2972   tags = b->tags;
2973   while (tags)
2974     {
2975       /* A NULL purpose means we have already processed all tags
2976          from here to the end of the list.  */
2977       if (TREE_PURPOSE (tags) == NULL_TREE)
2978         break;
2979       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2980         TREE_PURPOSE (tags) = NULL_TREE;
2981       tags = TREE_CHAIN (tags);
2982     }
2983   last_cnt = anon_cnt;
2984 }
2985 \f
2986 /* Subroutine of duplicate_decls: return truthvalue of whether
2987    or not types of these decls match.
2988
2989    For C++, we must compare the parameter list so that `int' can match
2990    `int&' in a parameter position, but `int&' is not confused with
2991    `const int&'.  */
2992
2993 int
2994 decls_match (newdecl, olddecl)
2995      tree newdecl, olddecl;
2996 {
2997   int types_match;
2998
2999   if (newdecl == olddecl)
3000     return 1;
3001
3002   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
3003     /* If the two DECLs are not even the same kind of thing, we're not
3004        interested in their types.  */
3005     return 0;
3006
3007   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3008     {
3009       tree f1 = TREE_TYPE (newdecl);
3010       tree f2 = TREE_TYPE (olddecl);
3011       tree p1 = TYPE_ARG_TYPES (f1);
3012       tree p2 = TYPE_ARG_TYPES (f2);
3013
3014       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
3015           && ! (DECL_EXTERN_C_P (newdecl)
3016                 && DECL_EXTERN_C_P (olddecl)))
3017         return 0;
3018
3019       if (TREE_CODE (f1) != TREE_CODE (f2))
3020         return 0;
3021
3022       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
3023         {
3024           if ((! strict_prototypes_lang_c || DECL_BUILT_IN (olddecl))
3025               && DECL_EXTERN_C_P (olddecl)
3026               && p2 == NULL_TREE)
3027             {
3028               types_match = self_promoting_args_p (p1);
3029               if (p1 == void_list_node)
3030                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3031             }
3032           else if (!strict_prototypes_lang_c
3033                    && DECL_EXTERN_C_P (olddecl)
3034                    && DECL_EXTERN_C_P (newdecl)
3035                    && p1 == NULL_TREE)
3036             {
3037               types_match = self_promoting_args_p (p2);
3038               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3039             }
3040           else
3041             types_match = compparms (p1, p2);
3042         }
3043       else
3044         types_match = 0;
3045     }
3046   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3047     {
3048       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3049                                 DECL_TEMPLATE_PARMS (olddecl)))
3050         return 0;
3051
3052       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3053         types_match = 1;
3054       else
3055         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3056                                    DECL_TEMPLATE_RESULT (newdecl));
3057     }
3058   else
3059     {
3060       if (TREE_TYPE (newdecl) == error_mark_node)
3061         types_match = TREE_TYPE (olddecl) == error_mark_node;
3062       else if (TREE_TYPE (olddecl) == NULL_TREE)
3063         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3064       else if (TREE_TYPE (newdecl) == NULL_TREE)
3065         types_match = 0;
3066       else
3067         types_match = comptypes (TREE_TYPE (newdecl),
3068                                  TREE_TYPE (olddecl),
3069                                  COMPARE_REDECLARATION);
3070     }
3071
3072   return types_match;
3073 }
3074
3075 /* If NEWDECL is `static' and an `extern' was seen previously,
3076    warn about it.  OLDDECL is the previous declaration.
3077
3078    Note that this does not apply to the C++ case of declaring
3079    a variable `extern const' and then later `const'.
3080
3081    Don't complain about built-in functions, since they are beyond
3082    the user's control.  */
3083
3084 static void
3085 warn_extern_redeclared_static (newdecl, olddecl)
3086      tree newdecl, olddecl;
3087 {
3088   static const char *explicit_extern_static_warning
3089     = "`%D' was declared `extern' and later `static'";
3090   static const char *implicit_extern_static_warning
3091     = "`%D' was declared implicitly `extern' and later `static'";
3092
3093   tree name;
3094
3095   if (TREE_CODE (newdecl) == TYPE_DECL
3096       || TREE_CODE (newdecl) == TEMPLATE_DECL
3097       || TREE_CODE (newdecl) == CONST_DECL)
3098     return;
3099
3100   /* Don't get confused by static member functions; that's a different
3101      use of `static'.  */
3102   if (TREE_CODE (newdecl) == FUNCTION_DECL
3103       && DECL_STATIC_FUNCTION_P (newdecl))
3104     return;
3105
3106   /* If the old declaration was `static', or the new one isn't, then
3107      then everything is OK.  */
3108   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3109     return;
3110
3111   /* It's OK to declare a builtin function as `static'.  */
3112   if (TREE_CODE (olddecl) == FUNCTION_DECL
3113       && DECL_ARTIFICIAL (olddecl))
3114     return;
3115
3116   name = DECL_ASSEMBLER_NAME (newdecl);
3117   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3118               ? implicit_extern_static_warning
3119               : explicit_extern_static_warning, newdecl);
3120   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3121 }
3122
3123 /* Handle when a new declaration NEWDECL has the same name as an old
3124    one OLDDECL in the same binding contour.  Prints an error message
3125    if appropriate.
3126
3127    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3128    Otherwise, return 0.  */
3129
3130 int
3131 duplicate_decls (newdecl, olddecl)
3132      tree newdecl, olddecl;
3133 {
3134   unsigned olddecl_uid = DECL_UID (olddecl);
3135   int olddecl_friend = 0, types_match = 0;
3136   int new_defines_function = 0;
3137
3138   if (newdecl == olddecl)
3139     return 1;
3140
3141   types_match = decls_match (newdecl, olddecl);
3142
3143   /* If either the type of the new decl or the type of the old decl is an
3144      error_mark_node, then that implies that we have already issued an
3145      error (earlier) for some bogus type specification, and in that case,
3146      it is rather pointless to harass the user with yet more error message
3147      about the same declaration, so just pretend the types match here.  */
3148   if (TREE_TYPE (newdecl) == error_mark_node
3149       || TREE_TYPE (olddecl) == error_mark_node)
3150     types_match = 1;
3151
3152   /* Check for redeclaration and other discrepancies. */
3153   if (TREE_CODE (olddecl) == FUNCTION_DECL
3154       && DECL_ARTIFICIAL (olddecl))
3155     {
3156       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3157         {
3158           /* If you declare a built-in or predefined function name as static,
3159              the old definition is overridden, but optionally warn this was a
3160              bad choice of name.  */
3161           if (! TREE_PUBLIC (newdecl))
3162             {
3163               if (warn_shadow)
3164                 cp_warning ("shadowing %s function `%#D'",
3165                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3166                             olddecl);
3167               /* Discard the old built-in function.  */
3168               return 0;
3169             }
3170           /* If the built-in is not ansi, then programs can override
3171              it even globally without an error.  */
3172           else if (! DECL_BUILT_IN (olddecl))
3173             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3174                         olddecl, newdecl);
3175           else
3176             {
3177               cp_error ("declaration of `%#D'", newdecl);
3178               cp_error ("conflicts with built-in declaration `%#D'",
3179                         olddecl);
3180             }
3181           return 0;
3182         }
3183       else if (!types_match)
3184         {
3185           if ((DECL_EXTERN_C_P (newdecl)
3186                && DECL_EXTERN_C_P (olddecl))
3187               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3188                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3189             {
3190               /* A near match; override the builtin.  */
3191
3192               if (TREE_PUBLIC (newdecl))
3193                 {
3194                   cp_warning ("new declaration `%#D'", newdecl);
3195                   cp_warning ("ambiguates built-in declaration `%#D'",
3196                               olddecl);
3197                 }
3198               else if (warn_shadow)
3199                 cp_warning ("shadowing %s function `%#D'",
3200                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3201                             olddecl);
3202             }
3203           else
3204             /* Discard the old built-in function.  */
3205             return 0;
3206         }
3207
3208       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3209         {
3210           /* If a builtin function is redeclared as `static', merge
3211              the declarations, but make the original one static.  */
3212           DECL_THIS_STATIC (olddecl) = 1;
3213           TREE_PUBLIC (olddecl) = 0;
3214
3215           /* Make the old declaration consistent with the new one so
3216              that all remnants of the builtin-ness of this function
3217              will be banished.  */
3218           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3219           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3220           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3221           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3222                                        newdecl);
3223         }
3224     }
3225   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3226     {
3227       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3228            && TREE_CODE (newdecl) != TYPE_DECL
3229            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3230                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3231           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3232               && TREE_CODE (olddecl) != TYPE_DECL
3233               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3234                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3235                         == TYPE_DECL))))
3236         {
3237           /* We do nothing special here, because C++ does such nasty
3238              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3239              get shadowed, and know that if we need to find a TYPE_DECL
3240              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3241              slot of the identifier.  */
3242           return 0;
3243         }
3244
3245       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3246            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3247           || (TREE_CODE (olddecl) == FUNCTION_DECL
3248               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3249         return 0;
3250
3251       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3252       if (TREE_CODE (olddecl) == TREE_LIST)
3253         olddecl = TREE_VALUE (olddecl);
3254       cp_error_at ("previous declaration of `%#D'", olddecl);
3255
3256       /* New decl is completely inconsistent with the old one =>
3257          tell caller to replace the old one.  */
3258
3259       return 0;
3260     }
3261   else if (!types_match)
3262     {
3263       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3264         /* These are certainly not duplicate declarations; they're
3265            from different scopes.  */
3266         return 0;
3267
3268       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3269         {
3270           /* The name of a class template may not be declared to refer to
3271              any other template, class, function, object, namespace, value,
3272              or type in the same scope.  */
3273           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3274               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3275             {
3276               cp_error ("declaration of template `%#D'", newdecl);
3277               cp_error_at ("conflicts with previous declaration `%#D'",
3278                            olddecl);
3279             }
3280           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3281                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3282                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3283                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3284                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3285                                            DECL_TEMPLATE_PARMS (olddecl)))
3286             {
3287               cp_error ("new declaration `%#D'", newdecl);
3288               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3289             }
3290           return 0;
3291         }
3292       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3293         {
3294           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3295             {
3296               cp_error ("declaration of C function `%#D' conflicts with",
3297                         newdecl);
3298               cp_error_at ("previous declaration `%#D' here", olddecl);
3299             }
3300           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3301                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3302             {
3303               cp_error ("new declaration `%#D'", newdecl);
3304               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3305             }
3306           else
3307             return 0;
3308         }
3309
3310       /* Already complained about this, so don't do so again.  */
3311       else if (current_class_type == NULL_TREE
3312           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3313         {
3314           cp_error ("conflicting types for `%#D'", newdecl);
3315           cp_error_at ("previous declaration as `%#D'", olddecl);
3316         }
3317     }
3318   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3319             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3320                  && (!DECL_TEMPLATE_INFO (newdecl)
3321                      || (DECL_TI_TEMPLATE (newdecl)
3322                          != DECL_TI_TEMPLATE (olddecl))))
3323                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3324                     && (!DECL_TEMPLATE_INFO (olddecl)
3325                         || (DECL_TI_TEMPLATE (olddecl)
3326                             != DECL_TI_TEMPLATE (newdecl))))))
3327     /* It's OK to have a template specialization and a non-template
3328        with the same type, or to have specializations of two
3329        different templates with the same type.  Note that if one is a
3330        specialization, and the other is an instantiation of the same
3331        template, that we do not exit at this point.  That situation
3332        can occur if we instantiate a template class, and then
3333        specialize one of its methods.  This situation is legal, but
3334        the declarations must be merged in the usual way.  */
3335     return 0;
3336   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3337            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3338                 && !DECL_USE_TEMPLATE (newdecl))
3339                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3340                    && !DECL_USE_TEMPLATE (olddecl))))
3341     /* One of the declarations is a template instantiation, and the
3342        other is not a template at all.  That's OK.  */
3343     return 0;
3344   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3345            && DECL_NAMESPACE_ALIAS (newdecl)
3346            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3347     /* Redeclaration of namespace alias, ignore it. */
3348     return 1;
3349   else
3350     {
3351       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3352       if (errmsg)
3353         {
3354           cp_error (errmsg, newdecl);
3355           if (DECL_NAME (olddecl) != NULL_TREE)
3356             cp_error_at ((DECL_INITIAL (olddecl)
3357                           && namespace_bindings_p ())
3358                          ? "`%#D' previously defined here"
3359                          : "`%#D' previously declared here", olddecl);
3360         }
3361       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3362                && DECL_INITIAL (olddecl) != NULL_TREE
3363                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3364                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3365         {
3366           /* Prototype decl follows defn w/o prototype.  */
3367           cp_warning_at ("prototype for `%#D'", newdecl);
3368           cp_warning_at ("follows non-prototype definition here", olddecl);
3369         }
3370       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3371                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3372         {
3373           /* extern "C" int foo ();
3374              int foo () { bar (); }
3375              is OK.  */
3376           if (current_lang_stack
3377               == &VARRAY_TREE (current_lang_base, 0))
3378             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3379           else
3380             {
3381               cp_error_at ("previous declaration of `%#D' with %L linkage",
3382                            olddecl, DECL_LANGUAGE (olddecl));
3383               cp_error ("conflicts with new declaration with %L linkage",
3384                         DECL_LANGUAGE (newdecl));
3385             }
3386         }
3387
3388       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3389         ;
3390       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3391         {
3392           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3393           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3394           int i = 1;
3395
3396           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3397             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3398
3399           for (; t1 && t1 != void_list_node;
3400                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3401             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3402               {
3403                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3404                                            TREE_PURPOSE (t2)))
3405                   {
3406                     if (pedantic)
3407                       {
3408                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3409                                     i, newdecl);
3410                         cp_pedwarn_at ("after previous specification in `%#D'",
3411                                        olddecl);
3412                       }
3413                   }
3414                 else
3415                   {
3416                     cp_error ("default argument given for parameter %d of `%#D'",
3417                               i, newdecl);
3418                     cp_error_at ("after previous specification in `%#D'",
3419                                  olddecl);
3420                   }
3421               }
3422
3423           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3424               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3425             {
3426               cp_warning ("`%#D' was used before it was declared inline",
3427                           newdecl);
3428               cp_warning_at ("previous non-inline declaration here",
3429                              olddecl);
3430             }
3431         }
3432     }
3433
3434   /* If new decl is `static' and an `extern' was seen previously,
3435      warn about it.  */
3436   warn_extern_redeclared_static (newdecl, olddecl);
3437
3438   /* We have committed to returning 1 at this point.  */
3439   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3440     {
3441       /* Now that functions must hold information normally held
3442          by field decls, there is extra work to do so that
3443          declaration information does not get destroyed during
3444          definition.  */
3445       if (DECL_VINDEX (olddecl))
3446         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3447       if (DECL_VIRTUAL_CONTEXT (olddecl))
3448         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3449       if (DECL_CONTEXT (olddecl))
3450         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3451       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3452         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3453       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3454       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3455       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3456       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3457       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3458       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3459       DECL_LANG_SPECIFIC (newdecl)->u2 = DECL_LANG_SPECIFIC (olddecl)->u2;
3460       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3461
3462       /* Optionally warn about more than one declaration for the same
3463          name, but don't warn about a function declaration followed by a
3464          definition.  */
3465       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3466           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3467           /* Don't warn about extern decl followed by definition. */
3468           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3469           /* Don't warn about friends, let add_friend take care of it. */
3470           && ! DECL_FRIEND_P (newdecl))
3471         {
3472           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3473           cp_warning_at ("previous declaration of `%D'", olddecl);
3474         }
3475     }
3476
3477   /* Deal with C++: must preserve virtual function table size.  */
3478   if (TREE_CODE (olddecl) == TYPE_DECL)
3479     {
3480       register tree newtype = TREE_TYPE (newdecl);
3481       register tree oldtype = TREE_TYPE (olddecl);
3482
3483       if (newtype != error_mark_node && oldtype != error_mark_node
3484           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3485         {
3486           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3487           CLASSTYPE_FRIEND_CLASSES (newtype)
3488             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3489         }
3490     }
3491
3492   /* Copy all the DECL_... slots specified in the new decl
3493      except for any that we copy here from the old type.  */
3494   DECL_MACHINE_ATTRIBUTES (newdecl)
3495     = merge_machine_decl_attributes (olddecl, newdecl);
3496
3497   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3498     {
3499       if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl),
3500                              DECL_TEMPLATE_RESULT (olddecl)))
3501         cp_error ("invalid redeclaration of %D", newdecl);
3502       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3503       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3504         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3505                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3506
3507       return 1;
3508     }
3509
3510   if (types_match)
3511     {
3512       /* Automatically handles default parameters.  */
3513       tree oldtype = TREE_TYPE (olddecl);
3514       tree newtype;
3515
3516       /* Merge the data types specified in the two decls.  */
3517       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3518
3519       if (TREE_CODE (newdecl) == VAR_DECL)
3520         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3521       /* Do this after calling `common_type' so that default
3522          parameters don't confuse us.  */
3523       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3524           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3525               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3526         {
3527           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3528                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3529           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3530                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3531
3532           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3533               && DECL_SOURCE_LINE (olddecl) != 0
3534               && flag_exceptions
3535               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3536                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3537             {
3538               cp_error ("declaration of `%F' throws different exceptions",
3539                         newdecl);
3540               cp_error_at ("than previous declaration `%F'", olddecl);
3541             }
3542         }
3543       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3544
3545       /* Lay the type out, unless already done.  */
3546       if (! same_type_p (newtype, oldtype)
3547           && TREE_TYPE (newdecl) != error_mark_node
3548           && !(processing_template_decl && uses_template_parms (newdecl)))
3549         layout_type (TREE_TYPE (newdecl));
3550
3551       if ((TREE_CODE (newdecl) == VAR_DECL
3552            || TREE_CODE (newdecl) == PARM_DECL
3553            || TREE_CODE (newdecl) == RESULT_DECL
3554            || TREE_CODE (newdecl) == FIELD_DECL
3555            || TREE_CODE (newdecl) == TYPE_DECL)
3556           && !(processing_template_decl && uses_template_parms (newdecl)))
3557         layout_decl (newdecl, 0);
3558
3559       /* Merge the type qualifiers.  */
3560       if (TREE_READONLY (newdecl))
3561         TREE_READONLY (olddecl) = 1;
3562       if (TREE_THIS_VOLATILE (newdecl))
3563         TREE_THIS_VOLATILE (olddecl) = 1;
3564
3565       /* Merge the initialization information.  */
3566       if (DECL_INITIAL (newdecl) == NULL_TREE
3567           && DECL_INITIAL (olddecl) != NULL_TREE)
3568         {
3569           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3570           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3571           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3572           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3573               && DECL_LANG_SPECIFIC (newdecl)
3574               && DECL_LANG_SPECIFIC (olddecl))
3575             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3576         }
3577
3578       /* Merge the section attribute.
3579          We want to issue an error if the sections conflict but that must be
3580          done later in decl_attributes since we are called before attributes
3581          are assigned.  */
3582       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3583         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3584
3585       /* Keep the old rtl since we can safely use it.  */
3586       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3587
3588       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3589         {
3590           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3591             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3592           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3593             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3594           DECL_NO_LIMIT_STACK (newdecl)
3595             |= DECL_NO_LIMIT_STACK (olddecl);
3596         }
3597     }
3598   /* If cannot merge, then use the new type and qualifiers,
3599      and don't preserve the old rtl.  */
3600   else
3601     {
3602       /* Clean out any memory we had of the old declaration.  */
3603       tree oldstatic = value_member (olddecl, static_aggregates);
3604       if (oldstatic)
3605         TREE_VALUE (oldstatic) = error_mark_node;
3606
3607       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3608       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3609       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3610       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3611     }
3612
3613   /* Merge the storage class information.  */
3614   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3615   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3616   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3617   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3618   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3619   if (! DECL_EXTERNAL (olddecl))
3620     DECL_EXTERNAL (newdecl) = 0;
3621
3622   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3623     {
3624       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3625       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3626       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3627       DECL_TEMPLATE_INSTANTIATED (newdecl)
3628         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3629       /* Don't really know how much of the language-specific
3630          values we should copy from old to new.  */
3631       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3632       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3633       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3634       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3635       olddecl_friend = DECL_FRIEND_P (olddecl);
3636
3637       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3638       if (TREE_CODE (newdecl) == FUNCTION_DECL
3639           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3640         DECL_BEFRIENDING_CLASSES (newdecl)
3641           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3642                      DECL_BEFRIENDING_CLASSES (olddecl));
3643     }
3644
3645   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3646     {
3647       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3648           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3649         {
3650           /* If newdecl is not a specialization, then it is not a
3651              template-related function at all.  And that means that we
3652              shoud have exited above, returning 0.  */
3653           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3654                               0);
3655
3656           if (TREE_USED (olddecl))
3657             /* From [temp.expl.spec]:
3658
3659                If a template, a member template or the member of a class
3660                template is explicitly specialized then that
3661                specialization shall be declared before the first use of
3662                that specialization that would cause an implicit
3663                instantiation to take place, in every translation unit in
3664                which such a use occurs.  */
3665             cp_error ("explicit specialization of %D after first use",
3666                       olddecl);
3667
3668           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3669         }
3670       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3671
3672       /* If either decl says `inline', this fn is inline, unless its
3673          definition was passed already.  */
3674       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3675         DECL_INLINE (olddecl) = 1;
3676       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3677
3678       if (! types_match)
3679         {
3680           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3681           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3682           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3683         }
3684       if (! types_match || new_defines_function)
3685         {
3686           /* These need to be copied so that the names are available.
3687              Note that if the types do match, we'll preserve inline
3688              info and other bits, but if not, we won't.  */
3689           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3690           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3691         }
3692       if (new_defines_function)
3693         /* If defining a function declared with other language
3694            linkage, use the previously declared language linkage.  */
3695         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3696       else if (types_match)
3697         {
3698           /* If redeclaring a builtin function, and not a definition,
3699              it stays built in.  */
3700           if (DECL_BUILT_IN (olddecl))
3701             {
3702               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3703               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3704               /* If we're keeping the built-in definition, keep the rtl,
3705                  regardless of declaration matches.  */
3706               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3707             }
3708           else
3709             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3710
3711           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3712           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3713             /* Previously saved insns go together with
3714                the function's previous definition.  */
3715             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3716           /* Don't clear out the arguments if we're redefining a function.  */
3717           if (DECL_ARGUMENTS (olddecl))
3718             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3719         }
3720     }
3721
3722   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3723     {
3724       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3725     }
3726
3727   /* Now preserve various other info from the definition.  */
3728   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3729   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3730   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3731   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3732
3733   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3734     {
3735       int function_size;
3736
3737       function_size = sizeof (struct tree_decl);
3738
3739       bcopy ((char *) newdecl + sizeof (struct tree_common),
3740              (char *) olddecl + sizeof (struct tree_common),
3741              function_size - sizeof (struct tree_common));
3742
3743       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3744         {
3745           /* If newdecl is a template instantiation, it is possible that
3746              the following sequence of events has occurred:
3747
3748              o A friend function was declared in a class template.  The
3749              class template was instantiated.
3750
3751              o The instantiation of the friend declaration was
3752              recorded on the instantiation list, and is newdecl.
3753
3754              o Later, however, instantiate_class_template called pushdecl
3755              on the newdecl to perform name injection.  But, pushdecl in
3756              turn called duplicate_decls when it discovered that another
3757              declaration of a global function with the same name already
3758              existed.
3759
3760              o Here, in duplicate_decls, we decided to clobber newdecl.
3761
3762              If we're going to do that, we'd better make sure that
3763              olddecl, and not newdecl, is on the list of
3764              instantiations so that if we try to do the instantiation
3765              again we won't get the clobbered declaration.  */
3766
3767           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3768           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3769
3770           for (; decls; decls = TREE_CHAIN (decls))
3771             if (TREE_VALUE (decls) == newdecl)
3772               TREE_VALUE (decls) = olddecl;
3773         }
3774     }
3775   else
3776     {
3777       bcopy ((char *) newdecl + sizeof (struct tree_common),
3778              (char *) olddecl + sizeof (struct tree_common),
3779              sizeof (struct tree_decl) - sizeof (struct tree_common)
3780              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3781     }
3782
3783   DECL_UID (olddecl) = olddecl_uid;
3784   if (olddecl_friend)
3785     DECL_FRIEND_P (olddecl) = 1;
3786
3787   /* NEWDECL contains the merged attribute lists.
3788      Update OLDDECL to be the same.  */
3789   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3790
3791   return 1;
3792 }
3793
3794 /* Record a decl-node X as belonging to the current lexical scope.
3795    Check for errors (such as an incompatible declaration for the same
3796    name already seen in the same scope).
3797
3798    Returns either X or an old decl for the same name.
3799    If an old decl is returned, it may have been smashed
3800    to agree with what X says.  */
3801
3802 tree
3803 pushdecl (x)
3804      tree x;
3805 {
3806   register tree t;
3807   register tree name;
3808   int need_new_binding;
3809
3810   /* We shouldn't be calling pushdecl when we're generating RTL for a
3811      function that we already did semantic analysis on previously.  */
3812   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3813                       19990913);
3814
3815   need_new_binding = 1;
3816
3817   if (DECL_TEMPLATE_PARM_P (x))
3818     /* Template parameters have no context; they are not X::T even
3819        when declared within a class or namespace.  */
3820     ;
3821   else
3822     {
3823       if (current_function_decl && x != current_function_decl
3824           /* A local declaration for a function doesn't constitute
3825              nesting.  */
3826           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3827           /* A local declaration for an `extern' variable is in the
3828              scoped of the current namespace, not the current
3829              function.  */
3830           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3831           && !DECL_CONTEXT (x))
3832         DECL_CONTEXT (x) = current_function_decl;
3833
3834       /* If this is the declaration for a namespace-scope function,
3835          but the declaration itself is in a local scope, mark the
3836          declaration.  */
3837       if (TREE_CODE (x) == FUNCTION_DECL
3838           && DECL_NAMESPACE_SCOPE_P (x)
3839           && current_function_decl
3840           && x != current_function_decl)
3841         DECL_LOCAL_FUNCTION_P (x) = 1;
3842     }
3843
3844   name = DECL_NAME (x);
3845   if (name)
3846     {
3847 #if 0
3848       /* Not needed...see below.  */
3849       char *file;
3850       int line;
3851 #endif
3852       if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3853         name = TREE_OPERAND (name, 0);
3854
3855       /* Namespace-scoped variables are not found in the current level. */
3856       if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3857         t = namespace_binding (name, DECL_CONTEXT (x));
3858       else
3859         t = lookup_name_current_level (name);
3860
3861       /* If we are declaring a function, and the result of name-lookup
3862          was an OVERLOAD, look for an overloaded instance that is
3863          actually the same as the function we are declaring.  (If
3864          there is one, we have to merge our declaration with the
3865          previous declaration.)  */
3866       if (t && TREE_CODE (t) == OVERLOAD)
3867         {
3868           tree match;
3869
3870           if (TREE_CODE (x) == FUNCTION_DECL)
3871             for (match = t; match; match = OVL_NEXT (match))
3872               {
3873                 if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t))
3874                     == DECL_ASSEMBLER_NAME (x))
3875                   break;
3876               }
3877           else
3878             /* Just choose one.  */
3879             match = t;
3880
3881           if (match)
3882             t = OVL_CURRENT (match);
3883           else
3884             t = NULL_TREE;
3885         }
3886
3887       if (t == error_mark_node)
3888         {
3889           /* error_mark_node is 0 for a while during initialization!  */
3890           t = NULL_TREE;
3891           cp_error_at ("`%#D' used prior to declaration", x);
3892         }
3893       else if (t != NULL_TREE)
3894         {
3895           if (TREE_CODE (t) == PARM_DECL)
3896             {
3897               if (DECL_CONTEXT (t) == NULL_TREE)
3898                 fatal ("parse errors have confused me too much");
3899
3900               /* Check for duplicate params.  */
3901               if (duplicate_decls (x, t))
3902                 return t;
3903             }
3904           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3905                     || DECL_FUNCTION_TEMPLATE_P (x))
3906                    && is_overloaded_fn (t))
3907             /* Don't do anything just yet. */;
3908           else if (t == wchar_decl_node)
3909             {
3910               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3911                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3912
3913               /* Throw away the redeclaration.  */
3914               return t;
3915             }
3916           else if (TREE_CODE (t) != TREE_CODE (x))
3917             {
3918               if (duplicate_decls (x, t))
3919                 return t;
3920             }
3921           else if (duplicate_decls (x, t))
3922             {
3923               if (TREE_CODE (t) == TYPE_DECL)
3924                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3925               else if (TREE_CODE (t) == FUNCTION_DECL)
3926                 check_default_args (t);
3927
3928               return t;
3929             }
3930           else if (DECL_MAIN_P (x))
3931             {
3932               /* A redeclaration of main, but not a duplicate of the
3933                  previous one.
3934
3935                  [basic.start.main]
3936
3937                  This function shall not be overloaded.  */
3938               cp_error_at ("invalid redeclaration of `%D'", t);
3939               cp_error ("as `%D'", x);
3940               /* We don't try to push this declaration since that
3941                  causes a crash.  */
3942               return x;
3943             }
3944         }
3945
3946       check_template_shadow (x);
3947
3948       /* If this is a function conjured up by the backend, massage it
3949          so it looks friendly.  */
3950       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3951         {
3952           retrofit_lang_decl (x);
3953           DECL_LANGUAGE (x) = lang_c;
3954         }
3955
3956       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3957         {
3958           t = push_overloaded_decl (x, PUSH_LOCAL);
3959           if (t != x)
3960             return t;
3961           if (!namespace_bindings_p ())
3962             /* We do not need to create a binding for this name;
3963                push_overloaded_decl will have already done so if
3964                necessary.  */
3965             need_new_binding = 0;
3966         }
3967       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3968         {
3969           t = push_overloaded_decl (x, PUSH_GLOBAL);
3970           if (t == x)
3971             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3972           return t;
3973         }
3974
3975       /* If declaring a type as a typedef, copy the type (unless we're
3976          at line 0), and install this TYPE_DECL as the new type's typedef
3977          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3978       if (TREE_CODE (x) == TYPE_DECL)
3979         {
3980           tree type = TREE_TYPE (x);
3981           if (DECL_SOURCE_LINE (x) == 0)
3982             {
3983               if (TYPE_NAME (type) == 0)
3984                 TYPE_NAME (type) = x;
3985             }
3986           else if (type != error_mark_node && TYPE_NAME (type) != x
3987                    /* We don't want to copy the type when all we're
3988                       doing is making a TYPE_DECL for the purposes of
3989                       inlining.  */
3990                    && (!TYPE_NAME (type)
3991                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3992             {
3993               DECL_ORIGINAL_TYPE (x) = type;
3994               type = build_type_copy (type);
3995               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3996               TYPE_NAME (type) = x;
3997               TREE_TYPE (x) = type;
3998             }
3999
4000           if (type != error_mark_node
4001               && TYPE_NAME (type)
4002               && TYPE_IDENTIFIER (type))
4003             set_identifier_type_value_with_scope (DECL_NAME (x), type,
4004                                                   current_binding_level);
4005
4006         }
4007
4008       /* Multiple external decls of the same identifier ought to match.
4009
4010          We get warnings about inline functions where they are defined.
4011          We get warnings about other functions from push_overloaded_decl.
4012
4013          Avoid duplicate warnings where they are used.  */
4014       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4015         {
4016           tree decl;
4017
4018           if (IDENTIFIER_NAMESPACE_VALUE (name) != NULL_TREE
4019               && IDENTIFIER_NAMESPACE_VALUE (name) != error_mark_node
4020               && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name))
4021                   || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name))))
4022             decl = IDENTIFIER_NAMESPACE_VALUE (name);
4023           else
4024             decl = NULL_TREE;
4025
4026           if (decl
4027               /* If different sort of thing, we already gave an error.  */
4028               && TREE_CODE (decl) == TREE_CODE (x)
4029               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4030             {
4031               cp_pedwarn ("type mismatch with previous external decl", x);
4032               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4033             }
4034         }
4035
4036       /* This name is new in its binding level.
4037          Install the new declaration and return it.  */
4038       if (namespace_bindings_p ())
4039         {
4040           /* Install a global value.  */
4041
4042           /* If the first global decl has external linkage,
4043              warn if we later see static one.  */
4044           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4045             TREE_PUBLIC (name) = 1;
4046
4047           /* Bind the mangled name for the entity.  In the future, we
4048              should not need to do this; mangled names are an
4049              implementation detail of which the front-end should not
4050              need to be aware.  */
4051           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4052                 && t != NULL_TREE)
4053               /* For an ordinary function, we create a binding from
4054                  the mangled name (i.e., NAME) to the DECL.  But, for
4055                  an `extern "C"' function, the mangled name and the
4056                  ordinary name are the same so we need not do this.  */
4057               && !DECL_EXTERN_C_FUNCTION_P (x))
4058             {
4059               tree mangled_name;
4060
4061               if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
4062                   || TREE_CODE (x) == NAMESPACE_DECL)
4063                 mangled_name = name;
4064               else
4065                 mangled_name = DECL_ASSEMBLER_NAME (x);
4066
4067               if (TREE_CODE (x) == FUNCTION_DECL)
4068                 my_friendly_assert
4069                   ((IDENTIFIER_GLOBAL_VALUE (mangled_name) == NULL_TREE)
4070                   || (IDENTIFIER_GLOBAL_VALUE (mangled_name) == x), 378);
4071               SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name, x);
4072             }
4073
4074           /* Don't forget if the function was used via an implicit decl.  */
4075           if (IDENTIFIER_IMPLICIT_DECL (name)
4076               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4077             TREE_USED (x) = 1;
4078
4079           /* Don't forget if its address was taken in that way.  */
4080           if (IDENTIFIER_IMPLICIT_DECL (name)
4081               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4082             TREE_ADDRESSABLE (x) = 1;
4083
4084           /* Warn about mismatches against previous implicit decl.  */
4085           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4086               /* If this real decl matches the implicit, don't complain.  */
4087               && ! (TREE_CODE (x) == FUNCTION_DECL
4088                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4089             cp_warning
4090               ("`%D' was previously implicitly declared to return `int'", x);
4091
4092           /* If new decl is `static' and an `extern' was seen previously,
4093              warn about it.  */
4094           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4095             warn_extern_redeclared_static (x, t);
4096         }
4097       else
4098         {
4099           /* Here to install a non-global value.  */
4100           tree oldlocal = IDENTIFIER_VALUE (name);
4101           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4102
4103           if (need_new_binding)
4104             {
4105               push_local_binding (name, x, 0);
4106               /* Because push_local_binding will hook X on to the
4107                  current_binding_level's name list, we don't want to
4108                  do that again below.  */
4109               need_new_binding = 0;
4110             }
4111
4112           /* If this is a TYPE_DECL, push it into the type value slot.  */
4113           if (TREE_CODE (x) == TYPE_DECL)
4114             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4115                                                   current_binding_level);
4116
4117           /* Clear out any TYPE_DECL shadowed by a namespace so that
4118              we won't think this is a type.  The C struct hack doesn't
4119              go through namespaces.  */
4120           if (TREE_CODE (x) == NAMESPACE_DECL)
4121             set_identifier_type_value_with_scope (name, NULL_TREE,
4122                                                   current_binding_level);
4123
4124           if (oldlocal)
4125             {
4126               tree d = oldlocal;
4127
4128               while (oldlocal
4129                      && TREE_CODE (oldlocal) == VAR_DECL
4130                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4131                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4132
4133               if (oldlocal == NULL_TREE)
4134                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4135             }
4136
4137           /* If this is an extern function declaration, see if we
4138              have a global definition or declaration for the function.  */
4139           if (oldlocal == NULL_TREE
4140               && DECL_EXTERNAL (x)
4141               && oldglobal != NULL_TREE
4142               && TREE_CODE (x) == FUNCTION_DECL
4143               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4144             {
4145               /* We have one.  Their types must agree.  */
4146               if (decls_match (x, oldglobal))
4147                 /* OK */;
4148               else
4149                 {
4150                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4151                   cp_warning_at ("global declaration `%#D'", oldglobal);
4152                 }
4153             }
4154           /* If we have a local external declaration,
4155              and no file-scope declaration has yet been seen,
4156              then if we later have a file-scope decl it must not be static.  */
4157           if (oldlocal == NULL_TREE
4158               && oldglobal == NULL_TREE
4159               && DECL_EXTERNAL (x)
4160               && TREE_PUBLIC (x))
4161             TREE_PUBLIC (name) = 1;
4162
4163           /* Warn if shadowing an argument at the top level of the body.  */
4164           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4165               /* Inline decls shadow nothing.  */
4166               && !DECL_FROM_INLINE (x)
4167               && TREE_CODE (oldlocal) == PARM_DECL
4168               /* Don't complain if it's from an enclosing function.  */
4169               && DECL_CONTEXT (oldlocal) == current_function_decl
4170               && TREE_CODE (x) != PARM_DECL)
4171             {
4172               /* Go to where the parms should be and see if we
4173                  find them there.  */
4174               struct binding_level *b = current_binding_level->level_chain;
4175
4176               if (cleanup_label)
4177                 b = b->level_chain;
4178
4179               /* ARM $8.3 */
4180               if (b->parm_flag == 1)
4181                 cp_error ("declaration of `%#D' shadows a parameter", name);
4182             }
4183
4184           /* Maybe warn if shadowing something else.  */
4185           if (warn_shadow && !DECL_EXTERNAL (x)
4186               /* Inline decls shadow nothing.  */
4187               && !DECL_FROM_INLINE (x)
4188               /* No shadow warnings for internally generated vars.  */
4189               && ! DECL_ARTIFICIAL (x)
4190               /* No shadow warnings for vars made for inlining.  */
4191               && ! DECL_FROM_INLINE (x))
4192             {
4193               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4194                 warning ("declaration of `%s' shadows a parameter",
4195                         IDENTIFIER_POINTER (name));
4196               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4197                        && current_class_ptr
4198                        && !TREE_STATIC (name))
4199                 warning ("declaration of `%s' shadows a member of `this'",
4200                         IDENTIFIER_POINTER (name));
4201               else if (oldlocal != NULL_TREE)
4202                 warning ("declaration of `%s' shadows previous local",
4203                         IDENTIFIER_POINTER (name));
4204               else if (oldglobal != NULL_TREE)
4205                 /* XXX shadow warnings in outer-more namespaces */
4206                 warning ("declaration of `%s' shadows global declaration",
4207                         IDENTIFIER_POINTER (name));
4208             }
4209         }
4210
4211       if (TREE_CODE (x) == FUNCTION_DECL)
4212         check_default_args (x);
4213
4214       /* Keep count of variables in this level with incomplete type.  */
4215       if (TREE_CODE (x) == VAR_DECL
4216           && TREE_TYPE (x) != error_mark_node
4217           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4218                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4219               /* RTTI TD entries are created while defining the type_info.  */
4220               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4221                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4222         {
4223           if (namespace_bindings_p ())
4224             namespace_scope_incomplete
4225               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4226           else
4227             current_binding_level->incomplete
4228               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4229         }
4230     }
4231
4232   if (need_new_binding)
4233     add_decl_to_level (x,
4234                        DECL_NAMESPACE_SCOPE_P (x)
4235                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4236                        : current_binding_level);
4237
4238   return x;
4239 }
4240
4241 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4242    caller to set DECL_CONTEXT properly.  */
4243
4244 static tree
4245 pushdecl_with_scope (x, level)
4246      tree x;
4247      struct binding_level *level;
4248 {
4249   register struct binding_level *b;
4250   tree function_decl = current_function_decl;
4251
4252   current_function_decl = NULL_TREE;
4253   if (level->parm_flag == 2)
4254     {
4255       b = class_binding_level;
4256       class_binding_level = level;
4257       pushdecl_class_level (x);
4258       class_binding_level = b;
4259     }
4260   else
4261     {
4262       b = current_binding_level;
4263       current_binding_level = level;
4264       x = pushdecl (x);
4265       current_binding_level = b;
4266     }
4267   current_function_decl = function_decl;
4268   return x;
4269 }
4270
4271 /* Like pushdecl, only it places X in the current namespace,
4272    if appropriate.  */
4273
4274 tree
4275 pushdecl_namespace_level (x)
4276      tree x;
4277 {
4278   register struct binding_level *b = current_binding_level;
4279   register tree t;
4280
4281   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4282
4283   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4284      what we want.  */
4285   if (TREE_CODE (x) == TYPE_DECL)
4286     {
4287       tree name = DECL_NAME (x);
4288       tree newval;
4289       tree *ptr = (tree *)0;
4290       for (; b != global_binding_level; b = b->level_chain)
4291         {
4292           tree shadowed = b->type_shadowed;
4293           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4294             if (TREE_PURPOSE (shadowed) == name)
4295               {
4296                 ptr = &TREE_VALUE (shadowed);
4297                 /* Can't break out of the loop here because sometimes
4298                    a binding level will have duplicate bindings for
4299                    PT names.  It's gross, but I haven't time to fix it.  */
4300               }
4301         }
4302       newval = TREE_TYPE (x);
4303       if (ptr == (tree *)0)
4304         {
4305           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4306              up here if this is changed to an assertion.  --KR  */
4307           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4308         }
4309       else
4310         {
4311           *ptr = newval;
4312         }
4313     }
4314   return t;
4315 }
4316
4317 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4318    if appropriate.  */
4319
4320 tree
4321 pushdecl_top_level (x)
4322      tree x;
4323 {
4324   push_to_top_level ();
4325   x = pushdecl_namespace_level (x);
4326   pop_from_top_level ();
4327   return x;
4328 }
4329
4330 /* Make the declaration of X appear in CLASS scope.  */
4331
4332 void
4333 pushdecl_class_level (x)
4334      tree x;
4335 {
4336   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4337      scope looks for the pre-mangled name.  */
4338   register tree name;
4339
4340   if (TREE_CODE (x) == OVERLOAD)
4341     x = OVL_CURRENT (x);
4342   name = DECL_NAME (x);
4343
4344   if (name)
4345     {
4346       push_class_level_binding (name, x);
4347       if (TREE_CODE (x) == TYPE_DECL)
4348         set_identifier_type_value (name, TREE_TYPE (x));
4349     }
4350   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4351     {
4352       tree f;
4353
4354       for (f = TYPE_FIELDS (TREE_TYPE (x));
4355            f;
4356            f = TREE_CHAIN (f))
4357         pushdecl_class_level (f);
4358     }
4359 }
4360
4361 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4362    DECL, or a modified version thereof.  */
4363
4364 tree
4365 maybe_push_decl (decl)
4366      tree decl;
4367 {
4368   tree type = TREE_TYPE (decl);
4369
4370   /* Add this decl to the current binding level, but not if it comes
4371      from another scope, e.g. a static member variable.  TEM may equal
4372      DECL or it may be a previous decl of the same name.  */
4373   if (decl == error_mark_node
4374       || (TREE_CODE (decl) != PARM_DECL
4375           && DECL_CONTEXT (decl) != NULL_TREE
4376           /* Definitions of namespace members outside their namespace are
4377              possible. */
4378           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4379       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4380       || TREE_CODE (type) == UNKNOWN_TYPE
4381       /* The declaration of a template specialization does not affect
4382          the functions available for overload resolution, so we do not
4383          call pushdecl.  */
4384       || (TREE_CODE (decl) == FUNCTION_DECL
4385           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4386     return decl;
4387   else
4388     return pushdecl (decl);
4389 }
4390
4391 /* Make the declaration(s) of X appear in CLASS scope
4392    under the name NAME.  */
4393
4394 void
4395 push_class_level_binding (name, x)
4396      tree name;
4397      tree x;
4398 {
4399   tree binding;
4400   /* The class_binding_level will be NULL if x is a template
4401      parameter name in a member template.  */
4402   if (!class_binding_level)
4403     return;
4404
4405   /* Make sure that this new member does not have the same name
4406      as a template parameter.  */
4407   if (TYPE_BEING_DEFINED (current_class_type))
4408     check_template_shadow (x);
4409
4410   /* If this declaration shadows a declaration from an enclosing
4411      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4412      we leave this class.  Record the shadowed declaration here.  */
4413   binding = IDENTIFIER_BINDING (name);
4414   if (binding
4415       && ((TREE_CODE (x) == OVERLOAD
4416            && BINDING_VALUE (binding)
4417            && is_overloaded_fn (BINDING_VALUE (binding)))
4418           || INHERITED_VALUE_BINDING_P (binding)))
4419     {
4420       tree shadow;
4421       tree old_decl;
4422
4423       /* If the old binding was from a base class, and was for a tag
4424          name, slide it over to make room for the new binding.  The
4425          old binding is still visible if explicitly qualified with a
4426          class-key.  */
4427       if (INHERITED_VALUE_BINDING_P (binding)
4428           && BINDING_VALUE (binding)
4429           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4430           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4431           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4432         {
4433           old_decl = BINDING_TYPE (binding);
4434           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4435           BINDING_VALUE (binding) = NULL_TREE;
4436           INHERITED_VALUE_BINDING_P (binding) = 0;
4437         }
4438       else
4439         old_decl = BINDING_VALUE (binding);
4440
4441       /* There was already a binding for X containing fewer
4442          functions than are named in X.  Find the previous
4443          declaration of X on the class-shadowed list, and update it.  */
4444       for (shadow = class_binding_level->class_shadowed;
4445            shadow;
4446            shadow = TREE_CHAIN (shadow))
4447         if (TREE_PURPOSE (shadow) == name
4448             && TREE_TYPE (shadow) == old_decl)
4449           {
4450             BINDING_VALUE (binding) = x;
4451             INHERITED_VALUE_BINDING_P (binding) = 0;
4452             TREE_TYPE (shadow) = x;
4453             return;
4454           }
4455     }
4456
4457   /* If we didn't replace an existing binding, put the binding on the
4458      stack of bindings for the identifier, and update
4459      IDENTIFIER_CLASS_VALUE.  */
4460   if (push_class_binding (name, x))
4461     {
4462       class_binding_level->class_shadowed
4463         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4464                      class_binding_level->class_shadowed);
4465       /* Record the value we are binding NAME to so that we can know
4466          what to pop later.  */
4467       TREE_TYPE (class_binding_level->class_shadowed) = x;
4468     }
4469 }
4470
4471 /* Insert another USING_DECL into the current binding level, returning
4472    this declaration. If this is a redeclaration, do nothing, and
4473    return NULL_TREE if this not in namespace scope (in namespace
4474    scope, a using decl might extend any previous bindings).  */
4475
4476 tree
4477 push_using_decl (scope, name)
4478      tree scope;
4479      tree name;
4480 {
4481   tree decl;
4482
4483   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4484   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4485   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4486     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4487       break;
4488   if (decl)
4489     return namespace_bindings_p () ? decl : NULL_TREE;
4490   decl = build_lang_decl (USING_DECL, name, void_type_node);
4491   DECL_INITIAL (decl) = scope;
4492   TREE_CHAIN (decl) = current_binding_level->usings;
4493   current_binding_level->usings = decl;
4494   return decl;
4495 }
4496
4497 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4498    changed (i.e. there was already a directive), or the fresh
4499    TREE_LIST otherwise.  */
4500
4501 tree
4502 push_using_directive (used)
4503      tree used;
4504 {
4505   tree ud = current_binding_level->using_directives;
4506   tree iter, ancestor;
4507
4508   /* Check if we already have this. */
4509   if (purpose_member (used, ud) != NULL_TREE)
4510     return NULL_TREE;
4511
4512   /* Recursively add all namespaces used. */
4513   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4514     push_using_directive (TREE_PURPOSE (iter));
4515
4516   ancestor = namespace_ancestor (current_decl_namespace (), used);
4517   ud = current_binding_level->using_directives;
4518   ud = tree_cons (used, ancestor, ud);
4519   current_binding_level->using_directives = ud;
4520   return ud;
4521 }
4522
4523 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4524    other definitions already in place.  We get around this by making
4525    the value of the identifier point to a list of all the things that
4526    want to be referenced by that name.  It is then up to the users of
4527    that name to decide what to do with that list.
4528
4529    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4530    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4531
4532    FLAGS is a bitwise-or of the following values:
4533      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4534                  namespace scope.
4535      PUSH_USING: DECL is being pushed as the result of a using
4536                  declaration.
4537
4538    The value returned may be a previous declaration if we guessed wrong
4539    about what language DECL should belong to (C or C++).  Otherwise,
4540    it's always DECL (and never something that's not a _DECL).  */
4541
4542 tree
4543 push_overloaded_decl (decl, flags)
4544      tree decl;
4545      int flags;
4546 {
4547   tree name = DECL_NAME (decl);
4548   tree old;
4549   tree new_binding;
4550   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4551
4552   if (doing_global)
4553     old = namespace_binding (name, DECL_CONTEXT (decl));
4554   else
4555     old = lookup_name_current_level (name);
4556
4557   if (old)
4558     {
4559       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4560         {
4561           tree t = TREE_TYPE (old);
4562           if (IS_AGGR_TYPE (t) && warn_shadow
4563               && (! DECL_IN_SYSTEM_HEADER (decl)
4564                   || ! DECL_IN_SYSTEM_HEADER (old)))
4565             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4566           old = NULL_TREE;
4567         }
4568       else if (is_overloaded_fn (old))
4569         {
4570           tree tmp;
4571
4572           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4573             {
4574               tree fn = OVL_CURRENT (tmp);
4575
4576               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4577                   && !(flags & PUSH_USING)
4578                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4579                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4580                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4581                           decl, fn);
4582
4583               if (duplicate_decls (decl, fn))
4584                 return fn;
4585             }
4586         }
4587       else if (old == error_mark_node)
4588         /* Ignore the undefined symbol marker.  */
4589         old = NULL_TREE;
4590       else
4591         {
4592           cp_error_at ("previous non-function declaration `%#D'", old);
4593           cp_error ("conflicts with function declaration `%#D'", decl);
4594           return decl;
4595         }
4596     }
4597
4598   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4599     {
4600       if (old && TREE_CODE (old) != OVERLOAD)
4601         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4602       else
4603         new_binding = ovl_cons (decl, old);
4604       if (flags & PUSH_USING)
4605         OVL_USED (new_binding) = 1;
4606     }
4607   else
4608     /* NAME is not ambiguous.  */
4609     new_binding = decl;
4610
4611   if (doing_global)
4612     set_namespace_binding (name, current_namespace, new_binding);
4613   else
4614     {
4615       /* We only create an OVERLOAD if there was a previous binding at
4616          this level, or if decl is a template. In the former case, we
4617          need to remove the old binding and replace it with the new
4618          binding.  We must also run through the NAMES on the binding
4619          level where the name was bound to update the chain.  */
4620
4621       if (TREE_CODE (new_binding) == OVERLOAD && old)
4622         {
4623           tree *d;
4624
4625           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4626                *d;
4627                d = &TREE_CHAIN (*d))
4628             if (*d == old
4629                 || (TREE_CODE (*d) == TREE_LIST
4630                     && TREE_VALUE (*d) == old))
4631               {
4632                 if (TREE_CODE (*d) == TREE_LIST)
4633                   /* Just replace the old binding with the new.  */
4634                   TREE_VALUE (*d) = new_binding;
4635                 else
4636                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4637                   *d = tree_cons (NULL_TREE, new_binding,
4638                                   TREE_CHAIN (*d));
4639
4640                 /* And update the CPLUS_BINDING node.  */
4641                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4642                   = new_binding;
4643                 return decl;
4644               }
4645
4646           /* We should always find a previous binding in this case.  */
4647           my_friendly_abort (0);
4648         }
4649
4650       /* Install the new binding.  */
4651       push_local_binding (name, new_binding, flags);
4652     }
4653
4654   return decl;
4655 }
4656 \f
4657 /* Generate an implicit declaration for identifier FUNCTIONID
4658    as a function of type int ().  Print a warning if appropriate.  */
4659
4660 tree
4661 implicitly_declare (functionid)
4662      tree functionid;
4663 {
4664   register tree decl;
4665
4666   /* We used to reuse an old implicit decl here,
4667      but this loses with inline functions because it can clobber
4668      the saved decl chains.  */
4669   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4670
4671   DECL_EXTERNAL (decl) = 1;
4672   TREE_PUBLIC (decl) = 1;
4673
4674   /* ISO standard says implicit declarations are in the innermost block.
4675      So we record the decl in the standard fashion.  */
4676   pushdecl (decl);
4677   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4678
4679   if (warn_implicit
4680       /* Only one warning per identifier.  */
4681       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4682     {
4683       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4684     }
4685
4686   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4687
4688   return decl;
4689 }
4690
4691 /* Return zero if the declaration NEWDECL is valid
4692    when the declaration OLDDECL (assumed to be for the same name)
4693    has already been seen.
4694    Otherwise return an error message format string with a %s
4695    where the identifier should go.  */
4696
4697 static const char *
4698 redeclaration_error_message (newdecl, olddecl)
4699      tree newdecl, olddecl;
4700 {
4701   if (TREE_CODE (newdecl) == TYPE_DECL)
4702     {
4703       /* Because C++ can put things into name space for free,
4704          constructs like "typedef struct foo { ... } foo"
4705          would look like an erroneous redeclaration.  */
4706       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4707         return 0;
4708       else
4709         return "redefinition of `%#D'";
4710     }
4711   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4712     {
4713       /* If this is a pure function, its olddecl will actually be
4714          the original initialization to `0' (which we force to call
4715          abort()).  Don't complain about redefinition in this case.  */
4716       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4717         return 0;
4718
4719       /* If both functions come from different namespaces, this is not
4720          a redeclaration - this is a conflict with a used function. */
4721       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4722           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4723         return "`%D' conflicts with used function";
4724
4725       /* We'll complain about linkage mismatches in
4726          warn_extern_redeclared_static.  */
4727
4728       /* Defining the same name twice is no good.  */
4729       if (DECL_INITIAL (olddecl) != NULL_TREE
4730           && DECL_INITIAL (newdecl) != NULL_TREE)
4731         {
4732           if (DECL_NAME (olddecl) == NULL_TREE)
4733             return "`%#D' not declared in class";
4734           else
4735             return "redefinition of `%#D'";
4736         }
4737       return 0;
4738     }
4739   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4740     {
4741       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4742            && (DECL_TEMPLATE_RESULT (newdecl)
4743                != DECL_TEMPLATE_RESULT (olddecl))
4744            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4745            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4746           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4747               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4748               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4749         return "redefinition of `%#D'";
4750       return 0;
4751     }
4752   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4753     {
4754       /* Objects declared at top level:  */
4755       /* If at least one is a reference, it's ok.  */
4756       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4757         return 0;
4758       /* Reject two definitions.  */
4759       return "redefinition of `%#D'";
4760     }
4761   else
4762     {
4763       /* Objects declared with block scope:  */
4764       /* Reject two definitions, and reject a definition
4765          together with an external reference.  */
4766       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4767         return "redeclaration of `%#D'";
4768       return 0;
4769     }
4770 }
4771 \f
4772 /* Create a new label, named ID.  */
4773
4774 static tree
4775 make_label_decl (id, local_p)
4776      tree id;
4777      int local_p;
4778 {
4779   tree decl;
4780
4781   decl = build_decl (LABEL_DECL, id, void_type_node);
4782   if (expanding_p)
4783     /* Make sure every label has an rtx.  */
4784     label_rtx (decl);
4785
4786   DECL_CONTEXT (decl) = current_function_decl;
4787   DECL_MODE (decl) = VOIDmode;
4788   C_DECLARED_LABEL_FLAG (decl) = local_p;
4789
4790   /* Say where one reference is to the label, for the sake of the
4791      error if it is not defined.  */
4792   DECL_SOURCE_LINE (decl) = lineno;
4793   DECL_SOURCE_FILE (decl) = input_filename;
4794
4795   /* Record the fact that this identifier is bound to this label.  */
4796   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4797
4798   return decl;
4799 }
4800
4801 /* Record this label on the list of used labels so that we can check
4802    at the end of the function to see whether or not the label was
4803    actually defined, and so we can check when the label is defined whether
4804    this use is valid.  */
4805
4806 static void
4807 use_label (decl)
4808      tree decl;
4809 {
4810   if (named_label_uses == NULL
4811       || named_label_uses->names_in_scope != current_binding_level->names
4812       || named_label_uses->label_decl != decl)
4813     {
4814       struct named_label_use_list *new_ent;
4815       new_ent = ((struct named_label_use_list *)
4816                  ggc_alloc (sizeof (struct named_label_use_list)));
4817       new_ent->label_decl = decl;
4818       new_ent->names_in_scope = current_binding_level->names;
4819       new_ent->binding_level = current_binding_level;
4820       new_ent->lineno_o_goto = lineno;
4821       new_ent->filename_o_goto = input_filename;
4822       new_ent->next = named_label_uses;
4823       named_label_uses = new_ent;
4824     }
4825 }
4826
4827 /* Look for a label named ID in the current function.  If one cannot
4828    be found, create one.  (We keep track of used, but undefined,
4829    labels, and complain about them at the end of a function.)  */
4830
4831 tree
4832 lookup_label (id)
4833      tree id;
4834 {
4835   tree decl;
4836   struct named_label_list *ent;
4837
4838   /* You can't use labels at global scope.  */
4839   if (current_function_decl == NULL_TREE)
4840     {
4841       error ("label `%s' referenced outside of any function",
4842              IDENTIFIER_POINTER (id));
4843       return NULL_TREE;
4844     }
4845
4846   /* See if we've already got this label.  */
4847   decl = IDENTIFIER_LABEL_VALUE (id);
4848   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4849     return decl;
4850
4851   /* Record this label on the list of labels used in this function.
4852      We do this before calling make_label_decl so that we get the
4853      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4854   ent = ((struct named_label_list *)
4855          ggc_alloc_cleared (sizeof (struct named_label_list)));
4856   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4857   ent->next = named_labels;
4858   named_labels = ent;
4859
4860   /* We need a new label.  */
4861   decl = make_label_decl (id, /*local_p=*/0);
4862
4863   /* Now fill in the information we didn't have before.  */
4864   ent->label_decl = decl;
4865
4866   return decl;
4867 }
4868
4869 /* Declare a local label named ID.  */
4870
4871 tree
4872 declare_local_label (id)
4873      tree id;
4874 {
4875   tree decl;
4876
4877   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4878      this scope we can restore the old value of
4879      IDENTIFIER_TYPE_VALUE.  */
4880   current_binding_level->shadowed_labels
4881     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4882                  current_binding_level->shadowed_labels);
4883   /* Look for the label.  */
4884   decl = make_label_decl (id, /*local_p=*/1);
4885   /* Now fill in the information we didn't have before.  */
4886   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4887
4888   return decl;
4889 }
4890
4891 /* Returns nonzero if it is ill-formed to jump past the declaration of
4892    DECL.  Returns 2 if it's also a real problem.  */
4893
4894 static int
4895 decl_jump_unsafe (decl)
4896      tree decl;
4897 {
4898   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4899     return 0;
4900
4901   if (DECL_INITIAL (decl) == NULL_TREE
4902       && pod_type_p (TREE_TYPE (decl)))
4903     return 0;
4904
4905   /* This is really only important if we're crossing an initialization.
4906      The POD stuff is just pedantry; why should it matter if the class
4907      contains a field of pointer to member type?  */
4908   if (DECL_INITIAL (decl)
4909       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4910     return 2;
4911   return 1;
4912 }
4913
4914 /* Check that a single previously seen jump to a newly defined label
4915    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4916    the jump context; NAMES are the names in scope in LEVEL at the jump
4917    context; FILE and LINE are the source position of the jump or 0.  */
4918
4919 static void
4920 check_previous_goto_1 (decl, level, names, file, line)
4921      tree decl;
4922      struct binding_level *level;
4923      tree names;
4924      const char *file;
4925      int line;
4926 {
4927   int identified = 0;
4928   int saw_eh = 0;
4929   struct binding_level *b = current_binding_level;
4930   for (; b; b = b->level_chain)
4931     {
4932       tree new_decls = b->names;
4933       tree old_decls = (b == level ? names : NULL_TREE);
4934       for (; new_decls != old_decls;
4935            new_decls = TREE_CHAIN (new_decls))
4936         {
4937           int problem = decl_jump_unsafe (new_decls);
4938           if (! problem)
4939             continue;
4940
4941           if (! identified)
4942             {
4943               if (decl)
4944                 cp_pedwarn ("jump to label `%D'", decl);
4945               else
4946                 pedwarn ("jump to case label");
4947
4948               if (file)
4949                 pedwarn_with_file_and_line (file, line, "  from here");
4950               identified = 1;
4951             }
4952
4953           if (problem > 1 && DECL_ARTIFICIAL (new_decls))
4954             /* Can't skip init of __exception_info.  */
4955             cp_error_at ("  enters catch block", new_decls);
4956           else if (problem > 1)
4957             cp_error_at ("  crosses initialization of `%#D'",
4958                          new_decls);
4959           else
4960             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4961                            new_decls);
4962         }
4963
4964       if (b == level)
4965         break;
4966       if (b->eh_region && ! saw_eh)
4967         {
4968           if (! identified)
4969             {
4970               if (decl)
4971                 cp_pedwarn ("jump to label `%D'", decl);
4972               else
4973                 pedwarn ("jump to case label");
4974
4975               if (file)
4976                 pedwarn_with_file_and_line (file, line, "  from here");
4977               identified = 1;
4978             }
4979           error ("  enters try block");
4980           saw_eh = 1;
4981         }
4982     }
4983 }
4984
4985 static void
4986 check_previous_goto (use)
4987      struct named_label_use_list *use;
4988 {
4989   check_previous_goto_1 (use->label_decl, use->binding_level,
4990                          use->names_in_scope, use->filename_o_goto,
4991                          use->lineno_o_goto);
4992 }
4993
4994 static void
4995 check_switch_goto (level)
4996      struct binding_level *level;
4997 {
4998   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
4999 }
5000
5001 /* Check that any previously seen jumps to a newly defined label DECL
5002    are OK.  Called by define_label.  */
5003
5004 static void
5005 check_previous_gotos (decl)
5006      tree decl;
5007 {
5008   struct named_label_use_list **usep;
5009
5010   if (! TREE_USED (decl))
5011     return;
5012
5013   for (usep = &named_label_uses; *usep; )
5014     {
5015       struct named_label_use_list *use = *usep;
5016       if (use->label_decl == decl)
5017         {
5018           check_previous_goto (use);
5019           *usep = use->next;
5020         }
5021       else
5022         usep = &(use->next);
5023     }
5024 }
5025
5026 /* Check that a new jump to a label DECL is OK.  Called by
5027    finish_goto_stmt.  */
5028
5029 void
5030 check_goto (decl)
5031      tree decl;
5032 {
5033   int identified = 0;
5034   tree bad;
5035   struct named_label_list *lab;
5036
5037   /* We can't know where a computed goto is jumping.  So we assume
5038      that it's OK.  */
5039   if (! DECL_P (decl))
5040     return;
5041
5042   /* If the label hasn't been defined yet, defer checking.  */
5043   if (! DECL_INITIAL (decl))
5044     {
5045       use_label (decl);
5046       return;
5047     }
5048
5049   for (lab = named_labels; lab; lab = lab->next)
5050     if (decl == lab->label_decl)
5051       break;
5052
5053   /* If the label is not on named_labels it's a gcc local label, so
5054      it must be in an outer scope, so jumping to it is always OK.  */
5055   if (lab == 0)
5056     return;
5057
5058   if ((lab->eh_region || lab->bad_decls) && !identified)
5059     {
5060       cp_pedwarn_at ("jump to label `%D'", decl);
5061       pedwarn ("  from here");
5062       identified = 1;
5063     }
5064
5065   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5066     {
5067       tree b = TREE_VALUE (bad);
5068       int u = decl_jump_unsafe (b);
5069
5070       if (u > 1 && DECL_ARTIFICIAL (b))
5071         /* Can't skip init of __exception_info.  */
5072         cp_error_at ("  enters catch block", b);
5073       else if (u > 1)
5074         cp_error_at ("  skips initialization of `%#D'", b);
5075       else
5076         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5077     }
5078
5079   if (lab->eh_region)
5080     error ("  enters try block");
5081 }
5082
5083 /* Define a label, specifying the location in the source file.
5084    Return the LABEL_DECL node for the label, if the definition is valid.
5085    Otherwise return 0.  */
5086
5087 tree
5088 define_label (filename, line, name)
5089      const char *filename;
5090      int line;
5091      tree name;
5092 {
5093   tree decl = lookup_label (name);
5094   struct named_label_list *ent;
5095
5096   for (ent = named_labels; ent; ent = ent->next)
5097     if (ent->label_decl == decl)
5098       break;
5099
5100   /* After labels, make any new cleanups go into their
5101      own new (temporary) binding contour.  */
5102   current_binding_level->more_cleanups_ok = 0;
5103
5104   if (name == get_identifier ("wchar_t"))
5105     cp_pedwarn ("label named wchar_t");
5106
5107   if (DECL_INITIAL (decl) != NULL_TREE)
5108     {
5109       cp_error ("duplicate label `%D'", decl);
5110       return 0;
5111     }
5112   else
5113     {
5114       /* Mark label as having been defined.  */
5115       DECL_INITIAL (decl) = error_mark_node;
5116       /* Say where in the source.  */
5117       DECL_SOURCE_FILE (decl) = filename;
5118       DECL_SOURCE_LINE (decl) = line;
5119       if (ent)
5120         {
5121           ent->names_in_scope = current_binding_level->names;
5122           ent->binding_level = current_binding_level;
5123         }
5124       check_previous_gotos (decl);
5125       current_function_return_value = NULL_TREE;
5126       return decl;
5127     }
5128 }
5129
5130 struct cp_switch
5131 {
5132   struct binding_level *level;
5133   struct cp_switch *next;
5134 };
5135
5136 static struct cp_switch *switch_stack;
5137
5138 void
5139 push_switch ()
5140 {
5141   struct cp_switch *p
5142     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5143   p->level = current_binding_level;
5144   p->next = switch_stack;
5145   switch_stack = p;
5146 }
5147
5148 void
5149 pop_switch ()
5150 {
5151   struct cp_switch *cs;
5152
5153   cs = switch_stack;
5154   switch_stack = switch_stack->next;
5155   free (cs);
5156 }
5157
5158 /* Note that we've seen a definition of a case label, and complain if this
5159    is a bad place for one.  */
5160
5161 void
5162 define_case_label ()
5163 {
5164   tree cleanup = last_cleanup_this_contour ();
5165
5166   if (! switch_stack)
5167     /* Don't crash; we'll complain in do_case.  */
5168     return;
5169
5170   if (cleanup)
5171     {
5172       static int explained = 0;
5173       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
5174       warning ("where case label appears here");
5175       if (!explained)
5176         {
5177           warning ("(enclose actions of previous case statements requiring");
5178           warning ("destructors in their own binding contours.)");
5179           explained = 1;
5180         }
5181     }
5182
5183   check_switch_goto (switch_stack->level);
5184
5185   /* After labels, make any new cleanups go into their
5186      own new (temporary) binding contour.  */
5187
5188   current_binding_level->more_cleanups_ok = 0;
5189   current_function_return_value = NULL_TREE;
5190 }
5191 \f
5192 /* Return the list of declarations of the current level.
5193    Note that this list is in reverse order unless/until
5194    you nreverse it; and when you do nreverse it, you must
5195    store the result back using `storedecls' or you will lose.  */
5196
5197 tree
5198 getdecls ()
5199 {
5200   return current_binding_level->names;
5201 }
5202
5203 /* Return the list of type-tags (for structs, etc) of the current level.  */
5204
5205 tree
5206 gettags ()
5207 {
5208   return current_binding_level->tags;
5209 }
5210
5211 /* Store the list of declarations of the current level.
5212    This is done for the parameter declarations of a function being defined,
5213    after they are modified in the light of any missing parameters.  */
5214
5215 static void
5216 storedecls (decls)
5217      tree decls;
5218 {
5219   current_binding_level->names = decls;
5220 }
5221
5222 /* Similarly, store the list of tags of the current level.  */
5223
5224 void
5225 storetags (tags)
5226      tree tags;
5227 {
5228   current_binding_level->tags = tags;
5229 }
5230 \f
5231 /* Given NAME, an IDENTIFIER_NODE,
5232    return the structure (or union or enum) definition for that name.
5233    Searches binding levels from BINDING_LEVEL up to the global level.
5234    If THISLEVEL_ONLY is nonzero, searches only the specified context
5235    (but skips any tag-transparent contexts to find one that is
5236    meaningful for tags).
5237    FORM says which kind of type the caller wants;
5238    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5239    If the wrong kind of type is found, and it's not a template, an error is
5240    reported.  */
5241
5242 static tree
5243 lookup_tag (form, name, binding_level, thislevel_only)
5244      enum tree_code form;
5245      tree name;
5246      struct binding_level *binding_level;
5247      int thislevel_only;
5248 {
5249   register struct binding_level *level;
5250   /* Non-zero if, we should look past a template parameter level, even
5251      if THISLEVEL_ONLY.  */
5252   int allow_template_parms_p = 1;
5253
5254   for (level = binding_level; level; level = level->level_chain)
5255     {
5256       register tree tail;
5257       if (ANON_AGGRNAME_P (name))
5258         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5259           {
5260             /* There's no need for error checking here, because
5261                anon names are unique throughout the compilation.  */
5262             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5263               return TREE_VALUE (tail);
5264           }
5265       else if (level->namespace_p)
5266         /* Do namespace lookup. */
5267         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5268           {
5269             tree old = binding_for_name (name, tail);
5270
5271             /* If we just skipped past a template parameter level,
5272                even though THISLEVEL_ONLY, and we find a template
5273                class declaration, then we use the _TYPE node for the
5274                template.  See the example below.  */
5275             if (thislevel_only && !allow_template_parms_p
5276                 && old && BINDING_VALUE (old)
5277                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5278               old = TREE_TYPE (BINDING_VALUE (old));
5279             else
5280               old = BINDING_TYPE (old);
5281
5282             /* If it has an original type, it is a typedef, and we
5283                should not return it.  */
5284             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5285               old = NULL_TREE;
5286             if (old && TREE_CODE (old) != form
5287                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5288               {
5289                 cp_error ("`%#D' redeclared as %C", old, form);
5290                 return NULL_TREE;
5291               }
5292             if (old)
5293               return old;
5294             if (thislevel_only || tail == global_namespace)
5295               return NULL_TREE;
5296           }
5297       else
5298         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5299           {
5300             if (TREE_PURPOSE (tail) == name)
5301               {
5302                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5303                 /* Should tighten this up; it'll probably permit
5304                    UNION_TYPE and a struct template, for example.  */
5305                 if (code != form
5306                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5307                   {
5308                     /* Definition isn't the kind we were looking for.  */
5309                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5310                               form);
5311                     return NULL_TREE;
5312                   }
5313                 return TREE_VALUE (tail);
5314               }
5315           }
5316       if (thislevel_only && ! level->tag_transparent)
5317         {
5318           if (level->template_parms_p && allow_template_parms_p)
5319             {
5320               /* We must deal with cases like this:
5321
5322                    template <class T> struct S;
5323                    template <class T> struct S {};
5324
5325                  When looking up `S', for the second declaration, we
5326                  would like to find the first declaration.  But, we
5327                  are in the pseudo-global level created for the
5328                  template parameters, rather than the (surrounding)
5329                  namespace level.  Thus, we keep going one more level,
5330                  even though THISLEVEL_ONLY is non-zero.  */
5331               allow_template_parms_p = 0;
5332               continue;
5333             }
5334           else
5335             return NULL_TREE;
5336         }
5337     }
5338   return NULL_TREE;
5339 }
5340
5341 #if 0
5342 void
5343 set_current_level_tags_transparency (tags_transparent)
5344      int tags_transparent;
5345 {
5346   current_binding_level->tag_transparent = tags_transparent;
5347 }
5348 #endif
5349
5350 /* Given a type, find the tag that was defined for it and return the tag name.
5351    Otherwise return 0.  However, the value can never be 0
5352    in the cases in which this is used.
5353
5354    C++: If NAME is non-zero, this is the new name to install.  This is
5355    done when replacing anonymous tags with real tag names.  */
5356
5357 static tree
5358 lookup_tag_reverse (type, name)
5359      tree type;
5360      tree name;
5361 {
5362   register struct binding_level *level;
5363
5364   for (level = current_binding_level; level; level = level->level_chain)
5365     {
5366       register tree tail;
5367       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5368         {
5369           if (TREE_VALUE (tail) == type)
5370             {
5371               if (name)
5372                 TREE_PURPOSE (tail) = name;
5373               return TREE_PURPOSE (tail);
5374             }
5375         }
5376     }
5377   return NULL_TREE;
5378 }
5379 \f
5380 /* Look up NAME in the NAMESPACE.  */
5381
5382 tree
5383 lookup_namespace_name (namespace, name)
5384      tree namespace, name;
5385 {
5386   tree val;
5387   tree template_id = NULL_TREE;
5388
5389   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5390
5391   if (TREE_CODE (name) == NAMESPACE_DECL)
5392     /* This happens for A::B<int> when B is a namespace. */
5393     return name;
5394   else if (TREE_CODE (name) == TEMPLATE_DECL)
5395     {
5396       /* This happens for A::B where B is a template, and there are no
5397          template arguments.  */
5398       cp_error ("invalid use of `%D'", name);
5399       return error_mark_node;
5400     }
5401
5402   namespace = ORIGINAL_NAMESPACE (namespace);
5403
5404   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5405     {
5406       template_id = name;
5407       name = TREE_OPERAND (name, 0);
5408       if (TREE_CODE (name) == OVERLOAD)
5409         name = DECL_NAME (OVL_CURRENT (name));
5410       else if (DECL_P (name))
5411         name = DECL_NAME (name);
5412     }
5413
5414   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5415
5416   val = make_node (CPLUS_BINDING);
5417   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5418     return error_mark_node;
5419
5420   if (BINDING_VALUE (val))
5421     {
5422       val = BINDING_VALUE (val);
5423
5424       if (template_id)
5425         {
5426           if (DECL_CLASS_TEMPLATE_P (val))
5427             val = lookup_template_class (val,
5428                                          TREE_OPERAND (template_id, 1),
5429                                          /*in_decl=*/NULL_TREE,
5430                                          /*context=*/NULL_TREE,
5431                                          /*entering_scope=*/0);
5432           else if (DECL_FUNCTION_TEMPLATE_P (val)
5433                    || TREE_CODE (val) == OVERLOAD)
5434             val = lookup_template_function (val,
5435                                             TREE_OPERAND (template_id, 1));
5436           else
5437             {
5438               cp_error ("`%D::%D' is not a template",
5439                         namespace, name);
5440               return error_mark_node;
5441             }
5442         }
5443
5444       /* If we have a single function from a using decl, pull it out.  */
5445       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5446         val = OVL_FUNCTION (val);
5447       return val;
5448     }
5449
5450   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5451   return error_mark_node;
5452 }
5453
5454 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5455
5456 static unsigned long
5457 typename_hash (k)
5458      hash_table_key k;
5459 {
5460   unsigned long hash;
5461   tree t;
5462
5463   t = (tree) k;
5464   hash = (((unsigned long) TYPE_CONTEXT (t))
5465           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5466
5467   return hash;
5468 }
5469
5470 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5471
5472 static boolean
5473 typename_compare (k1, k2)
5474      hash_table_key k1;
5475      hash_table_key k2;
5476 {
5477   tree t1;
5478   tree t2;
5479   tree d1;
5480   tree d2;
5481
5482   t1 = (tree) k1;
5483   t2 = (tree) k2;
5484   d1 = TYPE_NAME (t1);
5485   d2 = TYPE_NAME (t2);
5486
5487   return (DECL_NAME (d1) == DECL_NAME (d2)
5488           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5489           && ((TREE_TYPE (t1) != NULL_TREE)
5490               == (TREE_TYPE (t2) != NULL_TREE))
5491           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5492           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5493 }
5494
5495 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5496    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5497    is non-NULL, this type is being created by the implicit typename
5498    extension, and BASE_TYPE is a type named `t' in some base class of
5499    `T' which depends on template parameters.
5500
5501    Returns the new TYPENAME_TYPE.  */
5502
5503 tree
5504 build_typename_type (context, name, fullname, base_type)
5505      tree context;
5506      tree name;
5507      tree fullname;
5508      tree base_type;
5509 {
5510   tree t;
5511   tree d;
5512   struct hash_entry* e;
5513
5514   static struct hash_table ht;
5515
5516   if (!ht.table)
5517     {
5518       static struct hash_table *h = &ht;
5519       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5520                             &typename_compare))
5521         fatal ("virtual memory exhausted");
5522       ggc_add_tree_hash_table_root (&h, 1);
5523     }
5524
5525   /* Build the TYPENAME_TYPE.  */
5526   t = make_aggr_type (TYPENAME_TYPE);
5527   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5528   TYPENAME_TYPE_FULLNAME (t) = fullname;
5529   TREE_TYPE (t) = base_type;
5530
5531   /* Build the corresponding TYPE_DECL.  */
5532   d = build_decl (TYPE_DECL, name, t);
5533   TYPE_NAME (TREE_TYPE (d)) = d;
5534   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5535   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5536   DECL_ARTIFICIAL (d) = 1;
5537
5538   /* See if we already have this type.  */
5539   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5540   if (e)
5541     t = (tree) e->key;
5542   else
5543     /* Insert the type into the table.  */
5544     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5545
5546   return t;
5547 }
5548
5549 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5550    unless an error occurs, in which case error_mark_node is returned.
5551    If COMPLAIN zero, don't complain about any errors that occur.  */
5552
5553 tree
5554 make_typename_type (context, name, complain)
5555      tree context, name;
5556      int complain;
5557 {
5558   tree fullname;
5559
5560   if (TYPE_P (name))
5561     {
5562       if (!(TYPE_LANG_SPECIFIC (name)
5563             && (CLASSTYPE_IS_TEMPLATE (name)
5564                 || CLASSTYPE_USE_TEMPLATE (name))))
5565         name = TYPE_IDENTIFIER (name);
5566       else
5567         /* Create a TEMPLATE_ID_EXPR for the type.  */
5568         name = build_nt (TEMPLATE_ID_EXPR,
5569                          CLASSTYPE_TI_TEMPLATE (name),
5570                          CLASSTYPE_TI_ARGS (name));
5571     }
5572   else if (TREE_CODE (name) == TYPE_DECL)
5573     name = DECL_NAME (name);
5574
5575   fullname = name;
5576
5577   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5578     {
5579       name = TREE_OPERAND (name, 0);
5580       if (TREE_CODE (name) == TEMPLATE_DECL)
5581         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5582     }
5583   if (TREE_CODE (name) != IDENTIFIER_NODE)
5584     my_friendly_abort (2000);
5585
5586   if (TREE_CODE (context) == NAMESPACE_DECL)
5587     {
5588       /* We can get here from typename_sub0 in the explicit_template_type
5589          expansion.  Just fail.  */
5590       if (complain)
5591         cp_error ("no class template named `%#T' in `%#T'",
5592                   name, context);
5593       return error_mark_node;
5594     }
5595
5596   if (! uses_template_parms (context)
5597       || currently_open_class (context))
5598     {
5599       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5600         {
5601           tree tmpl = NULL_TREE;
5602           if (IS_AGGR_TYPE (context))
5603             tmpl = lookup_field (context, name, 0, 0);
5604           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5605             {
5606               if (complain)
5607                 cp_error ("no class template named `%#T' in `%#T'",
5608                           name, context);
5609               return error_mark_node;
5610             }
5611
5612           return lookup_template_class (tmpl,
5613                                         TREE_OPERAND (fullname, 1),
5614                                         NULL_TREE, context,
5615                                         /*entering_scope=*/0);
5616         }
5617       else
5618         {
5619           tree t;
5620
5621           if (!IS_AGGR_TYPE (context))
5622             {
5623               if (complain)
5624                 cp_error ("no type named `%#T' in `%#T'", name, context);
5625               return error_mark_node;
5626             }
5627
5628           t = lookup_field (context, name, 0, 1);
5629           if (t)
5630             return TREE_TYPE (t);
5631         }
5632     }
5633
5634   /* If the CONTEXT is not a template type, then either the field is
5635      there now or its never going to be.  */
5636   if (!uses_template_parms (context))
5637     {
5638       if (complain)
5639         cp_error ("no type named `%#T' in `%#T'", name, context);
5640       return error_mark_node;
5641     }
5642
5643
5644   return build_typename_type (context, name, fullname,  NULL_TREE);
5645 }
5646
5647 /* Select the right _DECL from multiple choices. */
5648
5649 static tree
5650 select_decl (binding, flags)
5651      tree binding;
5652      int flags;
5653 {
5654   tree val;
5655   val = BINDING_VALUE (binding);
5656   if (LOOKUP_NAMESPACES_ONLY (flags))
5657     {
5658       /* We are not interested in types. */
5659       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5660         return val;
5661       return NULL_TREE;
5662     }
5663
5664   /* If we could have a type and
5665      we have nothing or we need a type and have none.  */
5666   if (BINDING_TYPE (binding)
5667       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5668                    && TREE_CODE (val) != TYPE_DECL)))
5669     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5670   /* Don't return non-types if we really prefer types. */
5671   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5672            && (TREE_CODE (val) != TEMPLATE_DECL
5673                || !DECL_CLASS_TEMPLATE_P (val)))
5674     val = NULL_TREE;
5675
5676   return val;
5677 }
5678
5679 /* Unscoped lookup of a global: iterate over current namespaces,
5680    considering using-directives.  If SPACESP is non-NULL, store a list
5681    of the namespaces we've considered in it.  */
5682
5683 tree
5684 unqualified_namespace_lookup (name, flags, spacesp)
5685      tree name;
5686      int flags;
5687      tree *spacesp;
5688 {
5689   tree b = make_node (CPLUS_BINDING);
5690   tree initial = current_decl_namespace();
5691   tree scope = initial;
5692   tree siter;
5693   struct binding_level *level;
5694   tree val = NULL_TREE;
5695
5696   if (spacesp)
5697     *spacesp = NULL_TREE;
5698
5699   for (; !val; scope = CP_DECL_CONTEXT (scope))
5700     {
5701       if (spacesp)
5702         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5703       val = binding_for_name (name, scope);
5704
5705       /* Initialize binding for this context. */
5706       BINDING_VALUE (b) = BINDING_VALUE (val);
5707       BINDING_TYPE (b) = BINDING_TYPE (val);
5708
5709       /* Add all _DECLs seen through local using-directives. */
5710       for (level = current_binding_level;
5711            !level->namespace_p;
5712            level = level->level_chain)
5713         if (!lookup_using_namespace (name, b, level->using_directives,
5714                                      scope, flags, spacesp))
5715           /* Give up because of error. */
5716           return error_mark_node;
5717
5718       /* Add all _DECLs seen through global using-directives. */
5719       /* XXX local and global using lists should work equally. */
5720       siter = initial;
5721       while (1)
5722         {
5723           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5724                                        scope, flags, spacesp))
5725             /* Give up because of error. */
5726             return error_mark_node;
5727           if (siter == scope) break;
5728           siter = CP_DECL_CONTEXT (siter);
5729         }
5730
5731       val = select_decl (b, flags);
5732       if (scope == global_namespace)
5733         break;
5734     }
5735   return val;
5736 }
5737
5738 /* Combine prefer_type and namespaces_only into flags.  */
5739
5740 static int
5741 lookup_flags (prefer_type, namespaces_only)
5742   int prefer_type, namespaces_only;
5743 {
5744   if (namespaces_only)
5745     return LOOKUP_PREFER_NAMESPACES;
5746   if (prefer_type > 1)
5747     return LOOKUP_PREFER_TYPES;
5748   if (prefer_type > 0)
5749     return LOOKUP_PREFER_BOTH;
5750   return 0;
5751 }
5752
5753 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5754    ignore it or not.  Subroutine of lookup_name_real.  */
5755
5756 static tree
5757 qualify_lookup (val, flags)
5758      tree val;
5759      int flags;
5760 {
5761   if (val == NULL_TREE)
5762     return val;
5763   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5764     return val;
5765   if ((flags & LOOKUP_PREFER_TYPES)
5766       && (TREE_CODE (val) == TYPE_DECL
5767           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5768               && DECL_CLASS_TEMPLATE_P (val))))
5769     return val;
5770   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5771     return NULL_TREE;
5772   return val;
5773 }
5774
5775 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5776    that.  */
5777
5778 static void
5779 warn_about_implicit_typename_lookup (typename, binding)
5780      tree typename;
5781      tree binding;
5782 {
5783   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5784   tree name = DECL_NAME (typename);
5785
5786   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5787          && CLASSTYPE_TEMPLATE_INFO (subtype)
5788          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5789       && ! (TREE_CODE (binding) == TYPE_DECL
5790             && same_type_p (TREE_TYPE (binding), subtype)))
5791     {
5792       cp_warning ("lookup of `%D' finds `%#D'",
5793                   name, binding);
5794       cp_warning ("  instead of `%D' from dependent base class",
5795                   typename);
5796       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5797                   constructor_name (current_class_type), name);
5798     }
5799 }
5800
5801 /* Look up NAME in the current binding level and its superiors in the
5802    namespace of variables, functions and typedefs.  Return a ..._DECL
5803    node of some kind representing its definition if there is only one
5804    such declaration, or return a TREE_LIST with all the overloaded
5805    definitions if there are many, or return 0 if it is undefined.
5806
5807    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5808    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5809    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5810    Otherwise we prefer non-TYPE_DECLs.
5811
5812    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5813    using IDENTIFIER_CLASS_VALUE.  */
5814
5815 static tree
5816 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5817      tree name;
5818      int prefer_type, nonclass, namespaces_only;
5819 {
5820   tree t;
5821   tree val = NULL_TREE;
5822   int yylex = 0;
5823   tree from_obj = NULL_TREE;
5824   int flags;
5825   int val_is_implicit_typename = 0;
5826
5827   /* Hack: copy flag set by parser, if set. */
5828   if (only_namespace_names)
5829     namespaces_only = 1;
5830
5831   if (prefer_type == -2)
5832     {
5833       extern int looking_for_typename;
5834       tree type = NULL_TREE;
5835
5836       yylex = 1;
5837       prefer_type = looking_for_typename;
5838
5839       flags = lookup_flags (prefer_type, namespaces_only);
5840       /* If the next thing is '<', class templates are types. */
5841       if (looking_for_template)
5842         flags |= LOOKUP_TEMPLATES_EXPECTED;
5843
5844       /* std:: becomes :: for now.  */
5845       if (got_scope == std_node)
5846         got_scope = void_type_node;
5847
5848       if (got_scope)
5849         type = got_scope;
5850       else if (got_object != error_mark_node)
5851         type = got_object;
5852
5853       if (type)
5854         {
5855           if (type == error_mark_node)
5856             return error_mark_node;
5857           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5858             type = TREE_TYPE (type);
5859
5860           if (TYPE_P (type))
5861             type = complete_type (type);
5862
5863           if (TREE_CODE (type) == VOID_TYPE)
5864             type = global_namespace;
5865           if (TREE_CODE (type) == NAMESPACE_DECL)
5866             {
5867               val = make_node (CPLUS_BINDING);
5868               flags |= LOOKUP_COMPLAIN;
5869               if (!qualified_lookup_using_namespace (name, type, val, flags))
5870                 return NULL_TREE;
5871               val = select_decl (val, flags);
5872             }
5873           else if (! IS_AGGR_TYPE (type)
5874                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5875                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5876                    || TREE_CODE (type) == TYPENAME_TYPE)
5877             /* Someone else will give an error about this if needed.  */
5878             val = NULL_TREE;
5879           else if (type == current_class_type)
5880             val = IDENTIFIER_CLASS_VALUE (name);
5881           else
5882             {
5883               val = lookup_member (type, name, 0, prefer_type);
5884               type_access_control (type, val);
5885             }
5886         }
5887       else
5888         val = NULL_TREE;
5889
5890       if (got_scope)
5891         goto done;
5892       else if (got_object && val)
5893         from_obj = val;
5894     }
5895   else
5896     {
5897       flags = lookup_flags (prefer_type, namespaces_only);
5898       /* If we're not parsing, we need to complain. */
5899       flags |= LOOKUP_COMPLAIN;
5900     }
5901
5902   /* First, look in non-namespace scopes.  */
5903
5904   if (current_class_type == NULL_TREE)
5905     nonclass = 1;
5906
5907   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5908     {
5909       tree binding;
5910
5911       if (!LOCAL_BINDING_P (t) && nonclass)
5912         /* We're not looking for class-scoped bindings, so keep going.  */
5913         continue;
5914
5915       /* If this is the kind of thing we're looking for, we're done.  */
5916       if (qualify_lookup (BINDING_VALUE (t), flags))
5917         binding = BINDING_VALUE (t);
5918       else if ((flags & LOOKUP_PREFER_TYPES)
5919                && qualify_lookup (BINDING_TYPE (t), flags))
5920         binding = BINDING_TYPE (t);
5921       else
5922         binding = NULL_TREE;
5923
5924       /* Handle access control on types from enclosing or base classes.  */
5925       if (binding && ! yylex
5926           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5927         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5928
5929       if (binding
5930           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5931         {
5932           if (val_is_implicit_typename && !yylex)
5933             warn_about_implicit_typename_lookup (val, binding);
5934           val = binding;
5935           val_is_implicit_typename
5936             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5937           if (!val_is_implicit_typename)
5938             break;
5939         }
5940     }
5941
5942   /* Now lookup in namespace scopes.  */
5943   if (!val || val_is_implicit_typename)
5944     {
5945       t = unqualified_namespace_lookup (name, flags, 0);
5946       if (t)
5947         {
5948           if (val_is_implicit_typename && !yylex)
5949             warn_about_implicit_typename_lookup (val, t);
5950           val = t;
5951         }
5952     }
5953
5954  done:
5955   if (val)
5956     {
5957       /* This should only warn about types used in qualified-ids.  */
5958       if (from_obj && from_obj != val)
5959         {
5960           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5961               && TREE_CODE (val) == TYPE_DECL
5962               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5963             {
5964               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5965                           name, got_object, TREE_TYPE (from_obj));
5966               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5967                           TREE_TYPE (val));
5968             }
5969
5970           /* We don't change val to from_obj if got_object depends on
5971              template parms because that breaks implicit typename for
5972              destructor calls.  */
5973           if (! uses_template_parms (got_object))
5974             val = from_obj;
5975         }
5976
5977       /* If we have a single function from a using decl, pull it out.  */
5978       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5979         val = OVL_FUNCTION (val);
5980     }
5981   else if (from_obj)
5982     val = from_obj;
5983
5984   return val;
5985 }
5986
5987 tree
5988 lookup_name_nonclass (name)
5989      tree name;
5990 {
5991   return lookup_name_real (name, 0, 1, 0);
5992 }
5993
5994 tree
5995 lookup_function_nonclass (name, args)
5996      tree name;
5997      tree args;
5998 {
5999   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6000 }
6001
6002 tree
6003 lookup_name_namespace_only (name)
6004      tree name;
6005 {
6006   /* type-or-namespace, nonclass, namespace_only */
6007   return lookup_name_real (name, 1, 1, 1);
6008 }
6009
6010 tree
6011 lookup_name (name, prefer_type)
6012      tree name;
6013      int prefer_type;
6014 {
6015   return lookup_name_real (name, prefer_type, 0, 0);
6016 }
6017
6018 /* Similar to `lookup_name' but look only in the innermost non-class
6019    binding level.  */
6020
6021 tree
6022 lookup_name_current_level (name)
6023      tree name;
6024 {
6025   struct binding_level *b;
6026   tree t = NULL_TREE;
6027
6028   b = current_binding_level;
6029   while (b->parm_flag == 2)
6030     b = b->level_chain;
6031
6032   if (b->namespace_p)
6033     {
6034       t = IDENTIFIER_NAMESPACE_VALUE (name);
6035
6036       /* extern "C" function() */
6037       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6038         t = TREE_VALUE (t);
6039     }
6040   else if (IDENTIFIER_BINDING (name)
6041            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6042     {
6043       while (1)
6044         {
6045           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6046             return IDENTIFIER_VALUE (name);
6047
6048           if (b->keep == 2)
6049             b = b->level_chain;
6050           else
6051             break;
6052         }
6053     }
6054
6055   return t;
6056 }
6057
6058 /* Like lookup_name_current_level, but for types.  */
6059
6060 tree
6061 lookup_type_current_level (name)
6062      tree name;
6063 {
6064   register tree t = NULL_TREE;
6065
6066   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6067
6068   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6069       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6070     {
6071       struct binding_level *b = current_binding_level;
6072       while (1)
6073         {
6074           if (purpose_member (name, b->type_shadowed))
6075             return REAL_IDENTIFIER_TYPE_VALUE (name);
6076           if (b->keep == 2)
6077             b = b->level_chain;
6078           else
6079             break;
6080         }
6081     }
6082
6083   return t;
6084 }
6085
6086 void
6087 begin_only_namespace_names ()
6088 {
6089   only_namespace_names = 1;
6090 }
6091
6092 void
6093 end_only_namespace_names ()
6094 {
6095   only_namespace_names = 0;
6096 }
6097 \f
6098 /* Arrange for the user to get a source line number, even when the
6099    compiler is going down in flames, so that she at least has a
6100    chance of working around problems in the compiler.  We used to
6101    call error(), but that let the segmentation fault continue
6102    through; now, it's much more passive by asking them to send the
6103    maintainers mail about the problem.  */
6104
6105 static void
6106 signal_catch (sig)
6107      int sig ATTRIBUTE_UNUSED;
6108 {
6109   signal (SIGSEGV, SIG_DFL);
6110 #ifdef SIGIOT
6111   signal (SIGIOT, SIG_DFL);
6112 #endif
6113 #ifdef SIGILL
6114   signal (SIGILL, SIG_DFL);
6115 #endif
6116 #ifdef SIGABRT
6117   signal (SIGABRT, SIG_DFL);
6118 #endif
6119 #ifdef SIGBUS
6120   signal (SIGBUS, SIG_DFL);
6121 #endif
6122   my_friendly_abort (0);
6123 }
6124
6125 /* Push the declarations of builtin types into the namespace.
6126    RID_INDEX, if < RID_MAX is the index of the builtin type
6127    in the array RID_POINTERS.  NAME is the name used when looking
6128    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6129
6130 static void
6131 record_builtin_type (rid_index, name, type)
6132      enum rid rid_index;
6133      const char *name;
6134      tree type;
6135 {
6136   tree rname = NULL_TREE, tname = NULL_TREE;
6137   tree tdecl = NULL_TREE;
6138
6139   if ((int) rid_index < (int) RID_MAX)
6140     rname = ridpointers[(int) rid_index];
6141   if (name)
6142     tname = get_identifier (name);
6143
6144   TYPE_BUILT_IN (type) = 1;
6145
6146   if (tname)
6147     {
6148       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6149       set_identifier_type_value (tname, NULL_TREE);
6150       if ((int) rid_index < (int) RID_MAX)
6151         /* Built-in types live in the global namespace. */
6152         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6153     }
6154   if (rname != NULL_TREE)
6155     {
6156       if (tname != NULL_TREE)
6157         {
6158           set_identifier_type_value (rname, NULL_TREE);
6159           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6160         }
6161       else
6162         {
6163           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6164           set_identifier_type_value (rname, NULL_TREE);
6165         }
6166     }
6167 }
6168
6169 /* Record one of the standard Java types.
6170  * Declare it as having the given NAME.
6171  * If SIZE > 0, it is the size of one of the integral types;
6172  * otherwise it is the negative of the size of one of the other types.  */
6173
6174 static tree
6175 record_builtin_java_type (name, size)
6176      const char *name;
6177      int size;
6178 {
6179   tree type, decl;
6180   if (size > 0)
6181     type = make_signed_type (size);
6182   else if (size > -32)
6183     { /* "__java_char" or ""__java_boolean". */
6184       type = make_unsigned_type (-size);
6185       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6186     }
6187   else
6188     { /* "__java_float" or ""__java_double". */
6189       type = make_node (REAL_TYPE);
6190       TYPE_PRECISION (type) = - size;
6191       layout_type (type);
6192     }
6193   record_builtin_type (RID_MAX, name, type);
6194   decl = TYPE_NAME (type);
6195
6196   /* Suppress generate debug symbol entries for these types,
6197      since for normal C++ they are just clutter.
6198      However, push_lang_context undoes this if extern "Java" is seen. */
6199   DECL_IGNORED_P (decl) = 1;
6200
6201   TYPE_FOR_JAVA (type) = 1;
6202   return type;
6203 }
6204
6205 /* Push a type into the namespace so that the back-ends ignore it. */
6206
6207 static void
6208 record_unknown_type (type, name)
6209      tree type;
6210      const char *name;
6211 {
6212   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6213   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6214   DECL_IGNORED_P (decl) = 1;
6215   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6216   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6217   TYPE_ALIGN (type) = 1;
6218   TYPE_USER_ALIGN (type) = 0;
6219   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6220 }
6221
6222 /* An string for which we should create an IDENTIFIER_NODE at
6223    startup.  */
6224
6225 typedef struct predefined_identifier
6226 {
6227   /* The name of the identifier.  */
6228   const char *name;
6229   /* The place where the IDENTIFIER_NODE should be stored.  */
6230   tree *node;
6231   /* Non-zero if this is the name of a constructor or destructor.  */
6232   int ctor_or_dtor_p;
6233 } predefined_identifier;
6234
6235 /* Create all the predefined identifiers.  */
6236
6237 static void
6238 initialize_predefined_identifiers ()
6239 {
6240   struct predefined_identifier *pid;
6241
6242   /* A table of identifiers to create at startup.  */
6243   static predefined_identifier predefined_identifiers[] = {
6244     { "C++", &lang_name_cplusplus, 0 },
6245     { "C", &lang_name_c, 0 },
6246     { "Java", &lang_name_java, 0 },
6247     { CTOR_NAME, &ctor_identifier, 1 },
6248     { "__base_ctor", &base_ctor_identifier, 1 },
6249     { "__comp_ctor", &complete_ctor_identifier, 1 },
6250     { DTOR_NAME, &dtor_identifier, 1 },
6251     { "__comp_dtor", &complete_dtor_identifier, 1 },
6252     { "__base_dtor", &base_dtor_identifier, 1 },
6253     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6254     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6255     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6256     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6257     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6258     { "nelts", &nelts_identifier, 0 },
6259     { THIS_NAME, &this_identifier, 0 },
6260     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6261     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6262     { "_vptr", &vptr_identifier, 0 },
6263     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6264     { "__vtt_parm", &vtt_parm_identifier, 0 },
6265     { "std", &std_identifier, 0 },
6266     { NULL, NULL, 0 }
6267   };
6268
6269   for (pid = predefined_identifiers; pid->name; ++pid)
6270     {
6271       *pid->node = get_identifier (pid->name);
6272       if (pid->ctor_or_dtor_p)
6273         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6274     }
6275 }
6276
6277 /* Create the predefined scalar types of C,
6278    and some nodes representing standard constants (0, 1, (void *)0).
6279    Initialize the global binding level.
6280    Make definitions for built-in primitive functions.  */
6281
6282 void
6283 init_decl_processing ()
6284 {
6285   tree fields[20];
6286   int wchar_type_size;
6287   tree array_domain_type;
6288
6289   /* Check to see that the user did not specify an invalid combination
6290      of command-line options.  */
6291   if (flag_new_abi && !flag_vtable_thunks)
6292     fatal ("the new ABI requires vtable thunks");
6293
6294   /* Create all the identifiers we need.  */
6295   initialize_predefined_identifiers ();
6296
6297   /* Let the back-end now how to save and restore language-specific
6298      per-function globals.  */
6299   init_lang_status = &push_cp_function_context;
6300   free_lang_status = &pop_cp_function_context;
6301   mark_lang_status = &mark_cp_function_context;
6302
6303   cp_parse_init ();
6304   init_decl2 ();
6305   init_pt ();
6306
6307   /* Create the global variables.  */
6308   push_to_top_level ();
6309
6310   /* Enter the global namespace. */
6311   my_friendly_assert (global_namespace == NULL_TREE, 375);
6312   push_namespace (get_identifier ("::"));
6313   global_namespace = current_namespace;
6314   current_lang_name = NULL_TREE;
6315
6316   /* Adjust various flags based on command-line settings.  */
6317   if (flag_strict_prototype == 2)
6318     flag_strict_prototype = pedantic;
6319   if (! flag_permissive && ! pedantic)
6320     flag_pedantic_errors = 1;
6321   if (!flag_no_inline)
6322     flag_inline_trees = 1;
6323
6324   strict_prototypes_lang_c = flag_strict_prototype;
6325
6326   /* Initially, C.  */
6327   current_lang_name = lang_name_c;
6328
6329   current_function_decl = NULL_TREE;
6330   current_binding_level = NULL_BINDING_LEVEL;
6331   free_binding_level = NULL_BINDING_LEVEL;
6332
6333   /* Because most segmentation signals can be traced back into user
6334      code, catch them and at least give the user a chance of working
6335      around compiler bugs.  */
6336   signal (SIGSEGV, signal_catch);
6337
6338   /* We will also catch aborts in the back-end through signal_catch and
6339      give the user a chance to see where the error might be, and to defeat
6340      aborts in the back-end when there have been errors previously in their
6341      code.  */
6342 #ifdef SIGIOT
6343   signal (SIGIOT, signal_catch);
6344 #endif
6345 #ifdef SIGILL
6346   signal (SIGILL, signal_catch);
6347 #endif
6348 #ifdef SIGABRT
6349   signal (SIGABRT, signal_catch);
6350 #endif
6351 #ifdef SIGBUS
6352   signal (SIGBUS, signal_catch);
6353 #endif
6354
6355   build_common_tree_nodes (flag_signed_char);
6356
6357   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6358   TREE_TYPE (error_mark_list) = error_mark_node;
6359
6360   /* Make the binding_level structure for global names.  */
6361   pushlevel (0);
6362   global_binding_level = current_binding_level;
6363   /* The global level is the namespace level of ::.  */
6364   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6365   declare_namespace_level ();
6366
6367   /* Define `int' and `char' first so that dbx will output them first.  */
6368   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6369   record_builtin_type (RID_CHAR, "char", char_type_node);
6370
6371   /* `signed' is the same as `int' */
6372   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6373   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6374   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6375   record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
6376   record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6377   record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
6378   record_builtin_type (RID_MAX, "long long unsigned int",
6379                        long_long_unsigned_type_node);
6380   record_builtin_type (RID_MAX, "long long unsigned",
6381                        long_long_unsigned_type_node);
6382   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6383   record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
6384   record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
6385
6386   ptrdiff_type_node
6387     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6388
6389   /* Define both `signed char' and `unsigned char'.  */
6390   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6391   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6392
6393   /* `unsigned long' is the standard type for sizeof.
6394      Note that stddef.h uses `unsigned long',
6395      and this must agree, even if long and int are the same size.  */
6396   set_sizetype
6397     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6398
6399   /* Create the widest literal types. */
6400   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6401   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6402                         widest_integer_literal_type_node));
6403
6404   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6405   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6406                         widest_unsigned_literal_type_node));
6407
6408   /* These are types that type_for_size and type_for_mode use.  */
6409   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6410   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6411   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6412   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6413 #if HOST_BITS_PER_WIDE_INT >= 64
6414   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6415 #endif
6416   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6417   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6418   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6419   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6420 #if HOST_BITS_PER_WIDE_INT >= 64
6421   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6422 #endif
6423
6424   build_common_tree_nodes_2 (flag_short_double);
6425
6426   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6427   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6428   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6429   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6430   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6431   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6432   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6433   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6434
6435   integer_two_node = build_int_2 (2, 0);
6436   TREE_TYPE (integer_two_node) = integer_type_node;
6437   integer_three_node = build_int_2 (3, 0);
6438   TREE_TYPE (integer_three_node) = integer_type_node;
6439
6440   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6441   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6442   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6443   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6444   TYPE_PRECISION (boolean_type_node) = 1;
6445   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6446   boolean_false_node = build_int_2 (0, 0);
6447   TREE_TYPE (boolean_false_node) = boolean_type_node;
6448   boolean_true_node = build_int_2 (1, 0);
6449   TREE_TYPE (boolean_true_node) = boolean_type_node;
6450
6451   signed_size_zero_node = build_int_2 (0, 0);
6452   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6453   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6454   record_builtin_type (RID_MAX, "long double", long_double_type_node);
6455
6456   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6457                         complex_integer_type_node));
6458   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6459                         complex_float_type_node));
6460   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6461                         complex_double_type_node));
6462   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6463                         complex_long_double_type_node));
6464
6465   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6466
6467   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6468   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6469   TREE_PARMLIST (void_list_node) = 1;
6470
6471   /* Used for expressions that do nothing, but are not errors.  */
6472   void_zero_node = build_int_2 (0, 0);
6473   TREE_TYPE (void_zero_node) = void_type_node;
6474
6475   string_type_node = build_pointer_type (char_type_node);
6476   const_string_type_node
6477     = build_pointer_type (build_qualified_type (char_type_node,
6478                                                 TYPE_QUAL_CONST));
6479   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6480 #if 0
6481   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6482 #endif
6483
6484   /* Make a type to be the domain of a few array types
6485      whose domains don't really matter.
6486      200 is small enough that it always fits in size_t.  */
6487   array_domain_type = build_index_type (build_int_2 (200, 0));
6488
6489   /* Make a type for arrays of characters.
6490      With luck nothing will ever really depend on the length of this
6491      array type.  */
6492   char_array_type_node
6493     = build_array_type (char_type_node, array_domain_type);
6494
6495   /* Likewise for arrays of ints.  */
6496   int_array_type_node
6497     = build_array_type (integer_type_node, array_domain_type);
6498
6499   if (flag_new_abi)
6500     delta_type_node = ptrdiff_type_node;
6501   else if (flag_huge_objects)
6502     delta_type_node = long_integer_type_node;
6503   else
6504     delta_type_node = short_integer_type_node;
6505
6506   if (flag_new_abi)
6507     vtable_index_type = ptrdiff_type_node;
6508   else
6509     vtable_index_type = delta_type_node;
6510
6511   default_function_type
6512     = build_function_type (integer_type_node, NULL_TREE);
6513
6514   ptr_type_node = build_pointer_type (void_type_node);
6515   const_ptr_type_node
6516     = build_pointer_type (build_qualified_type (void_type_node,
6517                                                 TYPE_QUAL_CONST));
6518   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6519   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6520   lang_type_promotes_to = convert_type_from_ellipsis;
6521
6522   void_ftype_ptr
6523     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6524
6525   /* C++ extensions */
6526
6527   unknown_type_node = make_node (UNKNOWN_TYPE);
6528   record_unknown_type (unknown_type_node, "unknown type");
6529
6530   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6531   TREE_TYPE (unknown_type_node) = unknown_type_node;
6532
6533   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6534
6535   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6536      result.  */
6537   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6538   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6539
6540   /* This is special for C++ so functions can be overloaded.  */
6541   wchar_type_node = get_identifier (flag_short_wchar
6542                                     ? "short unsigned int"
6543                                     : WCHAR_TYPE);
6544   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6545   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6546   signed_wchar_type_node = make_signed_type (wchar_type_size);
6547   unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
6548   wchar_type_node
6549     = TREE_UNSIGNED (wchar_type_node)
6550       ? unsigned_wchar_type_node
6551       : signed_wchar_type_node;
6552   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6553
6554   /* Artificial declaration of wchar_t -- can be bashed */
6555   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6556                                 wchar_type_node);
6557   pushdecl (wchar_decl_node);
6558
6559   /* This is for wide string constants.  */
6560   wchar_array_type_node
6561     = build_array_type (wchar_type_node, array_domain_type);
6562
6563   if (flag_vtable_thunks)
6564     {
6565       /* Make sure we get a unique function type, so we can give
6566          its pointer type a name.  (This wins for gdb.) */
6567       tree vfunc_type = make_node (FUNCTION_TYPE);
6568       TREE_TYPE (vfunc_type) = integer_type_node;
6569       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6570       layout_type (vfunc_type);
6571
6572       vtable_entry_type = build_pointer_type (vfunc_type);
6573     }
6574   else
6575     {
6576       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6577       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6578                               delta_type_node);
6579       fields[1] = build_decl (FIELD_DECL, index_identifier,
6580                               delta_type_node);
6581       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6582                               ptr_type_node);
6583       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6584                            double_type_node);
6585
6586       /* Make this part of an invisible union.  */
6587       fields[3] = copy_node (fields[2]);
6588       TREE_TYPE (fields[3]) = delta_type_node;
6589       DECL_NAME (fields[3]) = delta2_identifier;
6590       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6591       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6592       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6593       TREE_UNSIGNED (fields[3]) = 0;
6594       TREE_CHAIN (fields[2]) = fields[3];
6595       vtable_entry_type = build_qualified_type (vtable_entry_type,
6596                                                 TYPE_QUAL_CONST);
6597     }
6598   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6599
6600   vtbl_type_node
6601     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6602   layout_type (vtbl_type_node);
6603   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6604   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6605   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6606   layout_type (vtbl_ptr_type_node);
6607   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6608
6609   std_node = build_decl (NAMESPACE_DECL,
6610                          flag_honor_std
6611                          ? get_identifier ("fake std") : std_identifier,
6612                          void_type_node);
6613   pushdecl (std_node);
6614
6615   if (flag_new_abi)
6616     {
6617       push_namespace (get_identifier ("__cxxabiv1"));
6618       abi_node = current_namespace;
6619       pop_namespace ();
6620     }
6621
6622   global_type_node = make_node (LANG_TYPE);
6623   record_unknown_type (global_type_node, "global type");
6624
6625   /* Now, C++.  */
6626   current_lang_name = lang_name_cplusplus;
6627
6628   {
6629     tree bad_alloc_type_node, newtype, deltype;
6630     if (flag_honor_std)
6631       push_namespace (get_identifier ("std"));
6632     bad_alloc_type_node = xref_tag
6633       (class_type_node, get_identifier ("bad_alloc"), 1);
6634     if (flag_honor_std)
6635       pop_namespace ();
6636     newtype = build_exception_variant
6637       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6638     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6639     push_cp_library_fn (NEW_EXPR, newtype);
6640     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6641     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6642     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6643   }
6644
6645   abort_fndecl
6646     = build_library_fn_ptr ("__pure_virtual", void_ftype);
6647
6648   /* Perform other language dependent initializations.  */
6649   init_class_processing ();
6650   init_init_processing ();
6651   init_search_processing ();
6652   init_rtti_processing ();
6653
6654   if (flag_exceptions)
6655     init_exception_processing ();
6656   if (flag_no_inline)
6657     {
6658       flag_inline_functions = 0;
6659     }
6660
6661   if (! supports_one_only ())
6662     flag_weak = 0;
6663
6664   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6665   make_fname_decl = cp_make_fname_decl;
6666   declare_function_name ();
6667
6668   /* Prepare to check format strings against argument lists.  */
6669   init_function_format_info ();
6670
6671   /* Show we use EH for cleanups.  */
6672   using_eh_for_cleanups ();
6673
6674   print_error_function = lang_print_error_function;
6675   valid_lang_attribute = cp_valid_lang_attribute;
6676
6677   /* Maintain consistency.  Perhaps we should just complain if they
6678      say -fwritable-strings?  */
6679   if (flag_writable_strings)
6680     flag_const_strings = 0;
6681
6682   /* Add GC roots for all of our global variables.  */
6683   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6684   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6685   ggc_add_tree_root (&integer_three_node, 1);
6686   ggc_add_tree_root (&integer_two_node, 1);
6687   ggc_add_tree_root (&signed_size_zero_node, 1);
6688   ggc_add_tree_root (&size_one_node, 1);
6689   ggc_add_tree_root (&size_zero_node, 1);
6690   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6691                 mark_binding_level);
6692   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6693   ggc_add_tree_root (&static_ctors, 1);
6694   ggc_add_tree_root (&static_dtors, 1);
6695   ggc_add_tree_root (&lastiddecl, 1);
6696
6697   ggc_add_tree_root (&last_function_parm_tags, 1);
6698   ggc_add_tree_root (&current_function_return_value, 1);
6699   ggc_add_tree_root (&current_function_parms, 1);
6700   ggc_add_tree_root (&current_function_parm_tags, 1);
6701   ggc_add_tree_root (&last_function_parms, 1);
6702   ggc_add_tree_root (&error_mark_list, 1);
6703
6704   ggc_add_tree_root (&global_namespace, 1);
6705   ggc_add_tree_root (&global_type_node, 1);
6706   ggc_add_tree_root (&anonymous_namespace_name, 1);
6707
6708   ggc_add_tree_root (&got_object, 1);
6709   ggc_add_tree_root (&got_scope, 1);
6710
6711   ggc_add_tree_root (&current_lang_name, 1);
6712   ggc_add_tree_root (&static_aggregates, 1);
6713 }
6714
6715 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6716    decl, NAME is the initialization string and TYPE_DEP indicates whether
6717    NAME depended on the type of the function. We make use of that to detect
6718    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6719    the function before emitting any of it, we don't need to treat the
6720    VAR_DECL specially. We can decide whether to emit it later, if it was
6721    used.  */
6722
6723 static tree
6724 cp_make_fname_decl (id, name, type_dep)
6725      tree id;
6726      const char *name;
6727      int type_dep;
6728 {
6729   tree decl, type, init;
6730   size_t length = strlen (name);
6731   tree domain = NULL_TREE;
6732
6733   if (!processing_template_decl)
6734     type_dep = 0;
6735   if (!type_dep)
6736     domain = build_index_type (build_int_2 (length, 0));
6737
6738   type =  build_cplus_array_type
6739           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6740            domain);
6741
6742   decl = build_decl (VAR_DECL, id, type);
6743   TREE_STATIC (decl) = 1;
6744   TREE_READONLY (decl) = 1;
6745   DECL_SOURCE_LINE (decl) = 0;
6746   DECL_ARTIFICIAL (decl) = 1;
6747   DECL_IN_SYSTEM_HEADER (decl) = 1;
6748   pushdecl (decl);
6749   if (processing_template_decl)
6750     decl = push_template_decl (decl);
6751   if (type_dep)
6752     {
6753       init = build (FUNCTION_NAME, type);
6754       DECL_PRETTY_FUNCTION_P (decl) = 1;
6755     }
6756   else
6757     {
6758       init = build_string (length + 1, name);
6759       TREE_TYPE (init) = type;
6760     }
6761   DECL_INITIAL (decl) = init;
6762   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6763
6764   /* We will have to make sure we only emit this, if it is actually used. */
6765   return decl;
6766 }
6767
6768 /* Function to print any language-specific context for an error message.  */
6769
6770 static void
6771 lang_print_error_function (file)
6772      const char *file;
6773 {
6774   default_print_error_function (file);
6775   maybe_print_template_context ();
6776 }
6777
6778 /* Entry point for the benefit of c_common_nodes_and_builtins.
6779
6780    Make a definition for a builtin function named NAME and whose data type
6781    is TYPE.  TYPE should be a function type with argument types.
6782
6783    CLASS and CODE tell later passes how to compile calls to this function.
6784    See tree.h for possible values.
6785
6786    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6787    the name to be called if we can't opencode the function.  */
6788
6789 tree
6790 builtin_function (name, type, code, class, libname)
6791      const char *name;
6792      tree type;
6793      int code;
6794      enum built_in_class class;
6795      const char *libname;
6796 {
6797   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6798   DECL_BUILT_IN_CLASS (decl) = class;
6799   DECL_FUNCTION_CODE (decl) = code;
6800
6801   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6802
6803   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6804      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6805      function in the namespace.  */
6806   pushdecl (decl);
6807   if (libname)
6808     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6809   make_function_rtl (decl);
6810
6811   /* Warn if a function in the namespace for users
6812      is used without an occasion to consider it declared.  */
6813   if (name[0] != '_' || name[1] != '_')
6814     DECL_ANTICIPATED (decl) = 1;
6815
6816   return decl;
6817 }
6818
6819 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6820    function.  Not called directly.  */
6821
6822 static tree
6823 build_library_fn_1 (name, operator_code, type)
6824      tree name;
6825      enum tree_code operator_code;
6826      tree type;
6827 {
6828   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6829   DECL_EXTERNAL (fn) = 1;
6830   TREE_PUBLIC (fn) = 1;
6831   DECL_ARTIFICIAL (fn) = 1;
6832   TREE_NOTHROW (fn) = 1;
6833   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6834   return fn;
6835 }
6836
6837 /* Returns the _DECL for a library function with C linkage.
6838    We assume that such functions never throw; if this is incorrect,
6839    callers should unset TREE_NOTHROW.  */
6840
6841 tree
6842 build_library_fn (name, type)
6843      tree name;
6844      tree type;
6845 {
6846   tree fn = build_library_fn_1 (name, ERROR_MARK, type);
6847   make_function_rtl (fn);
6848   return fn;
6849 }
6850
6851 /* Returns the _DECL for a library function with C++ linkage.  */
6852
6853 static tree
6854 build_cp_library_fn (name, operator_code, type)
6855      tree name;
6856      enum tree_code operator_code;
6857      tree type;
6858 {
6859   tree fn = build_library_fn_1 (name, operator_code, type);
6860   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6861   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6862   set_mangled_name_for_decl (fn);
6863   make_function_rtl (fn);
6864   return fn;
6865 }
6866
6867 /* Like build_library_fn, but takes a C string instead of an
6868    IDENTIFIER_NODE.  */
6869
6870 tree
6871 build_library_fn_ptr (name, type)
6872      const char *name;
6873      tree type;
6874 {
6875   return build_library_fn (get_identifier (name), type);
6876 }
6877
6878 /* Like build_cp_library_fn, but takes a C string instead of an
6879    IDENTIFIER_NODE.  */
6880
6881 tree
6882 build_cp_library_fn_ptr (name, type)
6883      const char *name;
6884      tree type;
6885 {
6886   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6887 }
6888
6889 /* Like build_library_fn, but also pushes the function so that we will
6890    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6891
6892 tree
6893 push_library_fn (name, type)
6894      tree name, type;
6895 {
6896   tree fn = build_library_fn (name, type);
6897   pushdecl_top_level (fn);
6898   return fn;
6899 }
6900
6901 /* Like build_cp_library_fn, but also pushes the function so that it
6902    will be found by normal lookup.  */
6903
6904 static tree
6905 push_cp_library_fn (operator_code, type)
6906      enum tree_code operator_code;
6907      tree type;
6908 {
6909   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6910                                  operator_code,
6911                                  type);
6912   pushdecl (fn);
6913   return fn;
6914 }
6915
6916 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6917    a FUNCTION_TYPE.  */
6918
6919 tree
6920 push_void_library_fn (name, parmtypes)
6921      tree name, parmtypes;
6922 {
6923   tree type = build_function_type (void_type_node, parmtypes);
6924   return push_library_fn (name, type);
6925 }
6926
6927 /* Like push_library_fn, but also note that this function throws
6928    and does not return.  Used for __throw_foo and the like.  */
6929
6930 tree
6931 push_throw_library_fn (name, type)
6932      tree name, type;
6933 {
6934   tree fn = push_library_fn (name, type);
6935   TREE_THIS_VOLATILE (fn) = 1;
6936   TREE_NOTHROW (fn) = 0;
6937   return fn;
6938 }
6939 \f
6940 /* When we call finish_struct for an anonymous union, we create
6941    default copy constructors and such.  But, an anonymous union
6942    shouldn't have such things; this function undoes the damage to the
6943    anonymous union type T.
6944
6945    (The reason that we create the synthesized methods is that we don't
6946    distinguish `union { int i; }' from `typedef union { int i; } U'.
6947    The first is an anonymous union; the second is just an ordinary
6948    union type.)  */
6949
6950 void
6951 fixup_anonymous_aggr (t)
6952      tree t;
6953 {
6954   tree *q;
6955
6956   /* Wipe out memory of synthesized methods */
6957   TYPE_HAS_CONSTRUCTOR (t) = 0;
6958   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6959   TYPE_HAS_INIT_REF (t) = 0;
6960   TYPE_HAS_CONST_INIT_REF (t) = 0;
6961   TYPE_HAS_ASSIGN_REF (t) = 0;
6962   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6963
6964   /* Splice the implicitly generated functions out of the TYPE_METHODS
6965      list.  */
6966   q = &TYPE_METHODS (t);
6967   while (*q)
6968     {
6969       if (DECL_ARTIFICIAL (*q))
6970         *q = TREE_CHAIN (*q);
6971       else
6972         q = &TREE_CHAIN (*q);
6973     }
6974
6975   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6976   if (TYPE_METHODS (t))
6977     error ("an anonymous union cannot have function members");
6978 }
6979
6980 /* Make sure that a declaration with no declarator is well-formed, i.e.
6981    just defines a tagged type or anonymous union.
6982
6983    Returns the type defined, if any.  */
6984
6985 tree
6986 check_tag_decl (declspecs)
6987      tree declspecs;
6988 {
6989   int found_type = 0;
6990   int saw_friend = 0;
6991   tree ob_modifier = NULL_TREE;
6992   register tree link;
6993   register tree t = NULL_TREE;
6994
6995   for (link = declspecs; link; link = TREE_CHAIN (link))
6996     {
6997       register tree value = TREE_VALUE (link);
6998
6999       if (TYPE_P (value)
7000           || (TREE_CODE (value) == IDENTIFIER_NODE
7001               && IDENTIFIER_GLOBAL_VALUE (value)
7002               && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
7003         {
7004           ++found_type;
7005
7006           if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
7007             {
7008               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
7009               t = value;
7010             }
7011         }
7012       else if (value == ridpointers[(int) RID_FRIEND])
7013         {
7014           if (current_class_type == NULL_TREE
7015               || current_scope () != current_class_type)
7016             ob_modifier = value;
7017           else
7018             saw_friend = 1;
7019         }
7020       else if (value == ridpointers[(int) RID_STATIC]
7021                || value == ridpointers[(int) RID_EXTERN]
7022                || value == ridpointers[(int) RID_AUTO]
7023                || value == ridpointers[(int) RID_REGISTER]
7024                || value == ridpointers[(int) RID_INLINE]
7025                || value == ridpointers[(int) RID_VIRTUAL]
7026                || value == ridpointers[(int) RID_CONST]
7027                || value == ridpointers[(int) RID_VOLATILE]
7028                || value == ridpointers[(int) RID_EXPLICIT])
7029         ob_modifier = value;
7030     }
7031
7032   if (found_type > 1)
7033     error ("multiple types in one declaration");
7034
7035   if (t == NULL_TREE && ! saw_friend)
7036     pedwarn ("declaration does not declare anything");
7037
7038   /* Check for an anonymous union.  We're careful
7039      accessing TYPE_IDENTIFIER because some built-in types, like
7040      pointer-to-member types, do not have TYPE_NAME.  */
7041   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7042            && TYPE_NAME (t)
7043            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
7044     {
7045       /* Anonymous unions are objects, so they can have specifiers.  */;
7046       SET_ANON_AGGR_TYPE_P (t);
7047
7048       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7049         pedwarn ("ISO C++ prohibits anonymous structs");
7050     }
7051
7052   else if (ob_modifier)
7053     {
7054       if (ob_modifier == ridpointers[(int) RID_INLINE]
7055           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7056         cp_error ("`%D' can only be specified for functions", ob_modifier);
7057       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7058         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7059       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7060         cp_error ("`%D' can only be specified for constructors",
7061                   ob_modifier);
7062       else
7063         cp_error ("`%D' can only be specified for objects and functions",
7064                   ob_modifier);
7065     }
7066
7067   return t;
7068 }
7069
7070 /* Called when a declaration is seen that contains no names to declare.
7071    If its type is a reference to a structure, union or enum inherited
7072    from a containing scope, shadow that tag name for the current scope
7073    with a forward reference.
7074    If its type defines a new named structure or union
7075    or defines an enum, it is valid but we need not do anything here.
7076    Otherwise, it is an error.
7077
7078    C++: may have to grok the declspecs to learn about static,
7079    complain for anonymous unions.  */
7080
7081 void
7082 shadow_tag (declspecs)
7083      tree declspecs;
7084 {
7085   tree t = check_tag_decl (declspecs);
7086
7087   if (t)
7088     maybe_process_partial_specialization (t);
7089
7090   /* This is where the variables in an anonymous union are
7091      declared.  An anonymous union declaration looks like:
7092      union { ... } ;
7093      because there is no declarator after the union, the parser
7094      sends that declaration here.  */
7095   if (t && ANON_AGGR_TYPE_P (t))
7096     {
7097       fixup_anonymous_aggr (t);
7098
7099       if (TYPE_FIELDS (t))
7100         {
7101           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7102                                       NULL_TREE);
7103           finish_anon_union (decl);
7104         }
7105     }
7106 }
7107 \f
7108 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7109
7110 tree
7111 groktypename (typename)
7112      tree typename;
7113 {
7114   if (TREE_CODE (typename) != TREE_LIST)
7115     return typename;
7116   return grokdeclarator (TREE_VALUE (typename),
7117                          TREE_PURPOSE (typename),
7118                          TYPENAME, 0, NULL_TREE);
7119 }
7120
7121 /* Decode a declarator in an ordinary declaration or data definition.
7122    This is called as soon as the type information and variable name
7123    have been parsed, before parsing the initializer if any.
7124    Here we create the ..._DECL node, fill in its type,
7125    and put it on the list of decls for the current context.
7126    The ..._DECL node is returned as the value.
7127
7128    Exception: for arrays where the length is not specified,
7129    the type is left null, to be filled in by `cp_finish_decl'.
7130
7131    Function definitions do not come here; they go to start_function
7132    instead.  However, external and forward declarations of functions
7133    do go through here.  Structure field declarations are done by
7134    grokfield and not through here.  */
7135
7136 tree
7137 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7138      tree declarator, declspecs;
7139      int initialized;
7140      tree attributes, prefix_attributes;
7141 {
7142   register tree decl;
7143   register tree type, tem;
7144   tree context;
7145   extern int have_extern_spec;
7146   extern int used_extern_spec;
7147   tree attrlist;
7148
7149 #if 0
7150   /* See code below that used this.  */
7151   int init_written = initialized;
7152 #endif
7153
7154   /* This should only be done once on the top most decl.  */
7155   if (have_extern_spec && !used_extern_spec)
7156     {
7157       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
7158                                   declspecs);
7159       used_extern_spec = 1;
7160     }
7161
7162   if (attributes || prefix_attributes)
7163     attrlist = build_tree_list (attributes, prefix_attributes);
7164   else
7165     attrlist = NULL_TREE;
7166
7167   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7168                          attrlist);
7169
7170   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7171     return NULL_TREE;
7172
7173   type = TREE_TYPE (decl);
7174
7175   if (type == error_mark_node)
7176     return NULL_TREE;
7177
7178   context = DECL_CONTEXT (decl);
7179
7180   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7181       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7182     {
7183       /* When parsing the initializer, lookup should use the object's
7184          namespace. */
7185       push_decl_namespace (context);
7186     }
7187
7188   /* We are only interested in class contexts, later. */
7189   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7190     context = NULL_TREE;
7191
7192   if (initialized)
7193     /* Is it valid for this decl to have an initializer at all?
7194        If not, set INITIALIZED to zero, which will indirectly
7195        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7196     switch (TREE_CODE (decl))
7197       {
7198       case TYPE_DECL:
7199         /* typedef foo = bar  means give foo the same type as bar.
7200            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7201            Any other case of an initialization in a TYPE_DECL is an error.  */
7202         if (pedantic || list_length (declspecs) > 1)
7203           {
7204             cp_error ("typedef `%D' is initialized", decl);
7205             initialized = 0;
7206           }
7207         break;
7208
7209       case FUNCTION_DECL:
7210         cp_error ("function `%#D' is initialized like a variable", decl);
7211         initialized = 0;
7212         break;
7213
7214       default:
7215         break;
7216       }
7217
7218   if (initialized)
7219     {
7220       if (! toplevel_bindings_p ()
7221           && DECL_EXTERNAL (decl))
7222         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7223                     decl);
7224       DECL_EXTERNAL (decl) = 0;
7225       if (toplevel_bindings_p ())
7226         TREE_STATIC (decl) = 1;
7227
7228       /* Tell `pushdecl' this is an initialized decl
7229          even though we don't yet have the initializer expression.
7230          Also tell `cp_finish_decl' it may store the real initializer.  */
7231       DECL_INITIAL (decl) = error_mark_node;
7232     }
7233
7234 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7235   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7236 #endif
7237
7238   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7239   cplus_decl_attributes (decl, attributes, prefix_attributes);
7240
7241   if (context && COMPLETE_TYPE_P (complete_type (context)))
7242     {
7243       push_nested_class (context, 2);
7244
7245       if (TREE_CODE (decl) == VAR_DECL)
7246         {
7247           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7248           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7249             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7250           else
7251             {
7252               if (DECL_CONTEXT (field) != context)
7253                 {
7254                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7255                               DECL_CONTEXT (field), DECL_NAME (decl),
7256                               context, DECL_NAME (decl));
7257                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7258                 }
7259               /* Static data member are tricky; an in-class initialization
7260                  still doesn't provide a definition, so the in-class
7261                  declaration will have DECL_EXTERNAL set, but will have an
7262                  initialization.  Thus, duplicate_decls won't warn
7263                  about this situation, and so we check here.  */
7264               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7265                 cp_error ("duplicate initialization of %D", decl);
7266               if (duplicate_decls (decl, field))
7267                 decl = field;
7268             }
7269         }
7270       else
7271         {
7272           tree field = check_classfn (context, decl);
7273           if (field && duplicate_decls (decl, field))
7274             decl = field;
7275         }
7276
7277       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7278       DECL_IN_AGGR_P (decl) = 0;
7279       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7280           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7281         {
7282           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7283           /* [temp.expl.spec] An explicit specialization of a static data
7284              member of a template is a definition if the declaration
7285              includes an initializer; otherwise, it is a declaration.
7286
7287              We check for processing_specialization so this only applies
7288              to the new specialization syntax.  */
7289           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7290             DECL_EXTERNAL (decl) = 1;
7291         }
7292
7293       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7294         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7295                     decl);
7296     }
7297
7298   /* Enter this declaration into the symbol table.  */
7299   tem = maybe_push_decl (decl);
7300
7301   if (processing_template_decl)
7302     tem = push_template_decl (tem);
7303
7304 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7305   /* Tell the back-end to use or not use .common as appropriate.  If we say
7306      -fconserve-space, we want this to save .data space, at the expense of
7307      wrong semantics.  If we say -fno-conserve-space, we want this to
7308      produce errors about redefs; to do this we force variables into the
7309      data segment.  */
7310   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7311 #endif
7312
7313   if (! processing_template_decl)
7314     start_decl_1 (tem);
7315
7316   return tem;
7317 }
7318
7319 void
7320 start_decl_1 (decl)
7321      tree decl;
7322 {
7323   tree type = TREE_TYPE (decl);
7324   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7325
7326   if (type == error_mark_node)
7327     return;
7328
7329   /* If this type of object needs a cleanup, but we're not allowed to
7330      add any more objects with cleanups to the current scope, create a
7331      new binding level.  */
7332   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7333       && current_binding_level->more_cleanups_ok == 0)
7334     {
7335       keep_next_level (2);
7336       pushlevel (1);
7337       clear_last_expr ();
7338       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7339     }
7340
7341   if (initialized)
7342     /* Is it valid for this decl to have an initializer at all?
7343        If not, set INITIALIZED to zero, which will indirectly
7344        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7345     {
7346       /* Don't allow initializations for incomplete types except for
7347          arrays which might be completed by the initialization.  */
7348       if (COMPLETE_TYPE_P (complete_type (type)))
7349         ;                       /* A complete type is ok.  */
7350       else if (TREE_CODE (type) != ARRAY_TYPE)
7351         {
7352           cp_error ("variable `%#D' has initializer but incomplete type",
7353                     decl);
7354           initialized = 0;
7355           type = TREE_TYPE (decl) = error_mark_node;
7356         }
7357       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7358         {
7359           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7360             cp_error ("elements of array `%#D' have incomplete type", decl);
7361           /* else we already gave an error in start_decl.  */
7362           initialized = 0;
7363         }
7364     }
7365
7366   if (!initialized
7367       && TREE_CODE (decl) != TYPE_DECL
7368       && TREE_CODE (decl) != TEMPLATE_DECL
7369       && type != error_mark_node
7370       && IS_AGGR_TYPE (type)
7371       && ! DECL_EXTERNAL (decl))
7372     {
7373       if ((! processing_template_decl || ! uses_template_parms (type))
7374           && !COMPLETE_TYPE_P (complete_type (type)))
7375         {
7376           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7377                  decl);
7378           /* Change the type so that assemble_variable will give
7379              DECL an rtl we can live with: (mem (const_int 0)).  */
7380           type = TREE_TYPE (decl) = error_mark_node;
7381         }
7382       else
7383         {
7384           /* If any base type in the hierarchy of TYPE needs a constructor,
7385              then we set initialized to 1.  This way any nodes which are
7386              created for the purposes of initializing this aggregate
7387              will live as long as it does.  This is necessary for global
7388              aggregates which do not have their initializers processed until
7389              the end of the file.  */
7390           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7391         }
7392     }
7393
7394   if (! initialized)
7395     DECL_INITIAL (decl) = NULL_TREE;
7396 }
7397
7398 /* Handle initialization of references.
7399    These three arguments are from `cp_finish_decl', and have the
7400    same meaning here that they do there.
7401
7402    Quotes on semantics can be found in ARM 8.4.3.  */
7403
7404 static void
7405 grok_reference_init (decl, type, init)
7406      tree decl, type, init;
7407 {
7408   tree tmp;
7409
7410   if (init == NULL_TREE)
7411     {
7412       if ((DECL_LANG_SPECIFIC (decl) == 0
7413            || DECL_IN_AGGR_P (decl) == 0)
7414           && ! DECL_THIS_EXTERN (decl))
7415         cp_error ("`%D' declared as reference but not initialized", decl);
7416       return;
7417     }
7418
7419   if (init == error_mark_node)
7420     return;
7421
7422   if (TREE_CODE (init) == CONSTRUCTOR)
7423     {
7424       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7425       return;
7426     }
7427
7428   if (TREE_CODE (init) == TREE_LIST)
7429     init = build_compound_expr (init);
7430
7431   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7432     init = convert_from_reference (init);
7433
7434   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7435       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7436     {
7437       /* Note: default conversion is only called in very special cases.  */
7438       init = default_conversion (init);
7439     }
7440
7441   /* Convert INIT to the reference type TYPE.  This may involve the
7442      creation of a temporary, whose lifetime must be the same as that
7443      of the reference.  If so, a DECL_STMT for the temporary will be
7444      added just after the DECL_STMT for DECL.  That's why we don't set
7445      DECL_INITIAL for local references (instead assigning to them
7446      explicitly); we need to allow the temporary to be initialized
7447      first.  */
7448   tmp = convert_to_reference
7449     (type, init, CONV_IMPLICIT,
7450      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7451      decl);
7452
7453   if (tmp == error_mark_node)
7454     return;
7455   else if (tmp != NULL_TREE)
7456     {
7457       init = tmp;
7458       tmp = save_expr (tmp);
7459       if (building_stmt_tree ())
7460         {
7461           /* Initialize the declaration.  */
7462           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7463           finish_expr_stmt (tmp);
7464         }
7465       else
7466         DECL_INITIAL (decl) = tmp;
7467     }
7468   else
7469     {
7470       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7471       return;
7472     }
7473
7474   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7475     {
7476       expand_static_init (decl, DECL_INITIAL (decl));
7477       DECL_INITIAL (decl) = NULL_TREE;
7478     }
7479   return;
7480 }
7481
7482 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7483    mucking with forces it does not comprehend (i.e. initialization with a
7484    constructor).  If we are at global scope and won't go into COMMON, fill
7485    it in with a dummy CONSTRUCTOR to force the variable into .data;
7486    otherwise we can use error_mark_node.  */
7487
7488 static tree
7489 obscure_complex_init (decl, init)
7490      tree decl, init;
7491 {
7492   if (! flag_no_inline && TREE_STATIC (decl))
7493     {
7494       if (extract_init (decl, init))
7495         return NULL_TREE;
7496     }
7497
7498 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7499   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7500     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7501                                  NULL_TREE);
7502   else
7503 #endif
7504     DECL_INITIAL (decl) = error_mark_node;
7505
7506   return init;
7507 }
7508
7509 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7510    array until we finish parsing the initializer.  If that's the
7511    situation we're in, update DECL accordingly.  */
7512
7513 static void
7514 maybe_deduce_size_from_array_init (decl, init)
7515      tree decl;
7516      tree init;
7517 {
7518   tree type = TREE_TYPE (decl);
7519
7520   if (TREE_CODE (type) == ARRAY_TYPE
7521       && TYPE_DOMAIN (type) == NULL_TREE
7522       && TREE_CODE (decl) != TYPE_DECL)
7523     {
7524       int do_default
7525         = (TREE_STATIC (decl)
7526            /* Even if pedantic, an external linkage array
7527               may have incomplete type at first.  */
7528            ? pedantic && ! DECL_EXTERNAL (decl)
7529            : !DECL_EXTERNAL (decl));
7530       tree initializer = init ? init : DECL_INITIAL (decl);
7531       int failure = complete_array_type (type, initializer, do_default);
7532
7533       if (failure == 1)
7534         cp_error ("initializer fails to determine size of `%D'", decl);
7535
7536       if (failure == 2)
7537         {
7538           if (do_default)
7539             cp_error ("array size missing in `%D'", decl);
7540           /* If a `static' var's size isn't known, make it extern as
7541              well as static, so it does not get allocated.  If it's not
7542              `static', then don't mark it extern; finish_incomplete_decl
7543              will give it a default size and it will get allocated.  */
7544           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7545             DECL_EXTERNAL (decl) = 1;
7546         }
7547
7548       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7549           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7550                               integer_zero_node))
7551         cp_error ("zero-size array `%D'", decl);
7552
7553       layout_decl (decl, 0);
7554     }
7555 }
7556
7557 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7558    any appropriate error messages regarding the layout.  */
7559
7560 static void
7561 layout_var_decl (decl)
7562      tree decl;
7563 {
7564   tree type = TREE_TYPE (decl);
7565 #if 0
7566   tree ttype = target_type (type);
7567 #endif
7568
7569   /* If we haven't already layed out this declaration, do so now.
7570      Note that we must not call complete type for an external object
7571      because it's type might involve templates that we are not
7572      supposed to isntantiate yet.  (And it's perfectly legal to say
7573      `extern X x' for some incomplete type `X'.)  */
7574   if (!DECL_EXTERNAL (decl))
7575     complete_type (type);
7576   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7577     layout_decl (decl, 0);
7578
7579   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7580     {
7581       /* An automatic variable with an incomplete type: that is an error.
7582          Don't talk about array types here, since we took care of that
7583          message in grokdeclarator.  */
7584       cp_error ("storage size of `%D' isn't known", decl);
7585       TREE_TYPE (decl) = error_mark_node;
7586     }
7587 #if 0
7588   /* Keep this code around in case we later want to control debug info
7589      based on whether a type is "used".  (jason 1999-11-11) */
7590
7591   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7592     /* Let debugger know it should output info for this type.  */
7593     note_debug_info_needed (ttype);
7594
7595   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7596     note_debug_info_needed (DECL_CONTEXT (decl));
7597 #endif
7598
7599   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7600       && DECL_SIZE (decl) != NULL_TREE
7601       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7602     {
7603       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7604         constant_expression_warning (DECL_SIZE (decl));
7605       else
7606         cp_error ("storage size of `%D' isn't constant", decl);
7607     }
7608 }
7609
7610 /* If a local static variable is declared in an inline function, or if
7611    we have a weak definition, we must endeavor to create only one
7612    instance of the variable at link-time.  */
7613
7614 static void
7615 maybe_commonize_var (decl)
7616      tree decl;
7617 {
7618   /* Static data in a function with comdat linkage also has comdat
7619      linkage.  */
7620   if (TREE_STATIC (decl)
7621       /* Don't mess with __FUNCTION__.  */
7622       && ! DECL_ARTIFICIAL (decl)
7623       && current_function_decl
7624       && DECL_CONTEXT (decl) == current_function_decl
7625       && (DECL_THIS_INLINE (current_function_decl)
7626           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7627       && TREE_PUBLIC (current_function_decl))
7628     {
7629       /* Rather than try to get this right with inlining, we suppress
7630          inlining of such functions.  */
7631       current_function_cannot_inline
7632         = "function with static variable cannot be inline";
7633
7634       /* If flag_weak, we don't need to mess with this, as we can just
7635          make the function weak, and let it refer to its unique local
7636          copy.  This works because we don't allow the function to be
7637          inlined.  */
7638       if (! flag_weak)
7639         {
7640           if (DECL_INTERFACE_KNOWN (current_function_decl))
7641             {
7642               TREE_PUBLIC (decl) = 1;
7643               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7644             }
7645           else if (DECL_INITIAL (decl) == NULL_TREE
7646                    || DECL_INITIAL (decl) == error_mark_node)
7647             {
7648               TREE_PUBLIC (decl) = 1;
7649               DECL_COMMON (decl) = 1;
7650             }
7651           /* else we lose. We can only do this if we can use common,
7652              which we can't if it has been initialized.  */
7653
7654           if (TREE_PUBLIC (decl))
7655             DECL_ASSEMBLER_NAME (decl)
7656               = build_static_name (current_function_decl, DECL_NAME (decl));
7657           else
7658             {
7659               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7660               cp_warning_at ("  you can work around this by removing the initializer", decl);
7661             }
7662         }
7663     }
7664   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7665     /* Set it up again; we might have set DECL_INITIAL since the last
7666        time.  */
7667     comdat_linkage (decl);
7668 }
7669
7670 /* Issue an error message if DECL is an uninitialized const variable.  */
7671
7672 static void
7673 check_for_uninitialized_const_var (decl)
7674      tree decl;
7675 {
7676   tree type = TREE_TYPE (decl);
7677
7678   /* ``Unless explicitly declared extern, a const object does not have
7679      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7680      7.1.6 */
7681   if (TREE_CODE (decl) == VAR_DECL
7682       && TREE_CODE (type) != REFERENCE_TYPE
7683       && CP_TYPE_CONST_P (type)
7684       && !TYPE_NEEDS_CONSTRUCTING (type)
7685       && !DECL_INITIAL (decl))
7686     cp_error ("uninitialized const `%D'", decl);
7687 }
7688
7689 /* Verify INIT (the initializer for DECL), and record the
7690    initialization in DECL_INITIAL, if appropriate.  Returns a new
7691    value for INIT.  */
7692
7693 static tree
7694 check_initializer (decl, init)
7695      tree decl;
7696      tree init;
7697 {
7698   tree type;
7699
7700   if (TREE_CODE (decl) == FIELD_DECL)
7701     return init;
7702
7703   type = TREE_TYPE (decl);
7704
7705   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7706   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7707     init = NULL_TREE;
7708
7709   /* Check the initializer.  */
7710   if (init)
7711     {
7712       /* Things that are going to be initialized need to have complete
7713          type.  */
7714       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7715
7716       if (type == error_mark_node)
7717         /* We will have already complained.  */
7718         init = NULL_TREE;
7719       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7720         {
7721           cp_error ("variable-sized object `%D' may not be initialized", decl);
7722           init = NULL_TREE;
7723         }
7724       else if (TREE_CODE (type) == ARRAY_TYPE
7725                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7726         {
7727           cp_error ("elements of array `%#D' have incomplete type", decl);
7728           init = NULL_TREE;
7729         }
7730       else if (!COMPLETE_TYPE_P (type))
7731         {
7732           cp_error ("`%D' has incomplete type", decl);
7733           TREE_TYPE (decl) = error_mark_node;
7734           init = NULL_TREE;
7735         }
7736     }
7737
7738   if (TREE_CODE (decl) == CONST_DECL)
7739     {
7740       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7741
7742       DECL_INITIAL (decl) = init;
7743
7744       /* This will keep us from needing to worry about our obstacks.  */
7745       my_friendly_assert (init != NULL_TREE, 149);
7746       init = NULL_TREE;
7747     }
7748   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7749     {
7750       if (TREE_STATIC (decl))
7751         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7752       grok_reference_init (decl, type, init);
7753       init = NULL_TREE;
7754     }
7755   else if (init)
7756     {
7757       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7758         {
7759           if (TREE_CODE (type) == ARRAY_TYPE)
7760             init = digest_init (type, init, (tree *) 0);
7761           else if (TREE_CODE (init) == CONSTRUCTOR
7762                    && TREE_HAS_CONSTRUCTOR (init))
7763             {
7764               if (TYPE_NON_AGGREGATE_CLASS (type))
7765                 {
7766                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7767                             decl);
7768                   init = error_mark_node;
7769                 }
7770               else
7771                 goto dont_use_constructor;
7772             }
7773         }
7774       else
7775         {
7776         dont_use_constructor:
7777           if (TREE_CODE (init) != TREE_VEC)
7778             init = store_init_value (decl, init);
7779         }
7780
7781       if (init)
7782         /* We must hide the initializer so that expand_decl
7783            won't try to do something it does not understand.  */
7784         init = obscure_complex_init (decl, init);
7785     }
7786   else if (DECL_EXTERNAL (decl))
7787     ;
7788   else if (TYPE_P (type)
7789            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7790     {
7791       tree core_type = strip_array_types (type);
7792
7793       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7794         {
7795           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7796             cp_error ("structure `%D' with uninitialized const members", decl);
7797           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7798             cp_error ("structure `%D' with uninitialized reference members",
7799                       decl);
7800         }
7801
7802       check_for_uninitialized_const_var (decl);
7803
7804       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7805         init = obscure_complex_init (decl, NULL_TREE);
7806
7807     }
7808   else
7809     check_for_uninitialized_const_var (decl);
7810
7811   return init;
7812 }
7813
7814 /* If DECL is not a local variable, give it RTL.  */
7815
7816 static void
7817 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7818      tree decl;
7819      tree init;
7820      const char *asmspec;
7821 {
7822   int toplev;
7823   tree type;
7824
7825   type = TREE_TYPE (decl);
7826   toplev = toplevel_bindings_p ();
7827
7828   /* Handle non-variables up front.  */
7829   if (TREE_CODE (decl) != VAR_DECL)
7830     {
7831       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7832       return;
7833     }
7834
7835   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7836   if (asmspec)
7837     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7838
7839   if (DECL_VIRTUAL_P (decl))
7840     make_decl_rtl (decl, NULL_PTR, toplev);
7841   else if (TREE_READONLY (decl)
7842            && DECL_INITIAL (decl) != NULL_TREE
7843            && DECL_INITIAL (decl) != error_mark_node
7844            && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7845     {
7846       DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
7847
7848       if (toplev && ! TREE_PUBLIC (decl))
7849         {
7850           /* If this is a static const, change its apparent linkage
7851              if it belongs to a #pragma interface.  */
7852           if (!interface_unknown)
7853             {
7854               TREE_PUBLIC (decl) = 1;
7855               DECL_EXTERNAL (decl) = interface_only;
7856             }
7857           make_decl_rtl (decl, asmspec, toplev);
7858         }
7859       else if (toplev)
7860         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7861     }
7862   else if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7863     {
7864       my_friendly_assert (TREE_STATIC (decl), 19990828);
7865
7866       if (init == NULL_TREE
7867 #ifdef DEFAULT_STATIC_DEFS
7868           /* If this code is dead, then users must
7869              explicitly declare static member variables
7870              outside the class def'n as well.  */
7871           && TYPE_NEEDS_CONSTRUCTING (type)
7872 #endif
7873           )
7874         {
7875           DECL_EXTERNAL (decl) = 1;
7876           make_decl_rtl (decl, asmspec, 1);
7877         }
7878       else
7879         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7880     }
7881   else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == NAMESPACE_DECL
7882            || (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)))
7883     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7884 }
7885
7886 /* Create RTL for the local static variable DECL.  */
7887
7888 void
7889 make_rtl_for_local_static (decl)
7890      tree decl;
7891 {
7892   const char *asmspec = NULL;
7893
7894   /* If we inlined this variable, we could see it's declaration
7895      again.  */
7896   if (DECL_RTL (decl))
7897     return;
7898
7899   if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7900     {
7901       /* The only way this situaton can occur is if the
7902          user specified a name for this DECL using the
7903          `attribute' syntax.  */
7904       asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
7905       DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
7906     }
7907
7908   rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
7909 }
7910
7911 /* The old ARM scoping rules injected variables declared in the
7912    initialization statement of a for-statement into the surrounding
7913    scope.  We support this usage, in order to be backward-compatible.
7914    DECL is a just-declared VAR_DECL; if necessary inject its
7915    declaration into the surrounding scope.  */
7916
7917 void
7918 maybe_inject_for_scope_var (decl)
7919      tree decl;
7920 {
7921   if (current_binding_level->is_for_scope)
7922     {
7923       struct binding_level *outer
7924         = current_binding_level->level_chain;
7925
7926       /* Check to see if the same name is already bound at the outer
7927          level, either because it was directly declared, or because a
7928          dead for-decl got preserved.  In either case, the code would
7929          not have been valid under the ARM scope rules, so clear
7930          is_for_scope for the current_binding_level.
7931
7932          Otherwise, we need to preserve the temp slot for decl to last
7933          into the outer binding level.  */
7934
7935       tree outer_binding
7936         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7937
7938       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7939           && (TREE_CODE (BINDING_VALUE (outer_binding))
7940               == VAR_DECL)
7941           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7942         {
7943           BINDING_VALUE (outer_binding)
7944             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7945           current_binding_level->is_for_scope = 0;
7946         }
7947       else if (DECL_IN_MEMORY_P (decl))
7948         preserve_temp_slots (DECL_RTL (decl));
7949     }
7950 }
7951
7952 /* Generate code to initialize DECL (a local variable).  */
7953
7954 void
7955 initialize_local_var (decl, init, flags)
7956      tree decl;
7957      tree init;
7958      int flags;
7959 {
7960   tree type = TREE_TYPE (decl);
7961
7962   /* If the type is bogus, don't bother initializing the variable.  */
7963   if (type == error_mark_node)
7964     return;
7965
7966   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7967     {
7968       /* If we used it already as memory, it must stay in memory.  */
7969       DECL_INITIAL (decl) = NULL_TREE;
7970       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7971     }
7972
7973   /* Local statics are handled differently from ordinary automatic
7974      variables.  */
7975   if (TREE_STATIC (decl))
7976     {
7977       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7978           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7979         expand_static_init (decl, init);
7980       return;
7981     }
7982
7983   if (DECL_SIZE (decl) && type != error_mark_node)
7984     {
7985       int already_used;
7986
7987       /* Compute and store the initial value.  */
7988       already_used = TREE_USED (decl) || TREE_USED (type);
7989
7990       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7991         {
7992           int saved_stmts_are_full_exprs_p;
7993
7994           emit_line_note (DECL_SOURCE_FILE (decl),
7995                           DECL_SOURCE_LINE (decl));
7996           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p;
7997           stmts_are_full_exprs_p = 1;
7998           if (building_stmt_tree ())
7999             finish_expr_stmt (build_aggr_init (decl, init, flags));
8000           else
8001             genrtl_expr_stmt (build_aggr_init (decl, init, flags));
8002           stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
8003         }
8004
8005       /* Set this to 0 so we can tell whether an aggregate which was
8006          initialized was ever used.  Don't do this if it has a
8007          destructor, so we don't complain about the 'resource
8008          allocation is initialization' idiom.  Now set
8009          attribute((unused)) on types so decls of that type will be
8010          marked used. (see TREE_USED, above.)  */
8011       if (TYPE_NEEDS_CONSTRUCTING (type)
8012           && ! already_used
8013           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
8014           && DECL_NAME (decl))
8015         TREE_USED (decl) = 0;
8016       else if (already_used)
8017         TREE_USED (decl) = 1;
8018     }
8019 }
8020
8021 /* Generate code to destroy DECL (a local variable).  */
8022
8023 static void
8024 destroy_local_var (decl)
8025      tree decl;
8026 {
8027   tree type = TREE_TYPE (decl);
8028   tree cleanup;
8029
8030   /* Only variables get cleaned up.  */
8031   if (TREE_CODE (decl) != VAR_DECL)
8032     return;
8033
8034   /* And only things with destructors need cleaning up.  */
8035   if (type == error_mark_node
8036       || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
8037     return;
8038
8039   if (TREE_CODE (decl) == VAR_DECL &&
8040       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
8041     /* We don't clean up things that aren't defined in this
8042        translation unit, or that need a static cleanup.  The latter
8043        are handled by finish_file.  */
8044     return;
8045
8046   /* Compute the cleanup.  */
8047   cleanup = maybe_build_cleanup (decl);
8048
8049   /* Record the cleanup required for this declaration.  */
8050   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
8051       && cleanup)
8052     finish_decl_cleanup (decl, cleanup);
8053 }
8054
8055 /* Let the back-end know about DECL.  */
8056
8057 void
8058 emit_local_var (decl)
8059      tree decl;
8060 {
8061   /* Create RTL for this variable.  */
8062   if (DECL_RTL (decl))
8063     /* Only a RESULT_DECL should have non-NULL RTL when arriving here.
8064        All other local variables are assigned RTL in this function.  */
8065     my_friendly_assert (TREE_CODE (decl) == RESULT_DECL,
8066                         19990828);
8067   else
8068     {
8069       if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
8070         /* The user must have specified an assembler name for this
8071            variable.  Set that up now.  */
8072         rest_of_decl_compilation
8073           (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
8074            /*top_level=*/0, /*at_end=*/0);
8075       else
8076         expand_decl (decl);
8077     }
8078
8079   /* Actually do the initialization.  */
8080   if (stmts_are_full_exprs_p)
8081     expand_start_target_temps ();
8082
8083   expand_decl_init (decl);
8084
8085   if (stmts_are_full_exprs_p)
8086     expand_end_target_temps ();
8087 }
8088
8089 /* Finish processing of a declaration;
8090    install its line number and initial value.
8091    If the length of an array type is not known before,
8092    it must be determined now, from the initial value, or it is an error.
8093
8094    INIT0 holds the value of an initializer that should be allowed to escape
8095    the normal rules.
8096
8097    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8098    if the (init) syntax was used.  */
8099
8100 void
8101 cp_finish_decl (decl, init, asmspec_tree, flags)
8102      tree decl, init;
8103      tree asmspec_tree;
8104      int flags;
8105 {
8106   register tree type;
8107   tree ttype = NULL_TREE;
8108   const char *asmspec = NULL;
8109   int was_readonly = 0;
8110
8111   if (! decl)
8112     {
8113       if (init)
8114         error ("assignment (not initialization) in declaration");
8115       return;
8116     }
8117
8118   /* If a name was specified, get the string.  */
8119   if (asmspec_tree)
8120       asmspec = TREE_STRING_POINTER (asmspec_tree);
8121
8122   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8123     {
8124       cp_error ("cannot initialize `%D' to namespace `%D'",
8125                 decl, init);
8126       init = NULL_TREE;
8127     }
8128
8129   if (current_class_type
8130       && CP_DECL_CONTEXT (decl) == current_class_type
8131       && TYPE_BEING_DEFINED (current_class_type)
8132       && (DECL_INITIAL (decl) || init))
8133     DECL_DEFINED_IN_CLASS_P (decl) = 1;
8134
8135   if (TREE_CODE (decl) == VAR_DECL
8136       && DECL_CONTEXT (decl)
8137       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8138       && DECL_CONTEXT (decl) != current_namespace
8139       && init)
8140     {
8141       /* Leave the namespace of the object. */
8142       pop_decl_namespace ();
8143     }
8144
8145   type = TREE_TYPE (decl);
8146
8147   if (type == error_mark_node)
8148     return;
8149
8150   /* Add this declaration to the statement-tree.  */
8151   if (building_stmt_tree () && at_function_scope_p ())
8152     add_decl_stmt (decl);
8153
8154   if (TYPE_HAS_MUTABLE_P (type))
8155     TREE_READONLY (decl) = 0;
8156
8157   if (processing_template_decl)
8158     {
8159       if (init && DECL_INITIAL (decl))
8160         DECL_INITIAL (decl) = init;
8161       goto finish_end0;
8162     }
8163
8164   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8165   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8166
8167   /* Take care of TYPE_DECLs up front.  */
8168   if (TREE_CODE (decl) == TYPE_DECL)
8169     {
8170       if (init && DECL_INITIAL (decl))
8171         {
8172           /* typedef foo = bar; store the type of bar as the type of foo.  */
8173           TREE_TYPE (decl) = type = TREE_TYPE (init);
8174           DECL_INITIAL (decl) = init = NULL_TREE;
8175         }
8176       if (type != error_mark_node
8177           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8178         {
8179           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8180             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8181           set_identifier_type_value (DECL_NAME (decl), type);
8182           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8183         }
8184       GNU_xref_decl (current_function_decl, decl);
8185
8186       /* If we have installed this as the canonical typedef for this
8187          type, and that type has not been defined yet, delay emitting
8188          the debug information for it, as we will emit it later.  */
8189       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8190           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8191         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8192
8193       rest_of_decl_compilation (decl, NULL_PTR,
8194                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8195       goto finish_end;
8196     }
8197
8198   if (TREE_CODE (decl) != FUNCTION_DECL)
8199     ttype = target_type (type);
8200
8201   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8202       && TYPE_NEEDS_CONSTRUCTING (type))
8203     {
8204       /* Currently, GNU C++ puts constants in text space, making them
8205          impossible to initialize.  In the future, one would hope for
8206          an operating system which understood the difference between
8207          initialization and the running of a program.  */
8208       was_readonly = 1;
8209       TREE_READONLY (decl) = 0;
8210     }
8211
8212   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8213     {
8214       /* This must override the asm specifier which was placed by
8215          grokclassfn.  Lay this out fresh.  */
8216       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8217       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8218       make_decl_rtl (decl, asmspec, 0);
8219     }
8220
8221   /* Deduce size of array from initialization, if not already known.  */
8222   maybe_deduce_size_from_array_init (decl, init);
8223   init = check_initializer (decl, init);
8224
8225   GNU_xref_decl (current_function_decl, decl);
8226
8227   if (TREE_CODE (decl) == VAR_DECL)
8228     layout_var_decl (decl);
8229
8230   /* Output the assembler code and/or RTL code for variables and functions,
8231      unless the type is an undefined structure or union.
8232      If not, it will get done when the type is completed.  */
8233   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8234       || TREE_CODE (decl) == RESULT_DECL)
8235     {
8236       if (TREE_CODE (decl) == VAR_DECL)
8237         maybe_commonize_var (decl);
8238
8239       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8240
8241       if (TREE_CODE (type) == FUNCTION_TYPE
8242           || TREE_CODE (type) == METHOD_TYPE)
8243         abstract_virtuals_error (decl,
8244                                  strip_array_types (TREE_TYPE (type)));
8245       else
8246         abstract_virtuals_error (decl, strip_array_types (type));
8247
8248       if (TREE_CODE (decl) == FUNCTION_DECL)
8249         ;
8250       else if (DECL_EXTERNAL (decl)
8251                && ! (DECL_LANG_SPECIFIC (decl)
8252                      && DECL_NOT_REALLY_EXTERN (decl)))
8253         {
8254           if (init)
8255             DECL_INITIAL (decl) = init;
8256         }
8257       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8258         {
8259           /* This is a local declaration.  */
8260           if (doing_semantic_analysis_p ())
8261             maybe_inject_for_scope_var (decl);
8262           /* Initialize the local variable.  But, if we're building a
8263              statement-tree, we'll do the initialization when we
8264              expand the tree.  */
8265           if (processing_template_decl)
8266             {
8267               if (init || DECL_INITIAL (decl) == error_mark_node)
8268                 DECL_INITIAL (decl) = init;
8269             }
8270           else
8271             {
8272               /* If we're not building RTL, then we need to do so
8273                  now.  */
8274               if (!building_stmt_tree ())
8275                 emit_local_var (decl);
8276               /* Initialize the variable.  */
8277               initialize_local_var (decl, init, flags);
8278               /* Clean up the variable.  */
8279               destroy_local_var (decl);
8280             }
8281         }
8282       else if (TREE_STATIC (decl) && type != error_mark_node)
8283         {
8284           /* Cleanups for static variables are handled by `finish_file'.  */
8285           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8286               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8287             expand_static_init (decl, init);
8288         }
8289     finish_end0:
8290
8291       /* Undo call to `pushclass' that was done in `start_decl'
8292          due to initialization of qualified member variable.
8293          I.e., Foo::x = 10;  */
8294       {
8295         tree context = CP_DECL_CONTEXT (decl);
8296         if (context
8297             && TYPE_P (context)
8298             && (TREE_CODE (decl) == VAR_DECL
8299                 /* We also have a pushclass done that we need to undo here
8300                    if we're at top level and declare a method.  */
8301                 || TREE_CODE (decl) == FUNCTION_DECL)
8302             /* If size hasn't been set, we're still defining it,
8303                and therefore inside the class body; don't pop
8304                the binding level..  */
8305             && COMPLETE_TYPE_P (context)
8306             && context == current_class_type)
8307           pop_nested_class ();
8308       }
8309     }
8310
8311  finish_end:
8312
8313   if (was_readonly)
8314     TREE_READONLY (decl) = 1;
8315 }
8316
8317 /* This is here for a midend callback from c-common.c */
8318
8319 void
8320 finish_decl (decl, init, asmspec_tree)
8321      tree decl, init;
8322      tree asmspec_tree;
8323 {
8324   cp_finish_decl (decl, init, asmspec_tree, 0);
8325 }
8326
8327 /* Returns a declaration for a VAR_DECL as if:
8328
8329      extern "C" TYPE NAME;
8330
8331    had been seen.  Used to create compiler-generated global
8332    variables.  */
8333
8334 tree
8335 declare_global_var (name, type)
8336      tree name;
8337      tree type;
8338 {
8339   tree decl;
8340
8341   push_to_top_level ();
8342   decl = build_decl (VAR_DECL, name, type);
8343   TREE_PUBLIC (decl) = 1;
8344   DECL_EXTERNAL (decl) = 1;
8345   DECL_ARTIFICIAL (decl) = 1;
8346   pushdecl (decl);
8347   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8348   pop_from_top_level ();
8349
8350   return decl;
8351 }
8352
8353 /* Returns a pointer to the `atexit' function.  Note that if
8354    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8355    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8356
8357 static tree
8358 get_atexit_node ()
8359 {
8360   tree atexit_fndecl;
8361   tree arg_types;
8362   tree fn_type;
8363   tree fn_ptr_type;
8364   const char *name;
8365
8366   if (atexit_node)
8367     return atexit_node;
8368
8369   if (flag_use_cxa_atexit)
8370     {
8371       /* The declaration for `__cxa_atexit' is:
8372
8373            int __cxa_atexit (void (*)(void *), void *, void *)
8374
8375          We build up the argument types and then then function type
8376          itself.  */
8377
8378       /* First, build the pointer-to-function type for the first
8379          argument.  */
8380       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8381       fn_type = build_function_type (void_type_node, arg_types);
8382       fn_ptr_type = build_pointer_type (fn_type);
8383       /* Then, build the rest of the argument types.  */
8384       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8385       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8386       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8387       /* And the final __cxa_atexit type.  */
8388       fn_type = build_function_type (integer_type_node, arg_types);
8389       fn_ptr_type = build_pointer_type (fn_type);
8390       name = "__cxa_atexit";
8391     }
8392   else
8393     {
8394       /* The declaration for `atexit' is:
8395
8396            int atexit (void (*)());
8397
8398          We build up the argument types and then then function type
8399          itself.  */
8400       fn_type = build_function_type (void_type_node, void_list_node);
8401       fn_ptr_type = build_pointer_type (fn_type);
8402       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8403       /* Build the final atexit type.  */
8404       fn_type = build_function_type (integer_type_node, arg_types);
8405       name = "atexit";
8406     }
8407
8408   /* Now, build the function declaration.  */
8409   push_lang_context (lang_name_c);
8410   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8411   mark_used (atexit_fndecl);
8412   pop_lang_context ();
8413   atexit_node = default_conversion (atexit_fndecl);
8414
8415   return atexit_node;
8416 }
8417
8418 /* Returns the __dso_handle VAR_DECL.  */
8419
8420 static tree
8421 get_dso_handle_node ()
8422 {
8423   if (dso_handle_node)
8424     return dso_handle_node;
8425
8426   /* Declare the variable.  */
8427   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8428                                         ptr_type_node);
8429
8430   return dso_handle_node;
8431 }
8432
8433 /* Begin a new function with internal linkage whose job will be simply
8434    to destroy some particular variable.  */
8435
8436 static tree
8437 start_cleanup_fn ()
8438 {
8439   static int counter = 0;
8440   int old_interface_unknown = interface_unknown;
8441   char name[32];
8442   tree parmtypes;
8443   tree fntype;
8444   tree fndecl;
8445
8446   push_to_top_level ();
8447
8448   /* No need to mangle this.  */
8449   push_lang_context (lang_name_c);
8450
8451   interface_unknown = 1;
8452
8453   /* Build the parameter-types.  */
8454   parmtypes = void_list_node;
8455   /* Functions passed to __cxa_atexit take an additional parameter.
8456      We'll just ignore it.  After we implement the new calling
8457      convention for destructors, we can eliminate the use of
8458      additional cleanup functions entirely in the -fnew-abi case.  */
8459   if (flag_use_cxa_atexit)
8460     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8461   /* Build the function type itself.  */
8462   fntype = build_function_type (void_type_node, parmtypes);
8463   /* Build the name of the function.  */
8464   sprintf (name, "__tcf_%d", counter++);
8465   /* Build the function declaration.  */
8466   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8467   /* It's a function with internal linkage, generated by the
8468      compiler.  */
8469   TREE_PUBLIC (fndecl) = 0;
8470   DECL_ARTIFICIAL (fndecl) = 1;
8471   /* Build the parameter.  */
8472   if (flag_use_cxa_atexit)
8473     {
8474       tree parmdecl;
8475
8476       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8477       DECL_CONTEXT (parmdecl) = fndecl;
8478       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8479       TREE_USED (parmdecl) = 1;
8480       DECL_ARGUMENTS (fndecl) = parmdecl;
8481     }
8482
8483   pushdecl (fndecl);
8484   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8485   do_pushlevel ();
8486
8487   interface_unknown = old_interface_unknown;
8488
8489   pop_lang_context ();
8490
8491   return current_function_decl;
8492 }
8493
8494 /* Finish the cleanup function begun by start_cleanup_fn.  */
8495
8496 static void
8497 end_cleanup_fn ()
8498 {
8499   do_poplevel ();
8500
8501   expand_body (finish_function (0));
8502
8503   pop_from_top_level ();
8504 }
8505
8506 /* Generate code to handle the destruction of DECL, an object with
8507    static storage duration.  */
8508
8509 void
8510 register_dtor_fn (decl)
8511      tree decl;
8512 {
8513   tree cleanup;
8514   tree compound_stmt;
8515   tree args;
8516   tree fcall;
8517
8518   int saved_flag_access_control;
8519
8520   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8521     return;
8522
8523   /* Call build_cleanup before we enter the anonymous function so that
8524      any access checks will be done relative to the current scope,
8525      rather than the scope of the anonymous function.  */
8526   build_cleanup (decl);
8527
8528   /* Now start the function.  */
8529   cleanup = start_cleanup_fn ();
8530
8531   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8532      to the original function, rather than the anonymous one.  That
8533      will make the back-end think that nested functions are in use,
8534      which causes confusion.  */
8535   saved_flag_access_control = flag_access_control;
8536   flag_access_control = 0;
8537   fcall = build_cleanup (decl);
8538   flag_access_control = saved_flag_access_control;
8539
8540   /* Create the body of the anonymous function.  */
8541   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8542   finish_expr_stmt (fcall);
8543   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8544   end_cleanup_fn ();
8545
8546   /* Call atexit with the cleanup function.  */
8547   mark_addressable (cleanup);
8548   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8549   if (flag_use_cxa_atexit)
8550     {
8551       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8552       args = tree_cons (NULL_TREE, null_pointer_node, args);
8553       args = tree_cons (NULL_TREE, cleanup, args);
8554     }
8555   else
8556     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8557   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8558 }
8559
8560 void
8561 expand_static_init (decl, init)
8562      tree decl;
8563      tree init;
8564 {
8565   tree oldstatic = value_member (decl, static_aggregates);
8566
8567   if (oldstatic)
8568     {
8569       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8570         cp_error ("multiple initializations given for `%D'", decl);
8571     }
8572   else if (! toplevel_bindings_p ())
8573     {
8574       /* Emit code to perform this initialization but once.  */
8575       tree temp;
8576       tree if_stmt;
8577       tree then_clause;
8578       tree assignment;
8579       tree temp_init;
8580
8581       /* Emit code to perform this initialization but once.  This code
8582          looks like:
8583
8584            static int temp = 0;
8585            if (!temp) {
8586              // Do initialization.
8587              temp = 1;
8588              // Register variable for destruction at end of program.
8589            }
8590
8591          Note that the `temp' variable is only set to 1 *after* the
8592          initialization is complete.  This ensures that an exception,
8593          thrown during the construction, will cause the variable to
8594          reinitialized when we pass through this code again, as per:
8595
8596            [stmt.dcl]
8597
8598            If the initialization exits by throwing an exception, the
8599            initialization is not complete, so it will be tried again
8600            the next time control enters the declaration.
8601
8602          In theory, this process should be thread-safe, too; multiple
8603          threads should not be able to initialize the variable more
8604          than once.  We don't yet attempt to ensure thread-safety.  */
8605       temp = get_temp_name (integer_type_node, 1);
8606       rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
8607
8608       /* Begin the conditional initialization.  */
8609       if_stmt = begin_if_stmt ();
8610       finish_if_stmt_cond (build_binary_op (EQ_EXPR, temp,
8611                                             integer_zero_node),
8612                            if_stmt);
8613       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8614
8615       /* Do the initialization itself.  */
8616       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8617           || (init && TREE_CODE (init) == TREE_LIST))
8618         assignment = build_aggr_init (decl, init, 0);
8619       else if (init)
8620         /* The initialization we're doing here is just a bitwise
8621            copy.  */
8622         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8623       else
8624         assignment = NULL_TREE;
8625
8626       /* Once the assignment is complete, set TEMP to 1.  Since the
8627          construction of the static object is complete at this point,
8628          we want to make sure TEMP is set to 1 even if a temporary
8629          constructed during the initialization throws an exception
8630          when it is destroyed.  So, we combine the initialization and
8631          the assignment to TEMP into a single expression, ensuring
8632          that when we call finish_expr_stmt the cleanups will not be
8633          run until after TEMP is set to 1.  */
8634       temp_init = build_modify_expr (temp, NOP_EXPR, integer_one_node);
8635       if (assignment)
8636         {
8637           assignment = tree_cons (NULL_TREE, assignment,
8638                                   build_tree_list (NULL_TREE,
8639                                                    temp_init));
8640           assignment = build_compound_expr (assignment);
8641         }
8642       else
8643         assignment = temp_init;
8644       finish_expr_stmt (assignment);
8645
8646       /* Use atexit to register a function for destroying this static
8647          variable.  */
8648       register_dtor_fn (decl);
8649
8650       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8651       finish_then_clause (if_stmt);
8652       finish_if_stmt ();
8653     }
8654   else
8655     static_aggregates = tree_cons (init, decl, static_aggregates);
8656 }
8657
8658 /* Finish the declaration of a catch-parameter.  */
8659
8660 tree
8661 start_handler_parms (declspecs, declarator)
8662      tree declspecs;
8663      tree declarator;
8664 {
8665   tree decl;
8666   if (declspecs)
8667     {
8668       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8669                              1, NULL_TREE);
8670       if (decl == NULL_TREE)
8671         error ("invalid catch parameter");
8672     }
8673   else
8674     decl = NULL_TREE;
8675
8676   return decl;
8677 }
8678
8679 \f
8680 /* Make TYPE a complete type based on INITIAL_VALUE.
8681    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8682    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8683
8684 int
8685 complete_array_type (type, initial_value, do_default)
8686      tree type, initial_value;
8687      int do_default;
8688 {
8689   register tree maxindex = NULL_TREE;
8690   int value = 0;
8691
8692   if (initial_value)
8693     {
8694       /* Note MAXINDEX  is really the maximum index,
8695          one less than the size.  */
8696       if (TREE_CODE (initial_value) == STRING_CST)
8697         {
8698           int eltsize
8699             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8700           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8701                                    / eltsize) - 1, 0);
8702         }
8703       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8704         {
8705           tree elts = CONSTRUCTOR_ELTS (initial_value);
8706
8707           maxindex = ssize_int (-1);
8708           for (; elts; elts = TREE_CHAIN (elts))
8709             {
8710               if (TREE_PURPOSE (elts))
8711                 maxindex = TREE_PURPOSE (elts);
8712               else
8713                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8714             }
8715           maxindex = copy_node (maxindex);
8716         }
8717       else
8718         {
8719           /* Make an error message unless that happened already.  */
8720           if (initial_value != error_mark_node)
8721             value = 1;
8722           else
8723             initial_value = NULL_TREE;
8724
8725           /* Prevent further error messages.  */
8726           maxindex = build_int_2 (0, 0);
8727         }
8728     }
8729
8730   if (!maxindex)
8731     {
8732       if (do_default)
8733         maxindex = build_int_2 (0, 0);
8734       value = 2;
8735     }
8736
8737   if (maxindex)
8738     {
8739       tree itype;
8740       tree domain;
8741
8742       domain = build_index_type (maxindex);
8743       TYPE_DOMAIN (type) = domain;
8744
8745       if (! TREE_TYPE (maxindex))
8746         TREE_TYPE (maxindex) = domain;
8747       if (initial_value)
8748         itype = TREE_TYPE (initial_value);
8749       else
8750         itype = NULL;
8751       if (itype && !TYPE_DOMAIN (itype))
8752         TYPE_DOMAIN (itype) = domain;
8753       /* The type of the main variant should never be used for arrays
8754          of different sizes.  It should only ever be completed with the
8755          size of the array.  */
8756       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8757         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8758     }
8759
8760   /* Lay out the type now that we can get the real answer.  */
8761
8762   layout_type (type);
8763
8764   return value;
8765 }
8766 \f
8767 /* Return zero if something is declared to be a member of type
8768    CTYPE when in the context of CUR_TYPE.  STRING is the error
8769    message to print in that case.  Otherwise, quietly return 1.  */
8770
8771 static int
8772 member_function_or_else (ctype, cur_type, flags)
8773      tree ctype, cur_type;
8774      enum overload_flags flags;
8775 {
8776   if (ctype && ctype != cur_type)
8777     {
8778       if (flags == DTOR_FLAG)
8779         error ("destructor for alien class `%s' cannot be a member",
8780                TYPE_NAME_STRING (ctype));
8781       else
8782         error ("constructor for alien class `%s' cannot be a member",
8783                TYPE_NAME_STRING (ctype));
8784       return 0;
8785     }
8786   return 1;
8787 }
8788 \f
8789 /* Subroutine of `grokdeclarator'.  */
8790
8791 /* Generate errors possibly applicable for a given set of specifiers.
8792    This is for ARM $7.1.2.  */
8793
8794 static void
8795 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8796      tree object;
8797      const char *type;
8798      int virtualp, quals, friendp, raises, inlinep;
8799 {
8800   if (virtualp)
8801     cp_error ("`%D' declared as a `virtual' %s", object, type);
8802   if (inlinep)
8803     cp_error ("`%D' declared as an `inline' %s", object, type);
8804   if (quals)
8805     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8806               object, type);
8807   if (friendp)
8808     cp_error_at ("`%D' declared as a friend", object);
8809   if (raises)
8810     cp_error_at ("`%D' declared with an exception specification", object);
8811 }
8812
8813 /* CTYPE is class type, or null if non-class.
8814    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8815    or METHOD_TYPE.
8816    DECLARATOR is the function's name.
8817    VIRTUALP is truthvalue of whether the function is virtual or not.
8818    FLAGS are to be passed through to `grokclassfn'.
8819    QUALS are qualifiers indicating whether the function is `const'
8820    or `volatile'.
8821    RAISES is a list of exceptions that this function can raise.
8822    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8823    not look, and -1 if we should not call `grokclassfn' at all.
8824
8825    Returns `NULL_TREE' if something goes wrong, after issuing
8826    applicable error messages.  */
8827
8828 static tree
8829 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8830             raises, check, friendp, publicp, inlinep, funcdef_flag,
8831             template_count, in_namespace)
8832      tree ctype, type;
8833      tree declarator;
8834      tree orig_declarator;
8835      int virtualp;
8836      enum overload_flags flags;
8837      tree quals, raises;
8838      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8839      tree in_namespace;
8840 {
8841   tree cname, decl;
8842   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8843   int has_default_arg = 0;
8844   tree t;
8845
8846   if (ctype)
8847     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8848       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8849   else
8850     cname = NULL_TREE;
8851
8852   if (raises)
8853     {
8854       type = build_exception_variant (type, raises);
8855     }
8856
8857   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8858   /* Propagate volatile out from type to decl. */
8859   if (TYPE_VOLATILE (type))
8860     TREE_THIS_VOLATILE (decl) = 1;
8861
8862   /* If this decl has namespace scope, set that up.  */
8863   if (in_namespace)
8864     set_decl_namespace (decl, in_namespace, friendp);
8865   else if (publicp && ! ctype)
8866     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8867
8868   /* `main' and builtins have implicit 'C' linkage.  */
8869   if ((MAIN_NAME_P (declarator)
8870        || (IDENTIFIER_LENGTH (declarator) > 10
8871            && IDENTIFIER_POINTER (declarator)[0] == '_'
8872            && IDENTIFIER_POINTER (declarator)[1] == '_'
8873            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8874       && current_lang_name == lang_name_cplusplus
8875       && ctype == NULL_TREE
8876       /* NULL_TREE means global namespace.  */
8877       && DECL_CONTEXT (decl) == NULL_TREE)
8878     DECL_LANGUAGE (decl) = lang_c;
8879
8880   /* Should probably propagate const out from type to decl I bet (mrs).  */
8881   if (staticp)
8882     {
8883       DECL_STATIC_FUNCTION_P (decl) = 1;
8884       DECL_CONTEXT (decl) = ctype;
8885     }
8886
8887   if (ctype)
8888     DECL_CONTEXT (decl) = ctype;
8889
8890   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8891     {
8892       if (processing_template_decl)
8893         error ("cannot declare `::main' to be a template");
8894       if (inlinep)
8895         error ("cannot declare `::main' to be inline");
8896       else if (! publicp)
8897         error ("cannot declare `::main' to be static");
8898       inlinep = 0;
8899       publicp = 1;
8900     }
8901
8902   /* Members of anonymous types and local classes have no linkage; make
8903      them internal.  */
8904   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8905                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8906     publicp = 0;
8907
8908   if (publicp)
8909     {
8910       /* [basic.link]: A name with no linkage (notably, the name of a class
8911          or enumeration declared in a local scope) shall not be used to
8912          declare an entity with linkage.
8913
8914          Only check this for public decls for now.  */
8915       t = no_linkage_check (TREE_TYPE (decl));
8916       if (t)
8917         {
8918           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8919             {
8920               if (DECL_EXTERN_C_P (decl))
8921                 /* Allow this; it's pretty common in C.  */;
8922               else
8923                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8924                             decl);
8925             }
8926           else
8927             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8928                         decl, t);
8929         }
8930     }
8931
8932   TREE_PUBLIC (decl) = publicp;
8933   if (! publicp)
8934     {
8935       DECL_INTERFACE_KNOWN (decl) = 1;
8936       DECL_NOT_REALLY_EXTERN (decl) = 1;
8937     }
8938
8939   if (inlinep)
8940     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8941
8942   DECL_EXTERNAL (decl) = 1;
8943   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8944     {
8945       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8946                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8947       quals = NULL_TREE;
8948     }
8949
8950   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8951     grok_op_properties (decl, virtualp, check < 0);
8952
8953   if (ctype && decl_function_context (decl))
8954     DECL_NO_STATIC_CHAIN (decl) = 1;
8955
8956   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8957     if (TREE_PURPOSE (t)
8958         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8959       {
8960         has_default_arg = 1;
8961         break;
8962       }
8963
8964   if (friendp
8965       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8966     {
8967       if (funcdef_flag)
8968         cp_error
8969           ("defining explicit specialization `%D' in friend declaration",
8970            orig_declarator);
8971       else
8972         {
8973           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8974             {
8975               /* Something like `template <class T> friend void f<T>()'.  */
8976               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8977                         orig_declarator);
8978               return NULL_TREE;
8979             }
8980
8981
8982           /* A friend declaration of the form friend void f<>().  Record
8983              the information in the TEMPLATE_ID_EXPR.  */
8984           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8985           DECL_TEMPLATE_INFO (decl)
8986             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8987                          TREE_OPERAND (orig_declarator, 1),
8988                          NULL_TREE);
8989
8990           if (has_default_arg)
8991             {
8992               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8993                         decl);
8994               return NULL_TREE;
8995             }
8996
8997           if (inlinep)
8998             {
8999               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
9000                         decl);
9001               return NULL_TREE;
9002             }
9003         }
9004     }
9005
9006   if (has_default_arg)
9007     add_defarg_fn (decl);
9008
9009   /* Plain overloading: will not be grok'd by grokclassfn.  */
9010   if (! ctype && ! processing_template_decl
9011       && !DECL_EXTERN_C_P (decl)
9012       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
9013     set_mangled_name_for_decl (decl);
9014
9015   if (funcdef_flag)
9016     /* Make the init_value nonzero so pushdecl knows this is not
9017        tentative.  error_mark_node is replaced later with the BLOCK.  */
9018     DECL_INITIAL (decl) = error_mark_node;
9019
9020   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
9021     TREE_NOTHROW (decl) = 1;
9022
9023   /* Caller will do the rest of this.  */
9024   if (check < 0)
9025     return decl;
9026
9027   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
9028     DECL_CONSTRUCTOR_P (decl) = 1;
9029
9030   /* Function gets the ugly name, field gets the nice one.  This call
9031      may change the type of the function (because of default
9032      parameters)!  */
9033   if (ctype != NULL_TREE)
9034     grokclassfn (ctype, decl, flags, quals);
9035
9036   decl = check_explicit_specialization (orig_declarator, decl,
9037                                         template_count,
9038                                         2 * (funcdef_flag != 0) +
9039                                         4 * (friendp != 0));
9040   if (decl == error_mark_node)
9041     return NULL_TREE;
9042
9043   if (ctype != NULL_TREE
9044       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9045       && check)
9046     {
9047       tree old_decl;
9048
9049       old_decl = check_classfn (ctype, decl);
9050
9051       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9052         /* Because grokfndecl is always supposed to return a
9053            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9054            here.  We depend on our callers to figure out that its
9055            really a template that's being returned.  */
9056         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9057
9058       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9059           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9060         {
9061           /* Remove the `this' parm added by grokclassfn.
9062              XXX Isn't this done in start_function, too?  */
9063           revert_static_member_fn (decl);
9064           last_function_parms = TREE_CHAIN (last_function_parms);
9065         }
9066       if (old_decl && DECL_ARTIFICIAL (old_decl))
9067         cp_error ("definition of implicitly-declared `%D'", old_decl);
9068
9069       if (old_decl)
9070         {
9071           /* Since we've smashed OLD_DECL to its
9072              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9073           if (TREE_CODE (decl) == TEMPLATE_DECL)
9074             decl = DECL_TEMPLATE_RESULT (decl);
9075
9076           /* Attempt to merge the declarations.  This can fail, in
9077              the case of some illegal specialization declarations.  */
9078           if (!duplicate_decls (decl, old_decl))
9079             cp_error ("no `%#D' member function declared in class `%T'",
9080                       decl, ctype);
9081           return old_decl;
9082         }
9083     }
9084
9085   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9086     return NULL_TREE;
9087
9088   if (ctype == NULL_TREE || check)
9089     return decl;
9090
9091   if (virtualp)
9092     {
9093       DECL_VIRTUAL_P (decl) = 1;
9094       if (DECL_VINDEX (decl) == NULL_TREE)
9095         DECL_VINDEX (decl) = error_mark_node;
9096       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
9097     }
9098
9099   return decl;
9100 }
9101
9102 static tree
9103 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9104      tree type;
9105      tree declarator;
9106      RID_BIT_TYPE *specbits_in;
9107      int initialized;
9108      int constp;
9109      tree in_namespace;
9110 {
9111   tree decl;
9112   RID_BIT_TYPE specbits;
9113
9114   specbits = *specbits_in;
9115
9116   if (TREE_CODE (type) == OFFSET_TYPE)
9117     {
9118       /* If you declare a static member so that it
9119          can be initialized, the code will reach here.  */
9120       tree basetype = TYPE_OFFSET_BASETYPE (type);
9121       type = TREE_TYPE (type);
9122       decl = build_lang_decl (VAR_DECL, declarator, type);
9123       DECL_CONTEXT (decl) = basetype;
9124       /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
9125          templates.  */
9126       if (!uses_template_parms (decl))
9127         {
9128           if (flag_new_abi)
9129             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9130           else
9131             DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype,
9132                                                             declarator);
9133         }
9134     }
9135   else
9136     {
9137       tree context;
9138
9139       if (in_namespace)
9140         context = in_namespace;
9141       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9142         context = current_namespace;
9143       else
9144         context = NULL_TREE;
9145
9146       if (processing_template_decl && context)
9147         /* For global variables, declared in a template, we need the
9148            full lang_decl.  */
9149         decl = build_lang_decl (VAR_DECL, declarator, type);
9150       else
9151         decl = build_decl (VAR_DECL, declarator, type);
9152
9153       if (context)
9154         set_decl_namespace (decl, context, 0);
9155
9156       context = DECL_CONTEXT (decl);
9157       if (declarator && context && current_lang_name != lang_name_c)
9158         {
9159           if (flag_new_abi)
9160             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9161           else
9162             DECL_ASSEMBLER_NAME (decl)
9163               = build_static_name (context, declarator);
9164         }
9165     }
9166
9167   if (in_namespace)
9168     set_decl_namespace (decl, in_namespace, 0);
9169
9170   if (RIDBIT_SETP (RID_EXTERN, specbits))
9171     {
9172       DECL_THIS_EXTERN (decl) = 1;
9173       DECL_EXTERNAL (decl) = !initialized;
9174     }
9175
9176   /* In class context, static means one per class,
9177      public access, and static storage.  */
9178   if (DECL_CLASS_SCOPE_P (decl))
9179     {
9180       TREE_PUBLIC (decl) = 1;
9181       TREE_STATIC (decl) = 1;
9182       DECL_EXTERNAL (decl) = 0;
9183     }
9184   /* At top level, either `static' or no s.c. makes a definition
9185      (perhaps tentative), and absence of `static' makes it public.  */
9186   else if (toplevel_bindings_p ())
9187     {
9188       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9189                             && (DECL_THIS_EXTERN (decl) || ! constp));
9190       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9191     }
9192   /* Not at top level, only `static' makes a static definition.  */
9193   else
9194     {
9195       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9196       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9197     }
9198
9199   if (TREE_PUBLIC (decl))
9200     {
9201       /* [basic.link]: A name with no linkage (notably, the name of a class
9202          or enumeration declared in a local scope) shall not be used to
9203          declare an entity with linkage.
9204
9205          Only check this for public decls for now.  */
9206       tree t = no_linkage_check (TREE_TYPE (decl));
9207       if (t)
9208         {
9209           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9210             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9211           else
9212             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9213                         decl, t);
9214         }
9215     }
9216
9217   return decl;
9218 }
9219
9220 /* Create and return a canonical pointer to member function type, for
9221    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9222
9223 tree
9224 build_ptrmemfunc_type (type)
9225      tree type;
9226 {
9227   tree fields[4];
9228   tree t;
9229   tree u;
9230   tree unqualified_variant = NULL_TREE;
9231
9232   /* If a canonical type already exists for this type, use it.  We use
9233      this method instead of type_hash_canon, because it only does a
9234      simple equality check on the list of field members.  */
9235
9236   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9237     return t;
9238
9239   /* Make sure that we always have the unqualified pointer-to-member
9240      type first.  */
9241   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9242     unqualified_variant
9243       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9244
9245   t = make_aggr_type (RECORD_TYPE);
9246   /* Let the front-end know this is a pointer to member function...  */
9247   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9248   /* ... and not really an aggregate.  */
9249   SET_IS_AGGR_TYPE (t, 0);
9250
9251   if (!flag_new_abi)
9252     {
9253       u = make_aggr_type (UNION_TYPE);
9254       SET_IS_AGGR_TYPE (u, 0);
9255       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9256       fields[1] = build_decl (FIELD_DECL, delta2_identifier,
9257                               delta_type_node);
9258       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9259       TYPE_NAME (u) = NULL_TREE;
9260
9261       fields[0] = build_decl (FIELD_DECL, delta_identifier,
9262                               delta_type_node);
9263       fields[1] = build_decl (FIELD_DECL, index_identifier,
9264                               delta_type_node);
9265       fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9266       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9267     }
9268   else
9269     {
9270       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9271       fields[1] = build_decl (FIELD_DECL, delta_identifier,
9272                               delta_type_node);
9273       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9274     }
9275
9276   /* Zap out the name so that the back-end will give us the debugging
9277      information for this anonymous RECORD_TYPE.  */
9278   TYPE_NAME (t) = NULL_TREE;
9279
9280   /* If this is not the unqualified form of this pointer-to-member
9281      type, set the TYPE_MAIN_VARIANT for this type to be the
9282      unqualified type.  Since they are actually RECORD_TYPEs that are
9283      not variants of each other, we must do this manually.  */
9284   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9285     {
9286       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9287       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9288       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9289       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9290     }
9291
9292   /* Cache this pointer-to-member type so that we can find it again
9293      later.  */
9294   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9295
9296   /* Seems to be wanted.  */
9297   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9298
9299   return t;
9300 }
9301
9302 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9303    Check to see that the definition is valid.  Issue appropriate error
9304    messages.  Return 1 if the definition is particularly bad, or 0
9305    otherwise.  */
9306
9307 int
9308 check_static_variable_definition (decl, type)
9309      tree decl;
9310      tree type;
9311 {
9312   /* Motion 10 at San Diego: If a static const integral data member is
9313      initialized with an integral constant expression, the initializer
9314      may appear either in the declaration (within the class), or in
9315      the definition, but not both.  If it appears in the class, the
9316      member is a member constant.  The file-scope definition is always
9317      required.  */
9318   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9319     {
9320       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9321                 type);
9322       /* If we just return the declaration, crashes will sometimes
9323          occur.  We therefore return void_type_node, as if this was a
9324          friend declaration, to cause callers to completely ignore
9325          this declaration.  */
9326       return 1;
9327     }
9328   else if (!CP_TYPE_CONST_P (type))
9329     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9330               decl);
9331   else if (pedantic && !INTEGRAL_TYPE_P (type))
9332     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9333
9334   return 0;
9335 }
9336
9337 /* Given the SIZE (i.e., number of elements) in an array, compute an
9338    appropriate index type for the array.  If non-NULL, NAME is the
9339    name of the thing being declared.  */
9340
9341 tree
9342 compute_array_index_type (name, size)
9343      tree name;
9344      tree size;
9345 {
9346   tree itype;
9347
9348   /* The size might be the result of a cast. */
9349   STRIP_TYPE_NOPS (size);
9350
9351   /* It might be a const variable or enumeration constant.  */
9352   size = decl_constant_value (size);
9353
9354   /* If this involves a template parameter, it will be a constant at
9355      instantiation time, but we don't know what the value is yet.
9356      Even if no template parameters are involved, we may an expression
9357      that is not a constant; we don't even simplify `1 + 2' when
9358      processing a template.  */
9359   if (processing_template_decl)
9360     {
9361       /* Resolve a qualified reference to an enumerator or static
9362          const data member of ours.  */
9363       if (TREE_CODE (size) == SCOPE_REF
9364           && TREE_OPERAND (size, 0) == current_class_type)
9365         {
9366           tree t = lookup_field (current_class_type,
9367                                  TREE_OPERAND (size, 1), 0, 0);
9368           if (t)
9369             size = t;
9370         }
9371
9372       return build_index_type (build_min (MINUS_EXPR, sizetype,
9373                                           size, integer_one_node));
9374     }
9375
9376   /* The array bound must be an integer type.  */
9377   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9378       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9379       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9380     {
9381       if (name)
9382         cp_error ("size of array `%D' has non-integer type", name);
9383       else
9384         cp_error ("size of array has non-integer type");
9385       size = integer_one_node;
9386     }
9387
9388   /* Normally, the array-bound will be a constant.  */
9389   if (TREE_CONSTANT (size))
9390     {
9391       /* Check to see if the array bound overflowed.  Make that an
9392          error, no matter how generous we're being.  */
9393       int old_flag_pedantic_errors = flag_pedantic_errors;
9394       int old_pedantic = pedantic;
9395       pedantic = flag_pedantic_errors = 1;
9396       constant_expression_warning (size);
9397       pedantic = old_pedantic;
9398       flag_pedantic_errors = old_flag_pedantic_errors;
9399
9400       /* An array must have a positive number of elements.  */
9401       if (INT_CST_LT (size, integer_zero_node))
9402         {
9403           if (name)
9404             cp_error ("size of array `%D' is negative", name);
9405           else
9406             cp_error ("size of array is negative");
9407           size = integer_one_node;
9408         }
9409       /* Except that an extension we allow zero-sized arrays.  We
9410          always allow them in system headers because glibc uses
9411          them.  */
9412       else if (integer_zerop (size) && pedantic && !in_system_header)
9413         {
9414           if (name)
9415             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9416           else
9417             cp_pedwarn ("ISO C++ forbids zero-size array");
9418         }
9419     }
9420
9421   /* Compute the index of the largest element in the array.  It is
9422      one less than the number of elements in the array.  */
9423   itype
9424     = fold (build_binary_op (MINUS_EXPR,
9425                              cp_convert (ssizetype, size),
9426                              cp_convert (ssizetype,
9427                                          integer_one_node)));
9428
9429   /* Check for variable-sized arrays.  We allow such things as an
9430      extension, even though they are not allowed in ANSI/ISO C++.  */
9431   if (!TREE_CONSTANT (itype))
9432     {
9433       if (pedantic)
9434         {
9435           if (name)
9436             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9437                         name);
9438           else
9439             cp_pedwarn ("ISO C++ forbids variable-size array");
9440         }
9441
9442       /* Create a variable-sized array index type.  */
9443       itype = variable_size (itype);
9444     }
9445   /* Make sure that there was no overflow when creating to a signed
9446      index type.  (For example, on a 32-bit machine, an array with
9447      size 2^32 - 1 is too big.)  */
9448   else if (TREE_OVERFLOW (itype))
9449     {
9450       error ("overflow in array dimension");
9451       TREE_OVERFLOW (itype) = 0;
9452     }
9453
9454   /* Create and return the appropriate index type.  */
9455   return build_index_type (itype);
9456 }
9457
9458 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9459    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9460    with this type.  */
9461
9462 static tree
9463 create_array_type_for_decl (name, type, size)
9464      tree name;
9465      tree type;
9466      tree size;
9467 {
9468   tree itype = NULL_TREE;
9469   const char* error_msg;
9470
9471   /* If things have already gone awry, bail now.  */
9472   if (type == error_mark_node || size == error_mark_node)
9473     return error_mark_node;
9474
9475   /* Assume that everything will go OK.  */
9476   error_msg = NULL;
9477
9478   /* There are some types which cannot be array elements.  */
9479   switch (TREE_CODE (type))
9480     {
9481     case VOID_TYPE:
9482       error_msg = "array of void";
9483       break;
9484
9485     case FUNCTION_TYPE:
9486       error_msg = "array of functions";
9487       break;
9488
9489     case REFERENCE_TYPE:
9490       error_msg = "array of references";
9491       break;
9492
9493     case OFFSET_TYPE:
9494       error_msg = "array of data members";
9495       break;
9496
9497     case METHOD_TYPE:
9498       error_msg = "array of function members";
9499       break;
9500
9501     default:
9502       break;
9503     }
9504
9505   /* If something went wrong, issue an error-message and return.  */
9506   if (error_msg)
9507     {
9508       if (name)
9509         cp_error ("declaration of `%D' as %s", name, error_msg);
9510       else
9511         cp_error ("creating %s", error_msg);
9512
9513       return error_mark_node;
9514     }
9515
9516   /* [dcl.array]
9517
9518      The constant expressions that specify the bounds of the arrays
9519      can be omitted only for the first member of the sequence.  */
9520   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9521     {
9522       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9523                 name);
9524
9525       return error_mark_node;
9526     }
9527
9528   /* Figure out the index type for the array.  */
9529   if (size)
9530     itype = compute_array_index_type (name, size);
9531
9532   return build_cplus_array_type (type, itype);
9533 }
9534
9535 /* Check that it's OK to declare a function with the indicated TYPE.
9536    SFK indicates the kind of special function (if any) that this
9537    function is.  CTYPE is the class of which this function is a
9538    member.  OPTYPE is the type given in a conversion operator
9539    declaration.  Returns the actual return type of the function; that
9540    may be different than TYPE if an error occurs, or for certain
9541    special functions.  */
9542
9543 static tree
9544 check_special_function_return_type (sfk, type, ctype, optype)
9545      special_function_kind sfk;
9546      tree type;
9547      tree ctype;
9548      tree optype;
9549 {
9550   switch (sfk)
9551     {
9552     case sfk_constructor:
9553       if (type)
9554         cp_error ("return type specification for constructor invalid");
9555
9556       /* In the old ABI, we return `this'; in the new ABI we don't
9557          bother.  */
9558       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9559       break;
9560
9561     case sfk_destructor:
9562       if (type)
9563         cp_error ("return type specification for destructor invalid");
9564       type = void_type_node;
9565       break;
9566
9567     case sfk_conversion:
9568       if (type && !same_type_p (type, optype))
9569         cp_error ("operator `%T' declared to return `%T'", optype, type);
9570       else if (type)
9571         cp_pedwarn ("return type specified for `operator %T'",  optype);
9572       type = optype;
9573       break;
9574
9575     default:
9576       my_friendly_abort (20000408);
9577       break;
9578     }
9579
9580   return type;
9581 }
9582
9583 /* Given declspecs and a declarator,
9584    determine the name and type of the object declared
9585    and construct a ..._DECL node for it.
9586    (In one case we can return a ..._TYPE node instead.
9587     For invalid input we sometimes return 0.)
9588
9589    DECLSPECS is a chain of tree_list nodes whose value fields
9590     are the storage classes and type specifiers.
9591
9592    DECL_CONTEXT says which syntactic context this declaration is in:
9593      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9594      FUNCDEF for a function definition.  Like NORMAL but a few different
9595       error messages in each case.  Return value may be zero meaning
9596       this definition is too screwy to try to parse.
9597      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9598       handle member functions (which have FIELD context).
9599       Return value may be zero meaning this definition is too screwy to
9600       try to parse.
9601      PARM for a parameter declaration (either within a function prototype
9602       or before a function body).  Make a PARM_DECL, or return void_type_node.
9603      CATCHPARM for a parameter declaration before a catch clause.
9604      TYPENAME if for a typename (in a cast or sizeof).
9605       Don't make a DECL node; just return the ..._TYPE node.
9606      FIELD for a struct or union field; make a FIELD_DECL.
9607      BITFIELD for a field with specified width.
9608    INITIALIZED is 1 if the decl has an initializer.
9609
9610    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9611    normal attributes in TREE_PURPOSE, or NULL_TREE.
9612
9613    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9614    It may also be so in the PARM case, for a prototype where the
9615    argument type is specified but not the name.
9616
9617    This function is where the complicated C meanings of `static'
9618    and `extern' are interpreted.
9619
9620    For C++, if there is any monkey business to do, the function which
9621    calls this one must do it, i.e., prepending instance variables,
9622    renaming overloaded function names, etc.
9623
9624    Note that for this C++, it is an error to define a method within a class
9625    which does not belong to that class.
9626
9627    Except in the case where SCOPE_REFs are implicitly known (such as
9628    methods within a class being redundantly qualified),
9629    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9630    (class_name::decl_name).  The caller must also deal with this.
9631
9632    If a constructor or destructor is seen, and the context is FIELD,
9633    then the type gains the attribute TREE_HAS_x.  If such a declaration
9634    is erroneous, NULL_TREE is returned.
9635
9636    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9637    function, these are the qualifiers to give to the `this' pointer. We
9638    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9639
9640    May return void_type_node if the declarator turned out to be a friend.
9641    See grokfield for details.  */
9642
9643 tree
9644 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9645      tree declspecs;
9646      tree declarator;
9647      enum decl_context decl_context;
9648      int initialized;
9649      tree attrlist;
9650 {
9651   RID_BIT_TYPE specbits;
9652   int nclasses = 0;
9653   tree spec;
9654   tree type = NULL_TREE;
9655   int longlong = 0;
9656   int constp;
9657   int restrictp;
9658   int volatilep;
9659   int type_quals;
9660   int virtualp, explicitp, friendp, inlinep, staticp;
9661   int explicit_int = 0;
9662   int explicit_char = 0;
9663   int defaulted_int = 0;
9664   tree typedef_decl = NULL_TREE;
9665   const char *name;
9666   tree typedef_type = NULL_TREE;
9667   int funcdef_flag = 0;
9668   enum tree_code innermost_code = ERROR_MARK;
9669   int bitfield = 0;
9670 #if 0
9671   /* See the code below that used this.  */
9672   tree decl_machine_attr = NULL_TREE;
9673 #endif
9674   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9675      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9676   tree init = NULL_TREE;
9677
9678   /* Keep track of what sort of function is being processed
9679      so that we can warn about default return values, or explicit
9680      return values which do not match prescribed defaults.  */
9681   special_function_kind sfk = sfk_none;
9682
9683   tree dname = NULL_TREE;
9684   tree ctype = current_class_type;
9685   tree ctor_return_type = NULL_TREE;
9686   enum overload_flags flags = NO_SPECIAL;
9687   tree quals = NULL_TREE;
9688   tree raises = NULL_TREE;
9689   int template_count = 0;
9690   tree in_namespace = NULL_TREE;
9691   tree inner_attrs;
9692   int ignore_attrs;
9693
9694   RIDBIT_RESET_ALL (specbits);
9695   if (decl_context == FUNCDEF)
9696     funcdef_flag = 1, decl_context = NORMAL;
9697   else if (decl_context == MEMFUNCDEF)
9698     funcdef_flag = -1, decl_context = FIELD;
9699   else if (decl_context == BITFIELD)
9700     bitfield = 1, decl_context = FIELD;
9701
9702   /* Look inside a declarator for the name being declared
9703      and get it as a string, for an error message.  */
9704   {
9705     tree *next = &declarator;
9706     register tree decl;
9707     name = NULL;
9708
9709     while (next && *next)
9710       {
9711         decl = *next;
9712         switch (TREE_CODE (decl))
9713           {
9714           case TREE_LIST:
9715             /* For attributes.  */
9716             next = &TREE_VALUE (decl);
9717             break;
9718
9719           case COND_EXPR:
9720             ctype = NULL_TREE;
9721             next = &TREE_OPERAND (decl, 0);
9722             break;
9723
9724           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9725             {
9726               tree name = TREE_OPERAND (decl, 0);
9727               tree rename = NULL_TREE;
9728
9729               my_friendly_assert (flags == NO_SPECIAL, 152);
9730               flags = DTOR_FLAG;
9731               sfk = sfk_destructor;
9732               if (TREE_CODE (name) == TYPE_DECL)
9733                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9734               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9735               if (ctype == NULL_TREE)
9736                 {
9737                   if (current_class_type == NULL_TREE)
9738                     {
9739                       error ("destructors must be member functions");
9740                       flags = NO_SPECIAL;
9741                     }
9742                   else
9743                     {
9744                       tree t = constructor_name (current_class_name);
9745                       if (t != name)
9746                         rename = t;
9747                     }
9748                 }
9749               else
9750                 {
9751                   tree t = constructor_name (ctype);
9752                   if (t != name)
9753                     rename = t;
9754                 }
9755
9756               if (rename)
9757                 {
9758                   cp_error ("destructor `%T' must match class name `%T'",
9759                             name, rename);
9760                   TREE_OPERAND (decl, 0) = rename;
9761                 }
9762               next = &name;
9763             }
9764             break;
9765
9766           case ADDR_EXPR:       /* C++ reference declaration */
9767             /* Fall through. */
9768           case ARRAY_REF:
9769           case INDIRECT_REF:
9770             ctype = NULL_TREE;
9771             innermost_code = TREE_CODE (decl);
9772             next = &TREE_OPERAND (decl, 0);
9773             break;
9774
9775           case CALL_EXPR:
9776             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9777               {
9778                 /* This is actually a variable declaration using
9779                    constructor syntax.  We need to call start_decl and
9780                    cp_finish_decl so we can get the variable
9781                    initialized...  */
9782
9783                 tree attributes, prefix_attributes;
9784
9785                 *next = TREE_OPERAND (decl, 0);
9786                 init = CALL_DECLARATOR_PARMS (decl);
9787
9788                 if (attrlist)
9789                   {
9790                     attributes = TREE_PURPOSE (attrlist);
9791                     prefix_attributes = TREE_VALUE (attrlist);
9792                   }
9793                 else
9794                   {
9795                     attributes = NULL_TREE;
9796                     prefix_attributes = NULL_TREE;
9797                   }
9798
9799                 decl = start_decl (declarator, declspecs, 1,
9800                                    attributes, prefix_attributes);
9801                 decl_type_access_control (decl);
9802                 if (decl)
9803                   {
9804                     /* Look for __unused__ attribute */
9805                     if (TREE_USED (TREE_TYPE (decl)))
9806                       TREE_USED (decl) = 1;
9807                     finish_decl (decl, init, NULL_TREE);
9808                   }
9809                 else
9810                   cp_error ("invalid declarator");
9811                 return 0;
9812               }
9813             innermost_code = TREE_CODE (decl);
9814             if (decl_context == FIELD && ctype == NULL_TREE)
9815               ctype = current_class_type;
9816             if (ctype
9817                 && TREE_OPERAND (decl, 0)
9818                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9819                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9820                          == constructor_name_full (ctype))
9821                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9822                             == constructor_name (ctype)))))
9823               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9824             next = &TREE_OPERAND (decl, 0);
9825             decl = *next;
9826             if (ctype != NULL_TREE
9827                 && decl != NULL_TREE && flags != DTOR_FLAG
9828                 && decl == constructor_name (ctype))
9829               {
9830                 sfk = sfk_constructor;
9831                 ctor_return_type = ctype;
9832               }
9833             ctype = NULL_TREE;
9834             break;
9835
9836           case TEMPLATE_ID_EXPR:
9837               {
9838                 tree fns = TREE_OPERAND (decl, 0);
9839
9840                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9841                   fns = TREE_OPERAND (fns, 0);
9842
9843                 dname = fns;
9844                 if (TREE_CODE (dname) == COMPONENT_REF)
9845                   dname = TREE_OPERAND (dname, 1);
9846                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9847                   {
9848                     my_friendly_assert (is_overloaded_fn (dname),
9849                                         19990331);
9850                     dname = DECL_NAME (get_first_fn (dname));
9851                   }
9852               }
9853           /* Fall through. */
9854
9855           case IDENTIFIER_NODE:
9856             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9857               dname = decl;
9858
9859             next = 0;
9860
9861             if (is_rid (dname))
9862               {
9863                 cp_error ("declarator-id missing; using reserved word `%D'",
9864                           dname);
9865                 name = IDENTIFIER_POINTER (dname);
9866               }
9867             else if (!IDENTIFIER_TYPENAME_P (dname))
9868               name = IDENTIFIER_POINTER (dname);
9869             else
9870               {
9871                 my_friendly_assert (flags == NO_SPECIAL, 154);
9872                 flags = TYPENAME_FLAG;
9873                 ctor_return_type = TREE_TYPE (dname);
9874                 sfk = sfk_conversion;
9875                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9876                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9877                         == TYPE_DECL))
9878                   name = IDENTIFIER_POINTER (dname);
9879                 else
9880                   name = "<invalid operator>";
9881               }
9882             break;
9883
9884             /* C++ extension */
9885           case SCOPE_REF:
9886             {
9887               /* Perform error checking, and decide on a ctype.  */
9888               tree cname = TREE_OPERAND (decl, 0);
9889               if (cname == NULL_TREE)
9890                 ctype = NULL_TREE;
9891               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9892                 {
9893                   ctype = NULL_TREE;
9894                   in_namespace = TREE_OPERAND (decl, 0);
9895                   TREE_OPERAND (decl, 0) = NULL_TREE;
9896                 }
9897               else if (! is_aggr_type (cname, 1))
9898                 TREE_OPERAND (decl, 0) = NULL_TREE;
9899               /* Must test TREE_OPERAND (decl, 1), in case user gives
9900                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9901               else if (TREE_OPERAND (decl, 1)
9902                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9903                 ctype = cname;
9904               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9905                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9906                 {
9907                   cp_error ("`%T::%D' is not a valid declarator", cname,
9908                             TREE_OPERAND (decl, 1));
9909                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9910                             cname, TREE_OPERAND (decl, 1));
9911                   return void_type_node;
9912                 }
9913               else if (ctype == NULL_TREE)
9914                 ctype = cname;
9915               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9916                 TREE_OPERAND (decl, 0) = ctype;
9917               else
9918                 {
9919                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9920                     {
9921                       cp_error ("type `%T' is not derived from type `%T'",
9922                                 cname, ctype);
9923                       TREE_OPERAND (decl, 0) = NULL_TREE;
9924                     }
9925                   else
9926                     ctype = cname;
9927                 }
9928
9929               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9930                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9931                        == constructor_name_full (ctype))
9932                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9933                           == constructor_name (ctype))))
9934                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9935               next = &TREE_OPERAND (decl, 1);
9936               decl = *next;
9937               if (ctype)
9938                 {
9939                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9940                       && constructor_name (ctype) == decl)
9941                     {
9942                       sfk = sfk_constructor;
9943                       ctor_return_type = ctype;
9944                     }
9945                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9946                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9947                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9948                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9949                     {
9950                       sfk = sfk_destructor;
9951                       ctor_return_type = ctype;
9952                       flags = DTOR_FLAG;
9953                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9954                       next = &TREE_OPERAND (decl, 0);
9955                     }
9956                 }
9957             }
9958             break;
9959
9960           case ERROR_MARK:
9961             next = 0;
9962             break;
9963
9964           case TYPE_DECL:
9965             /* Parse error puts this typespec where
9966                a declarator should go.  */
9967             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9968             if (TREE_TYPE (decl) == current_class_type)
9969               cp_error ("  perhaps you want `%T' for a constructor",
9970                         current_class_name);
9971             dname = DECL_NAME (decl);
9972             name = IDENTIFIER_POINTER (dname);
9973
9974             /* Avoid giving two errors for this.  */
9975             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9976
9977             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9978             *next = dname;
9979             next = 0;
9980             break;
9981
9982           default:
9983             cp_compiler_error ("`%D' as declarator", decl);
9984             return 0; /* We used to do a 155 abort here.  */
9985           }
9986       }
9987   }
9988
9989   /* A function definition's declarator must have the form of
9990      a function declarator.  */
9991
9992   if (funcdef_flag && innermost_code != CALL_EXPR)
9993     return 0;
9994
9995   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9996       && innermost_code != CALL_EXPR
9997       && ! (ctype && declspecs == NULL_TREE))
9998     {
9999       cp_error ("declaration of `%D' as non-function", dname);
10000       return void_type_node;
10001     }
10002
10003   /* Anything declared one level down from the top level
10004      must be one of the parameters of a function
10005      (because the body is at least two levels down).  */
10006
10007   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10008      by not allowing C++ class definitions to specify their parameters
10009      with xdecls (must be spec.d in the parmlist).
10010
10011      Since we now wait to push a class scope until we are sure that
10012      we are in a legitimate method context, we must set oldcname
10013      explicitly (since current_class_name is not yet alive).
10014
10015      We also want to avoid calling this a PARM if it is in a namespace.  */
10016
10017   if (decl_context == NORMAL && !toplevel_bindings_p ())
10018     {
10019       struct binding_level *b = current_binding_level;
10020       current_binding_level = b->level_chain;
10021       if (current_binding_level != 0 && toplevel_bindings_p ())
10022         decl_context = PARM;
10023       current_binding_level = b;
10024     }
10025
10026   if (name == NULL)
10027     name = decl_context == PARM ? "parameter" : "type name";
10028
10029   /* Look through the decl specs and record which ones appear.
10030      Some typespecs are defined as built-in typenames.
10031      Others, the ones that are modifiers of other types,
10032      are represented by bits in SPECBITS: set the bits for
10033      the modifiers that appear.  Storage class keywords are also in SPECBITS.
10034
10035      If there is a typedef name or a type, store the type in TYPE.
10036      This includes builtin typedefs such as `int'.
10037
10038      Set EXPLICIT_INT if the type is `int' or `char' and did not
10039      come from a user typedef.
10040
10041      Set LONGLONG if `long' is mentioned twice.
10042
10043      For C++, constructors and destructors have their own fast treatment.  */
10044
10045   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10046     {
10047       register int i;
10048       register tree id;
10049
10050       /* Certain parse errors slip through.  For example,
10051          `int class;' is not caught by the parser. Try
10052          weakly to recover here.  */
10053       if (TREE_CODE (spec) != TREE_LIST)
10054         return 0;
10055
10056       id = TREE_VALUE (spec);
10057
10058       if (TREE_CODE (id) == IDENTIFIER_NODE)
10059         {
10060           if (id == ridpointers[(int) RID_INT]
10061               || id == ridpointers[(int) RID_CHAR]
10062               || id == ridpointers[(int) RID_BOOL]
10063               || id == ridpointers[(int) RID_WCHAR])
10064             {
10065               if (type)
10066                 {
10067                   if (id == ridpointers[(int) RID_BOOL])
10068                     error ("`bool' is now a keyword");
10069                   else
10070                     cp_error ("extraneous `%T' ignored", id);
10071                 }
10072               else
10073                 {
10074                   if (id == ridpointers[(int) RID_INT])
10075                     explicit_int = 1;
10076                   else if (id == ridpointers[(int) RID_CHAR])
10077                     explicit_char = 1;
10078                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10079                 }
10080               goto found;
10081             }
10082           /* C++ aggregate types.  */
10083           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10084             {
10085               if (type)
10086                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10087               else
10088                 type = IDENTIFIER_TYPE_VALUE (id);
10089               goto found;
10090             }
10091
10092           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10093             {
10094               if (ridpointers[i] == id)
10095                 {
10096                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10097                     {
10098                       if (pedantic && ! in_system_header && warn_long_long)
10099                         pedwarn ("ISO C++ does not support `long long'");
10100                       if (longlong)
10101                         error ("`long long long' is too long for GCC");
10102                       else
10103                         longlong = 1;
10104                     }
10105                   else if (RIDBIT_SETP (i, specbits))
10106                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10107                   RIDBIT_SET (i, specbits);
10108                   goto found;
10109                 }
10110             }
10111         }
10112       /* C++ aggregate types.  */
10113       else if (TREE_CODE (id) == TYPE_DECL)
10114         {
10115           if (type)
10116             cp_error ("multiple declarations `%T' and `%T'", type,
10117                       TREE_TYPE (id));
10118           else
10119             {
10120               type = TREE_TYPE (id);
10121               TREE_VALUE (spec) = type;
10122             }
10123           goto found;
10124         }
10125       if (type)
10126         error ("two or more data types in declaration of `%s'", name);
10127       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10128         {
10129           register tree t = lookup_name (id, 1);
10130           if (!t || TREE_CODE (t) != TYPE_DECL)
10131             error ("`%s' fails to be a typedef or built in type",
10132                    IDENTIFIER_POINTER (id));
10133           else
10134             {
10135               type = TREE_TYPE (t);
10136 #if 0
10137               /* See the code below that used this.  */
10138               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10139 #endif
10140               typedef_decl = t;
10141             }
10142         }
10143       else if (id != error_mark_node)
10144         /* Can't change CLASS nodes into RECORD nodes here!  */
10145         type = id;
10146
10147     found: ;
10148     }
10149
10150   typedef_type = type;
10151
10152   /* No type at all: default to `int', and set DEFAULTED_INT
10153      because it was not a user-defined typedef.  */
10154
10155   if (type == NULL_TREE
10156       && (RIDBIT_SETP (RID_SIGNED, specbits)
10157           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10158           || RIDBIT_SETP (RID_LONG, specbits)
10159           || RIDBIT_SETP (RID_SHORT, specbits)))
10160     {
10161       /* These imply 'int'.  */
10162       type = integer_type_node;
10163       defaulted_int = 1;
10164     }
10165
10166   if (sfk != sfk_none)
10167     type = check_special_function_return_type (sfk, type,
10168                                                ctor_return_type,
10169                                                ctor_return_type);
10170   else if (type == NULL_TREE)
10171     {
10172       int is_main;
10173
10174       explicit_int = -1;
10175
10176           /* We handle `main' specially here, because 'main () { }' is so
10177              common.  With no options, it is allowed.  With -Wreturn-type,
10178              it is a warning.  It is only an error with -pedantic-errors.  */
10179       is_main = (funcdef_flag
10180                  && MAIN_NAME_P (dname)
10181                  && ctype == NULL_TREE
10182                  && in_namespace == NULL_TREE
10183                  && current_namespace == global_namespace);
10184
10185       if (in_system_header || flag_ms_extensions)
10186         /* Allow it, sigh.  */;
10187       else if (pedantic || ! is_main)
10188         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10189                     name);
10190       else if (warn_return_type)
10191         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10192                     name);
10193
10194       type = integer_type_node;
10195     }
10196
10197   ctype = NULL_TREE;
10198
10199   /* Now process the modifiers that were specified
10200      and check for invalid combinations.  */
10201
10202   /* Long double is a special combination.  */
10203
10204   if (RIDBIT_SETP (RID_LONG, specbits)
10205       && TYPE_MAIN_VARIANT (type) == double_type_node)
10206     {
10207       RIDBIT_RESET (RID_LONG, specbits);
10208       type = build_qualified_type (long_double_type_node,
10209                                    CP_TYPE_QUALS (type));
10210     }
10211
10212   /* Check all other uses of type modifiers.  */
10213
10214   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10215       || RIDBIT_SETP (RID_SIGNED, specbits)
10216       || RIDBIT_SETP (RID_LONG, specbits)
10217       || RIDBIT_SETP (RID_SHORT, specbits))
10218     {
10219       int ok = 0;
10220
10221       if (TREE_CODE (type) == REAL_TYPE)
10222         error ("short, signed or unsigned invalid for `%s'", name);
10223       else if (TREE_CODE (type) != INTEGER_TYPE)
10224         error ("long, short, signed or unsigned invalid for `%s'", name);
10225       else if (RIDBIT_SETP (RID_LONG, specbits)
10226                && RIDBIT_SETP (RID_SHORT, specbits))
10227         error ("long and short specified together for `%s'", name);
10228       else if ((RIDBIT_SETP (RID_LONG, specbits)
10229                 || RIDBIT_SETP (RID_SHORT, specbits))
10230                && explicit_char)
10231         error ("long or short specified with char for `%s'", name);
10232       else if ((RIDBIT_SETP (RID_LONG, specbits)
10233                 || RIDBIT_SETP (RID_SHORT, specbits))
10234                && TREE_CODE (type) == REAL_TYPE)
10235         error ("long or short specified with floating type for `%s'", name);
10236       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10237                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10238         error ("signed and unsigned given together for `%s'", name);
10239       else
10240         {
10241           ok = 1;
10242           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10243             {
10244               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10245                        name);
10246               if (flag_pedantic_errors)
10247                 ok = 0;
10248             }
10249         }
10250
10251       /* Discard the type modifiers if they are invalid.  */
10252       if (! ok)
10253         {
10254           RIDBIT_RESET (RID_UNSIGNED, specbits);
10255           RIDBIT_RESET (RID_SIGNED, specbits);
10256           RIDBIT_RESET (RID_LONG, specbits);
10257           RIDBIT_RESET (RID_SHORT, specbits);
10258           longlong = 0;
10259         }
10260     }
10261
10262   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10263       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10264     {
10265       error ("complex invalid for `%s'", name);
10266       RIDBIT_RESET (RID_COMPLEX, specbits);
10267     }
10268
10269   /* Decide whether an integer type is signed or not.
10270      Optionally treat bitfields as signed by default.  */
10271   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10272       /* [class.bit]
10273
10274          It is implementation-defined whether a plain (neither
10275          explicitly signed or unsigned) char, short, int, or long
10276          bit-field is signed or unsigned.
10277
10278          Naturally, we extend this to long long as well.  Note that
10279          this does not include wchar_t.  */
10280       || (bitfield && !flag_signed_bitfields
10281           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10282           /* A typedef for plain `int' without `signed' can be
10283              controlled just like plain `int', but a typedef for
10284              `signed int' cannot be so controlled.  */
10285           && !(typedef_decl
10286                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10287           && (TREE_CODE (type) == INTEGER_TYPE
10288               || TREE_CODE (type) == CHAR_TYPE)
10289           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10290     {
10291       if (longlong)
10292         type = long_long_unsigned_type_node;
10293       else if (RIDBIT_SETP (RID_LONG, specbits))
10294         type = long_unsigned_type_node;
10295       else if (RIDBIT_SETP (RID_SHORT, specbits))
10296         type = short_unsigned_type_node;
10297       else if (type == char_type_node)
10298         type = unsigned_char_type_node;
10299       else if (typedef_decl)
10300         type = unsigned_type (type);
10301       else
10302         type = unsigned_type_node;
10303     }
10304   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10305            && type == char_type_node)
10306     type = signed_char_type_node;
10307   else if (longlong)
10308     type = long_long_integer_type_node;
10309   else if (RIDBIT_SETP (RID_LONG, specbits))
10310     type = long_integer_type_node;
10311   else if (RIDBIT_SETP (RID_SHORT, specbits))
10312     type = short_integer_type_node;
10313
10314   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10315     {
10316       /* If we just have "complex", it is equivalent to
10317          "complex double", but if any modifiers at all are specified it is
10318          the complex form of TYPE.  E.g, "complex short" is
10319          "complex short int".  */
10320
10321       if (defaulted_int && ! longlong
10322           && ! (RIDBIT_SETP (RID_LONG, specbits)
10323                 || RIDBIT_SETP (RID_SHORT, specbits)
10324                 || RIDBIT_SETP (RID_SIGNED, specbits)
10325                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10326         type = complex_double_type_node;
10327       else if (type == integer_type_node)
10328         type = complex_integer_type_node;
10329       else if (type == float_type_node)
10330         type = complex_float_type_node;
10331       else if (type == double_type_node)
10332         type = complex_double_type_node;
10333       else if (type == long_double_type_node)
10334         type = complex_long_double_type_node;
10335       else
10336         type = build_complex_type (type);
10337     }
10338
10339   if (sfk == sfk_conversion
10340       && (RIDBIT_SETP (RID_CONST, specbits)
10341           || RIDBIT_SETP (RID_VOLATILE, specbits)
10342           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10343     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10344               ctor_return_type);
10345
10346   /* Set CONSTP if this declaration is `const', whether by
10347      explicit specification or via a typedef.
10348      Likewise for VOLATILEP.  */
10349
10350   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10351   restrictp =
10352     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10353   volatilep =
10354     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10355   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10356                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10357                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10358   type = cp_build_qualified_type (type, type_quals);
10359   staticp = 0;
10360   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10361   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10362   RIDBIT_RESET (RID_VIRTUAL, specbits);
10363   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10364   RIDBIT_RESET (RID_EXPLICIT, specbits);
10365
10366   if (RIDBIT_SETP (RID_STATIC, specbits))
10367     staticp = 1 + (decl_context == FIELD);
10368
10369   if (virtualp && staticp == 2)
10370     {
10371       cp_error ("member `%D' cannot be declared both virtual and static",
10372                 dname);
10373       staticp = 0;
10374     }
10375   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10376   RIDBIT_RESET (RID_FRIEND, specbits);
10377
10378   /* Warn if two storage classes are given. Default to `auto'.  */
10379
10380   if (RIDBIT_ANY_SET (specbits))
10381     {
10382       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10383       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10384       if (decl_context == PARM && nclasses > 0)
10385         error ("storage class specifiers invalid in parameter declarations");
10386       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10387         {
10388           if (decl_context == PARM)
10389             error ("typedef declaration invalid in parameter declaration");
10390           nclasses++;
10391         }
10392       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10393       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10394     }
10395
10396   /* Give error if `virtual' is used outside of class declaration.  */
10397   if (virtualp
10398       && (current_class_name == NULL_TREE || decl_context != FIELD))
10399     {
10400       error ("virtual outside class declaration");
10401       virtualp = 0;
10402     }
10403
10404   /* Static anonymous unions are dealt with here.  */
10405   if (staticp && decl_context == TYPENAME
10406       && TREE_CODE (declspecs) == TREE_LIST
10407       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10408     decl_context = FIELD;
10409
10410   /* Warn about storage classes that are invalid for certain
10411      kinds of declarations (parameters, typenames, etc.).  */
10412
10413   if (nclasses > 1)
10414     error ("multiple storage classes in declaration of `%s'", name);
10415   else if (decl_context != NORMAL && nclasses > 0)
10416     {
10417       if ((decl_context == PARM || decl_context == CATCHPARM)
10418           && (RIDBIT_SETP (RID_REGISTER, specbits)
10419               || RIDBIT_SETP (RID_AUTO, specbits)))
10420         ;
10421       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10422         ;
10423       else if (decl_context == FIELD
10424                /* C++ allows static class elements  */
10425                && RIDBIT_SETP (RID_STATIC, specbits))
10426         /* C++ also allows inlines and signed and unsigned elements,
10427            but in those cases we don't come in here.  */
10428         ;
10429       else
10430         {
10431           if (decl_context == FIELD)
10432             {
10433               tree tmp = NULL_TREE;
10434               register int op = 0;
10435
10436               if (declarator)
10437                 {
10438                   /* Avoid trying to get an operand off an identifier node.  */
10439                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10440                     tmp = declarator;
10441                   else
10442                     tmp = TREE_OPERAND (declarator, 0);
10443                   op = IDENTIFIER_OPNAME_P (tmp);
10444                   if (IDENTIFIER_TYPENAME_P (tmp))
10445                     {
10446                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10447                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10448                               == TYPE_DECL))
10449                         name = IDENTIFIER_POINTER (tmp);
10450                       else
10451                         name = "<invalid operator>";
10452                     }
10453                 }
10454               error ("storage class specified for %s `%s'",
10455                      op ? "member operator" : "field",
10456                      name);
10457             }
10458           else
10459             {
10460               if (decl_context == PARM || decl_context == CATCHPARM)
10461                 error ("storage class specified for parameter `%s'", name);
10462               else
10463                 error ("storage class specified for typename");
10464             }
10465           RIDBIT_RESET (RID_REGISTER, specbits);
10466           RIDBIT_RESET (RID_AUTO, specbits);
10467           RIDBIT_RESET (RID_EXTERN, specbits);
10468         }
10469     }
10470   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10471     {
10472       if (toplevel_bindings_p ())
10473         {
10474           /* It's common practice (and completely valid) to have a const
10475              be initialized and declared extern.  */
10476           if (!(type_quals & TYPE_QUAL_CONST))
10477             warning ("`%s' initialized and declared `extern'", name);
10478         }
10479       else
10480         error ("`%s' has both `extern' and initializer", name);
10481     }
10482   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10483            && ! toplevel_bindings_p ())
10484     error ("nested function `%s' declared `extern'", name);
10485   else if (toplevel_bindings_p ())
10486     {
10487       if (RIDBIT_SETP (RID_AUTO, specbits))
10488         error ("top-level declaration of `%s' specifies `auto'", name);
10489     }
10490
10491   if (nclasses > 0 && friendp)
10492     error ("storage class specifiers invalid in friend function declarations");
10493
10494   /* Now figure out the structure of the declarator proper.
10495      Descend through it, creating more complex types, until we reach
10496      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10497
10498   inner_attrs = NULL_TREE;
10499   ignore_attrs = 0;
10500
10501   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10502          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10503     {
10504       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10505          an INDIRECT_REF (for *...),
10506          a CALL_EXPR (for ...(...)),
10507          an identifier (for the name being declared)
10508          or a null pointer (for the place in an absolute declarator
10509          where the name was omitted).
10510          For the last two cases, we have just exited the loop.
10511
10512          For C++ it could also be
10513          a SCOPE_REF (for class :: ...).  In this case, we have converted
10514          sensible names to types, and those are the values we use to
10515          qualify the member name.
10516          an ADDR_EXPR (for &...),
10517          a BIT_NOT_EXPR (for destructors)
10518
10519          At this point, TYPE is the type of elements of an array,
10520          or for a function to return, or for a pointer to point to.
10521          After this sequence of ifs, TYPE is the type of the
10522          array or function or pointer, and DECLARATOR has had its
10523          outermost layer removed.  */
10524
10525       if (type == error_mark_node)
10526         {
10527           if (TREE_CODE (declarator) == SCOPE_REF)
10528             declarator = TREE_OPERAND (declarator, 1);
10529           else
10530             declarator = TREE_OPERAND (declarator, 0);
10531           continue;
10532         }
10533       if (quals != NULL_TREE
10534           && (declarator == NULL_TREE
10535               || TREE_CODE (declarator) != SCOPE_REF))
10536         {
10537           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10538             ctype = TYPE_METHOD_BASETYPE (type);
10539           if (ctype != NULL_TREE)
10540             {
10541               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10542               grok_method_quals (ctype, dummy, quals);
10543               type = TREE_TYPE (dummy);
10544               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10545               quals = NULL_TREE;
10546             }
10547         }
10548
10549       /* See the comment for the TREE_LIST case, below.  */
10550       if (ignore_attrs)
10551         ignore_attrs = 0;
10552       else if (inner_attrs)
10553         {
10554           decl_attributes (type, inner_attrs, NULL_TREE);
10555           inner_attrs = NULL_TREE;
10556         }
10557
10558       switch (TREE_CODE (declarator))
10559         {
10560         case TREE_LIST:
10561           {
10562             /* We encode a declarator with embedded attributes using
10563                a TREE_LIST.  The attributes apply to the declarator
10564                directly inside them, so we have to skip an iteration
10565                before applying them to the type.  If the declarator just
10566                inside is the declarator-id, we apply the attrs to the
10567                decl itself.  */
10568             inner_attrs = TREE_PURPOSE (declarator);
10569             ignore_attrs = 1;
10570             declarator = TREE_VALUE (declarator);
10571           }
10572           break;
10573
10574         case ARRAY_REF:
10575           {
10576             register tree size;
10577
10578             size = TREE_OPERAND (declarator, 1);
10579
10580             /* VC++ spells a zero-sized array with [].  */
10581             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10582                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10583               size = integer_zero_node;
10584
10585             declarator = TREE_OPERAND (declarator, 0);
10586
10587             type = create_array_type_for_decl (dname, type, size);
10588
10589             /* VLAs never work as fields. */
10590             if (decl_context == FIELD && !processing_template_decl
10591                 && TREE_CODE (type) == ARRAY_TYPE
10592                 && TYPE_DOMAIN (type) != NULL_TREE
10593                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10594               {
10595                 cp_error ("size of member `%D' is not constant", dname);
10596                 /* Proceed with arbitrary constant size, so that offset
10597                    computations don't get confused. */
10598                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10599                                                    integer_one_node);
10600               }
10601
10602             ctype = NULL_TREE;
10603           }
10604           break;
10605
10606         case CALL_EXPR:
10607           {
10608             tree arg_types;
10609             int funcdecl_p;
10610             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10611             tree inner_decl = TREE_OPERAND (declarator, 0);
10612
10613             /* Declaring a function type.
10614                Make sure we have a valid type for the function to return.  */
10615
10616             /* We now know that the TYPE_QUALS don't apply to the
10617                decl, but to its return type.  */
10618             type_quals = TYPE_UNQUALIFIED;
10619
10620             /* Warn about some types functions can't return.  */
10621
10622             if (TREE_CODE (type) == FUNCTION_TYPE)
10623               {
10624                 error ("`%s' declared as function returning a function", name);
10625                 type = integer_type_node;
10626               }
10627             if (TREE_CODE (type) == ARRAY_TYPE)
10628               {
10629                 error ("`%s' declared as function returning an array", name);
10630                 type = integer_type_node;
10631               }
10632
10633             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10634               inner_decl = TREE_OPERAND (inner_decl, 1);
10635
10636             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10637               inner_decl = dname;
10638
10639             /* Pick up type qualifiers which should be applied to `this'.  */
10640             quals = CALL_DECLARATOR_QUALS (declarator);
10641
10642             /* Pick up the exception specifications.  */
10643             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10644
10645             /* Say it's a definition only for the CALL_EXPR
10646                closest to the identifier.  */
10647             funcdecl_p
10648               = inner_decl
10649               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10650                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10651                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10652
10653             if (ctype == NULL_TREE
10654                 && decl_context == FIELD
10655                 && funcdecl_p
10656                 && (friendp == 0 || dname == current_class_name))
10657               ctype = current_class_type;
10658
10659             if (ctype && sfk == sfk_conversion)
10660               TYPE_HAS_CONVERSION (ctype) = 1;
10661             if (ctype && constructor_name (ctype) == dname)
10662               {
10663                 /* We are within a class's scope. If our declarator name
10664                    is the same as the class name, and we are defining
10665                    a function, then it is a constructor/destructor, and
10666                    therefore returns a void type.  */
10667
10668                 if (flags == DTOR_FLAG)
10669                   {
10670                     /* ISO C++ 12.4/2.  A destructor may not be
10671                        declared const or volatile.  A destructor may
10672                        not be static.  */
10673                     if (staticp == 2)
10674                       error ("destructor cannot be static member function");
10675                     if (quals)
10676                       {
10677                         cp_error ("destructors may not be `%s'",
10678                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10679                         quals = NULL_TREE;
10680                       }
10681                     if (decl_context == FIELD)
10682                       {
10683                         if (! member_function_or_else (ctype,
10684                                                        current_class_type,
10685                                                        flags))
10686                           return void_type_node;
10687                       }
10688                   }
10689                 else            /* It's a constructor.  */
10690                   {
10691                     if (explicitp == 1)
10692                       explicitp = 2;
10693                     /* ISO C++ 12.1.  A constructor may not be
10694                        declared const or volatile.  A constructor may
10695                        not be virtual.  A constructor may not be
10696                        static.  */
10697                     if (staticp == 2)
10698                       error ("constructor cannot be static member function");
10699                     if (virtualp)
10700                       {
10701                         pedwarn ("constructors cannot be declared virtual");
10702                         virtualp = 0;
10703                       }
10704                     if (quals)
10705                       {
10706                         cp_error ("constructors may not be `%s'",
10707                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10708                         quals = NULL_TREE;
10709                       }
10710                     {
10711                       RID_BIT_TYPE tmp_bits;
10712                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10713                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10714                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10715                       if (RIDBIT_ANY_SET (tmp_bits))
10716                         error ("return value type specifier for constructor ignored");
10717                     }
10718                     if (decl_context == FIELD)
10719                       {
10720                         if (! member_function_or_else (ctype,
10721                                                        current_class_type,
10722                                                        flags))
10723                           return void_type_node;
10724                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10725                         if (sfk != sfk_constructor)
10726                           return NULL_TREE;
10727                       }
10728                   }
10729                 if (decl_context == FIELD)
10730                   staticp = 0;
10731               }
10732             else if (friendp)
10733               {
10734                 if (initialized)
10735                   error ("can't initialize friend function `%s'", name);
10736                 if (virtualp)
10737                   {
10738                     /* Cannot be both friend and virtual.  */
10739                     error ("virtual functions cannot be friends");
10740                     RIDBIT_RESET (RID_FRIEND, specbits);
10741                     friendp = 0;
10742                   }
10743                 if (decl_context == NORMAL)
10744                   error ("friend declaration not in class definition");
10745                 if (current_function_decl && funcdef_flag)
10746                   cp_error ("can't define friend function `%s' in a local class definition",
10747                             name);
10748               }
10749
10750             /* Construct the function type and go to the next
10751                inner layer of declarator.  */
10752
10753             declarator = TREE_OPERAND (declarator, 0);
10754
10755             /* FIXME: This is where default args should be fully
10756                processed.  */
10757
10758             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10759
10760             if (declarator && flags == DTOR_FLAG)
10761               {
10762                 /* A destructor declared in the body of a class will
10763                    be represented as a BIT_NOT_EXPR.  But, we just
10764                    want the underlying IDENTIFIER.  */
10765                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10766                   declarator = TREE_OPERAND (declarator, 0);
10767
10768                 if (strict_prototype == 0 && arg_types == NULL_TREE)
10769                   arg_types = void_list_node;
10770                 else if (arg_types == NULL_TREE
10771                          || arg_types != void_list_node)
10772                   {
10773                     cp_error ("destructors may not have parameters");
10774                     arg_types = void_list_node;
10775                     last_function_parms = NULL_TREE;
10776                   }
10777               }
10778
10779             /* ANSI says that `const int foo ();'
10780                does not make the function foo const.  */
10781             type = build_function_type (type, arg_types);
10782
10783             {
10784               tree t;
10785               for (t = arg_types; t; t = TREE_CHAIN (t))
10786                 if (TREE_PURPOSE (t)
10787                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10788                   {
10789                     add_defarg_fn (type);
10790                     break;
10791                   }
10792             }
10793           }
10794           break;
10795
10796         case ADDR_EXPR:
10797         case INDIRECT_REF:
10798           /* Filter out pointers-to-references and references-to-references.
10799              We can get these if a TYPE_DECL is used.  */
10800
10801           if (TREE_CODE (type) == REFERENCE_TYPE)
10802             {
10803               error ("cannot declare %s to references",
10804                      TREE_CODE (declarator) == ADDR_EXPR
10805                      ? "references" : "pointers");
10806               declarator = TREE_OPERAND (declarator, 0);
10807               continue;
10808             }
10809
10810           if (TREE_CODE (type) == OFFSET_TYPE
10811               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10812                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10813             {
10814               cp_error ("cannot declare pointer to `%#T' member",
10815                         TREE_TYPE (type));
10816               type = TREE_TYPE (type);
10817             }
10818
10819           /* Merge any constancy or volatility into the target type
10820              for the pointer.  */
10821
10822           /* We now know that the TYPE_QUALS don't apply to the decl,
10823              but to the target of the pointer.  */
10824           type_quals = TYPE_UNQUALIFIED;
10825
10826           if (TREE_CODE (declarator) == ADDR_EXPR)
10827             {
10828               if (TREE_CODE (type) == VOID_TYPE)
10829                 error ("invalid type: `void &'");
10830               else
10831                 type = build_reference_type (type);
10832             }
10833           else if (TREE_CODE (type) == METHOD_TYPE)
10834             type = build_ptrmemfunc_type (build_pointer_type (type));
10835           else
10836             type = build_pointer_type (type);
10837
10838           /* Process a list of type modifier keywords (such as
10839              const or volatile) that were given inside the `*' or `&'.  */
10840
10841           if (TREE_TYPE (declarator))
10842             {
10843               register tree typemodlist;
10844               int erred = 0;
10845
10846               constp = 0;
10847               volatilep = 0;
10848               restrictp = 0;
10849               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10850                    typemodlist = TREE_CHAIN (typemodlist))
10851                 {
10852                   tree qualifier = TREE_VALUE (typemodlist);
10853
10854                   if (qualifier == ridpointers[(int) RID_CONST])
10855                     constp++;
10856                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10857                     volatilep++;
10858                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10859                     restrictp++;
10860                   else if (!erred)
10861                     {
10862                       erred = 1;
10863                       error ("invalid type modifier within pointer declarator");
10864                     }
10865                 }
10866               if (constp > 1)
10867                 pedwarn ("duplicate `const'");
10868               if (volatilep > 1)
10869                 pedwarn ("duplicate `volatile'");
10870               if (restrictp > 1)
10871                 pedwarn ("duplicate `restrict'");
10872
10873               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10874                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10875                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10876               if (TREE_CODE (declarator) == ADDR_EXPR
10877                   && (constp || volatilep))
10878                 {
10879                   if (constp)
10880                     pedwarn ("discarding `const' applied to a reference");
10881                   if (volatilep)
10882                     pedwarn ("discarding `volatile' applied to a reference");
10883                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10884                 }
10885               type = cp_build_qualified_type (type, type_quals);
10886             }
10887           declarator = TREE_OPERAND (declarator, 0);
10888           ctype = NULL_TREE;
10889           break;
10890
10891         case SCOPE_REF:
10892           {
10893             /* We have converted type names to NULL_TREE if the
10894                name was bogus, or to a _TYPE node, if not.
10895
10896                The variable CTYPE holds the type we will ultimately
10897                resolve to.  The code here just needs to build
10898                up appropriate member types.  */
10899             tree sname = TREE_OPERAND (declarator, 1);
10900             tree t;
10901
10902             /* Destructors can have their visibilities changed as well.  */
10903             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10904               sname = TREE_OPERAND (sname, 0);
10905
10906             if (TREE_COMPLEXITY (declarator) == 0)
10907               /* This needs to be here, in case we are called
10908                  multiple times.  */ ;
10909             else if (TREE_COMPLEXITY (declarator) == -1)
10910               /* Namespace member. */
10911               pop_decl_namespace ();
10912             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10913               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10914             else if (! IS_AGGR_TYPE_CODE
10915                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10916               ;
10917             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10918               {
10919                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10920                    that refer to ctype.  They couldn't be resolved earlier
10921                    because we hadn't pushed into the class yet.
10922                    Example: resolve 'B<T>::type' in
10923                    'B<typename B<T>::type> B<T>::f () { }'.  */
10924                 if (current_template_parms
10925                     && uses_template_parms (type)
10926                     && uses_template_parms (current_class_type))
10927                   {
10928                     tree args = current_template_args ();
10929                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10930                   }
10931
10932                 /* This pop_nested_class corresponds to the
10933                    push_nested_class used to push into class scope for
10934                    parsing the argument list of a function decl, in
10935                    qualified_id.  */
10936                 pop_nested_class ();
10937                 TREE_COMPLEXITY (declarator) = current_class_depth;
10938               }
10939             else
10940               my_friendly_abort (16);
10941
10942             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10943               {
10944                 /* We had a reference to a global decl, or
10945                    perhaps we were given a non-aggregate typedef,
10946                    in which case we cleared this out, and should just
10947                    keep going as though it wasn't there.  */
10948                 declarator = sname;
10949                 continue;
10950               }
10951             ctype = TREE_OPERAND (declarator, 0);
10952
10953             t = ctype;
10954             while (t != NULL_TREE && CLASS_TYPE_P (t))
10955               {
10956                 /* You're supposed to have one `template <...>'
10957                    for every template class, but you don't need one
10958                    for a full specialization.  For example:
10959
10960                      template <class T> struct S{};
10961                      template <> struct S<int> { void f(); };
10962                      void S<int>::f () {}
10963
10964                    is correct; there shouldn't be a `template <>' for
10965                    the definition of `S<int>::f'.  */
10966                 if (CLASSTYPE_TEMPLATE_INFO (t)
10967                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10968                         || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
10969                   template_count += 1;
10970
10971                 t = TYPE_MAIN_DECL (t);
10972                 if (DECL_LANG_SPECIFIC (t))
10973                   t = DECL_CONTEXT (t);
10974                 else
10975                   t = NULL_TREE;
10976               }
10977
10978             if (sname == NULL_TREE)
10979               goto done_scoping;
10980
10981             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10982               {
10983                 /* This is the `standard' use of the scoping operator:
10984                    basetype :: member .  */
10985
10986                 if (ctype == current_class_type)
10987                   {
10988                     /* class A {
10989                          void A::f ();
10990                        };
10991
10992                        Is this ill-formed?  */
10993
10994                     if (pedantic)
10995                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10996                                   ctype, name);
10997                   }
10998                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10999                   {
11000                     if (current_class_type == NULL_TREE
11001                         || friendp)
11002                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11003                                                       TYPE_ARG_TYPES (type));
11004                     else
11005                       {
11006                         cp_error ("cannot declare member function `%T::%s' within `%T'",
11007                                   ctype, name, current_class_type);
11008                         return void_type_node;
11009                       }
11010                   }
11011                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
11012                          || COMPLETE_TYPE_P (complete_type (ctype)))
11013                   {
11014                     /* Have to move this code elsewhere in this function.
11015                        this code is used for i.e., typedef int A::M; M *pm;
11016
11017                        It is?  How? jason 10/2/94 */
11018
11019                     if (current_class_type)
11020                       {
11021                         cp_error ("cannot declare member `%T::%s' within `%T'",
11022                                   ctype, name, current_class_type);
11023                         return void_type_node;
11024                       }
11025                     type = build_offset_type (ctype, type);
11026                   }
11027                 else if (uses_template_parms (ctype))
11028                   {
11029                     if (TREE_CODE (type) == FUNCTION_TYPE)
11030                       type
11031                         = build_cplus_method_type (ctype, TREE_TYPE (type),
11032                                                    TYPE_ARG_TYPES (type));
11033                   }
11034                 else
11035                   {
11036                     cp_error ("structure `%T' not yet defined", ctype);
11037                     return error_mark_node;
11038                   }
11039
11040                 declarator = sname;
11041               }
11042             else if (TREE_CODE (sname) == SCOPE_REF)
11043               my_friendly_abort (17);
11044             else
11045               {
11046               done_scoping:
11047                 declarator = TREE_OPERAND (declarator, 1);
11048                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
11049                   /* In this case, we will deal with it later.  */
11050                   ;
11051                 else
11052                   {
11053                     if (TREE_CODE (type) == FUNCTION_TYPE)
11054                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11055                                                       TYPE_ARG_TYPES (type));
11056                     else
11057                       type = build_offset_type (ctype, type);
11058                   }
11059               }
11060           }
11061           break;
11062
11063         case BIT_NOT_EXPR:
11064           declarator = TREE_OPERAND (declarator, 0);
11065           break;
11066
11067         case RECORD_TYPE:
11068         case UNION_TYPE:
11069         case ENUMERAL_TYPE:
11070           declarator = NULL_TREE;
11071           break;
11072
11073         case ERROR_MARK:
11074           declarator = NULL_TREE;
11075           break;
11076
11077         default:
11078           my_friendly_abort (158);
11079         }
11080     }
11081
11082   /* See the comment for the TREE_LIST case, above.  */
11083   if (inner_attrs)
11084     {
11085       if (! ignore_attrs)
11086         decl_attributes (type, inner_attrs, NULL_TREE);
11087       else if (attrlist)
11088         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
11089       else
11090         attrlist = build_decl_list (NULL_TREE, inner_attrs);
11091     }
11092
11093   /* Now TYPE has the actual type.  */
11094
11095   if (explicitp == 1 || (explicitp && friendp))
11096     {
11097       /* [dcl.fct.spec] The explicit specifier shall only be used in
11098          declarations of constructors within a class definition.  */
11099       error ("only declarations of constructors can be `explicit'");
11100       explicitp = 0;
11101     }
11102
11103   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11104     {
11105       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11106         {
11107           error ("non-member `%s' cannot be declared `mutable'", name);
11108           RIDBIT_RESET (RID_MUTABLE, specbits);
11109         }
11110       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11111         {
11112           error ("non-object member `%s' cannot be declared `mutable'", name);
11113           RIDBIT_RESET (RID_MUTABLE, specbits);
11114         }
11115       else if (TREE_CODE (type) == FUNCTION_TYPE
11116                || TREE_CODE (type) == METHOD_TYPE)
11117         {
11118           error ("function `%s' cannot be declared `mutable'", name);
11119           RIDBIT_RESET (RID_MUTABLE, specbits);
11120         }
11121       else if (staticp)
11122         {
11123           error ("static `%s' cannot be declared `mutable'", name);
11124           RIDBIT_RESET (RID_MUTABLE, specbits);
11125         }
11126       else if (type_quals & TYPE_QUAL_CONST)
11127         {
11128           error ("const `%s' cannot be declared `mutable'", name);
11129           RIDBIT_RESET (RID_MUTABLE, specbits);
11130         }
11131     }
11132
11133   if (declarator == NULL_TREE
11134       || TREE_CODE (declarator) == IDENTIFIER_NODE
11135       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11136           && (TREE_CODE (type) == FUNCTION_TYPE
11137               || TREE_CODE (type) == METHOD_TYPE)))
11138     /* OK */;
11139   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11140     {
11141       cp_error ("template-id `%D' used as a declarator", declarator);
11142       declarator = dname;
11143     }
11144   else
11145     /* Unexpected declarator format.  */
11146     my_friendly_abort (990210);
11147
11148   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11149
11150   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11151     {
11152       tree decl;
11153
11154       /* Note that the grammar rejects storage classes
11155          in typenames, fields or parameters.  */
11156       if (current_lang_name == lang_name_java)
11157         TYPE_FOR_JAVA (type) = 1;
11158
11159       if (decl_context == FIELD)
11160         {
11161           if (declarator == constructor_name (current_class_type))
11162             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11163                         declarator);
11164           decl = build_lang_decl (TYPE_DECL, declarator, type);
11165         }
11166       else
11167         decl = build_decl (TYPE_DECL, declarator, type);
11168
11169       /* If the user declares "typedef struct {...} foo" then the
11170          struct will have an anonymous name.  Fill that name in now.
11171          Nothing can refer to it, so nothing needs know about the name
11172          change.  */
11173       if (type != error_mark_node
11174           && declarator
11175           && TYPE_NAME (type)
11176           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11177           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
11178           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11179         {
11180           tree oldname = TYPE_NAME (type);
11181           tree t;
11182
11183           /* Replace the anonymous name with the real name everywhere.  */
11184           lookup_tag_reverse (type, declarator);
11185           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11186             if (TYPE_NAME (t) == oldname)
11187               TYPE_NAME (t) = decl;
11188
11189           if (TYPE_LANG_SPECIFIC (type))
11190             TYPE_WAS_ANONYMOUS (type) = 1;
11191
11192           /* If this is a typedef within a template class, the nested
11193              type is a (non-primary) template.  The name for the
11194              template needs updating as well.  */
11195           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11196             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11197               = TYPE_IDENTIFIER (type);
11198
11199           if (flag_new_abi)
11200             DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
11201           else
11202             {
11203               /* XXX Temporarily set the scope.
11204                  When returning, start_decl expects it as NULL_TREE,
11205                  and will then then set it using pushdecl. */
11206               my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
11207               if (current_class_type)
11208                 DECL_CONTEXT (decl) = current_class_type;
11209               else
11210                 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11211
11212               DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
11213               DECL_ASSEMBLER_NAME (decl)
11214                 = get_identifier (build_overload_name (type, 1, 1));
11215               DECL_CONTEXT (decl) = NULL_TREE;
11216             }
11217
11218           /* FIXME remangle member functions; member functions of a
11219              type with external linkage have external linkage.  */
11220         }
11221
11222       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11223         {
11224           cp_error_at ("typedef name may not be class-qualified", decl);
11225           return NULL_TREE;
11226         }
11227       else if (quals)
11228         {
11229           if (ctype == NULL_TREE)
11230             {
11231               if (TREE_CODE (type) != METHOD_TYPE)
11232                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11233               else
11234                 ctype = TYPE_METHOD_BASETYPE (type);
11235             }
11236           if (ctype != NULL_TREE)
11237             grok_method_quals (ctype, decl, quals);
11238         }
11239
11240       if (RIDBIT_SETP (RID_SIGNED, specbits)
11241           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11242         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11243
11244       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11245                       inlinep, friendp, raises != NULL_TREE);
11246
11247       if (initialized)
11248         error ("typedef declaration includes an initializer");
11249
11250       return decl;
11251     }
11252
11253   /* Detect the case of an array type of unspecified size
11254      which came, as such, direct from a typedef name.
11255      We must copy the type, so that each identifier gets
11256      a distinct type, so that each identifier's size can be
11257      controlled separately by its own initializer.  */
11258
11259   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11260       && TYPE_DOMAIN (type) == NULL_TREE)
11261     {
11262       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11263     }
11264
11265   /* If this is a type name (such as, in a cast or sizeof),
11266      compute the type and return it now.  */
11267
11268   if (decl_context == TYPENAME)
11269     {
11270       /* Note that the grammar rejects storage classes
11271          in typenames, fields or parameters.  */
11272       if (type_quals != TYPE_UNQUALIFIED)
11273         type_quals = TYPE_UNQUALIFIED;
11274
11275       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11276       if (friendp)
11277         {
11278           if (type_quals != TYPE_UNQUALIFIED)
11279             {
11280               cp_error ("type qualifiers specified for friend class declaration");
11281               type_quals = TYPE_UNQUALIFIED;
11282             }
11283           if (inlinep)
11284             {
11285               cp_error ("`inline' specified for friend class declaration");
11286               inlinep = 0;
11287             }
11288
11289           /* Only try to do this stuff if we didn't already give up.  */
11290           if (type != integer_type_node)
11291             {
11292               /* A friendly class?  */
11293               if (current_class_type)
11294                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11295               else
11296                 error ("trying to make class `%s' a friend of global scope",
11297                        TYPE_NAME_STRING (type));
11298               type = void_type_node;
11299             }
11300         }
11301       else if (quals)
11302         {
11303           if (ctype == NULL_TREE)
11304             {
11305               if (TREE_CODE (type) != METHOD_TYPE)
11306                 cp_error ("invalid qualifiers on non-member function type");
11307               else
11308                 ctype = TYPE_METHOD_BASETYPE (type);
11309             }
11310           if (ctype)
11311             {
11312               tree dummy = build_decl (TYPE_DECL, declarator, type);
11313               grok_method_quals (ctype, dummy, quals);
11314               type = TREE_TYPE (dummy);
11315             }
11316         }
11317
11318       return type;
11319     }
11320   else if (declarator == NULL_TREE && decl_context != PARM
11321            && decl_context != CATCHPARM
11322            && TREE_CODE (type) != UNION_TYPE
11323            && ! bitfield)
11324     {
11325       cp_error ("abstract declarator `%T' used as declaration", type);
11326       declarator = make_anon_name ();
11327     }
11328
11329   /* `void' at top level (not within pointer)
11330      is allowed only in typedefs or type names.
11331      We don't complain about parms either, but that is because
11332      a better error message can be made later.  */
11333
11334   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11335     {
11336       if (! declarator)
11337         error ("unnamed variable or field declared void");
11338       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11339         {
11340           if (IDENTIFIER_OPNAME_P (declarator))
11341             my_friendly_abort (356);
11342           else
11343             error ("variable or field `%s' declared void", name);
11344         }
11345       else
11346         error ("variable or field declared void");
11347       type = integer_type_node;
11348     }
11349
11350   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11351      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11352
11353   if (decl_context == PARM || decl_context == CATCHPARM)
11354     {
11355       if (ctype || in_namespace)
11356         error ("cannot use `::' in parameter declaration");
11357
11358       /* A parameter declared as an array of T is really a pointer to T.
11359          One declared as a function is really a pointer to a function.
11360          One declared as a member is really a pointer to member.  */
11361
11362       if (TREE_CODE (type) == ARRAY_TYPE)
11363         {
11364           /* Transfer const-ness of array into that of type pointed to.  */
11365           type = build_pointer_type (TREE_TYPE (type));
11366           type_quals = TYPE_UNQUALIFIED;
11367         }
11368       else if (TREE_CODE (type) == FUNCTION_TYPE)
11369         type = build_pointer_type (type);
11370       else if (TREE_CODE (type) == OFFSET_TYPE)
11371         type = build_pointer_type (type);
11372       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11373         {
11374           error ("declaration of `%s' as void", name);
11375           return NULL_TREE;
11376         }
11377     }
11378
11379   {
11380     register tree decl;
11381
11382     if (decl_context == PARM)
11383       {
11384         decl = build_decl (PARM_DECL, declarator, type);
11385
11386         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11387                         inlinep, friendp, raises != NULL_TREE);
11388
11389         /* Compute the type actually passed in the parmlist,
11390            for the case where there is no prototype.
11391            (For example, shorts and chars are passed as ints.)
11392            When there is a prototype, this is overridden later.  */
11393
11394         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11395       }
11396     else if (decl_context == FIELD)
11397       {
11398         if (type == error_mark_node)
11399           {
11400             /* Happens when declaring arrays of sizes which
11401                are error_mark_node, for example.  */
11402             decl = NULL_TREE;
11403           }
11404         else if (in_namespace && !friendp)
11405           {
11406             /* Something like struct S { int N::j; };  */
11407             cp_error ("invalid use of `::'");
11408             decl = NULL_TREE;
11409           }
11410         else if (TREE_CODE (type) == FUNCTION_TYPE)
11411           {
11412             int publicp = 0;
11413             tree function_context;
11414
11415             /* We catch the others as conflicts with the builtin
11416                typedefs.  */
11417             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11418               {
11419                 cp_error ("function `%D' cannot be declared friend",
11420                           declarator);
11421                 friendp = 0;
11422               }
11423
11424             if (friendp == 0)
11425               {
11426                 if (ctype == NULL_TREE)
11427                   ctype = current_class_type;
11428
11429                 if (ctype == NULL_TREE)
11430                   {
11431                     cp_error ("can't make `%D' into a method -- not in a class",
11432                               declarator);
11433                     return void_type_node;
11434                   }
11435
11436                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11437                    ARM 9.5 */
11438                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11439                   {
11440                     cp_error ("function `%D' declared virtual inside a union",
11441                               declarator);
11442                     return void_type_node;
11443                   }
11444
11445                 if (declarator == ansi_opname (NEW_EXPR)
11446                     || declarator == ansi_opname (VEC_NEW_EXPR)
11447                     || declarator == ansi_opname (DELETE_EXPR)
11448                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11449                   {
11450                     if (virtualp)
11451                       {
11452                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11453                                   declarator);
11454                         virtualp = 0;
11455                       }
11456                   }
11457                 else if (staticp < 2)
11458                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11459                                                   TYPE_ARG_TYPES (type));
11460               }
11461
11462             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11463             function_context = (ctype != NULL_TREE) ?
11464               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11465             publicp = (! friendp || ! staticp)
11466               && function_context == NULL_TREE;
11467             decl = grokfndecl (ctype, type,
11468                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11469                                ? declarator : dname,
11470                                declarator,
11471                                virtualp, flags, quals, raises,
11472                                friendp ? -1 : 0, friendp, publicp, inlinep,
11473                                funcdef_flag, template_count, in_namespace);
11474             if (decl == NULL_TREE)
11475               return decl;
11476 #if 0
11477             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11478             /* The decl and setting of decl_machine_attr is also turned off.  */
11479             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11480 #endif
11481
11482             /* [class.conv.ctor]
11483
11484                A constructor declared without the function-specifier
11485                explicit that can be called with a single parameter
11486                specifies a conversion from the type of its first
11487                parameter to the type of its class.  Such a constructor
11488                is called a converting constructor.  */
11489             if (explicitp == 2)
11490               DECL_NONCONVERTING_P (decl) = 1;
11491             else if (DECL_CONSTRUCTOR_P (decl))
11492               {
11493                 /* The constructor can be called with exactly one
11494                    parameter if there is at least one parameter, and
11495                    any subsequent parameters have default arguments.
11496                    We don't look at the first parameter, which is
11497                    really just the `this' parameter for the new
11498                    object.  */
11499                 tree arg_types =
11500                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11501
11502                 /* Skip the `in_chrg' argument too, if present.  */
11503                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11504                   arg_types = TREE_CHAIN (arg_types);
11505
11506                 if (arg_types == void_list_node
11507                     || (arg_types
11508                         && TREE_CHAIN (arg_types)
11509                         && TREE_CHAIN (arg_types) != void_list_node
11510                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11511                   DECL_NONCONVERTING_P (decl) = 1;
11512               }
11513           }
11514         else if (TREE_CODE (type) == METHOD_TYPE)
11515           {
11516             /* We only get here for friend declarations of
11517                members of other classes.  */
11518             /* All method decls are public, so tell grokfndecl to set
11519                TREE_PUBLIC, also.  */
11520             decl = grokfndecl (ctype, type, declarator, declarator,
11521                                virtualp, flags, quals, raises,
11522                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11523                                template_count, in_namespace);
11524             if (decl == NULL_TREE)
11525               return NULL_TREE;
11526           }
11527         else if (!staticp && ! processing_template_decl
11528                  && !COMPLETE_TYPE_P (complete_type (type))
11529                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11530           {
11531             if (declarator)
11532               cp_error ("field `%D' has incomplete type", declarator);
11533             else
11534               cp_error ("name `%T' has incomplete type", type);
11535
11536             /* If we're instantiating a template, tell them which
11537                instantiation made the field's type be incomplete.  */
11538             if (current_class_type
11539                 && TYPE_NAME (current_class_type)
11540                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11541                 && declspecs && TREE_VALUE (declspecs)
11542                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11543               cp_error ("  in instantiation of template `%T'",
11544                         current_class_type);
11545
11546             type = error_mark_node;
11547             decl = NULL_TREE;
11548           }
11549         else
11550           {
11551             if (friendp)
11552               {
11553                 error ("`%s' is neither function nor member function; cannot be declared friend",
11554                        IDENTIFIER_POINTER (declarator));
11555                 friendp = 0;
11556               }
11557             decl = NULL_TREE;
11558           }
11559
11560         if (friendp)
11561           {
11562             /* Friends are treated specially.  */
11563             if (ctype == current_class_type)
11564               warning ("member functions are implicitly friends of their class");
11565             else
11566               {
11567                 tree t = NULL_TREE;
11568                 if (decl && DECL_NAME (decl))
11569                   {
11570                     if (template_class_depth (current_class_type) == 0)
11571                       {
11572                         decl
11573                           = check_explicit_specialization
11574                           (declarator, decl,
11575                            template_count, 2 * (funcdef_flag != 0) + 4);
11576                         if (decl == error_mark_node)
11577                           return error_mark_node;
11578                       }
11579
11580                     t = do_friend (ctype, declarator, decl,
11581                                    last_function_parms, attrlist, flags, quals,
11582                                    funcdef_flag);
11583                   }
11584                 if (t && funcdef_flag)
11585                   return t;
11586
11587                 return void_type_node;
11588               }
11589           }
11590
11591         /* Structure field.  It may not be a function, except for C++ */
11592
11593         if (decl == NULL_TREE)
11594           {
11595             if (initialized)
11596               {
11597                 if (!staticp)
11598                   {
11599                     /* An attempt is being made to initialize a non-static
11600                        member.  But, from [class.mem]:
11601
11602                        4 A member-declarator can contain a
11603                        constant-initializer only if it declares a static
11604                        member (_class.static_) of integral or enumeration
11605                        type, see _class.static.data_.
11606
11607                        This used to be relatively common practice, but
11608                        the rest of the compiler does not correctly
11609                        handle the initialization unless the member is
11610                        static so we make it static below.  */
11611                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11612                                 declarator);
11613                     cp_pedwarn ("making `%D' static", declarator);
11614                     staticp = 1;
11615                   }
11616
11617                 if (uses_template_parms (type))
11618                   /* We'll check at instantiation time.  */
11619                   ;
11620                 else if (check_static_variable_definition (declarator,
11621                                                            type))
11622                   /* If we just return the declaration, crashes
11623                      will sometimes occur.  We therefore return
11624                      void_type_node, as if this was a friend
11625                      declaration, to cause callers to completely
11626                      ignore this declaration.  */
11627                   return void_type_node;
11628               }
11629
11630             /* 9.2p13 [class.mem] */
11631             if (declarator == constructor_name (current_class_type)
11632                 /* The standard does not allow non-static data members
11633                    here either, but we agreed at the 10/99 meeting
11634                    to change that in TC 1 so that they are allowed in
11635                    classes with no user-defined constructors.  */
11636                 && staticp)
11637               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11638                           declarator);
11639
11640             if (staticp)
11641               {
11642                 /* C++ allows static class members.  All other work
11643                    for this is done by grokfield.  */
11644                 decl = build_lang_decl (VAR_DECL, declarator, type);
11645                 TREE_STATIC (decl) = 1;
11646                 /* In class context, 'static' means public access.  */
11647                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11648               }
11649             else
11650               {
11651                 decl = build_decl (FIELD_DECL, declarator, type);
11652                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11653                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11654                   {
11655                     DECL_MUTABLE_P (decl) = 1;
11656                     RIDBIT_RESET (RID_MUTABLE, specbits);
11657                   }
11658               }
11659
11660             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11661                             inlinep, friendp, raises != NULL_TREE);
11662           }
11663       }
11664     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11665       {
11666         tree original_name;
11667         int publicp = 0;
11668
11669         if (! declarator)
11670           return NULL_TREE;
11671
11672         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11673           original_name = dname;
11674         else
11675           original_name = declarator;
11676
11677         if (RIDBIT_SETP (RID_AUTO, specbits))
11678           error ("storage class `auto' invalid for function `%s'", name);
11679         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11680           error ("storage class `register' invalid for function `%s'", name);
11681
11682         /* Function declaration not at top level.
11683            Storage classes other than `extern' are not allowed
11684            and `extern' makes no difference.  */
11685         if (! toplevel_bindings_p ()
11686             && (RIDBIT_SETP (RID_STATIC, specbits)
11687                 || RIDBIT_SETP (RID_INLINE, specbits))
11688             && pedantic)
11689           {
11690             if (RIDBIT_SETP (RID_STATIC, specbits))
11691               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11692             else
11693               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11694           }
11695
11696         if (ctype == NULL_TREE)
11697           {
11698             if (virtualp)
11699               {
11700                 error ("virtual non-class function `%s'", name);
11701                 virtualp = 0;
11702               }
11703           }
11704         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11705           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11706                                           TYPE_ARG_TYPES (type));
11707
11708         /* Record presence of `static'.  */
11709         publicp = (ctype != NULL_TREE
11710                    || RIDBIT_SETP (RID_EXTERN, specbits)
11711                    || !RIDBIT_SETP (RID_STATIC, specbits));
11712
11713         decl = grokfndecl (ctype, type, original_name, declarator,
11714                            virtualp, flags, quals, raises,
11715                            1, friendp,
11716                            publicp, inlinep, funcdef_flag,
11717                            template_count, in_namespace);
11718         if (decl == NULL_TREE)
11719           return NULL_TREE;
11720
11721         if (staticp == 1)
11722           {
11723             int illegal_static = 0;
11724
11725             /* Don't allow a static member function in a class, and forbid
11726                declaring main to be static.  */
11727             if (TREE_CODE (type) == METHOD_TYPE)
11728               {
11729                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11730                 illegal_static = 1;
11731               }
11732             else if (current_function_decl)
11733               {
11734                 /* FIXME need arm citation */
11735                 error ("cannot declare static function inside another function");
11736                 illegal_static = 1;
11737               }
11738
11739             if (illegal_static)
11740               {
11741                 staticp = 0;
11742                 RIDBIT_RESET (RID_STATIC, specbits);
11743               }
11744           }
11745       }
11746     else
11747       {
11748         /* It's a variable.  */
11749
11750         /* An uninitialized decl with `extern' is a reference.  */
11751         decl = grokvardecl (type, declarator, &specbits,
11752                             initialized,
11753                             (type_quals & TYPE_QUAL_CONST) != 0,
11754                             in_namespace);
11755         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11756                         inlinep, friendp, raises != NULL_TREE);
11757
11758         if (ctype)
11759           {
11760             DECL_CONTEXT (decl) = ctype;
11761             if (staticp == 1)
11762               {
11763                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11764                 staticp = 0;
11765                 RIDBIT_RESET (RID_STATIC, specbits);
11766               }
11767             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11768               {
11769                 cp_error ("static member `%D' declared `register'", decl);
11770                 RIDBIT_RESET (RID_REGISTER, specbits);
11771               }
11772             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11773               {
11774                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11775                             decl);
11776                 RIDBIT_RESET (RID_EXTERN, specbits);
11777               }
11778           }
11779       }
11780
11781     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11782
11783     /* Record `register' declaration for warnings on &
11784        and in case doing stupid register allocation.  */
11785
11786     if (RIDBIT_SETP (RID_REGISTER, specbits))
11787       DECL_REGISTER (decl) = 1;
11788
11789     if (RIDBIT_SETP (RID_EXTERN, specbits))
11790       DECL_THIS_EXTERN (decl) = 1;
11791
11792     if (RIDBIT_SETP (RID_STATIC, specbits))
11793       DECL_THIS_STATIC (decl) = 1;
11794
11795     /* Record constancy and volatility.  There's no need to do this
11796        when processing a template; we'll do this for the instantiated
11797        declaration based on the type of DECL.  */
11798     if (!processing_template_decl)
11799       c_apply_type_quals_to_decl (type_quals, decl);
11800
11801     return decl;
11802   }
11803 }
11804 \f
11805 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11806    An empty exprlist is a parmlist.  An exprlist which
11807    contains only identifiers at the global level
11808    is a parmlist.  Otherwise, it is an exprlist.  */
11809
11810 int
11811 parmlist_is_exprlist (exprs)
11812      tree exprs;
11813 {
11814   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11815     return 0;
11816
11817   if (toplevel_bindings_p ())
11818     {
11819       /* At the global level, if these are all identifiers,
11820          then it is a parmlist.  */
11821       while (exprs)
11822         {
11823           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11824             return 1;
11825           exprs = TREE_CHAIN (exprs);
11826         }
11827       return 0;
11828     }
11829   return 1;
11830 }
11831
11832 /* Subroutine of start_function.  Ensure that each of the parameter
11833    types (as listed in PARMS) is complete, as is required for a
11834    function definition.  */
11835
11836 static void
11837 require_complete_types_for_parms (parms)
11838      tree parms;
11839 {
11840   for (; parms; parms = TREE_CHAIN (parms))
11841     {
11842       tree type = TREE_TYPE (parms);
11843
11844       /* Try to complete the TYPE.  */
11845       type = complete_type (type);
11846
11847       if (type == error_mark_node)
11848         continue;
11849
11850       if (!COMPLETE_TYPE_P (type))
11851         {
11852           if (DECL_NAME (parms))
11853             error ("parameter `%s' has incomplete type",
11854                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11855           else
11856             error ("parameter has incomplete type");
11857           TREE_TYPE (parms) = error_mark_node;
11858         }
11859       else
11860         layout_decl (parms, 0);
11861     }
11862 }
11863
11864 /* Returns non-zero if T is a local variable.  */
11865
11866 int
11867 local_variable_p (t)
11868      tree t;
11869 {
11870   if ((TREE_CODE (t) == VAR_DECL
11871        /* A VAR_DECL with a context that is a _TYPE is a static data
11872           member.  */
11873        && !TYPE_P (CP_DECL_CONTEXT (t))
11874        /* Any other non-local variable must be at namespace scope.  */
11875        && !DECL_NAMESPACE_SCOPE_P (t))
11876       || (TREE_CODE (t) == PARM_DECL))
11877     return 1;
11878
11879   return 0;
11880 }
11881
11882 /* Returns non-zero if T is an automatic local variable or a label.
11883    (These are the declarations that need to be remapped when the code
11884    containing them is duplicated.)  */
11885
11886 int
11887 nonstatic_local_decl_p (t)
11888      tree t;
11889 {
11890   return ((local_variable_p (t) && !TREE_STATIC (t))
11891           || TREE_CODE (t) == LABEL_DECL
11892           || TREE_CODE (t) == RESULT_DECL);
11893 }
11894
11895 /* Like local_variable_p, but suitable for use as a tree-walking
11896    function.  */
11897
11898 static tree
11899 local_variable_p_walkfn (tp, walk_subtrees, data)
11900      tree *tp;
11901      int *walk_subtrees ATTRIBUTE_UNUSED;
11902      void *data ATTRIBUTE_UNUSED;
11903 {
11904   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11905           ? *tp : NULL_TREE);
11906 }
11907
11908 /* Check that ARG, which is a default-argument expression for a
11909    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11910    something goes wrong.  DECL may also be a _TYPE node, rather than a
11911    DECL, if there is no DECL available.  */
11912
11913 tree
11914 check_default_argument (decl, arg)
11915      tree decl;
11916      tree arg;
11917 {
11918   tree var;
11919   tree decl_type;
11920
11921   if (TREE_CODE (arg) == DEFAULT_ARG)
11922     /* We get a DEFAULT_ARG when looking at an in-class declaration
11923        with a default argument.  Ignore the argument for now; we'll
11924        deal with it after the class is complete.  */
11925     return arg;
11926
11927   if (processing_template_decl || uses_template_parms (arg))
11928     /* We don't do anything checking until instantiation-time.  Note
11929        that there may be uninstantiated arguments even for an
11930        instantiated function, since default arguments are not
11931        instantiated until they are needed.  */
11932     return arg;
11933
11934   if (TYPE_P (decl))
11935     {
11936       decl_type = decl;
11937       decl = NULL_TREE;
11938     }
11939   else
11940     decl_type = TREE_TYPE (decl);
11941
11942   if (arg == error_mark_node
11943       || decl == error_mark_node
11944       || TREE_TYPE (arg) == error_mark_node
11945       || decl_type == error_mark_node)
11946     /* Something already went wrong.  There's no need to check
11947        further.  */
11948     return error_mark_node;
11949
11950   /* [dcl.fct.default]
11951
11952      A default argument expression is implicitly converted to the
11953      parameter type.  */
11954   if (!TREE_TYPE (arg)
11955       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11956     {
11957       if (decl)
11958         cp_error ("default argument for `%#D' has type `%T'",
11959                   decl, TREE_TYPE (arg));
11960       else
11961         cp_error ("default argument for parameter of type `%T' has type `%T'",
11962                   decl_type, TREE_TYPE (arg));
11963
11964       return error_mark_node;
11965     }
11966
11967   /* [dcl.fct.default]
11968
11969      Local variables shall not be used in default argument
11970      expressions.
11971
11972      The keyword `this' shall not be used in a default argument of a
11973      member function.  */
11974   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11975   if (var)
11976     {
11977       cp_error ("default argument `%E' uses local variable `%D'",
11978                 arg, var);
11979       return error_mark_node;
11980     }
11981
11982   /* All is well.  */
11983   return arg;
11984 }
11985
11986 /* Decode the list of parameter types for a function type.
11987    Given the list of things declared inside the parens,
11988    return a list of types.
11989
11990    The list we receive can have three kinds of elements:
11991    an IDENTIFIER_NODE for names given without types,
11992    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11993    or void_type_node, to mark the end of an argument list
11994    when additional arguments are not permitted (... was not used).
11995
11996    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11997    a mere declaration.  A nonempty identifier-list gets an error message
11998    when FUNCDEF_FLAG is zero.
11999    If FUNCDEF_FLAG is 1, then parameter types must be complete.
12000    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
12001
12002    If all elements of the input list contain types,
12003    we return a list of the types.
12004    If all elements contain no type (except perhaps a void_type_node
12005    at the end), we return a null list.
12006    If some have types and some do not, it is an error, and we
12007    return a null list.
12008
12009    Also set last_function_parms to either
12010    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
12011    A list of names is converted to a chain of PARM_DECLs
12012    by store_parm_decls so that ultimately it is always a chain of decls.
12013
12014    Note that in C++, parameters can take default values.  These default
12015    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
12016    an error to specify default values which are followed by parameters
12017    that have no default values, or an ELLIPSES.  For simplicities sake,
12018    only parameters which are specified with their types can take on
12019    default values.  */
12020
12021 static tree
12022 grokparms (first_parm, funcdef_flag)
12023      tree first_parm;
12024      int funcdef_flag;
12025 {
12026   tree result = NULL_TREE;
12027   tree decls = NULL_TREE;
12028
12029   if (first_parm != NULL_TREE
12030       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
12031     {
12032       if (! funcdef_flag)
12033         pedwarn ("parameter names (without types) in function declaration");
12034       last_function_parms = first_parm;
12035       return NULL_TREE;
12036     }
12037   else if (first_parm != NULL_TREE
12038            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
12039            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
12040     my_friendly_abort (145);
12041   else
12042     {
12043       /* Types were specified.  This is a list of declarators
12044          each represented as a TREE_LIST node.  */
12045       register tree parm, chain;
12046       int any_init = 0, any_error = 0;
12047
12048       if (first_parm != NULL_TREE)
12049         {
12050           tree last_result = NULL_TREE;
12051           tree last_decl = NULL_TREE;
12052
12053           for (parm = first_parm; parm != NULL_TREE; parm = chain)
12054             {
12055               tree type = NULL_TREE, list_node = parm;
12056               register tree decl = TREE_VALUE (parm);
12057               tree init = TREE_PURPOSE (parm);
12058
12059               chain = TREE_CHAIN (parm);
12060               /* @@ weak defense against parse errors.  */
12061               if (TREE_CODE (decl) != VOID_TYPE
12062                   && TREE_CODE (decl) != TREE_LIST)
12063                 {
12064                   /* Give various messages as the need arises.  */
12065                   if (TREE_CODE (decl) == STRING_CST)
12066                     cp_error ("invalid string constant `%E'", decl);
12067                   else if (TREE_CODE (decl) == INTEGER_CST)
12068                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12069                   continue;
12070                 }
12071
12072               if (TREE_CODE (decl) != VOID_TYPE)
12073                 {
12074                   decl = grokdeclarator (TREE_VALUE (decl),
12075                                          TREE_PURPOSE (decl),
12076                                          PARM, init != NULL_TREE,
12077                                          NULL_TREE);
12078                   if (! decl || TREE_TYPE (decl) == error_mark_node)
12079                     continue;
12080
12081                   /* Top-level qualifiers on the parameters are
12082                      ignored for function types.  */
12083                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
12084
12085                   if (TREE_CODE (type) == VOID_TYPE)
12086                     decl = void_type_node;
12087                   else if (TREE_CODE (type) == METHOD_TYPE)
12088                     {
12089                       if (DECL_NAME (decl))
12090                         /* Cannot use the decl here because
12091                            we don't have DECL_CONTEXT set up yet.  */
12092                         cp_error ("parameter `%D' invalidly declared method type",
12093                                   DECL_NAME (decl));
12094                       else
12095                         error ("parameter invalidly declared method type");
12096                       type = build_pointer_type (type);
12097                       TREE_TYPE (decl) = type;
12098                     }
12099                   else if (TREE_CODE (type) == OFFSET_TYPE)
12100                     {
12101                       if (DECL_NAME (decl))
12102                         cp_error ("parameter `%D' invalidly declared offset type",
12103                                   DECL_NAME (decl));
12104                       else
12105                         error ("parameter invalidly declared offset type");
12106                       type = build_pointer_type (type);
12107                       TREE_TYPE (decl) = type;
12108                     }
12109                   else if (abstract_virtuals_error (decl, type))
12110                     any_error = 1;  /* Seems like a good idea. */
12111                   else if (POINTER_TYPE_P (type))
12112                     {
12113                       tree t = type;
12114                       while (POINTER_TYPE_P (t)
12115                              || (TREE_CODE (t) == ARRAY_TYPE
12116                                  && TYPE_DOMAIN (t) != NULL_TREE))
12117                         t = TREE_TYPE (t);
12118                       if (TREE_CODE (t) == ARRAY_TYPE)
12119                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
12120                                   type,
12121                                   TYPE_PTR_P (type) ? "pointer" : "reference");
12122                     }
12123                 }
12124
12125               if (TREE_CODE (decl) == VOID_TYPE)
12126                 {
12127                   if (result == NULL_TREE)
12128                     {
12129                       result = void_list_node;
12130                       last_result = result;
12131                     }
12132                   else
12133                     {
12134                       TREE_CHAIN (last_result) = void_list_node;
12135                       last_result = void_list_node;
12136                     }
12137                   if (chain
12138                       && (chain != void_list_node || TREE_CHAIN (chain)))
12139                     error ("`void' in parameter list must be entire list");
12140                   break;
12141                 }
12142
12143               /* Since there is a prototype, args are passed in their own types.  */
12144               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12145               if (PROMOTE_PROTOTYPES
12146                   && (TREE_CODE (type) == INTEGER_TYPE
12147                       || TREE_CODE (type) == ENUMERAL_TYPE)
12148                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12149                 DECL_ARG_TYPE (decl) = integer_type_node;
12150               if (!any_error && init)
12151                 {
12152                   any_init++;
12153                   init = check_default_argument (decl, init);
12154                 }
12155               else
12156                 init = NULL_TREE;
12157
12158               if (decls == NULL_TREE)
12159                 {
12160                   decls = decl;
12161                   last_decl = decls;
12162                 }
12163               else
12164                 {
12165                   TREE_CHAIN (last_decl) = decl;
12166                   last_decl = decl;
12167                 }
12168               list_node = tree_cons (init, type, NULL_TREE);
12169               if (result == NULL_TREE)
12170                 {
12171                   result = list_node;
12172                   last_result = result;
12173                 }
12174               else
12175                 {
12176                   TREE_CHAIN (last_result) = list_node;
12177                   last_result = list_node;
12178                 }
12179             }
12180           if (last_result)
12181             TREE_CHAIN (last_result) = NULL_TREE;
12182           /* If there are no parameters, and the function does not end
12183              with `...', then last_decl will be NULL_TREE.  */
12184           if (last_decl != NULL_TREE)
12185             TREE_CHAIN (last_decl) = NULL_TREE;
12186         }
12187     }
12188
12189   last_function_parms = decls;
12190
12191   return result;
12192 }
12193
12194 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12195    FUNCTION_TYPE with the newly parsed version of its default argument, which
12196    was previously digested as text.  See snarf_defarg et al in lex.c.  */
12197
12198 void
12199 replace_defarg (arg, init)
12200      tree arg, init;
12201 {
12202   if (! processing_template_decl
12203       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
12204     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12205                 TREE_TYPE (init), TREE_VALUE (arg));
12206   TREE_PURPOSE (arg) = init;
12207 }
12208 \f
12209 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12210    D's arguments allow it to be a copy constructor, or copy assignment
12211    operator.  */
12212
12213 int
12214 copy_args_p (d)
12215      tree d;
12216 {
12217   tree t;
12218
12219   if (!DECL_FUNCTION_MEMBER_P (d))
12220     return 0;
12221
12222   t = FUNCTION_ARG_CHAIN (d);
12223   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
12224     t = TREE_CHAIN (t);
12225   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12226       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12227           == DECL_CONTEXT (d))
12228       && (TREE_CHAIN (t) == NULL_TREE
12229           || TREE_CHAIN (t) == void_list_node
12230           || TREE_PURPOSE (TREE_CHAIN (t))))
12231     return 1;
12232   return 0;
12233 }
12234
12235 /* These memoizing functions keep track of special properties which
12236    a class may have.  `grok_ctor_properties' notices whether a class
12237    has a constructor of the form X(X&), and also complains
12238    if the class has a constructor of the form X(X).
12239    `grok_op_properties' takes notice of the various forms of
12240    operator= which are defined, as well as what sorts of type conversion
12241    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12242
12243 int
12244 grok_ctor_properties (ctype, decl)
12245      tree ctype, decl;
12246 {
12247   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
12248   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12249
12250   /* When a type has virtual baseclasses, a magical first int argument is
12251      added to any ctor so we can tell if the class has been initialized
12252      yet.  This could screw things up in this function, so we deliberately
12253      ignore the leading int if we're in that situation.  */
12254   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
12255     {
12256       my_friendly_assert (parmtypes
12257                           && TREE_VALUE (parmtypes) == integer_type_node,
12258                           980529);
12259       parmtypes = TREE_CHAIN (parmtypes);
12260       parmtype = TREE_VALUE (parmtypes);
12261     }
12262
12263   /* [class.copy]
12264
12265      A non-template constructor for class X is a copy constructor if
12266      its first parameter is of type X&, const X&, volatile X& or const
12267      volatile X&, and either there are no other parameters or else all
12268      other parameters have default arguments.  */
12269   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12270       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12271       && (TREE_CHAIN (parmtypes) == NULL_TREE
12272           || TREE_CHAIN (parmtypes) == void_list_node
12273           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12274       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12275            && is_member_template (DECL_TI_TEMPLATE (decl))))
12276     {
12277       TYPE_HAS_INIT_REF (ctype) = 1;
12278       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12279         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12280     }
12281   /* [class.copy]
12282
12283      A declaration of a constructor for a class X is ill-formed if its
12284      first parameter is of type (optionally cv-qualified) X and either
12285      there are no other parameters or else all other parameters have
12286      default arguments.
12287
12288      We *don't* complain about member template instantiations that
12289      have this form, though; they can occur as we try to decide what
12290      constructor to use during overload resolution.  Since overload
12291      resolution will never prefer such a constructor to the
12292      non-template copy constructor (which is either explicitly or
12293      implicitly defined), there's no need to worry about their
12294      existence.  Theoretically, they should never even be
12295      instantiated, but that's hard to forestall.  */
12296   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12297            && (TREE_CHAIN (parmtypes) == NULL_TREE
12298                || TREE_CHAIN (parmtypes) == void_list_node
12299                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12300            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12301                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12302     {
12303       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12304                 ctype, ctype);
12305       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12306       return 0;
12307     }
12308   else if (TREE_CODE (parmtype) == VOID_TYPE
12309            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12310     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12311
12312   return 1;
12313 }
12314
12315 /* An operator with this code is unary, but can also be binary.  */
12316
12317 static int
12318 ambi_op_p (code)
12319      enum tree_code code;
12320 {
12321   return (code == INDIRECT_REF
12322           || code == ADDR_EXPR
12323           || code == CONVERT_EXPR
12324           || code == NEGATE_EXPR
12325           || code == PREINCREMENT_EXPR
12326           || code == PREDECREMENT_EXPR);
12327 }
12328
12329 /* An operator with this name can only be unary.  */
12330
12331 static int
12332 unary_op_p (code)
12333      enum tree_code code;
12334 {
12335   return (code == TRUTH_NOT_EXPR
12336           || code == BIT_NOT_EXPR
12337           || code == COMPONENT_REF
12338           || code == TYPE_EXPR);
12339 }
12340
12341 /* Do a little sanity-checking on how they declared their operator.  */
12342
12343 void
12344 grok_op_properties (decl, virtualp, friendp)
12345      tree decl;
12346      int virtualp, friendp;
12347 {
12348   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12349   tree argtype;
12350   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12351   tree name = DECL_NAME (decl);
12352   enum tree_code operator_code;
12353   int arity;
12354
12355   /* Count the number of arguments.  */
12356   for (argtype = argtypes, arity = 0;
12357        argtype && argtype != void_list_node;
12358        argtype = TREE_CHAIN (argtype))
12359     ++arity;
12360
12361   if (current_class_type == NULL_TREE)
12362     friendp = 1;
12363
12364   if (DECL_CONV_FN_P (decl))
12365     operator_code = TYPE_EXPR;
12366   else
12367     do
12368       {
12369 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P)  \
12370         if (ansi_opname (CODE) == name)                                     \
12371           {                                                                 \
12372             operator_code = CODE;                                           \
12373             break;                                                          \
12374           }                                                                 \
12375         else if (ansi_assopname (CODE) == name)                             \
12376           {                                                                 \
12377             operator_code = CODE;                                           \
12378             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;                          \
12379             break;                                                          \
12380           }
12381
12382 #include "operators.def"
12383 #undef DEF_OPERATOR
12384
12385         my_friendly_abort (20000527);
12386       }
12387     while (0);
12388   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12389   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12390
12391   if (! friendp)
12392     {
12393       switch (operator_code)
12394         {
12395         case CALL_EXPR:
12396           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12397           break;
12398
12399         case ARRAY_REF:
12400           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12401           break;
12402
12403         case COMPONENT_REF:
12404         case MEMBER_REF:
12405           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12406           break;
12407
12408         case NEW_EXPR:
12409           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12410           break;
12411
12412         case DELETE_EXPR:
12413           TYPE_GETS_DELETE (current_class_type) |= 1;
12414           break;
12415
12416         case VEC_NEW_EXPR:
12417           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12418           break;
12419
12420         case VEC_DELETE_EXPR:
12421           TYPE_GETS_DELETE (current_class_type) |= 2;
12422           break;
12423
12424         default:
12425           break;
12426         }
12427     }
12428
12429   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12430     {
12431       /* When the compiler encounters the definition of A::operator new, it
12432          doesn't look at the class declaration to find out if it's static.  */
12433       if (methodp)
12434         revert_static_member_fn (decl);
12435
12436       /* Take care of function decl if we had syntax errors.  */
12437       if (argtypes == NULL_TREE)
12438         TREE_TYPE (decl)
12439           = build_function_type (ptr_type_node,
12440                                  hash_tree_chain (integer_type_node,
12441                                                   void_list_node));
12442       else
12443         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12444     }
12445   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12446     {
12447       if (methodp)
12448         revert_static_member_fn (decl);
12449
12450       if (argtypes == NULL_TREE)
12451         TREE_TYPE (decl)
12452           = build_function_type (void_type_node,
12453                                  hash_tree_chain (ptr_type_node,
12454                                                   void_list_node));
12455       else
12456         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12457     }
12458   else
12459     {
12460       /* An operator function must either be a non-static member function
12461          or have at least one parameter of a class, a reference to a class,
12462          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12463       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12464         {
12465           if (operator_code == TYPE_EXPR
12466               || operator_code == CALL_EXPR
12467               || operator_code == COMPONENT_REF
12468               || operator_code == ARRAY_REF
12469               || operator_code == NOP_EXPR)
12470             cp_error ("`%D' must be a nonstatic member function", decl);
12471           else
12472             {
12473               tree p = argtypes;
12474
12475               if (DECL_STATIC_FUNCTION_P (decl))
12476                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12477
12478               if (p)
12479                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12480                   {
12481                     tree arg = TREE_VALUE (p);
12482                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12483                       arg = TREE_TYPE (arg);
12484
12485                     /* This lets bad template code slip through.  */
12486                     if (IS_AGGR_TYPE (arg)
12487                         || TREE_CODE (arg) == ENUMERAL_TYPE
12488                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12489                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12490                       goto foundaggr;
12491                   }
12492               cp_error
12493                 ("`%D' must have an argument of class or enumerated type",
12494                  decl);
12495             foundaggr:
12496               ;
12497             }
12498         }
12499
12500       if (operator_code == CALL_EXPR)
12501         return;                 /* No restrictions on args. */
12502
12503       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12504         {
12505           tree t = TREE_TYPE (name);
12506           if (! friendp)
12507             {
12508               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12509               const char *what = 0;
12510
12511               if (ref)
12512                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12513
12514               if (TREE_CODE (t) == VOID_TYPE)
12515                 what = "void";
12516               else if (t == current_class_type)
12517                 what = "the same type";
12518               /* Don't force t to be complete here.  */
12519               else if (IS_AGGR_TYPE (t)
12520                        && COMPLETE_TYPE_P (t)
12521                        && DERIVED_FROM_P (t, current_class_type))
12522                 what = "a base class";
12523
12524               if (what)
12525                 warning ("conversion to %s%s will never use a type conversion operator",
12526                          ref ? "a reference to " : "", what);
12527             }
12528         }
12529
12530       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12531           && operator_code == NOP_EXPR)
12532         {
12533           tree parmtype;
12534
12535           if (arity != 2 && methodp)
12536             {
12537               cp_error ("`%D' must take exactly one argument", decl);
12538               return;
12539             }
12540           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12541
12542           /* [class.copy]
12543
12544              A user-declared copy assignment operator X::operator= is
12545              a non-static non-template member function of class X with
12546              exactly one parameter of type X, X&, const X&, volatile
12547              X& or const volatile X&.  */
12548           if (copy_assignment_arg_p (parmtype, virtualp)
12549               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12550                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12551               && ! friendp)
12552             {
12553               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12554               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12555                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12556                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12557             }
12558         }
12559       else if (operator_code == COND_EXPR)
12560         {
12561           /* 13.4.0.3 */
12562           cp_error ("ISO C++ prohibits overloading operator ?:");
12563         }
12564       else if (ambi_op_p (operator_code))
12565         {
12566           if (arity == 1)
12567             /* We pick the one-argument operator codes by default, so
12568                we don't have to change anything.  */
12569             ;
12570           else if (arity == 2)
12571             {
12572               /* If we thought this was a unary operator, we now know
12573                  it to be a binary operator.  */
12574               switch (operator_code)
12575                 {
12576                 case INDIRECT_REF:
12577                   operator_code = MULT_EXPR;
12578                   break;
12579
12580                 case ADDR_EXPR:
12581                   operator_code = BIT_AND_EXPR;
12582                   break;
12583
12584                 case CONVERT_EXPR:
12585                   operator_code = PLUS_EXPR;
12586                   break;
12587
12588                 case NEGATE_EXPR:
12589                   operator_code = MINUS_EXPR;
12590                   break;
12591
12592                 case PREINCREMENT_EXPR:
12593                   operator_code = POSTINCREMENT_EXPR;
12594                   break;
12595
12596                 case PREDECREMENT_EXPR:
12597                   operator_code = POSTDECREMENT_EXPR;
12598                   break;
12599
12600                 default:
12601                   my_friendly_abort (20000527);
12602                 }
12603
12604               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12605
12606               if ((operator_code == POSTINCREMENT_EXPR
12607                    || operator_code == POSTDECREMENT_EXPR)
12608                   && ! processing_template_decl
12609                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12610                 {
12611                   if (methodp)
12612                     cp_error ("postfix `%D' must take `int' as its argument",
12613                               decl);
12614                   else
12615                     cp_error
12616                       ("postfix `%D' must take `int' as its second argument",
12617                        decl);
12618                 }
12619             }
12620           else
12621             {
12622               if (methodp)
12623                 cp_error ("`%D' must take either zero or one argument", decl);
12624               else
12625                 cp_error ("`%D' must take either one or two arguments", decl);
12626             }
12627
12628           /* More Effective C++ rule 6.  */
12629           if (warn_ecpp
12630               && (operator_code == POSTINCREMENT_EXPR
12631                   || operator_code == POSTDECREMENT_EXPR
12632                   || operator_code == PREINCREMENT_EXPR
12633                   || operator_code == PREDECREMENT_EXPR))
12634             {
12635               tree arg = TREE_VALUE (argtypes);
12636               tree ret = TREE_TYPE (TREE_TYPE (decl));
12637               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12638                 arg = TREE_TYPE (arg);
12639               arg = TYPE_MAIN_VARIANT (arg);
12640               if (operator_code == PREINCREMENT_EXPR
12641                   || operator_code == PREDECREMENT_EXPR)
12642                 {
12643                   if (TREE_CODE (ret) != REFERENCE_TYPE
12644                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12645                                        arg))
12646                     cp_warning ("prefix `%D' should return `%T'", decl,
12647                                 build_reference_type (arg));
12648                 }
12649               else
12650                 {
12651                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12652                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12653                 }
12654             }
12655         }
12656       else if (unary_op_p (operator_code))
12657         {
12658           if (arity != 1)
12659             {
12660               if (methodp)
12661                 cp_error ("`%D' must take `void'", decl);
12662               else
12663                 cp_error ("`%D' must take exactly one argument", decl);
12664             }
12665         }
12666       else /* if (binary_op_p (operator_code)) */
12667         {
12668           if (arity != 2)
12669             {
12670               if (methodp)
12671                 cp_error ("`%D' must take exactly one argument", decl);
12672               else
12673                 cp_error ("`%D' must take exactly two arguments", decl);
12674             }
12675
12676           /* More Effective C++ rule 7.  */
12677           if (warn_ecpp
12678               && (operator_code == TRUTH_ANDIF_EXPR
12679                   || operator_code == TRUTH_ORIF_EXPR
12680                   || operator_code == COMPOUND_EXPR))
12681             cp_warning ("user-defined `%D' always evaluates both arguments",
12682                         decl);
12683         }
12684
12685       /* Effective C++ rule 23.  */
12686       if (warn_ecpp
12687           && arity == 2
12688           && (operator_code == PLUS_EXPR
12689               || operator_code == MINUS_EXPR
12690               || operator_code == TRUNC_DIV_EXPR
12691               || operator_code == MULT_EXPR)
12692           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12693         cp_warning ("`%D' should return by value", decl);
12694
12695       /* 13.4.0.8 */
12696       for (; argtypes && argtypes != void_list_node;
12697           argtypes = TREE_CHAIN (argtypes))
12698         if (TREE_PURPOSE (argtypes))
12699           {
12700             TREE_PURPOSE (argtypes) = NULL_TREE;
12701             if (operator_code == POSTINCREMENT_EXPR
12702                 || operator_code == POSTDECREMENT_EXPR)
12703               {
12704                 if (pedantic)
12705                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12706               }
12707             else
12708               cp_error ("`%D' cannot have default arguments", decl);
12709           }
12710
12711     }
12712 }
12713 \f
12714 static const char *
12715 tag_name (code)
12716      enum tag_types code;
12717 {
12718   switch (code)
12719     {
12720     case record_type:
12721       return "struct";
12722     case class_type:
12723       return "class";
12724     case union_type:
12725       return "union ";
12726     case enum_type:
12727       return "enum";
12728     default:
12729       my_friendly_abort (981122);
12730     }
12731 }
12732
12733 /* Get the struct, enum or union (CODE says which) with tag NAME.
12734    Define the tag as a forward-reference if it is not defined.
12735
12736    C++: If a class derivation is given, process it here, and report
12737    an error if multiple derivation declarations are not identical.
12738
12739    If this is a definition, come in through xref_tag and only look in
12740    the current frame for the name (since C++ allows new names in any
12741    scope.)  */
12742
12743 tree
12744 xref_tag (code_type_node, name, globalize)
12745      tree code_type_node;
12746      tree name;
12747      int globalize;
12748 {
12749   enum tag_types tag_code;
12750   enum tree_code code;
12751   register tree ref, t;
12752   struct binding_level *b = current_binding_level;
12753   int got_type = 0;
12754   tree attributes = NULL_TREE;
12755   tree context = NULL_TREE;
12756
12757   /* If we are called from the parser, code_type_node will sometimes be a
12758      TREE_LIST.  This indicates that the user wrote
12759      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12760      use them later.  */
12761   if (TREE_CODE (code_type_node) == TREE_LIST)
12762     {
12763       attributes = TREE_PURPOSE (code_type_node);
12764       code_type_node = TREE_VALUE (code_type_node);
12765     }
12766
12767   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12768   switch (tag_code)
12769     {
12770     case record_type:
12771     case class_type:
12772       code = RECORD_TYPE;
12773       break;
12774     case union_type:
12775       code = UNION_TYPE;
12776       break;
12777     case enum_type:
12778       code = ENUMERAL_TYPE;
12779       break;
12780     default:
12781       my_friendly_abort (18);
12782     }
12783
12784   /* If a cross reference is requested, look up the type
12785      already defined for this tag and return it.  */
12786   if (TYPE_P (name))
12787     {
12788       t = name;
12789       name = TYPE_IDENTIFIER (t);
12790       got_type = 1;
12791     }
12792   else
12793     t = IDENTIFIER_TYPE_VALUE (name);
12794
12795   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12796       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12797     t = NULL_TREE;
12798
12799   if (! globalize)
12800     {
12801       /* If we know we are defining this tag, only look it up in
12802          this scope and don't try to find it as a type.  */
12803       ref = lookup_tag (code, name, b, 1);
12804     }
12805   else
12806     {
12807       if (t)
12808         {
12809           /* [dcl.type.elab] If the identifier resolves to a
12810              typedef-name or a template type-parameter, the
12811              elaborated-type-specifier is ill-formed.  */
12812           if (t != TYPE_MAIN_VARIANT (t)
12813               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12814             cp_pedwarn ("using typedef-name `%D' after `%s'",
12815                         TYPE_NAME (t), tag_name (tag_code));
12816           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12817             cp_error ("using template type parameter `%T' after `%s'",
12818                       t, tag_name (tag_code));
12819
12820           ref = t;
12821         }
12822       else
12823         ref = lookup_tag (code, name, b, 0);
12824
12825       if (! ref)
12826         {
12827           /* Try finding it as a type declaration.  If that wins,
12828              use it.  */
12829           ref = lookup_name (name, 1);
12830
12831           if (ref != NULL_TREE
12832               && processing_template_decl
12833               && DECL_CLASS_TEMPLATE_P (ref)
12834               && template_class_depth (current_class_type) == 0)
12835             /* Since GLOBALIZE is true, we're declaring a global
12836                template, so we want this type.  */
12837             ref = DECL_TEMPLATE_RESULT (ref);
12838
12839           if (ref && TREE_CODE (ref) == TYPE_DECL
12840               && TREE_CODE (TREE_TYPE (ref)) == code)
12841             ref = TREE_TYPE (ref);
12842           else
12843             ref = NULL_TREE;
12844         }
12845
12846       if (ref && current_class_type
12847           && template_class_depth (current_class_type)
12848           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12849         {
12850           /* Since GLOBALIZE is non-zero, we are not looking at a
12851              definition of this tag.  Since, in addition, we are currently
12852              processing a (member) template declaration of a template
12853              class, we must be very careful; consider:
12854
12855                template <class X>
12856                struct S1
12857
12858                template <class U>
12859                struct S2
12860                { template <class V>
12861                friend struct S1; };
12862
12863              Here, the S2::S1 declaration should not be confused with the
12864              outer declaration.  In particular, the inner version should
12865              have a template parameter of level 2, not level 1.  This
12866              would be particularly important if the member declaration
12867              were instead:
12868
12869                template <class V = U> friend struct S1;
12870
12871              say, when we should tsubst into `U' when instantiating
12872              S2.  On the other hand, when presented with:
12873
12874                  template <class T>
12875                  struct S1 {
12876                    template <class U>
12877                    struct S2 {};
12878                    template <class U>
12879                    friend struct S2;
12880                  };
12881
12882               we must find the inner binding eventually.  We
12883               accomplish this by making sure that the new type we
12884               create to represent this declaration has the right
12885               TYPE_CONTEXT.  */
12886           context = TYPE_CONTEXT (ref);
12887           ref = NULL_TREE;
12888         }
12889     }
12890
12891   if (! ref)
12892     {
12893       /* If no such tag is yet defined, create a forward-reference node
12894          and record it as the "definition".
12895          When a real declaration of this type is found,
12896          the forward-reference will be altered into a real type.  */
12897       if (code == ENUMERAL_TYPE)
12898         {
12899           cp_error ("use of enum `%#D' without previous declaration", name);
12900
12901           ref = make_node (ENUMERAL_TYPE);
12902
12903           /* Give the type a default layout like unsigned int
12904              to avoid crashing if it does not get defined.  */
12905           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12906           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12907           TYPE_USER_ALIGN (ref) = 0;
12908           TREE_UNSIGNED (ref) = 1;
12909           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12910           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12911           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12912
12913           /* Enable us to recognize when a type is created in class context.
12914              To do nested classes correctly, this should probably be cleared
12915              out when we leave this classes scope.  Currently this in only
12916              done in `start_enum'.  */
12917
12918           pushtag (name, ref, globalize);
12919         }
12920       else
12921         {
12922           struct binding_level *old_b = class_binding_level;
12923
12924           ref = make_aggr_type (code);
12925           TYPE_CONTEXT (ref) = context;
12926
12927 #ifdef NONNESTED_CLASSES
12928           /* Class types don't nest the way enums do.  */
12929           class_binding_level = (struct binding_level *)0;
12930 #endif
12931           pushtag (name, ref, globalize);
12932           class_binding_level = old_b;
12933         }
12934     }
12935   else
12936     {
12937       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12938         redeclare_class_template (ref, current_template_parms);
12939     }
12940
12941   /* Until the type is defined, tentatively accept whatever
12942      structure tag the user hands us.  */
12943   if (!COMPLETE_TYPE_P (ref)
12944       && ref != current_class_type
12945       /* Have to check this, in case we have contradictory tag info.  */
12946       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12947     {
12948       if (tag_code == class_type)
12949         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12950       else if (tag_code == record_type)
12951         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12952     }
12953
12954   TREE_TYPE (ref) = attributes;
12955
12956   return ref;
12957 }
12958
12959 tree
12960 xref_tag_from_type (old, id, globalize)
12961      tree old, id;
12962      int globalize;
12963 {
12964   tree code_type_node;
12965
12966   if (TREE_CODE (old) == RECORD_TYPE)
12967     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12968                       ? class_type_node : record_type_node);
12969   else
12970     code_type_node = union_type_node;
12971
12972   if (id == NULL_TREE)
12973     id = TYPE_IDENTIFIER (old);
12974
12975   return xref_tag (code_type_node, id, globalize);
12976 }
12977
12978 /* REF is a type (named NAME), for which we have just seen some
12979    baseclasses.  BINFO is a list of those baseclasses; the
12980    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12981    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12982    struct, or union.  */
12983
12984 void
12985 xref_basetypes (code_type_node, name, ref, binfo)
12986      tree code_type_node;
12987      tree name, ref;
12988      tree binfo;
12989 {
12990   /* In the declaration `A : X, Y, ... Z' we mark all the types
12991      (A, X, Y, ..., Z) so we can check for duplicates.  */
12992   tree binfos;
12993   tree base;
12994
12995   int i, len;
12996   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12997
12998   if (tag_code == union_type)
12999     {
13000       cp_error ("derived union `%T' invalid", ref);
13001       return;
13002     }
13003
13004   len = list_length (binfo);
13005
13006   /* First, make sure that any templates in base-classes are
13007      instantiated.  This ensures that if we call ourselves recursively
13008      we do not get confused about which classes are marked and which
13009      are not.  */
13010   for (base = binfo; base; base = TREE_CHAIN (base))
13011     complete_type (TREE_VALUE (base));
13012
13013   SET_CLASSTYPE_MARKED (ref);
13014   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
13015
13016   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
13017     {
13018       /* The base of a derived struct is public by default.  */
13019       int via_public
13020         = (TREE_PURPOSE (binfo) == access_public_node
13021            || TREE_PURPOSE (binfo) == access_public_virtual_node
13022            || (tag_code != class_type
13023                && (TREE_PURPOSE (binfo) == access_default_node
13024                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
13025       int via_protected
13026         = (TREE_PURPOSE (binfo) == access_protected_node
13027            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
13028       int via_virtual
13029         = (TREE_PURPOSE (binfo) == access_private_virtual_node
13030            || TREE_PURPOSE (binfo) == access_protected_virtual_node
13031            || TREE_PURPOSE (binfo) == access_public_virtual_node
13032            || TREE_PURPOSE (binfo) == access_default_virtual_node);
13033       tree basetype = TREE_VALUE (binfo);
13034       tree base_binfo;
13035
13036       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
13037         basetype = TREE_TYPE (basetype);
13038       if (!basetype
13039           || (TREE_CODE (basetype) != RECORD_TYPE
13040               && TREE_CODE (basetype) != TYPENAME_TYPE
13041               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
13042               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
13043         {
13044           cp_error ("base type `%T' fails to be a struct or class type",
13045                     TREE_VALUE (binfo));
13046           continue;
13047         }
13048
13049       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
13050
13051       /* This code replaces similar code in layout_basetypes.
13052          We put the complete_type first for implicit `typename'.  */
13053       if (!COMPLETE_TYPE_P (basetype)
13054           && ! (current_template_parms && uses_template_parms (basetype)))
13055         {
13056           cp_error ("base class `%T' has incomplete type", basetype);
13057           continue;
13058         }
13059       else
13060         {
13061           if (CLASSTYPE_MARKED (basetype))
13062             {
13063               if (basetype == ref)
13064                 cp_error ("recursive type `%T' undefined", basetype);
13065               else
13066                 cp_error ("duplicate base type `%T' invalid", basetype);
13067               continue;
13068             }
13069
13070           if (TYPE_FOR_JAVA (basetype)
13071               && (current_lang_stack
13072                   == &VARRAY_TREE (current_lang_base, 0)))
13073             TYPE_FOR_JAVA (ref) = 1;
13074
13075           /* Note that the BINFO records which describe individual
13076              inheritances are *not* shared in the lattice!  They
13077              cannot be shared because a given baseclass may be
13078              inherited with different `accessibility' by different
13079              derived classes.  (Each BINFO record describing an
13080              individual inheritance contains flags which say what
13081              the `accessibility' of that particular inheritance is.)  */
13082
13083           base_binfo
13084             = make_binfo (size_zero_node, basetype,
13085                           CLASS_TYPE_P (basetype)
13086                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13087                           CLASS_TYPE_P (basetype)
13088                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13089
13090           TREE_VEC_ELT (binfos, i) = base_binfo;
13091           TREE_VIA_PUBLIC (base_binfo) = via_public;
13092           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13093           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13094           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13095
13096           /* We need to unshare the binfos now so that lookups during class
13097              definition work.  */
13098           unshare_base_binfos (base_binfo);
13099
13100           SET_CLASSTYPE_MARKED (basetype);
13101
13102           /* We are free to modify these bits because they are meaningless
13103              at top level, and BASETYPE is a top-level type.  */
13104           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13105             {
13106               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13107               /* Converting to a virtual base class requires looking
13108                  up the offset of the virtual base.  */
13109               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13110             }
13111
13112           if (CLASS_TYPE_P (basetype))
13113             {
13114               TYPE_HAS_NEW_OPERATOR (ref)
13115                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13116               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13117                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13118               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13119               /* If the base-class uses multiple inheritance, so do we.  */
13120               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13121                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13122               /* Likewise, if converting to a base of the base may require
13123                  code, then we may need to generate code to convert to a
13124                  base as well.  */
13125               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13126                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13127             }
13128
13129           i += 1;
13130         }
13131     }
13132   if (i)
13133     TREE_VEC_LENGTH (binfos) = i;
13134   else
13135     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13136
13137   if (i > 1)
13138     {
13139       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13140       /* If there is more than one non-empty they cannot be at the same
13141          address.  */
13142       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13143     }
13144
13145   /* Unmark all the types.  */
13146   while (--i >= 0)
13147     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13148   CLEAR_CLASSTYPE_MARKED (ref);
13149
13150   /* Now that we know all the base-classes, set up the list of virtual
13151      bases.  */
13152   get_vbase_types (ref);
13153 }
13154
13155 \f
13156 /* Begin compiling the definition of an enumeration type.
13157    NAME is its name (or null if anonymous).
13158    Returns the type object, as yet incomplete.
13159    Also records info about it so that build_enumerator
13160    may be used to declare the individual values as they are read.  */
13161
13162 tree
13163 start_enum (name)
13164      tree name;
13165 {
13166   register tree enumtype = NULL_TREE;
13167   struct binding_level *b = current_binding_level;
13168
13169   /* If this is the real definition for a previous forward reference,
13170      fill in the contents in the same object that used to be the
13171      forward reference.  */
13172
13173   if (name != NULL_TREE)
13174     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13175
13176   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13177     {
13178       cp_error ("multiple definition of `%#T'", enumtype);
13179       cp_error_at ("previous definition here", enumtype);
13180       /* Clear out TYPE_VALUES, and start again.  */
13181       TYPE_VALUES (enumtype) = NULL_TREE;
13182     }
13183   else
13184     {
13185       enumtype = make_node (ENUMERAL_TYPE);
13186       pushtag (name, enumtype, 0);
13187     }
13188
13189   if (current_class_type)
13190     TREE_ADDRESSABLE (b->tags) = 1;
13191
13192   GNU_xref_decl (current_function_decl, enumtype);
13193   return enumtype;
13194 }
13195
13196 /* After processing and defining all the values of an enumeration type,
13197    install their decls in the enumeration type and finish it off.
13198    ENUMTYPE is the type object and VALUES a list of name-value pairs.
13199    Returns ENUMTYPE.  */
13200
13201 tree
13202 finish_enum (enumtype)
13203      tree enumtype;
13204 {
13205   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
13206   /* Calculate the maximum value of any enumerator in this type.  */
13207
13208   tree values = TYPE_VALUES (enumtype);
13209   if (values)
13210     {
13211       tree pair;
13212
13213       for (pair = values; pair; pair = TREE_CHAIN (pair))
13214         {
13215           tree decl;
13216           tree value;
13217
13218           /* The TREE_VALUE is a CONST_DECL for this enumeration
13219              constant.  */
13220           decl = TREE_VALUE (pair);
13221
13222           /* [dcl.enum]
13223
13224              Following the closing brace of an enum-specifier, each
13225              enumerator has the type of its enumeration.  Prior to the
13226              closing brace, the type of each enumerator is the type of
13227              its initializing value.  */
13228           TREE_TYPE (decl) = enumtype;
13229
13230           /* The DECL_INITIAL will be NULL if we are processing a
13231              template declaration and this enumeration constant had no
13232              explicit initializer.  */
13233           value = DECL_INITIAL (decl);
13234           if (value && !processing_template_decl)
13235             {
13236               /* Set the TREE_TYPE for the VALUE as well.  That's so
13237                  that when we call decl_constant_value we get an
13238                  entity of the right type (but with the constant
13239                  value).  Since we shouldn't ever call
13240                  decl_constant_value on a template type, there's no
13241                  reason to do that when processing_template_decl.
13242                  And, if the expression is something like a
13243                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13244                  wreak havoc on the intended type of the expression.
13245
13246                  Of course, there's also no point in trying to compute
13247                  minimum or maximum values if we're in a template.  */
13248               TREE_TYPE (value) = enumtype;
13249
13250               if (!minnode)
13251                 minnode = maxnode = value;
13252               else if (tree_int_cst_lt (maxnode, value))
13253                 maxnode = value;
13254               else if (tree_int_cst_lt (value, minnode))
13255                 minnode = value;
13256             }
13257
13258           if (processing_template_decl)
13259             /* If this is just a template, leave the CONST_DECL
13260                alone.  That way tsubst_copy will find CONST_DECLs for
13261                CONST_DECLs, and not INTEGER_CSTs.  */
13262             ;
13263           else
13264             /* In the list we're building up, we want the enumeration
13265                values, not the CONST_DECLs.  */
13266             TREE_VALUE (pair) = value;
13267         }
13268     }
13269   else
13270     maxnode = minnode = integer_zero_node;
13271
13272   TYPE_VALUES (enumtype) = nreverse (values);
13273
13274   if (processing_template_decl)
13275     {
13276       tree scope = current_scope ();
13277       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13278         add_tree (build_min (TAG_DEFN, enumtype));
13279     }
13280   else
13281     {
13282       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
13283       int lowprec = min_precision (minnode, unsignedp);
13284       int highprec = min_precision (maxnode, unsignedp);
13285       int precision = MAX (lowprec, highprec);
13286       tree tem;
13287
13288       TYPE_SIZE (enumtype) = NULL_TREE;
13289
13290       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13291
13292       TYPE_PRECISION (enumtype) = precision;
13293       if (unsignedp)
13294         fixup_unsigned_type (enumtype);
13295       else
13296         fixup_signed_type (enumtype);
13297
13298       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13299         /* Use the width of the narrowest normal C type which is wide
13300            enough.  */
13301         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13302                                                     (precision, 1));
13303       else
13304         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13305
13306       TYPE_SIZE (enumtype) = 0;
13307       layout_type (enumtype);
13308
13309       /* Fix up all variant types of this enum type.  */
13310       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
13311            tem = TYPE_NEXT_VARIANT (tem))
13312         {
13313           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
13314           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
13315           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
13316           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
13317           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
13318           TYPE_MODE (tem) = TYPE_MODE (enumtype);
13319           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
13320           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
13321           TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
13322           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
13323         }
13324
13325       /* Finish debugging output for this type.  */
13326       rest_of_type_compilation (enumtype, namespace_bindings_p ());
13327     }
13328
13329   return enumtype;
13330 }
13331
13332 /* Build and install a CONST_DECL for an enumeration constant of the
13333    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13334    Assignment of sequential values by default is handled here.  */
13335
13336 void
13337 build_enumerator (name, value, enumtype)
13338      tree name;
13339      tree value;
13340      tree enumtype;
13341 {
13342   tree decl;
13343   tree context;
13344   tree type;
13345   tree values;
13346
13347   /* Remove no-op casts from the value.  */
13348   if (value)
13349     STRIP_TYPE_NOPS (value);
13350
13351   if (! processing_template_decl)
13352     {
13353       /* Validate and default VALUE.  */
13354       if (value != NULL_TREE)
13355         {
13356           value = decl_constant_value (value);
13357
13358           if (TREE_CODE (value) == INTEGER_CST)
13359             {
13360               value = default_conversion (value);
13361               constant_expression_warning (value);
13362             }
13363           else
13364             {
13365               cp_error ("enumerator value for `%D' not integer constant", name);
13366               value = NULL_TREE;
13367             }
13368         }
13369
13370       /* Default based on previous value.  */
13371       if (value == NULL_TREE && ! processing_template_decl)
13372         {
13373           tree prev_value;
13374
13375           if (TYPE_VALUES (enumtype))
13376             {
13377               /* The next value is the previous value ... */
13378               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13379               /* ... plus one.  */
13380               value = build_binary_op (PLUS_EXPR,
13381                                        prev_value,
13382                                        integer_one_node);
13383
13384               if (tree_int_cst_lt (value, prev_value))
13385                 cp_error ("overflow in enumeration values at `%D'", name);
13386             }
13387           else
13388             value = integer_zero_node;
13389         }
13390
13391       /* Remove no-op casts from the value.  */
13392       if (value)
13393         STRIP_TYPE_NOPS (value);
13394 #if 0
13395       /* To fix MAX_VAL enum consts. (bkoz)  */
13396       TREE_TYPE (value) = integer_type_node;
13397 #endif
13398     }
13399
13400   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13401      Even in other cases, we will later (in finish_enum) be setting
13402      the type of VALUE.  But, we don't need to make a copy if this
13403      VALUE is one of the enumeration constants for this same
13404      enumeration type.  */
13405   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13406     if (TREE_VALUE (values) == value)
13407       break;
13408   /* If we didn't break out of the loop, then we do need a copy.  */
13409   if (!values && value)
13410     value = copy_node (value);
13411
13412   /* C++ associates enums with global, function, or class declarations.  */
13413   context = current_scope ();
13414
13415   /* Build the actual enumeration constant.  Note that the enumeration
13416     constants have the type of their initializers until the
13417     enumeration is complete:
13418
13419       [ dcl.enum ]
13420
13421       Following the closing brace of an enum-specifier, each enumer-
13422       ator has the type of its enumeration.  Prior to the closing
13423       brace, the type of each enumerator is the type of its
13424       initializing value.
13425
13426     In finish_enum we will reset the type.  Of course, if we're
13427     processing a template, there may be no value.   */
13428   type = value ? TREE_TYPE (value) : NULL_TREE;
13429
13430   if (context && context == current_class_type)
13431     /* This enum declaration is local to the class.  We need the full
13432       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13433     decl = build_lang_decl (CONST_DECL, name, type);
13434   else
13435     /* It's a global enum, or it's local to a function.  (Note local to
13436       a function could mean local to a class method.  */
13437     decl = build_decl (CONST_DECL, name, type);
13438
13439   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13440   DECL_INITIAL (decl) = value;
13441   TREE_READONLY (decl) = 1;
13442
13443   if (context && context == current_class_type)
13444     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13445       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13446       things like `S::i' later.)  */
13447     finish_member_declaration (decl);
13448   else
13449     {
13450       pushdecl (decl);
13451       GNU_xref_decl (current_function_decl, decl);
13452     }
13453
13454   /* Add this enumeration constant to the list for this type.  */
13455   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13456 }
13457
13458 \f
13459 static int function_depth;
13460
13461 /* We're defining DECL.  Make sure that it's type is OK.  */
13462
13463 static void
13464 check_function_type (decl)
13465      tree decl;
13466 {
13467   tree fntype = TREE_TYPE (decl);
13468   tree return_type = complete_type (TREE_TYPE (fntype));
13469
13470   /* In a function definition, arg types must be complete.  */
13471   require_complete_types_for_parms (current_function_parms);
13472
13473   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13474     {
13475       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13476
13477       /* Make it return void instead, but don't change the
13478          type of the DECL_RESULT, in case we have a named return value.  */
13479       if (TREE_CODE (fntype) == METHOD_TYPE)
13480         {
13481           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13482           TREE_TYPE (decl)
13483             = build_cplus_method_type (ctype,
13484                                        void_type_node,
13485                                        FUNCTION_ARG_CHAIN (decl));
13486         }
13487       else
13488         TREE_TYPE (decl)
13489           = build_function_type (void_type_node,
13490                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13491       TREE_TYPE (decl)
13492         = build_exception_variant (fntype,
13493                                    TYPE_RAISES_EXCEPTIONS (fntype));
13494     }
13495   else
13496     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13497 }
13498
13499 /* Create the FUNCTION_DECL for a function definition.
13500    DECLSPECS and DECLARATOR are the parts of the declaration;
13501    they describe the function's name and the type it returns,
13502    but twisted together in a fashion that parallels the syntax of C.
13503
13504    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13505    DECLARATOR is really the DECL for the function we are about to
13506    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13507    indicating that the function is an inline defined in-class, and
13508    SF_EXPAND indicating that we should generate RTL for this
13509    function.
13510
13511    This function creates a binding context for the function body
13512    as well as setting up the FUNCTION_DECL in current_function_decl.
13513
13514    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13515    (it defines a datum instead), we return 0, which tells
13516    yyparse to report a parse error.
13517
13518    For C++, we must first check whether that datum makes any sense.
13519    For example, "class A local_a(1,2);" means that variable local_a
13520    is an aggregate of type A, which should have a constructor
13521    applied to it with the argument list [1, 2].  */
13522
13523 int
13524 start_function (declspecs, declarator, attrs, flags)
13525      tree declspecs, declarator, attrs;
13526      int flags;
13527 {
13528   tree decl1;
13529   tree ctype = NULL_TREE;
13530   tree fntype;
13531   tree restype;
13532   extern int have_extern_spec;
13533   extern int used_extern_spec;
13534   int doing_friend = 0;
13535   struct binding_level *bl;
13536
13537   /* Sanity check.  */
13538   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13539   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13540
13541   /* This should only be done once on the top most decl.  */
13542   if (have_extern_spec && !used_extern_spec)
13543     {
13544       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13545       used_extern_spec = 1;
13546     }
13547
13548   if (flags & SF_PRE_PARSED)
13549     {
13550       decl1 = declarator;
13551
13552       fntype = TREE_TYPE (decl1);
13553       if (TREE_CODE (fntype) == METHOD_TYPE)
13554         ctype = TYPE_METHOD_BASETYPE (fntype);
13555
13556       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13557          the (lexical) scope of the class in which it is defined.  */
13558       if (!ctype && DECL_FRIEND_P (decl1))
13559         {
13560           ctype = DECL_FRIEND_CONTEXT (decl1);
13561
13562           /* CTYPE could be null here if we're dealing with a template;
13563              for example, `inline friend float foo()' inside a template
13564              will have no CTYPE set.  */
13565           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13566             ctype = NULL_TREE;
13567           else
13568             doing_friend = 1;
13569         }
13570
13571       last_function_parms = DECL_ARGUMENTS (decl1);
13572       last_function_parm_tags = NULL_TREE;
13573     }
13574   else
13575     {
13576       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13577       /* If the declarator is not suitable for a function definition,
13578          cause a syntax error.  */
13579       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13580
13581       fntype = TREE_TYPE (decl1);
13582
13583       restype = TREE_TYPE (fntype);
13584       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13585         {
13586           cp_error ("semicolon missing after declaration of `%#T'", restype);
13587           shadow_tag (build_tree_list (NULL_TREE, restype));
13588           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13589           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13590             fntype = build_function_type (integer_type_node,
13591                                           TYPE_ARG_TYPES (fntype));
13592           else
13593             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13594                                               integer_type_node,
13595                                               TYPE_ARG_TYPES (fntype));
13596           TREE_TYPE (decl1) = fntype;
13597         }
13598
13599       if (TREE_CODE (fntype) == METHOD_TYPE)
13600         ctype = TYPE_METHOD_BASETYPE (fntype);
13601       else if (DECL_MAIN_P (decl1))
13602         {
13603           /* If this doesn't return integer_type, complain.  */
13604           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13605             {
13606               if (pedantic || warn_return_type)
13607                 pedwarn ("return type for `main' changed to `int'");
13608               TREE_TYPE (decl1) = fntype = default_function_type;
13609             }
13610         }
13611     }
13612
13613   /* Sometimes we don't notice that a function is a static member, and
13614      build a METHOD_TYPE for it.  Fix that up now.  */
13615   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13616       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13617     {
13618       revert_static_member_fn (decl1);
13619       last_function_parms = TREE_CHAIN (last_function_parms);
13620       ctype = NULL_TREE;
13621     }
13622
13623   /* Warn if function was previously implicitly declared
13624      (but not if we warned then).  */
13625   if (! warn_implicit
13626       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13627     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13628
13629   /* Set up current_class_type, and enter the scope of the class, if
13630      appropriate.  */
13631   if (ctype)
13632     push_nested_class (ctype, 1);
13633   else if (DECL_STATIC_FUNCTION_P (decl1))
13634     push_nested_class (DECL_CONTEXT (decl1), 2);
13635
13636   /* Now that we have entered the scope of the class, we must restore
13637      the bindings for any template parameters surrounding DECL1, if it
13638      is an inline member template.  (Order is important; consider the
13639      case where a template parameter has the same name as a field of
13640      the class.)  It is not until after this point that
13641      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13642   if (flags & SF_INCLASS_INLINE)
13643     maybe_begin_member_template_processing (decl1);
13644
13645   /* Effective C++ rule 15.  See also c_expand_return.  */
13646   if (warn_ecpp
13647       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13648       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13649     cp_warning ("`operator=' should return a reference to `*this'");
13650
13651   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13652      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13653   if (!DECL_INITIAL (decl1))
13654     DECL_INITIAL (decl1) = error_mark_node;
13655
13656 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13657   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13658 #endif
13659
13660   /* This function exists in static storage.
13661      (This does not mean `static' in the C sense!)  */
13662   TREE_STATIC (decl1) = 1;
13663
13664   /* We must call push_template_decl after current_class_type is set
13665      up.  (If we are processing inline definitions after exiting a
13666      class scope, current_class_type will be NULL_TREE until set above
13667      by push_nested_class.)  */
13668   if (processing_template_decl)
13669     decl1 = push_template_decl (decl1);
13670
13671   /* We are now in the scope of the function being defined.  */
13672   current_function_decl = decl1;
13673
13674   /* Save the parm names or decls from this function's declarator
13675      where store_parm_decls will find them.  */
13676   current_function_parms = last_function_parms;
13677   current_function_parm_tags = last_function_parm_tags;
13678
13679   /* Make sure the parameter and return types are reasonable.  When
13680      you declare a function, these types can be incomplete, but they
13681      must be complete when you define the function.  */
13682   if (! processing_template_decl)
13683     check_function_type (decl1);
13684
13685   /* Build the return declaration for the function.  */
13686   restype = TREE_TYPE (fntype);
13687   if (!processing_template_decl)
13688     {
13689       if (!DECL_RESULT (decl1))
13690         {
13691           DECL_RESULT (decl1)
13692             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13693           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13694                                       DECL_RESULT (decl1));
13695         }
13696     }
13697   else
13698     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13699     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13700
13701   /* Initialize RTL machinery.  We cannot do this until
13702      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13703      even when processing a template; this is how we get
13704      CFUN set up, and our per-function variables initialized.  */
13705   bl = current_binding_level;
13706   init_function_start (decl1, input_filename, lineno);
13707   current_binding_level = bl;
13708   expanding_p = (flags & SF_EXPAND) != 0;
13709
13710   /* Even though we're inside a function body, we still don't want to
13711      call expand_expr to calculate the size of a variable-sized array.
13712      We haven't necessarily assigned RTL to all variables yet, so it's
13713      not safe to try to expand expressions involving them.  */
13714   immediate_size_expand = 0;
13715   cfun->x_dont_save_pending_sizes_p = 1;
13716
13717   /* If we're building a statement-tree, start the tree now.  */
13718   if (processing_template_decl || !expanding_p)
13719     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13720
13721   /* Let the user know we're compiling this function.  */
13722   announce_function (decl1);
13723
13724   /* Record the decl so that the function name is defined.
13725      If we already have a decl for this name, and it is a FUNCTION_DECL,
13726      use the old decl.  */
13727   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13728     {
13729       /* A specialization is not used to guide overload resolution.  */
13730       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13731           && ! DECL_FUNCTION_MEMBER_P (decl1))
13732         decl1 = pushdecl (decl1);
13733       else
13734         {
13735           /* We need to set the DECL_CONTEXT. */
13736           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13737             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13738           /* And make sure we have enough default args.  */
13739           check_default_args (decl1);
13740         }
13741       fntype = TREE_TYPE (decl1);
13742     }
13743
13744   /* Reset these in case the call to pushdecl changed them.  */
13745   current_function_decl = decl1;
13746   cfun->decl = decl1;
13747
13748   /* Initialize the per-function data.  */
13749   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13750     {
13751       /* If we already parsed this function, and we're just expanding it
13752          now, restore saved state.  */
13753       struct binding_level *bl = current_binding_level;
13754       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13755       current_binding_level = bl;
13756
13757       /* This function is being processed in whole-function mode; we
13758          already did semantic analysis.  */
13759       cfun->x_whole_function_mode_p = 1;
13760
13761       /* If we decided that we didn't want to inline this function,
13762          make sure the back-end knows that.  */
13763       if (!current_function_cannot_inline)
13764         current_function_cannot_inline = cp_function_chain->cannot_inline;
13765
13766       /* We don't need the saved data anymore.  */
13767       free (DECL_SAVED_FUNCTION_DATA (decl1));
13768       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13769     }
13770   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13771     {
13772       /* We know that this was set up by `grokclassfn'.  We do not
13773          wait until `store_parm_decls', since evil parse errors may
13774          never get us to that point.  Here we keep the consistency
13775          between `current_class_type' and `current_class_ptr'.  */
13776       tree t = DECL_ARGUMENTS (decl1);
13777
13778       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13779                           162);
13780       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13781                           19990811);
13782
13783       cp_function_chain->x_current_class_ref
13784         = build_indirect_ref (t, NULL_PTR);
13785       cp_function_chain->x_current_class_ptr = t;
13786
13787       /* Constructors and destructors need to know whether they're "in
13788          charge" of initializing virtual base classes.  */
13789       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13790         current_in_charge_parm = TREE_CHAIN (t);
13791     }
13792
13793   if (DECL_INTERFACE_KNOWN (decl1))
13794     {
13795       tree ctx = decl_function_context (decl1);
13796
13797       if (DECL_NOT_REALLY_EXTERN (decl1))
13798         DECL_EXTERNAL (decl1) = 0;
13799
13800       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13801           && TREE_PUBLIC (ctx))
13802         /* This is a function in a local class in an extern inline
13803            function.  */
13804         comdat_linkage (decl1);
13805     }
13806   /* If this function belongs to an interface, it is public.
13807      If it belongs to someone else's interface, it is also external.
13808      This only affects inlines and template instantiations.  */
13809   else if (interface_unknown == 0
13810            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13811                || flag_alt_external_templates))
13812     {
13813       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13814           || processing_template_decl)
13815         {
13816           DECL_EXTERNAL (decl1)
13817             = (interface_only
13818                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13819                    && !DECL_VINDEX (decl1)));
13820
13821           /* For WIN32 we also want to put these in linkonce sections.  */
13822           maybe_make_one_only (decl1);
13823         }
13824       else
13825         DECL_EXTERNAL (decl1) = 0;
13826       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13827       DECL_INTERFACE_KNOWN (decl1) = 1;
13828     }
13829   else if (interface_unknown && interface_only
13830            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13831                || flag_alt_external_templates))
13832     {
13833       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13834          interface, we will have interface_only set but not
13835          interface_known.  In that case, we don't want to use the normal
13836          heuristics because someone will supply a #pragma implementation
13837          elsewhere, and deducing it here would produce a conflict.  */
13838       comdat_linkage (decl1);
13839       DECL_EXTERNAL (decl1) = 0;
13840       DECL_INTERFACE_KNOWN (decl1) = 1;
13841       DECL_DEFER_OUTPUT (decl1) = 1;
13842     }
13843   else
13844     {
13845       /* This is a definition, not a reference.
13846          So clear DECL_EXTERNAL.  */
13847       DECL_EXTERNAL (decl1) = 0;
13848
13849       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13850           && ! DECL_INTERFACE_KNOWN (decl1)
13851           /* Don't try to defer nested functions for now.  */
13852           && ! decl_function_context (decl1))
13853         DECL_DEFER_OUTPUT (decl1) = 1;
13854       else
13855         DECL_INTERFACE_KNOWN (decl1) = 1;
13856     }
13857
13858   if (doing_semantic_analysis_p ())
13859     {
13860       pushlevel (0);
13861       current_binding_level->parm_flag = 1;
13862     }
13863
13864   if (attrs)
13865     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13866
13867   if (!building_stmt_tree ())
13868     {
13869       GNU_xref_function (decl1, current_function_parms);
13870       make_function_rtl (decl1);
13871     }
13872
13873   /* Promote the value to int before returning it.  */
13874   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13875     restype = type_promotes_to (restype);
13876
13877   /* If this fcn was already referenced via a block-scope `extern' decl
13878      (or an implicit decl), propagate certain information about the usage.  */
13879   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13880     TREE_ADDRESSABLE (decl1) = 1;
13881
13882   if (DECL_RESULT (decl1) == NULL_TREE)
13883     {
13884       DECL_RESULT (decl1)
13885         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13886       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13887       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13888     }
13889
13890   ++function_depth;
13891
13892   if (DECL_DESTRUCTOR_P (decl1))
13893     {
13894       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13895       DECL_CONTEXT (dtor_label) = current_function_decl;
13896     }
13897   /* Under the old ABI we return `this' from constructors, so we make
13898      ordinary `return' statements in constructors jump to CTOR_LABEL;
13899      from there we return `this'.  Under the new ABI, we don't bother
13900      with any of this.  By not setting CTOR_LABEL the remainder of the
13901      machinery is automatically disabled.  */
13902   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13903     {
13904       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13905       DECL_CONTEXT (ctor_label) = current_function_decl;
13906     }
13907
13908   return 1;
13909 }
13910 \f
13911 /* Called after store_parm_decls for a function-try-block.  */
13912
13913 void
13914 expand_start_early_try_stmts ()
13915 {
13916   expand_start_try_stmts ();
13917 }
13918
13919 /* Store the parameter declarations into the current function declaration.
13920    This is called after parsing the parameter declarations, before
13921    digesting the body of the function.
13922
13923    Also install to binding contour return value identifier, if any.  */
13924
13925 void
13926 store_parm_decls ()
13927 {
13928   register tree fndecl = current_function_decl;
13929   register tree parm;
13930   int parms_have_cleanups = 0;
13931   tree cleanups = NULL_TREE;
13932
13933   /* This is a list of types declared among parms in a prototype.  */
13934   tree parmtags = current_function_parm_tags;
13935
13936   /* This is a chain of any other decls that came in among the parm
13937      declarations.  If a parm is declared with  enum {foo, bar} x;
13938      then CONST_DECLs for foo and bar are put here.  */
13939   tree nonparms = NULL_TREE;
13940
13941   /* Create a binding level for the parms.  */
13942   if (!building_stmt_tree ())
13943     expand_start_bindings (2);
13944
13945   if (current_function_parms)
13946     {
13947       /* This case is when the function was defined with an ANSI prototype.
13948          The parms already have decls, so we need not do anything here
13949          except record them as in effect
13950          and complain if any redundant old-style parm decls were written.  */
13951
13952       tree specparms = current_function_parms;
13953       tree next;
13954
13955       if (doing_semantic_analysis_p ())
13956         {
13957           /* Must clear this because it might contain TYPE_DECLs declared
13958              at class level.  */
13959           storedecls (NULL_TREE);
13960
13961           /* If we're doing semantic analysis, then we'll call pushdecl
13962              for each of these.  We must do them in reverse order so that
13963              they end in the correct forward order.  */
13964           specparms = nreverse (specparms);
13965         }
13966
13967       for (parm = specparms; parm; parm = next)
13968         {
13969           next = TREE_CHAIN (parm);
13970           if (TREE_CODE (parm) == PARM_DECL)
13971             {
13972               tree type = TREE_TYPE (parm);
13973
13974               if (doing_semantic_analysis_p ())
13975                 {
13976                   tree cleanup;
13977
13978                   if (DECL_NAME (parm) == NULL_TREE
13979                       || TREE_CODE (parm) != VOID_TYPE)
13980                     pushdecl (parm);
13981                   else
13982                     cp_error ("parameter `%D' declared void", parm);
13983
13984                   cleanup = (processing_template_decl
13985                              ? NULL_TREE
13986                              : maybe_build_cleanup (parm));
13987
13988                   if (cleanup)
13989                     cleanups = tree_cons (parm, cleanup, cleanups);
13990                 }
13991               else if (type != error_mark_node
13992                        && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13993                 parms_have_cleanups = 1;
13994             }
13995           else
13996             {
13997               /* If we find an enum constant or a type tag,
13998                  put it aside for the moment.  */
13999               TREE_CHAIN (parm) = NULL_TREE;
14000               nonparms = chainon (nonparms, parm);
14001             }
14002         }
14003
14004       if (doing_semantic_analysis_p ())
14005         {
14006           /* Get the decls in their original chain order
14007              and record in the function.  This is all and only the
14008              PARM_DECLs that were pushed into scope by the loop above.  */
14009           DECL_ARGUMENTS (fndecl) = getdecls ();
14010           storetags (chainon (parmtags, gettags ()));
14011         }
14012     }
14013   else
14014     DECL_ARGUMENTS (fndecl) = NULL_TREE;
14015
14016   /* Now store the final chain of decls for the arguments
14017      as the decl-chain of the current lexical scope.
14018      Put the enumerators in as well, at the front so that
14019      DECL_ARGUMENTS is not modified.  */
14020   if (doing_semantic_analysis_p ())
14021     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
14022
14023   /* Initialize the RTL code for the function.  */
14024   DECL_SAVED_INSNS (fndecl) = 0;
14025   if (! building_stmt_tree ())
14026     expand_function_start (fndecl, parms_have_cleanups);
14027
14028   current_function_parms_stored = 1;
14029
14030   /* If this function is `main', emit a call to `__main'
14031      to run global initializers, etc.  */
14032   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
14033     expand_main_function ();
14034
14035   /* Now that we have initialized the parms, we can start their
14036      cleanups.  We cannot do this before, since expand_decl_cleanup
14037      should not be called before the parm can be used.  */
14038   while (cleanups)
14039     {
14040       finish_decl_cleanup (TREE_PURPOSE (cleanups),
14041                            TREE_VALUE (cleanups));
14042       cleanups = TREE_CHAIN (cleanups);
14043     }
14044
14045   /* Create a binding contour which can be used to catch
14046      cleanup-generated temporaries.  Also, if the return value needs or
14047      has initialization, deal with that now.  */
14048   if (parms_have_cleanups)
14049     {
14050       pushlevel (0);
14051       if (!building_stmt_tree ())
14052         expand_start_bindings (2);
14053     }
14054
14055   /* Do the starting of the exception specifications, if we have any.  */
14056   if (flag_exceptions && !processing_template_decl
14057       && flag_enforce_eh_specs
14058       && building_stmt_tree ()
14059       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14060     current_eh_spec_try_block = expand_start_eh_spec ();
14061 }
14062
14063 /* Bind a name and initialization to the return value of
14064    the current function.  */
14065
14066 void
14067 store_return_init (decl)
14068      tree decl;
14069 {
14070   /* If this named return value comes in a register, put it in a
14071      pseudo-register.  */
14072   if (DECL_REGISTER (decl))
14073     {
14074       original_result_rtx = DECL_RTL (decl);
14075       /* Note that the mode of the old DECL_RTL may be wider than the
14076          mode of DECL_RESULT, depending on the calling conventions for
14077          the processor.  For example, on the Alpha, a 32-bit integer
14078          is returned in a DImode register -- the DECL_RESULT has
14079          SImode but the DECL_RTL for the DECL_RESULT has DImode.  So,
14080          here, we use the mode the back-end has already assigned for
14081          the return value.  */
14082       DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
14083       if (TREE_ADDRESSABLE (decl))
14084         put_var_into_stack (decl);
14085     }
14086 }
14087
14088 \f
14089 /* We have finished doing semantic analysis on DECL, but have not yet
14090    generated RTL for its body.  Save away our current state, so that
14091    when we want to generate RTL later we know what to do.  */
14092
14093 static void
14094 save_function_data (decl)
14095      tree decl;
14096 {
14097   struct language_function *f;
14098
14099   /* Save the language-specific per-function data so that we can
14100      get it back when we really expand this function.  */
14101   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14102                       19990908);
14103
14104   /* Make a copy.  */
14105   f = ((struct language_function *)
14106        xmalloc (sizeof (struct language_function)));
14107   bcopy ((char *) cp_function_chain, (char *) f,
14108          sizeof (struct language_function));
14109   DECL_SAVED_FUNCTION_DATA (decl) = f;
14110
14111   /* Clear out the bits we don't need.  */
14112   f->x_stmt_tree.x_last_stmt = NULL_TREE;
14113   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
14114   f->x_result_rtx = NULL_RTX;
14115   f->x_named_label_uses = NULL;
14116   f->bindings = NULL;
14117
14118   /* When we get back here again, we will be expanding.  */
14119   f->x_expanding_p = 1;
14120
14121   /* If we've already decided that we cannot inline this function, we
14122      must remember that fact when we actually go to expand the
14123      function.  */
14124   f->cannot_inline = current_function_cannot_inline;
14125 }
14126
14127 /* At the end of every constructor we generate to code to return
14128    `this'.  Do that now.  */
14129
14130 static void
14131 finish_constructor_body ()
14132 {
14133   /* Any return from a constructor will end up here.  */
14134   if (ctor_label)
14135     add_tree (build_min_nt (LABEL_STMT, ctor_label));
14136
14137   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
14138      generate the return, rather than a goto to CTOR_LABEL.  */
14139   ctor_label = NULL_TREE;
14140   /* In check_return_expr we translate an empty return from a
14141      constructor to a return of `this'.  */
14142   finish_return_stmt (NULL_TREE);
14143   /* Mark the end of the constructor.  */
14144   add_tree (build_min_nt (CTOR_STMT));
14145 }
14146
14147 /* At the end of every destructor we generate code to restore virtual
14148    function tables to the values desired by base classes and to call
14149    to base class destructors.  Do that now.  */
14150
14151 static void
14152 finish_destructor_body ()
14153 {
14154   tree compound_stmt;
14155   tree virtual_size;
14156   tree exprstmt;
14157   tree if_stmt;
14158
14159   /* Create a block to contain all the extra code.  */
14160   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14161
14162   /* Any return from a destructor will end up here.  */
14163   add_tree (build_min_nt (LABEL_STMT, dtor_label));
14164
14165   /* Generate the code to call destructor on base class.  If this
14166      destructor belongs to a class with virtual functions, then set
14167      the virtual function table pointer to represent the type of our
14168      base class.  */
14169
14170   /* This side-effect makes call to `build_delete' generate the code
14171      we have to have at the end of this destructor.  `build_delete'
14172      will set the flag again.  */
14173   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
14174
14175   exprstmt = build_delete (current_class_type,
14176                            current_class_ref,
14177                            sfk_base_destructor,
14178                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
14179                            0);
14180
14181   if (exprstmt != error_mark_node
14182       && (TREE_CODE (exprstmt) != NOP_EXPR
14183           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
14184           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
14185     {
14186       if (exprstmt != void_zero_node)
14187         /* Don't call `expand_expr_stmt' if we're not going to do
14188            anything, since -Wall will give a diagnostic.  */
14189         finish_expr_stmt (exprstmt);
14190
14191       /* Run destructors for all virtual baseclasses.  */
14192       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
14193         {
14194           tree vbases;
14195           tree if_stmt;
14196
14197           if_stmt = begin_if_stmt ();
14198           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14199                                       current_in_charge_parm,
14200                                       integer_two_node),
14201                                if_stmt);
14202
14203           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
14204           /* The CLASSTYPE_VBASECLASSES list is in initialization
14205              order, so we have to march through it in reverse order.  */
14206           for (vbases = nreverse (copy_list (vbases));
14207                vbases;
14208                vbases = TREE_CHAIN (vbases))
14209             {
14210               tree vbase = TREE_VALUE (vbases);
14211
14212               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase)))
14213                 {
14214                   tree vb = get_vbase
14215                     (BINFO_TYPE (vbase),
14216                      TYPE_BINFO (current_class_type));
14217                   finish_expr_stmt
14218                     (build_scoped_method_call
14219                      (current_class_ref, vb, base_dtor_identifier,
14220                       NULL_TREE));
14221                 }
14222             }
14223
14224           finish_then_clause (if_stmt);
14225           finish_if_stmt ();
14226         }
14227     }
14228
14229   virtual_size = c_sizeof (current_class_type);
14230
14231   /* At the end, call delete if that's what's requested.  */
14232
14233   /* FDIS sez: At the point of definition of a virtual destructor
14234      (including an implicit definition), non-placement operator delete
14235      shall be looked up in the scope of the destructor's class and if
14236      found shall be accessible and unambiguous.
14237
14238      This is somewhat unclear, but I take it to mean that if the class
14239      only defines placement deletes we don't do anything here.  So we
14240      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14241      they ever try to delete one of these.  */
14242   exprstmt = build_op_delete_call
14243     (DELETE_EXPR, current_class_ptr, virtual_size,
14244      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14245
14246   if_stmt = begin_if_stmt ();
14247   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14248                               current_in_charge_parm,
14249                               integer_one_node),
14250                        if_stmt);
14251   finish_expr_stmt (exprstmt);
14252   finish_then_clause (if_stmt);
14253   finish_if_stmt ();
14254
14255   /* Close the block we started above.  */
14256   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14257 }
14258
14259 /* Finish up a function declaration and compile that function
14260    all the way to assembler language output.  The free the storage
14261    for the function definition.
14262
14263    FLAGS is a bitwise or of the following values:
14264      1 - CALL_POPLEVEL
14265        An extra call to poplevel (and expand_end_bindings) must be
14266        made to take care of the binding contour for the base
14267        initializers.  This is only relevant for constructors.
14268      2 - INCLASS_INLINE
14269        We just finished processing the body of an in-class inline
14270        function definition.  (This processing will have taken place
14271        after the class definition is complete.)  */
14272
14273 tree
14274 finish_function (flags)
14275      int flags;
14276 {
14277   register tree fndecl = current_function_decl;
14278   tree fntype, ctype = NULL_TREE;
14279   /* Label to use if this function is supposed to return a value.  */
14280   tree no_return_label = NULL_TREE;
14281   int call_poplevel = (flags & 1) != 0;
14282   int inclass_inline = (flags & 2) != 0;
14283   int expand_p;
14284   int nested;
14285   int current_line = lineno;
14286
14287   /* When we get some parse errors, we can end up without a
14288      current_function_decl, so cope.  */
14289   if (fndecl == NULL_TREE)
14290     return error_mark_node;
14291
14292   nested = function_depth > 1;
14293   fntype = TREE_TYPE (fndecl);
14294
14295   /*  TREE_READONLY (fndecl) = 1;
14296       This caused &foo to be of type ptr-to-const-function
14297       which then got a warning when stored in a ptr-to-function variable.  */
14298
14299   /* This happens on strange parse errors.  */
14300   if (! current_function_parms_stored)
14301     {
14302       call_poplevel = 0;
14303       store_parm_decls ();
14304     }
14305
14306   /* For a cloned function, we've already got all the code we need;
14307      there's no need to add any extra bits.  */
14308   if (building_stmt_tree () && DECL_CLONED_FUNCTION_P (fndecl))
14309     ;
14310   else if (building_stmt_tree ())
14311     {
14312       if (DECL_CONSTRUCTOR_P (fndecl))
14313         {
14314           finish_constructor_body ();
14315           if (call_poplevel)
14316             do_poplevel ();
14317         }
14318       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14319         finish_destructor_body ();
14320       else if (DECL_MAIN_P (fndecl))
14321         {
14322           /* Make it so that `main' always returns 0 by default.  */
14323 #ifdef VMS
14324           finish_return_stmt (integer_one_node);
14325 #else
14326           finish_return_stmt (integer_zero_node);
14327 #endif
14328         }
14329
14330       /* Finish dealing with exception specifiers.  */
14331       if (flag_exceptions && !processing_template_decl
14332           && flag_enforce_eh_specs
14333           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14334         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14335                             (TREE_TYPE (current_function_decl)),
14336                             current_eh_spec_try_block);
14337     }
14338   else
14339     {
14340 #if 0
14341       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
14342         {
14343           /* Keep this code around in case we later want to control debug info
14344              based on whether a type is "used".  (jason 1999-11-11) */
14345
14346           tree ttype = target_type (fntype);
14347           tree parmdecl;
14348
14349           if (IS_AGGR_TYPE (ttype))
14350             /* Let debugger know it should output info for this type.  */
14351             note_debug_info_needed (ttype);
14352
14353           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
14354             {
14355               ttype = target_type (TREE_TYPE (parmdecl));
14356               if (IS_AGGR_TYPE (ttype))
14357                 /* Let debugger know it should output info for this type.  */
14358                 note_debug_info_needed (ttype);
14359             }
14360         }
14361 #endif
14362
14363       /* Clean house because we will need to reorder insns here.  */
14364       do_pending_stack_adjust ();
14365
14366       if (dtor_label)
14367         ;
14368       else if (DECL_CONSTRUCTOR_P (fndecl))
14369         {
14370           if (call_poplevel)
14371             do_poplevel ();
14372         }
14373       else if (return_label != NULL_RTX
14374                && flag_this_is_variable <= 0
14375                && current_function_return_value == NULL_TREE
14376                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
14377         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14378
14379       if (flag_exceptions)
14380         expand_exception_blocks ();
14381
14382       /* If this function is supposed to return a value, ensure that
14383          we do not fall into the cleanups by mistake.  The end of our
14384          function will look like this:
14385
14386          user code (may have return stmt somewhere)
14387          goto no_return_label
14388          cleanup_label:
14389          cleanups
14390          goto return_label
14391          no_return_label:
14392          NOTE_INSN_FUNCTION_END
14393          return_label:
14394          things for return
14395
14396          If the user omits a return stmt in the USER CODE section, we
14397          will have a control path which reaches NOTE_INSN_FUNCTION_END.
14398          Otherwise, we won't.  */
14399       if (no_return_label)
14400         {
14401           DECL_CONTEXT (no_return_label) = fndecl;
14402           DECL_INITIAL (no_return_label) = error_mark_node;
14403           DECL_SOURCE_FILE (no_return_label) = input_filename;
14404           DECL_SOURCE_LINE (no_return_label) = current_line;
14405           expand_goto (no_return_label);
14406         }
14407
14408       if (cleanup_label)
14409         {
14410           /* Remove the binding contour which is used
14411              to catch cleanup-generated temporaries.  */
14412           expand_end_bindings (0, 0, 0);
14413           poplevel (0, 0, 0);
14414
14415           /* Emit label at beginning of cleanup code for parameters.  */
14416           emit_label (cleanup_label);
14417         }
14418
14419       /* Get return value into register if that's where it's supposed
14420          to be.  */
14421       if (original_result_rtx)
14422         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
14423
14424       /* Finish building code that will trigger warnings if users forget
14425          to make their functions return values.  */
14426       if (no_return_label || cleanup_label)
14427         emit_jump (return_label);
14428       if (no_return_label)
14429         {
14430           /* We don't need to call `expand_*_return' here because we
14431              don't need any cleanups here--this path of code is only
14432              for error checking purposes.  */
14433           expand_label (no_return_label);
14434         }
14435
14436       /* We hard-wired immediate_size_expand to zero in
14437          start_function.  Expand_function_end will decrement this
14438          variable.  So, we set the variable to one here, so that after
14439          the decrement it will remain zero.  */
14440       immediate_size_expand = 1;
14441
14442       /* Generate rtl for function exit.  */
14443       expand_function_end (input_filename, current_line, 1);
14444     }
14445
14446   /* We have to save this value here in case
14447      maybe_end_member_template_processing decides to pop all the
14448      template parameters.  */
14449   expand_p = !building_stmt_tree ();
14450
14451   /* If we're saving up tree structure, tie off the function now.  */
14452   if (!expand_p)
14453     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14454
14455   /* This must come after expand_function_end because cleanups might
14456      have declarations (from inline functions) that need to go into
14457      this function's blocks.  */
14458   if (doing_semantic_analysis_p ())
14459     {
14460       if (current_binding_level->parm_flag != 1)
14461         my_friendly_abort (122);
14462       poplevel (1, 0, 1);
14463     }
14464
14465   /* Remember that we were in class scope.  */
14466   if (current_class_name)
14467     ctype = current_class_type;
14468
14469   /* Must mark the RESULT_DECL as being in this function.  */
14470   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14471
14472   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14473      to the FUNCTION_DECL node itself.  */
14474   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14475
14476   /* Save away current state, if appropriate.  */
14477   if (!expanding_p && !processing_template_decl)
14478     save_function_data (fndecl);
14479
14480   /* If this function calls `setjmp' it cannot be inlined.  When
14481      `longjmp' is called it is not guaranteed to restore the value of
14482      local variables that have been modified since the call to
14483      `setjmp'.  So, if were to inline this function into some caller
14484      `c', then when we `longjmp', we might not restore all variables
14485      in `c'.  (It might seem, at first blush, that there's no way for
14486      this function to modify local variables in `c', but their
14487      addresses may have been stored somewhere accessible to this
14488      function.)  */
14489   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
14490     DECL_UNINLINABLE (fndecl) = 1;
14491
14492   if (expand_p)
14493     {
14494       int returns_null;
14495       int returns_value;
14496
14497       /* So we can tell if jump_optimize sets it to 1.  */
14498       can_reach_end = 0;
14499
14500       /* Before we call rest_of_compilation (which will pop the
14501          CURRENT_FUNCTION), we must save these values.  */
14502       returns_null = current_function_returns_null;
14503       returns_value = current_function_returns_value;
14504
14505       /* If this is a nested function (like a template instantiation
14506          that we're compiling in the midst of compiling something
14507          else), push a new GC context.  That will keep local variables
14508          on the stack from being collected while we're doing the
14509          compilation of this function.  */
14510       if (function_depth > 1)
14511         ggc_push_context ();
14512
14513       /* Run the optimizers and output the assembler code for this
14514          function.  */
14515       rest_of_compilation (fndecl);
14516
14517       /* Undo the call to ggc_push_context above.  */
14518       if (function_depth > 1)
14519         ggc_pop_context ();
14520
14521       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
14522         {
14523           /* Set DECL_EXTERNAL so that assemble_external will be called as
14524              necessary.  We'll clear it again in finish_file.  */
14525           if (! DECL_EXTERNAL (fndecl))
14526             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
14527           DECL_EXTERNAL (fndecl) = 1;
14528           defer_fn (fndecl);
14529         }
14530
14531 #if 0
14532       /* Keep this code around in case we later want to control debug info
14533          based on whether a type is "used".  (jason 1999-11-11) */
14534
14535       if (ctype && TREE_ASM_WRITTEN (fndecl))
14536         note_debug_info_needed (ctype);
14537 #endif
14538
14539       returns_null |= can_reach_end;
14540
14541       /* Since we don't normally go through c_expand_return for constructors,
14542          this normally gets the wrong value.
14543          Also, named return values have their return codes emitted after
14544          NOTE_INSN_FUNCTION_END, confusing jump.c.  */
14545       if (DECL_CONSTRUCTOR_P (fndecl)
14546           || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
14547         returns_null = 0;
14548
14549       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
14550         cp_warning ("`noreturn' function `%D' does return", fndecl);
14551       else if ((warn_return_type || pedantic)
14552                && returns_null
14553                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14554         {
14555           /* If this function returns non-void and control can drop through,
14556              complain.  */
14557           cp_warning ("control reaches end of non-void function `%D'", fndecl);
14558         }
14559       /* With just -W, complain only if function returns both with
14560          and without a value.  */
14561       else if (extra_warnings && returns_value && returns_null)
14562         warning ("this function may return with or without a value");
14563     }
14564   else
14565     {
14566       /* Clear out memory we no longer need.  */
14567       free_after_parsing (cfun);
14568       /* Since we never call rest_of_compilation, we never clear
14569          CFUN.  Do so explicitly.  */
14570       free_after_compilation (cfun);
14571       cfun = NULL;
14572     }
14573
14574   /* If this is a in-class inline definition, we may have to pop the
14575      bindings for the template parameters that we added in
14576      maybe_begin_member_template_processing when start_function was
14577      called.  */
14578   if (inclass_inline)
14579     maybe_end_member_template_processing ();
14580
14581   /* Leave the scope of the class.  */
14582   if (ctype)
14583     pop_nested_class ();
14584
14585   --function_depth;
14586
14587   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14588       && !(flag_inline_trees && DECL_INLINE (fndecl)))
14589     {
14590       tree t;
14591
14592       /* Stop pointing to the local nodes about to be freed.  */
14593       /* But DECL_INITIAL must remain nonzero so we know this
14594          was an actual function definition.  */
14595       DECL_INITIAL (fndecl) = error_mark_node;
14596       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14597         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14598     }
14599
14600   if (DECL_STATIC_CONSTRUCTOR (fndecl))
14601     static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14602   if (DECL_STATIC_DESTRUCTOR (fndecl))
14603     static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14604
14605   /* Clean up.  */
14606   if (! nested)
14607     {
14608       /* Let the error reporting routines know that we're outside a
14609          function.  For a nested function, this value is used in
14610          pop_cp_function_context and then reset via pop_function_context.  */
14611       current_function_decl = NULL_TREE;
14612       /* We don't really care about obstacks, but the middle-end
14613          sometimes cares on what obstck things are located.  */
14614       permanent_allocation (1);
14615     }
14616
14617   return fndecl;
14618 }
14619 \f
14620 /* Create the FUNCTION_DECL for a function definition.
14621    DECLSPECS and DECLARATOR are the parts of the declaration;
14622    they describe the return type and the name of the function,
14623    but twisted together in a fashion that parallels the syntax of C.
14624
14625    This function creates a binding context for the function body
14626    as well as setting up the FUNCTION_DECL in current_function_decl.
14627
14628    Returns a FUNCTION_DECL on success.
14629
14630    If the DECLARATOR is not suitable for a function (it defines a datum
14631    instead), we return 0, which tells yyparse to report a parse error.
14632
14633    May return void_type_node indicating that this method is actually
14634    a friend.  See grokfield for more details.
14635
14636    Came here with a `.pushlevel' .
14637
14638    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14639    CHANGES TO CODE IN `grokfield'.  */
14640
14641 tree
14642 start_method (declspecs, declarator, attrlist)
14643      tree declarator, declspecs, attrlist;
14644 {
14645   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14646                                 attrlist);
14647
14648   /* Something too ugly to handle.  */
14649   if (fndecl == NULL_TREE)
14650     return NULL_TREE;
14651
14652   /* Pass friends other than inline friend functions back.  */
14653   if (fndecl == void_type_node)
14654     return fndecl;
14655
14656   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14657     /* Not a function, tell parser to report parse error.  */
14658     return NULL_TREE;
14659
14660   if (DECL_IN_AGGR_P (fndecl))
14661     {
14662       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14663         {
14664           if (DECL_CONTEXT (fndecl)
14665               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14666             cp_error ("`%D' is already defined in class %s", fndecl,
14667                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14668         }
14669       return void_type_node;
14670     }
14671
14672   check_template_shadow (fndecl);
14673
14674   DECL_THIS_INLINE (fndecl) = 1;
14675
14676   if (flag_default_inline)
14677     DECL_INLINE (fndecl) = 1;
14678
14679   /* We process method specializations in finish_struct_1.  */
14680   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14681     fndecl = push_template_decl (fndecl);
14682
14683   if (! DECL_FRIEND_P (fndecl))
14684     {
14685       if (TREE_CHAIN (fndecl))
14686         {
14687           fndecl = copy_node (fndecl);
14688           TREE_CHAIN (fndecl) = NULL_TREE;
14689         }
14690
14691       if (DECL_CONSTRUCTOR_P (fndecl))
14692         {
14693           if (! grok_ctor_properties (current_class_type, fndecl))
14694             return void_type_node;
14695         }
14696       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14697         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14698     }
14699
14700   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14701
14702   /* Make a place for the parms */
14703   pushlevel (0);
14704   current_binding_level->parm_flag = 1;
14705
14706   DECL_IN_AGGR_P (fndecl) = 1;
14707   return fndecl;
14708 }
14709
14710 /* Go through the motions of finishing a function definition.
14711    We don't compile this method until after the whole class has
14712    been processed.
14713
14714    FINISH_METHOD must return something that looks as though it
14715    came from GROKFIELD (since we are defining a method, after all).
14716
14717    This is called after parsing the body of the function definition.
14718    STMTS is the chain of statements that makes up the function body.
14719
14720    DECL is the ..._DECL that `start_method' provided.  */
14721
14722 tree
14723 finish_method (decl)
14724      tree decl;
14725 {
14726   register tree fndecl = decl;
14727   tree old_initial;
14728
14729   register tree link;
14730
14731   if (decl == void_type_node)
14732     return decl;
14733
14734   old_initial = DECL_INITIAL (fndecl);
14735
14736   /* Undo the level for the parms (from start_method).
14737      This is like poplevel, but it causes nothing to be
14738      saved.  Saving information here confuses symbol-table
14739      output routines.  Besides, this information will
14740      be correctly output when this method is actually
14741      compiled.  */
14742
14743   /* Clear out the meanings of the local variables of this level;
14744      also record in each decl which block it belongs to.  */
14745
14746   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14747     {
14748       if (DECL_NAME (link) != NULL_TREE)
14749         pop_binding (DECL_NAME (link), link);
14750       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14751       DECL_CONTEXT (link) = NULL_TREE;
14752     }
14753
14754   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14755                       (HOST_WIDE_INT) current_binding_level->level_chain,
14756                       current_binding_level->parm_flag,
14757                       current_binding_level->keep);
14758
14759   poplevel (0, 0, 0);
14760
14761   DECL_INITIAL (fndecl) = old_initial;
14762
14763   /* We used to check if the context of FNDECL was different from
14764      current_class_type as another way to get inside here.  This didn't work
14765      for String.cc in libg++.  */
14766   if (DECL_FRIEND_P (fndecl))
14767     {
14768       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14769         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14770       decl = void_type_node;
14771     }
14772
14773   return decl;
14774 }
14775 \f
14776 /* Called when a new struct TYPE is defined.
14777    If this structure or union completes the type of any previous
14778    variable declaration, lay it out and output its rtl.  */
14779
14780 void
14781 hack_incomplete_structures (type)
14782      tree type;
14783 {
14784   tree *list;
14785   struct binding_level *level;
14786
14787   if (!type) /* Don't do this for class templates.  */
14788     return;
14789
14790   if (namespace_bindings_p ())
14791     {
14792       level = 0;
14793       list = &namespace_scope_incomplete;
14794     }
14795   else
14796     {
14797       level = innermost_nonclass_level ();
14798       list = &level->incomplete;
14799     }
14800
14801   while (1)
14802     {
14803       while (*list)
14804         {
14805           tree decl = TREE_VALUE (*list);
14806           if ((decl && TREE_TYPE (decl) == type)
14807               || (TREE_TYPE (decl)
14808                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14809                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14810             {
14811               int toplevel = toplevel_bindings_p ();
14812               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14813                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14814                 layout_type (TREE_TYPE (decl));
14815               layout_decl (decl, 0);
14816               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14817               if (! toplevel)
14818                 {
14819                   tree cleanup;
14820                   expand_decl (decl);
14821                   cleanup = maybe_build_cleanup (decl);
14822                   expand_decl_init (decl);
14823                   if (! expand_decl_cleanup (decl, cleanup))
14824                     cp_error ("parser lost in parsing declaration of `%D'",
14825                               decl);
14826                 }
14827               *list = TREE_CHAIN (*list);
14828             }
14829           else
14830             list = &TREE_CHAIN (*list);
14831         }
14832
14833       /* Keep looking through artificial binding levels generated
14834          for local variables.  */
14835       if (level && level->keep == 2)
14836         {
14837           level = level->level_chain;
14838           list = &level->incomplete;
14839         }
14840       else
14841         break;
14842     }
14843 }
14844
14845 /* If DECL is of a type which needs a cleanup, build that cleanup
14846    here.  */
14847
14848 tree
14849 maybe_build_cleanup (decl)
14850      tree decl;
14851 {
14852   tree type = TREE_TYPE (decl);
14853
14854   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14855     {
14856       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14857       tree rval;
14858
14859       if (TREE_CODE (type) == ARRAY_TYPE)
14860         rval = decl;
14861       else
14862         {
14863           mark_addressable (decl);
14864           rval = build_unary_op (ADDR_EXPR, decl, 0);
14865         }
14866
14867       /* Optimize for space over speed here.  */
14868       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14869           || flag_expensive_optimizations)
14870         flags |= LOOKUP_NONVIRTUAL;
14871
14872       rval = build_delete (TREE_TYPE (rval), rval,
14873                            sfk_complete_destructor, flags, 0);
14874
14875       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14876           && ! TYPE_HAS_DESTRUCTOR (type))
14877         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14878                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14879
14880       return rval;
14881     }
14882   return 0;
14883 }
14884 \f
14885 /* Expand a C++ expression at the statement level.
14886    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14887    The C++ type checker should get all of these out when
14888    expressions are combined with other, type-providing, expressions,
14889    leaving only orphan expressions, such as:
14890
14891    &class::bar;         / / takes its address, but does nothing with it.  */
14892
14893 void
14894 cplus_expand_expr_stmt (exp)
14895      tree exp;
14896 {
14897 #if 0
14898   /* We should do this eventually, but right now this causes regex.o from
14899      libg++ to miscompile, and tString to core dump.  */
14900   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14901 #endif
14902
14903   /* If we don't do this, we end up down inside expand_expr
14904      trying to do TYPE_MODE on the ERROR_MARK, and really
14905      go outside the bounds of the type.  */
14906   if (exp != error_mark_node)
14907     expand_expr_stmt (exp);
14908 }
14909
14910 /* When a stmt has been parsed, this function is called.  */
14911
14912 void
14913 finish_stmt ()
14914 {
14915   /* Always assume this statement was not an expression statement.  If
14916      it actually was an expression statement, its our callers
14917      responsibility to fix this up.  */
14918   last_expr_type = NULL_TREE;
14919 }
14920
14921 /* DECL was originally constructed as a non-static member function,
14922    but turned out to be static.  Update it accordingly.  */
14923
14924 void
14925 revert_static_member_fn (decl)
14926      tree decl;
14927 {
14928   tree tmp;
14929   tree function = TREE_TYPE (decl);
14930   tree args = TYPE_ARG_TYPES (function);
14931
14932   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14933       != TYPE_UNQUALIFIED)
14934     cp_error ("static member function `%#D' declared with type qualifiers",
14935               *decl);
14936
14937   args = TREE_CHAIN (args);
14938   tmp = build_function_type (TREE_TYPE (function), args);
14939   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14940   tmp = build_exception_variant (tmp,
14941                                  TYPE_RAISES_EXCEPTIONS (function));
14942   TREE_TYPE (decl) = tmp;
14943   if (DECL_ARGUMENTS (decl))
14944     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14945   DECL_STATIC_FUNCTION_P (decl) = 1;
14946 }
14947
14948 /* Initialize the variables used during compilation of a C++
14949    function.  */
14950
14951 static void
14952 push_cp_function_context (f)
14953      struct function *f;
14954 {
14955   struct language_function *p
14956     = ((struct language_function *)
14957        xcalloc (1, sizeof (struct language_function)));
14958   f->language = p;
14959
14960   /* It takes an explicit call to expand_body to generate RTL for a
14961      function.  */
14962   expanding_p = 0;
14963
14964   /* Whenever we start a new function, we destroy temporaries in the
14965      usual way.  */
14966   stmts_are_full_exprs_p = 1;
14967 }
14968
14969 /* Free the language-specific parts of F, now that we've finished
14970    compiling the function.  */
14971
14972 static void
14973 pop_cp_function_context (f)
14974      struct function *f;
14975 {
14976   if (f->language)
14977     free (f->language);
14978   f->language = 0;
14979 }
14980
14981 /* Mark P for GC.  */
14982
14983 static void
14984 mark_lang_function (p)
14985      struct language_function *p;
14986 {
14987   if (!p)
14988     return;
14989
14990   ggc_mark_tree (p->x_ctor_label);
14991   ggc_mark_tree (p->x_dtor_label);
14992   ggc_mark_tree (p->x_current_class_ptr);
14993   ggc_mark_tree (p->x_current_class_ref);
14994   ggc_mark_tree (p->x_eh_spec_try_block);
14995   ggc_mark_tree (p->x_scope_stmt_stack);
14996
14997   ggc_mark_rtx (p->x_result_rtx);
14998
14999   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
15000   mark_stmt_tree (&p->x_stmt_tree);
15001   mark_binding_level (&p->bindings);
15002 }
15003
15004 /* Mark the language-specific data in F for GC.  */
15005
15006 static void
15007 mark_cp_function_context (f)
15008      struct function *f;
15009 {
15010   mark_lang_function (f->language);
15011 }
15012
15013 void
15014 lang_mark_false_label_stack (l)
15015      struct label_node *l;
15016 {
15017   /* C++ doesn't use false_label_stack.  It better be NULL.  */
15018   my_friendly_assert (l == NULL, 19990904);
15019 }
15020
15021 void
15022 lang_mark_tree (t)
15023      tree t;
15024 {
15025   enum tree_code code = TREE_CODE (t);
15026   if (code == IDENTIFIER_NODE)
15027     {
15028       struct lang_identifier *li = (struct lang_identifier *) t;
15029       struct lang_id2 *li2 = li->x;
15030       ggc_mark_tree (li->namespace_bindings);
15031       ggc_mark_tree (li->bindings);
15032       ggc_mark_tree (li->class_value);
15033       ggc_mark_tree (li->class_template_info);
15034
15035       if (li2)
15036         {
15037           ggc_mark_tree (li2->label_value);
15038           ggc_mark_tree (li2->implicit_decl);
15039           ggc_mark_tree (li2->error_locus);
15040         }
15041     }
15042   else if (code == CPLUS_BINDING)
15043     {
15044       if (BINDING_HAS_LEVEL_P (t))
15045         mark_binding_level (&BINDING_LEVEL (t));
15046       else
15047         ggc_mark_tree (BINDING_SCOPE (t));
15048       ggc_mark_tree (BINDING_VALUE (t));
15049     }
15050   else if (code == OVERLOAD)
15051     ggc_mark_tree (OVL_FUNCTION (t));
15052   else if (code == TEMPLATE_PARM_INDEX)
15053     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
15054   else if (TREE_CODE_CLASS (code) == 'd')
15055     {
15056       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
15057
15058       if (ld)
15059         {
15060           ggc_mark (ld);
15061           if (!DECL_GLOBAL_CTOR_P (t)
15062               && !DECL_GLOBAL_DTOR_P (t)
15063               && !DECL_THUNK_P (t))
15064             ggc_mark_tree (ld->decl_flags.u2.access);
15065           else if (DECL_THUNK_P (t))
15066             ggc_mark_tree (ld->decl_flags.u2.vcall_offset);
15067           ggc_mark_tree (ld->decl_flags.context);
15068           if (TREE_CODE (t) != NAMESPACE_DECL)
15069             ggc_mark_tree (ld->decl_flags.u.template_info);
15070           else
15071             mark_binding_level (&NAMESPACE_LEVEL (t));
15072           if (CAN_HAVE_FULL_LANG_DECL_P (t))
15073             {
15074               ggc_mark_tree (ld->befriending_classes);
15075               ggc_mark_tree (ld->saved_tree);
15076               ggc_mark_tree (ld->cloned_function);
15077               if (!DECL_OVERLOADED_OPERATOR_P (t))
15078                 ggc_mark_tree (ld->u2.vtt_parm);
15079               if (TREE_CODE (t) == TYPE_DECL)
15080                 ggc_mark_tree (ld->u.sorted_fields);
15081               else if (TREE_CODE (t) == FUNCTION_DECL
15082                        && !DECL_PENDING_INLINE_P (t))
15083                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
15084             }
15085         }
15086     }
15087   else if (TREE_CODE_CLASS (code) == 't')
15088     {
15089       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
15090
15091       if (lt && !(TREE_CODE (t) == POINTER_TYPE
15092                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
15093         {
15094           ggc_mark (lt);
15095           ggc_mark_tree (lt->vfields);
15096           ggc_mark_tree (lt->vbases);
15097           ggc_mark_tree (lt->tags);
15098           ggc_mark_tree (lt->size);
15099           ggc_mark_tree (lt->pure_virtuals);
15100           ggc_mark_tree (lt->friend_classes);
15101           ggc_mark_tree (lt->rtti);
15102           ggc_mark_tree (lt->methods);
15103           ggc_mark_tree (lt->template_info);
15104           ggc_mark_tree (lt->befriending_classes);
15105         }
15106       else if (lt)
15107         /* In the case of pointer-to-member function types, the
15108            TYPE_LANG_SPECIFIC is really just a tree.  */
15109         ggc_mark_tree ((tree) lt);
15110     }
15111 }