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           d = pushdecl (d);
2373           pushlevel (0);
2374           declare_namespace_level ();
2375           NAMESPACE_LEVEL (d) = current_binding_level;
2376         }
2377     }
2378   else
2379     resume_binding_level (NAMESPACE_LEVEL (d));
2380
2381   if (implicit_use)
2382     do_using_directive (d);
2383   /* Enter the name space. */
2384   current_namespace = d;
2385 }
2386
2387 /* Pop from the scope of the current namespace.  */
2388
2389 void
2390 pop_namespace ()
2391 {
2392   if (current_namespace == global_namespace)
2393     {
2394       my_friendly_assert (in_std>0, 980421);
2395       in_std--;
2396       return;
2397     }
2398   current_namespace = CP_DECL_CONTEXT (current_namespace);
2399   /* The binding level is not popped, as it might be re-opened later.  */
2400   suspend_binding_level ();
2401 }
2402
2403 /* Push into the scope of the namespace NS, even if it is deeply
2404    nested within another namespace.  */
2405
2406 void
2407 push_nested_namespace (ns)
2408      tree ns;
2409 {
2410   if (ns == global_namespace)
2411     push_to_top_level ();
2412   else
2413     {
2414       push_nested_namespace (CP_DECL_CONTEXT (ns));
2415       push_namespace (DECL_NAME (ns));
2416     }
2417 }
2418
2419 /* Pop back from the scope of the namespace NS, which was previously
2420    entered with push_nested_namespace.  */
2421
2422 void
2423 pop_nested_namespace (ns)
2424      tree ns;
2425 {
2426   while (ns != global_namespace)
2427     {
2428       pop_namespace ();
2429       ns = CP_DECL_CONTEXT (ns);
2430     }
2431
2432   pop_from_top_level ();
2433 }
2434
2435 \f
2436 /* Subroutines for reverting temporarily to top-level for instantiation
2437    of templates and such.  We actually need to clear out the class- and
2438    local-value slots of all identifiers, so that only the global values
2439    are at all visible.  Simply setting current_binding_level to the global
2440    scope isn't enough, because more binding levels may be pushed.  */
2441 struct saved_scope *scope_chain;
2442
2443 /* Mark ST for GC.  */
2444
2445 static void
2446 mark_stmt_tree (st)
2447      struct stmt_tree *st;
2448 {
2449   ggc_mark_tree (st->x_last_stmt);
2450   ggc_mark_tree (st->x_last_expr_type);
2451 }
2452
2453 /* Mark ARG (which is really a struct saved_scope **) for GC.  */
2454
2455 static void
2456 mark_saved_scope (arg)
2457      void *arg;
2458 {
2459   struct saved_scope *t = *(struct saved_scope **)arg;
2460   while (t)
2461     {
2462       mark_binding_level (&t->class_bindings);
2463       ggc_mark_tree (t->old_bindings);
2464       ggc_mark_tree (t->old_namespace);
2465       ggc_mark_tree (t->class_name);
2466       ggc_mark_tree (t->class_type);
2467       ggc_mark_tree (t->access_specifier);
2468       ggc_mark_tree (t->function_decl);
2469       if (t->lang_base)
2470         ggc_mark_tree_varray (t->lang_base);
2471       ggc_mark_tree (t->lang_name);
2472       ggc_mark_tree (t->x_function_parms);
2473       ggc_mark_tree (t->template_parms);
2474       ggc_mark_tree (t->x_previous_class_type);
2475       ggc_mark_tree (t->x_previous_class_values);
2476       ggc_mark_tree (t->x_saved_tree);
2477       ggc_mark_tree (t->incomplete);
2478       ggc_mark_tree (t->lookups);
2479
2480       mark_stmt_tree (&t->x_stmt_tree);
2481       mark_binding_level (&t->bindings);
2482       t = t->prev;
2483     }
2484 }
2485
2486 static tree
2487 store_bindings (names, old_bindings)
2488      tree names, old_bindings;
2489 {
2490   tree t;
2491   for (t = names; t; t = TREE_CHAIN (t))
2492     {
2493       tree binding, t1, id;
2494
2495       if (TREE_CODE (t) == TREE_LIST)
2496         id = TREE_PURPOSE (t);
2497       else
2498         id = DECL_NAME (t);
2499
2500       if (!id
2501           /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2502              we have no IDENTIFIER_BINDING if we have left the class
2503              scope, but cached the class-level declarations.  */
2504           || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2505         continue;
2506
2507       for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2508         if (TREE_VEC_ELT (t1, 0) == id)
2509           goto skip_it;
2510
2511       binding = make_tree_vec (4);
2512
2513       if (id)
2514         {
2515           my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2516           TREE_VEC_ELT (binding, 0) = id;
2517           TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2518           TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2519           TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2520           IDENTIFIER_BINDING (id) = NULL_TREE;
2521           IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2522         }
2523       TREE_CHAIN (binding) = old_bindings;
2524       old_bindings = binding;
2525     skip_it:
2526       ;
2527     }
2528   return old_bindings;
2529 }
2530
2531 void
2532 maybe_push_to_top_level (pseudo)
2533      int pseudo;
2534 {
2535   struct saved_scope *s;
2536   struct binding_level *b;
2537   tree old_bindings;
2538   int need_pop;
2539
2540   s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2541
2542   b = scope_chain ? current_binding_level : 0;
2543
2544   /* If we're in the middle of some function, save our state.  */
2545   if (cfun)
2546     {
2547       need_pop = 1;
2548       push_function_context_to (NULL_TREE);
2549     }
2550   else
2551     need_pop = 0;
2552
2553   old_bindings = NULL_TREE;
2554   if (scope_chain && previous_class_type)
2555     old_bindings = store_bindings (previous_class_values, old_bindings);
2556
2557   /* Have to include global_binding_level, because class-level decls
2558      aren't listed anywhere useful.  */
2559   for (; b; b = b->level_chain)
2560     {
2561       tree t;
2562
2563       /* Template IDs are inserted into the global level. If they were
2564          inserted into namespace level, finish_file wouldn't find them
2565          when doing pending instantiations. Therefore, don't stop at
2566          namespace level, but continue until :: .  */
2567       if (b == global_binding_level || (pseudo && b->template_parms_p))
2568         break;
2569
2570       old_bindings = store_bindings (b->names, old_bindings);
2571       /* We also need to check class_shadowed to save class-level type
2572          bindings, since pushclass doesn't fill in b->names.  */
2573       if (b->parm_flag == 2)
2574         old_bindings = store_bindings (b->class_shadowed, old_bindings);
2575
2576       /* Unwind type-value slots back to top level.  */
2577       for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2578         SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2579     }
2580   s->prev = scope_chain;
2581   s->old_bindings = old_bindings;
2582   s->bindings = b;
2583   s->need_pop_function_context = need_pop;
2584   s->function_decl = current_function_decl;
2585
2586   scope_chain = s;
2587   current_function_decl = NULL_TREE;
2588   VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2589   current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2590   current_lang_name = lang_name_cplusplus;
2591   strict_prototype = strict_prototypes_lang_cplusplus;
2592   current_namespace = global_namespace;
2593 }
2594
2595 void
2596 push_to_top_level ()
2597 {
2598   maybe_push_to_top_level (0);
2599 }
2600
2601 void
2602 pop_from_top_level ()
2603 {
2604   struct saved_scope *s = scope_chain;
2605   tree t;
2606
2607   /* Clear out class-level bindings cache.  */
2608   if (previous_class_type)
2609     invalidate_class_lookup_cache ();
2610
2611   VARRAY_FREE (current_lang_base);
2612
2613   scope_chain = s->prev;
2614   for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2615     {
2616       tree id = TREE_VEC_ELT (t, 0);
2617       if (id)
2618         {
2619           SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2620           IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2621           IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2622         }
2623     }
2624
2625   if (current_lang_name == lang_name_cplusplus)
2626     strict_prototype = strict_prototypes_lang_cplusplus;
2627   else if (current_lang_name == lang_name_c)
2628     strict_prototype = strict_prototypes_lang_c;
2629
2630   /* If we were in the middle of compiling a function, restore our
2631      state.  */
2632   if (s->need_pop_function_context)
2633     pop_function_context_from (NULL_TREE);
2634   current_function_decl = s->function_decl;
2635
2636   free (s);
2637 }
2638 \f
2639 /* Push a definition of struct, union or enum tag "name".
2640    into binding_level "b".   "type" should be the type node,
2641    We assume that the tag "name" is not already defined.
2642
2643    Note that the definition may really be just a forward reference.
2644    In that case, the TYPE_SIZE will be a NULL_TREE.
2645
2646    C++ gratuitously puts all these tags in the name space.  */
2647
2648 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2649    record the shadowed value for this binding contour.  TYPE is
2650    the type that ID maps to.  */
2651
2652 static void
2653 set_identifier_type_value_with_scope (id, type, b)
2654      tree id;
2655      tree type;
2656      struct binding_level *b;
2657 {
2658   if (!b->namespace_p)
2659     {
2660       /* Shadow the marker, not the real thing, so that the marker
2661          gets restored later. */
2662       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2663       b->type_shadowed
2664         = tree_cons (id, old_type_value, b->type_shadowed);
2665     }
2666   else
2667     {
2668       tree binding = binding_for_name (id, current_namespace);
2669       BINDING_TYPE (binding) = type;
2670       /* Store marker instead of real type. */
2671       type = global_type_node;
2672     }
2673   SET_IDENTIFIER_TYPE_VALUE (id, type);
2674 }
2675
2676 /* As set_identifier_type_value_with_scope, but using current_binding_level.  */
2677
2678 void
2679 set_identifier_type_value (id, type)
2680      tree id;
2681      tree type;
2682 {
2683   set_identifier_type_value_with_scope (id, type, current_binding_level);
2684 }
2685
2686 /* Return the type associated with id. */
2687
2688 tree
2689 identifier_type_value (id)
2690      tree id;
2691 {
2692   /* There is no type with that name, anywhere. */
2693   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2694     return NULL_TREE;
2695   /* This is not the type marker, but the real thing. */
2696   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2697     return REAL_IDENTIFIER_TYPE_VALUE (id);
2698   /* Have to search for it. It must be on the global level, now.
2699      Ask lookup_name not to return non-types. */
2700   id = lookup_name_real (id, 2, 1, 0);
2701   if (id)
2702     return TREE_TYPE (id);
2703   return NULL_TREE;
2704 }
2705
2706 /* Pop off extraneous binding levels left over due to syntax errors.
2707
2708    We don't pop past namespaces, as they might be valid.  */
2709
2710 void
2711 pop_everything ()
2712 {
2713 #ifdef DEBUG_CP_BINDING_LEVELS
2714   fprintf (stderr, "XXX entering pop_everything ()\n");
2715 #endif
2716   while (!toplevel_bindings_p ())
2717     {
2718       if (current_binding_level->parm_flag == 2)
2719         pop_nested_class ();
2720       else
2721         poplevel (0, 0, 0);
2722     }
2723 #ifdef DEBUG_CP_BINDING_LEVELS
2724   fprintf (stderr, "XXX leaving pop_everything ()\n");
2725 #endif
2726 }
2727
2728 /* The type TYPE is being declared.  If it is a class template, or a
2729    specialization of a class template, do any processing required and
2730    perform error-checking.  If IS_FRIEND is non-zero, this TYPE is
2731    being declared a friend.  B is the binding level at which this TYPE
2732    should be bound.
2733
2734    Returns the TYPE_DECL for TYPE, which may have been altered by this
2735    processing.  */
2736
2737 static tree
2738 maybe_process_template_type_declaration (type, globalize, b)
2739      tree type;
2740      int globalize;
2741      struct binding_level* b;
2742 {
2743   tree decl = TYPE_NAME (type);
2744
2745   if (processing_template_parmlist)
2746     /* You can't declare a new template type in a template parameter
2747        list.  But, you can declare a non-template type:
2748
2749          template <class A*> struct S;
2750
2751        is a forward-declaration of `A'.  */
2752     ;
2753   else
2754     {
2755       maybe_check_template_type (type);
2756
2757       my_friendly_assert (IS_AGGR_TYPE (type)
2758                           || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2759
2760
2761       if (processing_template_decl)
2762         {
2763           /* This may change after the call to
2764              push_template_decl_real, but we want the original value.  */
2765           tree name = DECL_NAME (decl);
2766
2767           decl = push_template_decl_real (decl, globalize);
2768           /* If the current binding level is the binding level for the
2769              template parameters (see the comment in
2770              begin_template_parm_list) and the enclosing level is a class
2771              scope, and we're not looking at a friend, push the
2772              declaration of the member class into the class scope.  In the
2773              friend case, push_template_decl will already have put the
2774              friend into global scope, if appropriate.  */
2775           if (TREE_CODE (type) != ENUMERAL_TYPE
2776               && !globalize && b->template_parms_p
2777               && b->level_chain->parm_flag == 2)
2778             {
2779               finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2780               /* Put this tag on the list of tags for the class, since
2781                  that won't happen below because B is not the class
2782                  binding level, but is instead the pseudo-global level.  */
2783               b->level_chain->tags =
2784                 tree_cons (name, type, b->level_chain->tags);
2785               if (!COMPLETE_TYPE_P (current_class_type))
2786                 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2787             }
2788         }
2789     }
2790
2791   return decl;
2792 }
2793
2794 /* In C++, you don't have to write `struct S' to refer to `S'; you
2795    can just use `S'.  We accomplish this by creating a TYPE_DECL as
2796    if the user had written `typedef struct S S'.  Create and return
2797    the TYPE_DECL for TYPE.  */
2798
2799 tree
2800 create_implicit_typedef (name, type)
2801      tree name;
2802      tree type;
2803 {
2804   tree decl;
2805
2806   decl = build_decl (TYPE_DECL, name, type);
2807   SET_DECL_ARTIFICIAL (decl);
2808   /* There are other implicit type declarations, like the one *within*
2809      a class that allows you to write `S::S'.  We must distinguish
2810      amongst these.  */
2811   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2812   TYPE_NAME (type) = decl;
2813
2814   return decl;
2815 }
2816
2817 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2818    Normally put it into the inner-most non-tag-transparent scope,
2819    but if GLOBALIZE is true, put it in the inner-most non-class scope.
2820    The latter is needed for implicit declarations.  */
2821
2822 void
2823 pushtag (name, type, globalize)
2824      tree name, type;
2825      int globalize;
2826 {
2827   register struct binding_level *b;
2828
2829   b = current_binding_level;
2830   while (b->tag_transparent
2831          || (globalize && b->parm_flag == 2))
2832     b = b->level_chain;
2833
2834   b->tags = tree_cons (name, type, b->tags);
2835
2836   if (name)
2837     {
2838       /* Do C++ gratuitous typedefing.  */
2839       if (IDENTIFIER_TYPE_VALUE (name) != type)
2840         {
2841           register tree d = NULL_TREE;
2842           int in_class = 0;
2843           tree context = TYPE_CONTEXT (type);
2844
2845           if (! context)
2846             {
2847               tree cs = current_scope ();
2848
2849               if (! globalize)
2850                 context = cs;
2851               else if (cs != NULL_TREE && TYPE_P (cs))
2852                 /* When declaring a friend class of a local class, we want
2853                    to inject the newly named class into the scope
2854                    containing the local class, not the namespace scope.  */
2855                 context = decl_function_context (get_type_decl (cs));
2856             }
2857           if (!context)
2858             context = current_namespace;
2859
2860           if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2861               || b->parm_flag == 2)
2862             in_class = 1;
2863
2864           if (current_lang_name == lang_name_java)
2865             TYPE_FOR_JAVA (type) = 1;
2866
2867           d = create_implicit_typedef (name, type);
2868           DECL_CONTEXT (d) = FROB_CONTEXT (context);
2869           if (! in_class)
2870             set_identifier_type_value_with_scope (name, type, b);
2871
2872           d = maybe_process_template_type_declaration (type,
2873                                                        globalize, b);
2874
2875           if (b->parm_flag == 2)
2876             {
2877               if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2878                 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2879                    class.  But if it's a member template class, we
2880                    want the TEMPLATE_DECL, not the TYPE_DECL, so this
2881                    is done later.  */
2882                 finish_member_declaration (d);
2883               else
2884                 pushdecl_class_level (d);
2885             }
2886           else
2887             d = pushdecl_with_scope (d, b);
2888
2889           if (ANON_AGGRNAME_P (name))
2890             DECL_IGNORED_P (d) = 1;
2891
2892           TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2893           DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2894
2895           /* If this is a local class, keep track of it.  We need this
2896              information for name-mangling, and so that it is possible to find
2897              all function definitions in a translation unit in a convenient
2898              way.  (It's otherwise tricky to find a member function definition
2899              it's only pointed to from within a local class.)  */
2900           if (TYPE_CONTEXT (type)
2901               && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
2902             VARRAY_PUSH_TREE (local_classes, type);
2903
2904           if (!uses_template_parms (type))
2905             {
2906               if (flag_new_abi)
2907                 DECL_ASSEMBLER_NAME (d) = mangle_type (type);
2908               else
2909                 DECL_ASSEMBLER_NAME (d)
2910                   = get_identifier (build_overload_name (type, 1, 1));
2911             }
2912         }
2913       if (b->parm_flag == 2)
2914         {
2915           if (!COMPLETE_TYPE_P (current_class_type))
2916             CLASSTYPE_TAGS (current_class_type) = b->tags;
2917         }
2918     }
2919
2920   if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2921     /* Use the canonical TYPE_DECL for this node.  */
2922     TYPE_STUB_DECL (type) = TYPE_NAME (type);
2923   else
2924     {
2925       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2926          will be the tagged type we just added to the current
2927          binding level.  This fake NULL-named TYPE_DECL node helps
2928          dwarfout.c to know when it needs to output a
2929          representation of a tagged type, and it also gives us a
2930          convenient place to record the "scope start" address for
2931          the tagged type.  */
2932
2933       tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2934       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2935     }
2936 }
2937
2938 /* Counter used to create anonymous type names.  */
2939
2940 static int anon_cnt = 0;
2941
2942 /* Return an IDENTIFIER which can be used as a name for
2943    anonymous structs and unions.  */
2944
2945 tree
2946 make_anon_name ()
2947 {
2948   char buf[32];
2949
2950   sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2951   return get_identifier (buf);
2952 }
2953
2954 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2955    This keeps dbxout from getting confused.  */
2956
2957 void
2958 clear_anon_tags ()
2959 {
2960   register struct binding_level *b;
2961   register tree tags;
2962   static int last_cnt = 0;
2963
2964   /* Fast out if no new anon names were declared.  */
2965   if (last_cnt == anon_cnt)
2966     return;
2967
2968   b = current_binding_level;
2969   while (b->tag_transparent)
2970     b = b->level_chain;
2971   tags = b->tags;
2972   while (tags)
2973     {
2974       /* A NULL purpose means we have already processed all tags
2975          from here to the end of the list.  */
2976       if (TREE_PURPOSE (tags) == NULL_TREE)
2977         break;
2978       if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2979         TREE_PURPOSE (tags) = NULL_TREE;
2980       tags = TREE_CHAIN (tags);
2981     }
2982   last_cnt = anon_cnt;
2983 }
2984 \f
2985 /* Subroutine of duplicate_decls: return truthvalue of whether
2986    or not types of these decls match.
2987
2988    For C++, we must compare the parameter list so that `int' can match
2989    `int&' in a parameter position, but `int&' is not confused with
2990    `const int&'.  */
2991
2992 int
2993 decls_match (newdecl, olddecl)
2994      tree newdecl, olddecl;
2995 {
2996   int types_match;
2997
2998   if (newdecl == olddecl)
2999     return 1;
3000
3001   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
3002     /* If the two DECLs are not even the same kind of thing, we're not
3003        interested in their types.  */
3004     return 0;
3005
3006   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3007     {
3008       tree f1 = TREE_TYPE (newdecl);
3009       tree f2 = TREE_TYPE (olddecl);
3010       tree p1 = TYPE_ARG_TYPES (f1);
3011       tree p2 = TYPE_ARG_TYPES (f2);
3012
3013       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
3014           && ! (DECL_EXTERN_C_P (newdecl)
3015                 && DECL_EXTERN_C_P (olddecl)))
3016         return 0;
3017
3018       if (TREE_CODE (f1) != TREE_CODE (f2))
3019         return 0;
3020
3021       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
3022         {
3023           if ((! strict_prototypes_lang_c || DECL_BUILT_IN (olddecl))
3024               && DECL_EXTERN_C_P (olddecl)
3025               && p2 == NULL_TREE)
3026             {
3027               types_match = self_promoting_args_p (p1);
3028               if (p1 == void_list_node)
3029                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3030             }
3031           else if (!strict_prototypes_lang_c
3032                    && DECL_EXTERN_C_P (olddecl)
3033                    && DECL_EXTERN_C_P (newdecl)
3034                    && p1 == NULL_TREE)
3035             {
3036               types_match = self_promoting_args_p (p2);
3037               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
3038             }
3039           else
3040             types_match = compparms (p1, p2);
3041         }
3042       else
3043         types_match = 0;
3044     }
3045   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3046     {
3047       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3048                                 DECL_TEMPLATE_PARMS (olddecl)))
3049         return 0;
3050
3051       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3052         types_match = 1;
3053       else
3054         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
3055                                    DECL_TEMPLATE_RESULT (newdecl));
3056     }
3057   else
3058     {
3059       if (TREE_TYPE (newdecl) == error_mark_node)
3060         types_match = TREE_TYPE (olddecl) == error_mark_node;
3061       else if (TREE_TYPE (olddecl) == NULL_TREE)
3062         types_match = TREE_TYPE (newdecl) == NULL_TREE;
3063       else if (TREE_TYPE (newdecl) == NULL_TREE)
3064         types_match = 0;
3065       else
3066         types_match = comptypes (TREE_TYPE (newdecl),
3067                                  TREE_TYPE (olddecl),
3068                                  COMPARE_REDECLARATION);
3069     }
3070
3071   return types_match;
3072 }
3073
3074 /* If NEWDECL is `static' and an `extern' was seen previously,
3075    warn about it.  OLDDECL is the previous declaration.
3076
3077    Note that this does not apply to the C++ case of declaring
3078    a variable `extern const' and then later `const'.
3079
3080    Don't complain about built-in functions, since they are beyond
3081    the user's control.  */
3082
3083 static void
3084 warn_extern_redeclared_static (newdecl, olddecl)
3085      tree newdecl, olddecl;
3086 {
3087   static const char *explicit_extern_static_warning
3088     = "`%D' was declared `extern' and later `static'";
3089   static const char *implicit_extern_static_warning
3090     = "`%D' was declared implicitly `extern' and later `static'";
3091
3092   tree name;
3093
3094   if (TREE_CODE (newdecl) == TYPE_DECL
3095       || TREE_CODE (newdecl) == TEMPLATE_DECL)
3096     return;
3097
3098   /* Don't get confused by static member functions; that's a different
3099      use of `static'.  */
3100   if (TREE_CODE (newdecl) == FUNCTION_DECL
3101       && DECL_STATIC_FUNCTION_P (newdecl))
3102     return;
3103
3104   /* If the old declaration was `static', or the new one isn't, then
3105      then everything is OK.  */
3106   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3107     return;
3108
3109   /* It's OK to declare a builtin function as `static'.  */
3110   if (TREE_CODE (olddecl) == FUNCTION_DECL
3111       && DECL_ARTIFICIAL (olddecl))
3112     return;
3113
3114   name = DECL_ASSEMBLER_NAME (newdecl);
3115   cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3116               ? implicit_extern_static_warning
3117               : explicit_extern_static_warning, newdecl);
3118   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3119 }
3120
3121 /* Handle when a new declaration NEWDECL has the same name as an old
3122    one OLDDECL in the same binding contour.  Prints an error message
3123    if appropriate.
3124
3125    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3126    Otherwise, return 0.  */
3127
3128 int
3129 duplicate_decls (newdecl, olddecl)
3130      tree newdecl, olddecl;
3131 {
3132   unsigned olddecl_uid = DECL_UID (olddecl);
3133   int olddecl_friend = 0, types_match = 0;
3134   int new_defines_function = 0;
3135
3136   if (newdecl == olddecl)
3137     return 1;
3138
3139   types_match = decls_match (newdecl, olddecl);
3140
3141   /* If either the type of the new decl or the type of the old decl is an
3142      error_mark_node, then that implies that we have already issued an
3143      error (earlier) for some bogus type specification, and in that case,
3144      it is rather pointless to harass the user with yet more error message
3145      about the same declaration, so just pretend the types match here.  */
3146   if (TREE_TYPE (newdecl) == error_mark_node
3147       || TREE_TYPE (olddecl) == error_mark_node)
3148     types_match = 1;
3149
3150   /* Check for redeclaration and other discrepancies. */
3151   if (TREE_CODE (olddecl) == FUNCTION_DECL
3152       && DECL_ARTIFICIAL (olddecl))
3153     {
3154       if (TREE_CODE (newdecl) != FUNCTION_DECL)
3155         {
3156           /* If you declare a built-in or predefined function name as static,
3157              the old definition is overridden, but optionally warn this was a
3158              bad choice of name.  */
3159           if (! TREE_PUBLIC (newdecl))
3160             {
3161               if (warn_shadow)
3162                 cp_warning ("shadowing %s function `%#D'",
3163                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3164                             olddecl);
3165               /* Discard the old built-in function.  */
3166               return 0;
3167             }
3168           /* If the built-in is not ansi, then programs can override
3169              it even globally without an error.  */
3170           else if (! DECL_BUILT_IN (olddecl))
3171             cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3172                         olddecl, newdecl);
3173           else
3174             {
3175               cp_error ("declaration of `%#D'", newdecl);
3176               cp_error ("conflicts with built-in declaration `%#D'",
3177                         olddecl);
3178             }
3179           return 0;
3180         }
3181       else if (!types_match)
3182         {
3183           if ((DECL_EXTERN_C_P (newdecl)
3184                && DECL_EXTERN_C_P (olddecl))
3185               || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3186                             TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3187             {
3188               /* A near match; override the builtin.  */
3189
3190               if (TREE_PUBLIC (newdecl))
3191                 {
3192                   cp_warning ("new declaration `%#D'", newdecl);
3193                   cp_warning ("ambiguates built-in declaration `%#D'",
3194                               olddecl);
3195                 }
3196               else if (warn_shadow)
3197                 cp_warning ("shadowing %s function `%#D'",
3198                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3199                             olddecl);
3200             }
3201           else
3202             /* Discard the old built-in function.  */
3203             return 0;
3204         }
3205
3206       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3207         {
3208           /* If a builtin function is redeclared as `static', merge
3209              the declarations, but make the original one static.  */
3210           DECL_THIS_STATIC (olddecl) = 1;
3211           TREE_PUBLIC (olddecl) = 0;
3212
3213           /* Make the old declaration consistent with the new one so
3214              that all remnants of the builtin-ness of this function
3215              will be banished.  */
3216           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3217           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3218           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3219           SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3220                                        newdecl);
3221         }
3222     }
3223   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3224     {
3225       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3226            && TREE_CODE (newdecl) != TYPE_DECL
3227            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3228                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3229           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3230               && TREE_CODE (olddecl) != TYPE_DECL
3231               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3232                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3233                         == TYPE_DECL))))
3234         {
3235           /* We do nothing special here, because C++ does such nasty
3236              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
3237              get shadowed, and know that if we need to find a TYPE_DECL
3238              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3239              slot of the identifier.  */
3240           return 0;
3241         }
3242
3243       if ((TREE_CODE (newdecl) == FUNCTION_DECL
3244            && DECL_FUNCTION_TEMPLATE_P (olddecl))
3245           || (TREE_CODE (olddecl) == FUNCTION_DECL
3246               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3247         return 0;
3248
3249       cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3250       if (TREE_CODE (olddecl) == TREE_LIST)
3251         olddecl = TREE_VALUE (olddecl);
3252       cp_error_at ("previous declaration of `%#D'", olddecl);
3253
3254       /* New decl is completely inconsistent with the old one =>
3255          tell caller to replace the old one.  */
3256
3257       return 0;
3258     }
3259   else if (!types_match)
3260     {
3261       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3262         /* These are certainly not duplicate declarations; they're
3263            from different scopes.  */
3264         return 0;
3265
3266       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3267         {
3268           /* The name of a class template may not be declared to refer to
3269              any other template, class, function, object, namespace, value,
3270              or type in the same scope.  */
3271           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3272               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3273             {
3274               cp_error ("declaration of template `%#D'", newdecl);
3275               cp_error_at ("conflicts with previous declaration `%#D'",
3276                            olddecl);
3277             }
3278           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3279                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3280                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3281                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3282                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3283                                            DECL_TEMPLATE_PARMS (olddecl)))
3284             {
3285               cp_error ("new declaration `%#D'", newdecl);
3286               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3287             }
3288           return 0;
3289         }
3290       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3291         {
3292           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3293             {
3294               cp_error ("declaration of C function `%#D' conflicts with",
3295                         newdecl);
3296               cp_error_at ("previous declaration `%#D' here", olddecl);
3297             }
3298           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3299                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3300             {
3301               cp_error ("new declaration `%#D'", newdecl);
3302               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3303             }
3304           else
3305             return 0;
3306         }
3307
3308       /* Already complained about this, so don't do so again.  */
3309       else if (current_class_type == NULL_TREE
3310           || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3311         {
3312           cp_error ("conflicting types for `%#D'", newdecl);
3313           cp_error_at ("previous declaration as `%#D'", olddecl);
3314         }
3315     }
3316   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3317             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3318                  && (!DECL_TEMPLATE_INFO (newdecl)
3319                      || (DECL_TI_TEMPLATE (newdecl)
3320                          != DECL_TI_TEMPLATE (olddecl))))
3321                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3322                     && (!DECL_TEMPLATE_INFO (olddecl)
3323                         || (DECL_TI_TEMPLATE (olddecl)
3324                             != DECL_TI_TEMPLATE (newdecl))))))
3325     /* It's OK to have a template specialization and a non-template
3326        with the same type, or to have specializations of two
3327        different templates with the same type.  Note that if one is a
3328        specialization, and the other is an instantiation of the same
3329        template, that we do not exit at this point.  That situation
3330        can occur if we instantiate a template class, and then
3331        specialize one of its methods.  This situation is legal, but
3332        the declarations must be merged in the usual way.  */
3333     return 0;
3334   else if (TREE_CODE (newdecl) == FUNCTION_DECL
3335            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3336                 && !DECL_USE_TEMPLATE (newdecl))
3337                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3338                    && !DECL_USE_TEMPLATE (olddecl))))
3339     /* One of the declarations is a template instantiation, and the
3340        other is not a template at all.  That's OK.  */
3341     return 0;
3342   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3343            && DECL_NAMESPACE_ALIAS (newdecl)
3344            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3345     /* Redeclaration of namespace alias, ignore it. */
3346     return 1;
3347   else
3348     {
3349       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3350       if (errmsg)
3351         {
3352           cp_error (errmsg, newdecl);
3353           if (DECL_NAME (olddecl) != NULL_TREE)
3354             cp_error_at ((DECL_INITIAL (olddecl)
3355                           && namespace_bindings_p ())
3356                          ? "`%#D' previously defined here"
3357                          : "`%#D' previously declared here", olddecl);
3358         }
3359       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3360                && DECL_INITIAL (olddecl) != NULL_TREE
3361                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3362                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3363         {
3364           /* Prototype decl follows defn w/o prototype.  */
3365           cp_warning_at ("prototype for `%#D'", newdecl);
3366           cp_warning_at ("follows non-prototype definition here", olddecl);
3367         }
3368       else if (TREE_CODE (olddecl) == FUNCTION_DECL
3369                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3370         {
3371           /* extern "C" int foo ();
3372              int foo () { bar (); }
3373              is OK.  */
3374           if (current_lang_stack
3375               == &VARRAY_TREE (current_lang_base, 0))
3376             DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3377           else
3378             {
3379               cp_error_at ("previous declaration of `%#D' with %L linkage",
3380                            olddecl, DECL_LANGUAGE (olddecl));
3381               cp_error ("conflicts with new declaration with %L linkage",
3382                         DECL_LANGUAGE (newdecl));
3383             }
3384         }
3385
3386       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3387         ;
3388       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3389         {
3390           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3391           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3392           int i = 1;
3393
3394           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3395             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3396
3397           for (; t1 && t1 != void_list_node;
3398                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3399             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3400               {
3401                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3402                                            TREE_PURPOSE (t2)))
3403                   {
3404                     if (pedantic)
3405                       {
3406                         cp_pedwarn ("default argument given for parameter %d of `%#D'",
3407                                     i, newdecl);
3408                         cp_pedwarn_at ("after previous specification in `%#D'",
3409                                        olddecl);
3410                       }
3411                   }
3412                 else
3413                   {
3414                     cp_error ("default argument given for parameter %d of `%#D'",
3415                               i, newdecl);
3416                     cp_error_at ("after previous specification in `%#D'",
3417                                  olddecl);
3418                   }
3419               }
3420
3421           if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3422               && TREE_ADDRESSABLE (olddecl) && warn_inline)
3423             {
3424               cp_warning ("`%#D' was used before it was declared inline",
3425                           newdecl);
3426               cp_warning_at ("previous non-inline declaration here",
3427                              olddecl);
3428             }
3429         }
3430     }
3431
3432   /* If new decl is `static' and an `extern' was seen previously,
3433      warn about it.  */
3434   warn_extern_redeclared_static (newdecl, olddecl);
3435
3436   /* We have committed to returning 1 at this point.  */
3437   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3438     {
3439       /* Now that functions must hold information normally held
3440          by field decls, there is extra work to do so that
3441          declaration information does not get destroyed during
3442          definition.  */
3443       if (DECL_VINDEX (olddecl))
3444         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3445       if (DECL_VIRTUAL_CONTEXT (olddecl))
3446         DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3447       if (DECL_CONTEXT (olddecl))
3448         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3449       if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3450         DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3451       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3452       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3453       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3454       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3455       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3456       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3457       DECL_LANG_SPECIFIC (newdecl)->u2 = DECL_LANG_SPECIFIC (olddecl)->u2;
3458       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3459
3460       /* Optionally warn about more than one declaration for the same
3461          name, but don't warn about a function declaration followed by a
3462          definition.  */
3463       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3464           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3465           /* Don't warn about extern decl followed by definition. */
3466           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3467           /* Don't warn about friends, let add_friend take care of it. */
3468           && ! DECL_FRIEND_P (newdecl))
3469         {
3470           cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3471           cp_warning_at ("previous declaration of `%D'", olddecl);
3472         }
3473     }
3474
3475   /* Deal with C++: must preserve virtual function table size.  */
3476   if (TREE_CODE (olddecl) == TYPE_DECL)
3477     {
3478       register tree newtype = TREE_TYPE (newdecl);
3479       register tree oldtype = TREE_TYPE (olddecl);
3480
3481       if (newtype != error_mark_node && oldtype != error_mark_node
3482           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3483         {
3484           CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3485           CLASSTYPE_FRIEND_CLASSES (newtype)
3486             = CLASSTYPE_FRIEND_CLASSES (oldtype);
3487         }
3488     }
3489
3490   /* Copy all the DECL_... slots specified in the new decl
3491      except for any that we copy here from the old type.  */
3492   DECL_MACHINE_ATTRIBUTES (newdecl)
3493     = merge_machine_decl_attributes (olddecl, newdecl);
3494
3495   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3496     {
3497       if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl),
3498                              DECL_TEMPLATE_RESULT (olddecl)))
3499         cp_error ("invalid redeclaration of %D", newdecl);
3500       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3501       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3502         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3503                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3504
3505       return 1;
3506     }
3507
3508   if (types_match)
3509     {
3510       /* Automatically handles default parameters.  */
3511       tree oldtype = TREE_TYPE (olddecl);
3512       tree newtype;
3513
3514       /* Merge the data types specified in the two decls.  */
3515       newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3516
3517       if (TREE_CODE (newdecl) == VAR_DECL)
3518         DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3519       /* Do this after calling `common_type' so that default
3520          parameters don't confuse us.  */
3521       else if (TREE_CODE (newdecl) == FUNCTION_DECL
3522           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3523               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3524         {
3525           TREE_TYPE (newdecl) = build_exception_variant (newtype,
3526                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3527           TREE_TYPE (olddecl) = build_exception_variant (newtype,
3528                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
3529
3530           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3531               && DECL_SOURCE_LINE (olddecl) != 0
3532               && flag_exceptions
3533               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3534                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3535             {
3536               cp_error ("declaration of `%F' throws different exceptions",
3537                         newdecl);
3538               cp_error_at ("than previous declaration `%F'", olddecl);
3539             }
3540         }
3541       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3542
3543       /* Lay the type out, unless already done.  */
3544       if (! same_type_p (newtype, oldtype)
3545           && TREE_TYPE (newdecl) != error_mark_node
3546           && !(processing_template_decl && uses_template_parms (newdecl)))
3547         layout_type (TREE_TYPE (newdecl));
3548
3549       if ((TREE_CODE (newdecl) == VAR_DECL
3550            || TREE_CODE (newdecl) == PARM_DECL
3551            || TREE_CODE (newdecl) == RESULT_DECL
3552            || TREE_CODE (newdecl) == FIELD_DECL
3553            || TREE_CODE (newdecl) == TYPE_DECL)
3554           && !(processing_template_decl && uses_template_parms (newdecl)))
3555         layout_decl (newdecl, 0);
3556
3557       /* Merge the type qualifiers.  */
3558       if (TREE_READONLY (newdecl))
3559         TREE_READONLY (olddecl) = 1;
3560       if (TREE_THIS_VOLATILE (newdecl))
3561         TREE_THIS_VOLATILE (olddecl) = 1;
3562
3563       /* Merge the initialization information.  */
3564       if (DECL_INITIAL (newdecl) == NULL_TREE
3565           && DECL_INITIAL (olddecl) != NULL_TREE)
3566         {
3567           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3568           DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3569           DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3570           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3571               && DECL_LANG_SPECIFIC (newdecl)
3572               && DECL_LANG_SPECIFIC (olddecl))
3573             DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3574         }
3575
3576       /* Merge the section attribute.
3577          We want to issue an error if the sections conflict but that must be
3578          done later in decl_attributes since we are called before attributes
3579          are assigned.  */
3580       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3581         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3582
3583       /* Keep the old rtl since we can safely use it.  */
3584       DECL_RTL (newdecl) = DECL_RTL (olddecl);
3585
3586       if (TREE_CODE (newdecl) == FUNCTION_DECL)
3587         {
3588           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3589             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3590           DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3591             |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3592           DECL_NO_LIMIT_STACK (newdecl)
3593             |= DECL_NO_LIMIT_STACK (olddecl);
3594         }
3595     }
3596   /* If cannot merge, then use the new type and qualifiers,
3597      and don't preserve the old rtl.  */
3598   else
3599     {
3600       /* Clean out any memory we had of the old declaration.  */
3601       tree oldstatic = value_member (olddecl, static_aggregates);
3602       if (oldstatic)
3603         TREE_VALUE (oldstatic) = error_mark_node;
3604
3605       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3606       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3607       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3608       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3609     }
3610
3611   /* Merge the storage class information.  */
3612   DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3613   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3614   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3615   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3616   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3617   if (! DECL_EXTERNAL (olddecl))
3618     DECL_EXTERNAL (newdecl) = 0;
3619
3620   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3621     {
3622       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3623       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3624       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3625       DECL_TEMPLATE_INSTANTIATED (newdecl)
3626         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3627       /* Don't really know how much of the language-specific
3628          values we should copy from old to new.  */
3629       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3630       DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3631       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3632       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3633       olddecl_friend = DECL_FRIEND_P (olddecl);
3634
3635       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
3636       if (TREE_CODE (newdecl) == FUNCTION_DECL
3637           || DECL_FUNCTION_TEMPLATE_P (newdecl))
3638         DECL_BEFRIENDING_CLASSES (newdecl)
3639           = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3640                      DECL_BEFRIENDING_CLASSES (olddecl));
3641     }
3642
3643   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3644     {
3645       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3646           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3647         {
3648           /* If newdecl is not a specialization, then it is not a
3649              template-related function at all.  And that means that we
3650              shoud have exited above, returning 0.  */
3651           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3652                               0);
3653
3654           if (TREE_USED (olddecl))
3655             /* From [temp.expl.spec]:
3656
3657                If a template, a member template or the member of a class
3658                template is explicitly specialized then that
3659                specialization shall be declared before the first use of
3660                that specialization that would cause an implicit
3661                instantiation to take place, in every translation unit in
3662                which such a use occurs.  */
3663             cp_error ("explicit specialization of %D after first use",
3664                       olddecl);
3665
3666           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3667         }
3668       DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3669
3670       /* If either decl says `inline', this fn is inline, unless its
3671          definition was passed already.  */
3672       if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3673         DECL_INLINE (olddecl) = 1;
3674       DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3675
3676       if (! types_match)
3677         {
3678           DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3679           DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3680           DECL_RTL (olddecl) = DECL_RTL (newdecl);
3681         }
3682       if (! types_match || new_defines_function)
3683         {
3684           /* These need to be copied so that the names are available.
3685              Note that if the types do match, we'll preserve inline
3686              info and other bits, but if not, we won't.  */
3687           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3688           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3689         }
3690       if (new_defines_function)
3691         /* If defining a function declared with other language
3692            linkage, use the previously declared language linkage.  */
3693         DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3694       else if (types_match)
3695         {
3696           /* If redeclaring a builtin function, and not a definition,
3697              it stays built in.  */
3698           if (DECL_BUILT_IN (olddecl))
3699             {
3700               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3701               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3702               /* If we're keeping the built-in definition, keep the rtl,
3703                  regardless of declaration matches.  */
3704               DECL_RTL (newdecl) = DECL_RTL (olddecl);
3705             }
3706           else
3707             DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3708
3709           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3710           if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3711             /* Previously saved insns go together with
3712                the function's previous definition.  */
3713             DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3714           /* Don't clear out the arguments if we're redefining a function.  */
3715           if (DECL_ARGUMENTS (olddecl))
3716             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3717         }
3718     }
3719
3720   if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3721     {
3722       NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3723     }
3724
3725   /* Now preserve various other info from the definition.  */
3726   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3727   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3728   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3729   DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3730
3731   if (TREE_CODE (newdecl) == FUNCTION_DECL)
3732     {
3733       int function_size;
3734
3735       function_size = sizeof (struct tree_decl);
3736
3737       bcopy ((char *) newdecl + sizeof (struct tree_common),
3738              (char *) olddecl + sizeof (struct tree_common),
3739              function_size - sizeof (struct tree_common));
3740
3741       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3742         {
3743           /* If newdecl is a template instantiation, it is possible that
3744              the following sequence of events has occurred:
3745
3746              o A friend function was declared in a class template.  The
3747              class template was instantiated.
3748
3749              o The instantiation of the friend declaration was
3750              recorded on the instantiation list, and is newdecl.
3751
3752              o Later, however, instantiate_class_template called pushdecl
3753              on the newdecl to perform name injection.  But, pushdecl in
3754              turn called duplicate_decls when it discovered that another
3755              declaration of a global function with the same name already
3756              existed.
3757
3758              o Here, in duplicate_decls, we decided to clobber newdecl.
3759
3760              If we're going to do that, we'd better make sure that
3761              olddecl, and not newdecl, is on the list of
3762              instantiations so that if we try to do the instantiation
3763              again we won't get the clobbered declaration.  */
3764
3765           tree tmpl = DECL_TI_TEMPLATE (newdecl);
3766           tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3767
3768           for (; decls; decls = TREE_CHAIN (decls))
3769             if (TREE_VALUE (decls) == newdecl)
3770               TREE_VALUE (decls) = olddecl;
3771         }
3772     }
3773   else
3774     {
3775       bcopy ((char *) newdecl + sizeof (struct tree_common),
3776              (char *) olddecl + sizeof (struct tree_common),
3777              sizeof (struct tree_decl) - sizeof (struct tree_common)
3778              + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3779     }
3780
3781   DECL_UID (olddecl) = olddecl_uid;
3782   if (olddecl_friend)
3783     DECL_FRIEND_P (olddecl) = 1;
3784
3785   /* NEWDECL contains the merged attribute lists.
3786      Update OLDDECL to be the same.  */
3787   DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3788
3789   return 1;
3790 }
3791
3792 /* Record a decl-node X as belonging to the current lexical scope.
3793    Check for errors (such as an incompatible declaration for the same
3794    name already seen in the same scope).
3795
3796    Returns either X or an old decl for the same name.
3797    If an old decl is returned, it may have been smashed
3798    to agree with what X says.  */
3799
3800 tree
3801 pushdecl (x)
3802      tree x;
3803 {
3804   register tree t;
3805   register tree name;
3806   int need_new_binding;
3807
3808   /* We shouldn't be calling pushdecl when we're generating RTL for a
3809      function that we already did semantic analysis on previously.  */
3810   my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3811                       19990913);
3812
3813   need_new_binding = 1;
3814
3815   if (DECL_TEMPLATE_PARM_P (x))
3816     /* Template parameters have no context; they are not X::T even
3817        when declared within a class or namespace.  */
3818     ;
3819   else
3820     {
3821       if (current_function_decl && x != current_function_decl
3822           /* A local declaration for a function doesn't constitute
3823              nesting.  */
3824           && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3825           /* A local declaration for an `extern' variable is in the
3826              scoped of the current namespace, not the current
3827              function.  */
3828           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3829           && !DECL_CONTEXT (x))
3830         DECL_CONTEXT (x) = current_function_decl;
3831       if (!DECL_CONTEXT (x))
3832         DECL_CONTEXT (x) = FROB_CONTEXT (current_namespace);
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 && TREE_CODE (x) == FUNCTION_DECL)
3867         {
3868           tree match;
3869
3870           for (match = t; match; match = OVL_NEXT (match))
3871             if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t))
3872                 == DECL_ASSEMBLER_NAME (x))
3873               break;
3874
3875           if (match)
3876             t = OVL_CURRENT (match);
3877           else
3878             t = NULL_TREE;
3879         }
3880
3881       if (t == error_mark_node)
3882         {
3883           /* error_mark_node is 0 for a while during initialization!  */
3884           t = NULL_TREE;
3885           cp_error_at ("`%#D' used prior to declaration", x);
3886         }
3887       else if (t != NULL_TREE)
3888         {
3889           if (TREE_CODE (t) == PARM_DECL)
3890             {
3891               if (DECL_CONTEXT (t) == NULL_TREE)
3892                 fatal ("parse errors have confused me too much");
3893
3894               /* Check for duplicate params.  */
3895               if (duplicate_decls (x, t))
3896                 return t;
3897             }
3898           else if ((DECL_EXTERN_C_FUNCTION_P (x)
3899                     || DECL_FUNCTION_TEMPLATE_P (x))
3900                    && is_overloaded_fn (t))
3901             /* Don't do anything just yet. */;
3902           else if (t == wchar_decl_node)
3903             {
3904               if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3905                 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3906
3907               /* Throw away the redeclaration.  */
3908               return t;
3909             }
3910           else if (TREE_CODE (t) != TREE_CODE (x))
3911             {
3912               if (duplicate_decls (x, t))
3913                 return t;
3914             }
3915           else if (duplicate_decls (x, t))
3916             {
3917               if (TREE_CODE (t) == TYPE_DECL)
3918                 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3919               else if (TREE_CODE (t) == FUNCTION_DECL)
3920                 check_default_args (t);
3921
3922               return t;
3923             }
3924           else if (DECL_MAIN_P (x))
3925             {
3926               /* A redeclaration of main, but not a duplicate of the
3927                  previous one.
3928
3929                  [basic.start.main]
3930
3931                  This function shall not be overloaded.  */
3932               cp_error_at ("invalid redeclaration of `%D'", t);
3933               cp_error ("as `%D'", x);
3934               /* We don't try to push this declaration since that
3935                  causes a crash.  */
3936               return x;
3937             }
3938         }
3939
3940       check_template_shadow (x);
3941
3942       /* If this is a function conjured up by the backend, massage it
3943          so it looks friendly.  */
3944       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3945         {
3946           retrofit_lang_decl (x);
3947           DECL_LANGUAGE (x) = lang_c;
3948         }
3949
3950       if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3951         {
3952           t = push_overloaded_decl (x, PUSH_LOCAL);
3953           if (t != x)
3954             return t;
3955           if (!namespace_bindings_p ())
3956             /* We do not need to create a binding for this name;
3957                push_overloaded_decl will have already done so if
3958                necessary.  */
3959             need_new_binding = 0;
3960         }
3961       else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3962         {
3963           t = push_overloaded_decl (x, PUSH_GLOBAL);
3964           if (t == x)
3965             add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3966           return t;
3967         }
3968
3969       /* If declaring a type as a typedef, copy the type (unless we're
3970          at line 0), and install this TYPE_DECL as the new type's typedef
3971          name.  See the extensive comment in ../c-decl.c (pushdecl). */
3972       if (TREE_CODE (x) == TYPE_DECL)
3973         {
3974           tree type = TREE_TYPE (x);
3975           if (DECL_SOURCE_LINE (x) == 0)
3976             {
3977               if (TYPE_NAME (type) == 0)
3978                 TYPE_NAME (type) = x;
3979             }
3980           else if (type != error_mark_node && TYPE_NAME (type) != x
3981                    /* We don't want to copy the type when all we're
3982                       doing is making a TYPE_DECL for the purposes of
3983                       inlining.  */
3984                    && (!TYPE_NAME (type)
3985                        || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3986             {
3987               DECL_ORIGINAL_TYPE (x) = type;
3988               type = build_type_copy (type);
3989               TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3990               TYPE_NAME (type) = x;
3991               TREE_TYPE (x) = type;
3992             }
3993
3994           if (type != error_mark_node
3995               && TYPE_NAME (type)
3996               && TYPE_IDENTIFIER (type))
3997             set_identifier_type_value_with_scope (DECL_NAME (x), type,
3998                                                   current_binding_level);
3999
4000         }
4001
4002       /* Multiple external decls of the same identifier ought to match.
4003
4004          We get warnings about inline functions where they are defined.
4005          We get warnings about other functions from push_overloaded_decl.
4006
4007          Avoid duplicate warnings where they are used.  */
4008       if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
4009         {
4010           tree decl;
4011
4012           if (IDENTIFIER_NAMESPACE_VALUE (name) != NULL_TREE
4013               && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name))
4014                   || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name))))
4015             decl = IDENTIFIER_NAMESPACE_VALUE (name);
4016           else
4017             decl = NULL_TREE;
4018
4019           if (decl
4020               /* If different sort of thing, we already gave an error.  */
4021               && TREE_CODE (decl) == TREE_CODE (x)
4022               && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
4023             {
4024               cp_pedwarn ("type mismatch with previous external decl", x);
4025               cp_pedwarn_at ("previous external decl of `%#D'", decl);
4026             }
4027         }
4028
4029       /* This name is new in its binding level.
4030          Install the new declaration and return it.  */
4031       if (namespace_bindings_p ())
4032         {
4033           /* Install a global value.  */
4034
4035           /* If the first global decl has external linkage,
4036              warn if we later see static one.  */
4037           if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
4038             TREE_PUBLIC (name) = 1;
4039
4040           /* Bind the mangled name for the entity.  In the future, we
4041              should not need to do this; mangled names are an
4042              implementation detail of which the front-end should not
4043              need to be aware.  */
4044           if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4045                 && t != NULL_TREE)
4046               /* For an ordinary function, we create a binding from
4047                  the mangled name (i.e., NAME) to the DECL.  But, for
4048                  an `extern "C"' function, the mangled name and the
4049                  ordinary name are the same so we need not do this.  */
4050               && !DECL_EXTERN_C_FUNCTION_P (x))
4051             {
4052               tree mangled_name;
4053
4054               if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
4055                   || TREE_CODE (x) == NAMESPACE_DECL)
4056                 mangled_name = name;
4057               else
4058                 mangled_name = DECL_ASSEMBLER_NAME (x);
4059
4060               if (TREE_CODE (x) == FUNCTION_DECL)
4061                 my_friendly_assert
4062                   ((IDENTIFIER_GLOBAL_VALUE (mangled_name) == NULL_TREE)
4063                   || (IDENTIFIER_GLOBAL_VALUE (mangled_name) == x), 378);
4064               SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name, x);
4065             }
4066
4067           /* Don't forget if the function was used via an implicit decl.  */
4068           if (IDENTIFIER_IMPLICIT_DECL (name)
4069               && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4070             TREE_USED (x) = 1;
4071
4072           /* Don't forget if its address was taken in that way.  */
4073           if (IDENTIFIER_IMPLICIT_DECL (name)
4074               && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4075             TREE_ADDRESSABLE (x) = 1;
4076
4077           /* Warn about mismatches against previous implicit decl.  */
4078           if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4079               /* If this real decl matches the implicit, don't complain.  */
4080               && ! (TREE_CODE (x) == FUNCTION_DECL
4081                     && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4082             cp_warning
4083               ("`%D' was previously implicitly declared to return `int'", x);
4084
4085           /* If new decl is `static' and an `extern' was seen previously,
4086              warn about it.  */
4087           if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4088             warn_extern_redeclared_static (x, t);
4089         }
4090       else
4091         {
4092           /* Here to install a non-global value.  */
4093           tree oldlocal = IDENTIFIER_VALUE (name);
4094           tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4095
4096           if (need_new_binding)
4097             {
4098               push_local_binding (name, x, 0);
4099               /* Because push_local_binding will hook X on to the
4100                  current_binding_level's name list, we don't want to
4101                  do that again below.  */
4102               need_new_binding = 0;
4103             }
4104
4105           /* If this is a TYPE_DECL, push it into the type value slot.  */
4106           if (TREE_CODE (x) == TYPE_DECL)
4107             set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4108                                                   current_binding_level);
4109
4110           /* Clear out any TYPE_DECL shadowed by a namespace so that
4111              we won't think this is a type.  The C struct hack doesn't
4112              go through namespaces.  */
4113           if (TREE_CODE (x) == NAMESPACE_DECL)
4114             set_identifier_type_value_with_scope (name, NULL_TREE,
4115                                                   current_binding_level);
4116
4117           if (oldlocal)
4118             {
4119               tree d = oldlocal;
4120
4121               while (oldlocal
4122                      && TREE_CODE (oldlocal) == VAR_DECL
4123                      && DECL_DEAD_FOR_LOCAL (oldlocal))
4124                 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4125
4126               if (oldlocal == NULL_TREE)
4127                 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4128             }
4129
4130           /* If this is an extern function declaration, see if we
4131              have a global definition or declaration for the function.  */
4132           if (oldlocal == NULL_TREE
4133               && DECL_EXTERNAL (x)
4134               && oldglobal != NULL_TREE
4135               && TREE_CODE (x) == FUNCTION_DECL
4136               && TREE_CODE (oldglobal) == FUNCTION_DECL)
4137             {
4138               /* We have one.  Their types must agree.  */
4139               if (decls_match (x, oldglobal))
4140                 /* OK */;
4141               else
4142                 {
4143                   cp_warning ("extern declaration of `%#D' doesn't match", x);
4144                   cp_warning_at ("global declaration `%#D'", oldglobal);
4145                 }
4146             }
4147           /* If we have a local external declaration,
4148              and no file-scope declaration has yet been seen,
4149              then if we later have a file-scope decl it must not be static.  */
4150           if (oldlocal == NULL_TREE
4151               && oldglobal == NULL_TREE
4152               && DECL_EXTERNAL (x)
4153               && TREE_PUBLIC (x))
4154             TREE_PUBLIC (name) = 1;
4155
4156           /* Warn if shadowing an argument at the top level of the body.  */
4157           if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4158               /* Inline decls shadow nothing.  */
4159               && !DECL_FROM_INLINE (x)
4160               && TREE_CODE (oldlocal) == PARM_DECL
4161               /* Don't complain if it's from an enclosing function.  */
4162               && DECL_CONTEXT (oldlocal) == current_function_decl
4163               && TREE_CODE (x) != PARM_DECL)
4164             {
4165               /* Go to where the parms should be and see if we
4166                  find them there.  */
4167               struct binding_level *b = current_binding_level->level_chain;
4168
4169               if (cleanup_label)
4170                 b = b->level_chain;
4171
4172               /* ARM $8.3 */
4173               if (b->parm_flag == 1)
4174                 cp_error ("declaration of `%#D' shadows a parameter", name);
4175             }
4176
4177           /* Maybe warn if shadowing something else.  */
4178           if (warn_shadow && !DECL_EXTERNAL (x)
4179               /* Inline decls shadow nothing.  */
4180               && !DECL_FROM_INLINE (x)
4181               /* No shadow warnings for internally generated vars.  */
4182               && ! DECL_ARTIFICIAL (x)
4183               /* No shadow warnings for vars made for inlining.  */
4184               && ! DECL_FROM_INLINE (x))
4185             {
4186               if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4187                 warning ("declaration of `%s' shadows a parameter",
4188                         IDENTIFIER_POINTER (name));
4189               else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4190                        && current_class_ptr
4191                        && !TREE_STATIC (name))
4192                 warning ("declaration of `%s' shadows a member of `this'",
4193                         IDENTIFIER_POINTER (name));
4194               else if (oldlocal != NULL_TREE)
4195                 warning ("declaration of `%s' shadows previous local",
4196                         IDENTIFIER_POINTER (name));
4197               else if (oldglobal != NULL_TREE)
4198                 /* XXX shadow warnings in outer-more namespaces */
4199                 warning ("declaration of `%s' shadows global declaration",
4200                         IDENTIFIER_POINTER (name));
4201             }
4202         }
4203
4204       if (TREE_CODE (x) == FUNCTION_DECL)
4205         check_default_args (x);
4206
4207       /* Keep count of variables in this level with incomplete type.  */
4208       if (TREE_CODE (x) == VAR_DECL
4209           && TREE_TYPE (x) != error_mark_node
4210           && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4211                && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4212               /* RTTI TD entries are created while defining the type_info.  */
4213               || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4214                   && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4215         {
4216           if (namespace_bindings_p ())
4217             namespace_scope_incomplete
4218               = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4219           else
4220             current_binding_level->incomplete
4221               = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4222         }
4223     }
4224
4225   if (need_new_binding)
4226     add_decl_to_level (x,
4227                        DECL_NAMESPACE_SCOPE_P (x)
4228                        ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4229                        : current_binding_level);
4230
4231   return x;
4232 }
4233
4234 /* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
4235    caller to set DECL_CONTEXT properly.  */
4236
4237 static tree
4238 pushdecl_with_scope (x, level)
4239      tree x;
4240      struct binding_level *level;
4241 {
4242   register struct binding_level *b;
4243   tree function_decl = current_function_decl;
4244
4245   current_function_decl = NULL_TREE;
4246   if (level->parm_flag == 2)
4247     {
4248       b = class_binding_level;
4249       class_binding_level = level;
4250       pushdecl_class_level (x);
4251       class_binding_level = b;
4252     }
4253   else
4254     {
4255       b = current_binding_level;
4256       current_binding_level = level;
4257       x = pushdecl (x);
4258       current_binding_level = b;
4259     }
4260   current_function_decl = function_decl;
4261   return x;
4262 }
4263
4264 /* Like pushdecl, only it places X in the current namespace,
4265    if appropriate.  */
4266
4267 tree
4268 pushdecl_namespace_level (x)
4269      tree x;
4270 {
4271   register struct binding_level *b = current_binding_level;
4272   register tree t;
4273
4274   t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4275
4276   /* Now, the type_shadowed stack may screw us.  Munge it so it does
4277      what we want.  */
4278   if (TREE_CODE (x) == TYPE_DECL)
4279     {
4280       tree name = DECL_NAME (x);
4281       tree newval;
4282       tree *ptr = (tree *)0;
4283       for (; b != global_binding_level; b = b->level_chain)
4284         {
4285           tree shadowed = b->type_shadowed;
4286           for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4287             if (TREE_PURPOSE (shadowed) == name)
4288               {
4289                 ptr = &TREE_VALUE (shadowed);
4290                 /* Can't break out of the loop here because sometimes
4291                    a binding level will have duplicate bindings for
4292                    PT names.  It's gross, but I haven't time to fix it.  */
4293               }
4294         }
4295       newval = TREE_TYPE (x);
4296       if (ptr == (tree *)0)
4297         {
4298           /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
4299              up here if this is changed to an assertion.  --KR  */
4300           SET_IDENTIFIER_TYPE_VALUE (name, newval);
4301         }
4302       else
4303         {
4304           *ptr = newval;
4305         }
4306     }
4307   return t;
4308 }
4309
4310 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4311    if appropriate.  */
4312
4313 tree
4314 pushdecl_top_level (x)
4315      tree x;
4316 {
4317   push_to_top_level ();
4318   x = pushdecl_namespace_level (x);
4319   pop_from_top_level ();
4320   return x;
4321 }
4322
4323 /* Make the declaration of X appear in CLASS scope.  */
4324
4325 void
4326 pushdecl_class_level (x)
4327      tree x;
4328 {
4329   /* Don't use DECL_ASSEMBLER_NAME here!  Everything that looks in class
4330      scope looks for the pre-mangled name.  */
4331   register tree name;
4332
4333   if (TREE_CODE (x) == OVERLOAD)
4334     x = OVL_CURRENT (x);
4335   name = DECL_NAME (x);
4336
4337   if (name)
4338     {
4339       push_class_level_binding (name, x);
4340       if (TREE_CODE (x) == TYPE_DECL)
4341         set_identifier_type_value (name, TREE_TYPE (x));
4342     }
4343   else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4344     {
4345       tree f;
4346
4347       for (f = TYPE_FIELDS (TREE_TYPE (x));
4348            f;
4349            f = TREE_CHAIN (f))
4350         pushdecl_class_level (f);
4351     }
4352 }
4353
4354 /* Enter DECL into the symbol table, if that's appropriate.  Returns
4355    DECL, or a modified version thereof.  */
4356
4357 tree
4358 maybe_push_decl (decl)
4359      tree decl;
4360 {
4361   tree type = TREE_TYPE (decl);
4362
4363   /* Add this decl to the current binding level, but not if it comes
4364      from another scope, e.g. a static member variable.  TEM may equal
4365      DECL or it may be a previous decl of the same name.  */
4366   if (decl == error_mark_node
4367       || (TREE_CODE (decl) != PARM_DECL
4368           && DECL_CONTEXT (decl) != NULL_TREE
4369           /* Definitions of namespace members outside their namespace are
4370              possible. */
4371           && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4372       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4373       || TREE_CODE (type) == UNKNOWN_TYPE
4374       /* The declaration of a template specialization does not affect
4375          the functions available for overload resolution, so we do not
4376          call pushdecl.  */
4377       || (TREE_CODE (decl) == FUNCTION_DECL
4378           && DECL_TEMPLATE_SPECIALIZATION (decl)))
4379     return decl;
4380   else
4381     return pushdecl (decl);
4382 }
4383
4384 /* Make the declaration(s) of X appear in CLASS scope
4385    under the name NAME.  */
4386
4387 void
4388 push_class_level_binding (name, x)
4389      tree name;
4390      tree x;
4391 {
4392   tree binding;
4393   /* The class_binding_level will be NULL if x is a template
4394      parameter name in a member template.  */
4395   if (!class_binding_level)
4396     return;
4397
4398   /* Make sure that this new member does not have the same name
4399      as a template parameter.  */
4400   if (TYPE_BEING_DEFINED (current_class_type))
4401     check_template_shadow (x);
4402
4403   /* If this declaration shadows a declaration from an enclosing
4404      class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4405      we leave this class.  Record the shadowed declaration here.  */
4406   binding = IDENTIFIER_BINDING (name);
4407   if (binding
4408       && ((TREE_CODE (x) == OVERLOAD
4409            && BINDING_VALUE (binding)
4410            && is_overloaded_fn (BINDING_VALUE (binding)))
4411           || INHERITED_VALUE_BINDING_P (binding)))
4412     {
4413       tree shadow;
4414       tree old_decl;
4415
4416       /* If the old binding was from a base class, and was for a tag
4417          name, slide it over to make room for the new binding.  The
4418          old binding is still visible if explicitly qualified with a
4419          class-key.  */
4420       if (INHERITED_VALUE_BINDING_P (binding)
4421           && BINDING_VALUE (binding)
4422           && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4423           && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4424           && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4425         {
4426           old_decl = BINDING_TYPE (binding);
4427           BINDING_TYPE (binding) = BINDING_VALUE (binding);
4428           BINDING_VALUE (binding) = NULL_TREE;
4429           INHERITED_VALUE_BINDING_P (binding) = 0;
4430         }
4431       else
4432         old_decl = BINDING_VALUE (binding);
4433
4434       /* There was already a binding for X containing fewer
4435          functions than are named in X.  Find the previous
4436          declaration of X on the class-shadowed list, and update it.  */
4437       for (shadow = class_binding_level->class_shadowed;
4438            shadow;
4439            shadow = TREE_CHAIN (shadow))
4440         if (TREE_PURPOSE (shadow) == name
4441             && TREE_TYPE (shadow) == old_decl)
4442           {
4443             BINDING_VALUE (binding) = x;
4444             INHERITED_VALUE_BINDING_P (binding) = 0;
4445             TREE_TYPE (shadow) = x;
4446             return;
4447           }
4448     }
4449
4450   /* If we didn't replace an existing binding, put the binding on the
4451      stack of bindings for the identifier, and update
4452      IDENTIFIER_CLASS_VALUE.  */
4453   if (push_class_binding (name, x))
4454     {
4455       class_binding_level->class_shadowed
4456         = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4457                      class_binding_level->class_shadowed);
4458       /* Record the value we are binding NAME to so that we can know
4459          what to pop later.  */
4460       TREE_TYPE (class_binding_level->class_shadowed) = x;
4461     }
4462 }
4463
4464 /* Insert another USING_DECL into the current binding level, returning
4465    this declaration. If this is a redeclaration, do nothing, and
4466    return NULL_TREE if this not in namespace scope (in namespace
4467    scope, a using decl might extend any previous bindings).  */
4468
4469 tree
4470 push_using_decl (scope, name)
4471      tree scope;
4472      tree name;
4473 {
4474   tree decl;
4475
4476   my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4477   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4478   for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4479     if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4480       break;
4481   if (decl)
4482     return namespace_bindings_p () ? decl : NULL_TREE;
4483   decl = build_lang_decl (USING_DECL, name, void_type_node);
4484   DECL_INITIAL (decl) = scope;
4485   TREE_CHAIN (decl) = current_binding_level->usings;
4486   current_binding_level->usings = decl;
4487   return decl;
4488 }
4489
4490 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4491    changed (i.e. there was already a directive), or the fresh
4492    TREE_LIST otherwise.  */
4493
4494 tree
4495 push_using_directive (used)
4496      tree used;
4497 {
4498   tree ud = current_binding_level->using_directives;
4499   tree iter, ancestor;
4500
4501   /* Check if we already have this. */
4502   if (purpose_member (used, ud) != NULL_TREE)
4503     return NULL_TREE;
4504
4505   /* Recursively add all namespaces used. */
4506   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4507     push_using_directive (TREE_PURPOSE (iter));
4508
4509   ancestor = namespace_ancestor (current_decl_namespace (), used);
4510   ud = current_binding_level->using_directives;
4511   ud = tree_cons (used, ancestor, ud);
4512   current_binding_level->using_directives = ud;
4513   return ud;
4514 }
4515
4516 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4517    other definitions already in place.  We get around this by making
4518    the value of the identifier point to a list of all the things that
4519    want to be referenced by that name.  It is then up to the users of
4520    that name to decide what to do with that list.
4521
4522    DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4523    DECL_TEMPLATE_RESULT.  It is dealt with the same way.
4524
4525    FLAGS is a bitwise-or of the following values:
4526      PUSH_LOCAL: Bind DECL in the current scope, rather than at
4527                  namespace scope.
4528      PUSH_USING: DECL is being pushed as the result of a using
4529                  declaration.
4530
4531    The value returned may be a previous declaration if we guessed wrong
4532    about what language DECL should belong to (C or C++).  Otherwise,
4533    it's always DECL (and never something that's not a _DECL).  */
4534
4535 tree
4536 push_overloaded_decl (decl, flags)
4537      tree decl;
4538      int flags;
4539 {
4540   tree name = DECL_NAME (decl);
4541   tree old;
4542   tree new_binding;
4543   int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4544
4545   if (doing_global)
4546     old = namespace_binding (name, DECL_CONTEXT (decl));
4547   else
4548     old = lookup_name_current_level (name);
4549
4550   if (old)
4551     {
4552       if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4553         {
4554           tree t = TREE_TYPE (old);
4555           if (IS_AGGR_TYPE (t) && warn_shadow
4556               && (! DECL_IN_SYSTEM_HEADER (decl)
4557                   || ! DECL_IN_SYSTEM_HEADER (old)))
4558             cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4559           old = NULL_TREE;
4560         }
4561       else if (is_overloaded_fn (old))
4562         {
4563           tree tmp;
4564
4565           for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4566             {
4567               tree fn = OVL_CURRENT (tmp);
4568
4569               if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4570                   && !(flags & PUSH_USING)
4571                   && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4572                                 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4573                 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4574                           decl, fn);
4575
4576               if (duplicate_decls (decl, fn))
4577                 return fn;
4578             }
4579         }
4580       else
4581         {
4582           cp_error_at ("previous non-function declaration `%#D'", old);
4583           cp_error ("conflicts with function declaration `%#D'", decl);
4584           return decl;
4585         }
4586     }
4587
4588   if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4589     {
4590       if (old && TREE_CODE (old) != OVERLOAD)
4591         new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4592       else
4593         new_binding = ovl_cons (decl, old);
4594       if (flags & PUSH_USING)
4595         OVL_USED (new_binding) = 1;
4596     }
4597   else
4598     /* NAME is not ambiguous.  */
4599     new_binding = decl;
4600
4601   if (doing_global)
4602     set_namespace_binding (name, current_namespace, new_binding);
4603   else
4604     {
4605       /* We only create an OVERLOAD if there was a previous binding at
4606          this level, or if decl is a template. In the former case, we
4607          need to remove the old binding and replace it with the new
4608          binding.  We must also run through the NAMES on the binding
4609          level where the name was bound to update the chain.  */
4610
4611       if (TREE_CODE (new_binding) == OVERLOAD && old)
4612         {
4613           tree *d;
4614
4615           for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4616                *d;
4617                d = &TREE_CHAIN (*d))
4618             if (*d == old
4619                 || (TREE_CODE (*d) == TREE_LIST
4620                     && TREE_VALUE (*d) == old))
4621               {
4622                 if (TREE_CODE (*d) == TREE_LIST)
4623                   /* Just replace the old binding with the new.  */
4624                   TREE_VALUE (*d) = new_binding;
4625                 else
4626                   /* Build a TREE_LIST to wrap the OVERLOAD.  */
4627                   *d = tree_cons (NULL_TREE, new_binding,
4628                                   TREE_CHAIN (*d));
4629
4630                 /* And update the CPLUS_BINDING node.  */
4631                 BINDING_VALUE (IDENTIFIER_BINDING (name))
4632                   = new_binding;
4633                 return decl;
4634               }
4635
4636           /* We should always find a previous binding in this case.  */
4637           my_friendly_abort (0);
4638         }
4639
4640       /* Install the new binding.  */
4641       push_local_binding (name, new_binding, flags);
4642     }
4643
4644   return decl;
4645 }
4646 \f
4647 /* Generate an implicit declaration for identifier FUNCTIONID
4648    as a function of type int ().  Print a warning if appropriate.  */
4649
4650 tree
4651 implicitly_declare (functionid)
4652      tree functionid;
4653 {
4654   register tree decl;
4655
4656   /* We used to reuse an old implicit decl here,
4657      but this loses with inline functions because it can clobber
4658      the saved decl chains.  */
4659   decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4660
4661   DECL_EXTERNAL (decl) = 1;
4662   TREE_PUBLIC (decl) = 1;
4663
4664   /* ISO standard says implicit declarations are in the innermost block.
4665      So we record the decl in the standard fashion.  */
4666   pushdecl (decl);
4667   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4668
4669   if (warn_implicit
4670       /* Only one warning per identifier.  */
4671       && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4672     {
4673       cp_pedwarn ("implicit declaration of function `%#D'", decl);
4674     }
4675
4676   SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4677
4678   return decl;
4679 }
4680
4681 /* Return zero if the declaration NEWDECL is valid
4682    when the declaration OLDDECL (assumed to be for the same name)
4683    has already been seen.
4684    Otherwise return an error message format string with a %s
4685    where the identifier should go.  */
4686
4687 static const char *
4688 redeclaration_error_message (newdecl, olddecl)
4689      tree newdecl, olddecl;
4690 {
4691   if (TREE_CODE (newdecl) == TYPE_DECL)
4692     {
4693       /* Because C++ can put things into name space for free,
4694          constructs like "typedef struct foo { ... } foo"
4695          would look like an erroneous redeclaration.  */
4696       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4697         return 0;
4698       else
4699         return "redefinition of `%#D'";
4700     }
4701   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4702     {
4703       /* If this is a pure function, its olddecl will actually be
4704          the original initialization to `0' (which we force to call
4705          abort()).  Don't complain about redefinition in this case.  */
4706       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4707         return 0;
4708
4709       /* If both functions come from different namespaces, this is not
4710          a redeclaration - this is a conflict with a used function. */
4711       if (DECL_NAMESPACE_SCOPE_P (olddecl)
4712           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4713         return "`%D' conflicts with used function";
4714
4715       /* We'll complain about linkage mismatches in
4716          warn_extern_redeclared_static.  */
4717
4718       /* Defining the same name twice is no good.  */
4719       if (DECL_INITIAL (olddecl) != NULL_TREE
4720           && DECL_INITIAL (newdecl) != NULL_TREE)
4721         {
4722           if (DECL_NAME (olddecl) == NULL_TREE)
4723             return "`%#D' not declared in class";
4724           else
4725             return "redefinition of `%#D'";
4726         }
4727       return 0;
4728     }
4729   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4730     {
4731       if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4732            && (DECL_TEMPLATE_RESULT (newdecl)
4733                != DECL_TEMPLATE_RESULT (olddecl))
4734            && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4735            && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4736           || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4737               && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4738               && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4739         return "redefinition of `%#D'";
4740       return 0;
4741     }
4742   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4743     {
4744       /* Objects declared at top level:  */
4745       /* If at least one is a reference, it's ok.  */
4746       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4747         return 0;
4748       /* Reject two definitions.  */
4749       return "redefinition of `%#D'";
4750     }
4751   else
4752     {
4753       /* Objects declared with block scope:  */
4754       /* Reject two definitions, and reject a definition
4755          together with an external reference.  */
4756       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4757         return "redeclaration of `%#D'";
4758       return 0;
4759     }
4760 }
4761 \f
4762 /* Create a new label, named ID.  */
4763
4764 static tree
4765 make_label_decl (id, local_p)
4766      tree id;
4767      int local_p;
4768 {
4769   tree decl;
4770
4771   decl = build_decl (LABEL_DECL, id, void_type_node);
4772   if (expanding_p)
4773     /* Make sure every label has an rtx.  */
4774     label_rtx (decl);
4775
4776   DECL_CONTEXT (decl) = current_function_decl;
4777   DECL_MODE (decl) = VOIDmode;
4778   C_DECLARED_LABEL_FLAG (decl) = local_p;
4779
4780   /* Say where one reference is to the label, for the sake of the
4781      error if it is not defined.  */
4782   DECL_SOURCE_LINE (decl) = lineno;
4783   DECL_SOURCE_FILE (decl) = input_filename;
4784
4785   /* Record the fact that this identifier is bound to this label.  */
4786   SET_IDENTIFIER_LABEL_VALUE (id, decl);
4787
4788   return decl;
4789 }
4790
4791 /* Record this label on the list of used labels so that we can check
4792    at the end of the function to see whether or not the label was
4793    actually defined, and so we can check when the label is defined whether
4794    this use is valid.  */
4795
4796 static void
4797 use_label (decl)
4798      tree decl;
4799 {
4800   if (named_label_uses == NULL
4801       || named_label_uses->names_in_scope != current_binding_level->names
4802       || named_label_uses->label_decl != decl)
4803     {
4804       struct named_label_use_list *new_ent;
4805       new_ent = ((struct named_label_use_list *)
4806                  ggc_alloc (sizeof (struct named_label_use_list)));
4807       new_ent->label_decl = decl;
4808       new_ent->names_in_scope = current_binding_level->names;
4809       new_ent->binding_level = current_binding_level;
4810       new_ent->lineno_o_goto = lineno;
4811       new_ent->filename_o_goto = input_filename;
4812       new_ent->next = named_label_uses;
4813       named_label_uses = new_ent;
4814     }
4815 }
4816
4817 /* Look for a label named ID in the current function.  If one cannot
4818    be found, create one.  (We keep track of used, but undefined,
4819    labels, and complain about them at the end of a function.)  */
4820
4821 tree
4822 lookup_label (id)
4823      tree id;
4824 {
4825   tree decl;
4826   struct named_label_list *ent;
4827
4828   /* You can't use labels at global scope.  */
4829   if (current_function_decl == NULL_TREE)
4830     {
4831       error ("label `%s' referenced outside of any function",
4832              IDENTIFIER_POINTER (id));
4833       return NULL_TREE;
4834     }
4835
4836   /* See if we've already got this label.  */
4837   decl = IDENTIFIER_LABEL_VALUE (id);
4838   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4839     return decl;
4840
4841   /* Record this label on the list of labels used in this function.
4842      We do this before calling make_label_decl so that we get the
4843      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
4844   ent = ((struct named_label_list *)
4845          ggc_alloc_cleared (sizeof (struct named_label_list)));
4846   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4847   ent->next = named_labels;
4848   named_labels = ent;
4849
4850   /* We need a new label.  */
4851   decl = make_label_decl (id, /*local_p=*/0);
4852
4853   /* Now fill in the information we didn't have before.  */
4854   ent->label_decl = decl;
4855
4856   return decl;
4857 }
4858
4859 /* Declare a local label named ID.  */
4860
4861 tree
4862 declare_local_label (id)
4863      tree id;
4864 {
4865   tree decl;
4866
4867   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4868      this scope we can restore the old value of
4869      IDENTIFIER_TYPE_VALUE.  */
4870   current_binding_level->shadowed_labels
4871     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4872                  current_binding_level->shadowed_labels);
4873   /* Look for the label.  */
4874   decl = make_label_decl (id, /*local_p=*/1);
4875   /* Now fill in the information we didn't have before.  */
4876   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4877
4878   return decl;
4879 }
4880
4881 /* Returns nonzero if it is ill-formed to jump past the declaration of
4882    DECL.  Returns 2 if it's also a real problem.  */
4883
4884 static int
4885 decl_jump_unsafe (decl)
4886      tree decl;
4887 {
4888   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4889     return 0;
4890
4891   if (DECL_INITIAL (decl) == NULL_TREE
4892       && pod_type_p (TREE_TYPE (decl)))
4893     return 0;
4894
4895   /* This is really only important if we're crossing an initialization.
4896      The POD stuff is just pedantry; why should it matter if the class
4897      contains a field of pointer to member type?  */
4898   if (DECL_INITIAL (decl)
4899       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4900     return 2;
4901   return 1;
4902 }
4903
4904 /* Check that a single previously seen jump to a newly defined label
4905    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4906    the jump context; NAMES are the names in scope in LEVEL at the jump
4907    context; FILE and LINE are the source position of the jump or 0.  */
4908
4909 static void
4910 check_previous_goto_1 (decl, level, names, file, line)
4911      tree decl;
4912      struct binding_level *level;
4913      tree names;
4914      const char *file;
4915      int line;
4916 {
4917   int identified = 0;
4918   int saw_eh = 0;
4919   struct binding_level *b = current_binding_level;
4920   for (; b; b = b->level_chain)
4921     {
4922       tree new_decls = b->names;
4923       tree old_decls = (b == level ? names : NULL_TREE);
4924       for (; new_decls != old_decls;
4925            new_decls = TREE_CHAIN (new_decls))
4926         {
4927           int problem = decl_jump_unsafe (new_decls);
4928           if (! problem)
4929             continue;
4930
4931           if (! identified)
4932             {
4933               if (decl)
4934                 cp_pedwarn ("jump to label `%D'", decl);
4935               else
4936                 pedwarn ("jump to case label");
4937
4938               if (file)
4939                 pedwarn_with_file_and_line (file, line, "  from here");
4940               identified = 1;
4941             }
4942
4943           if (problem > 1 && DECL_ARTIFICIAL (new_decls))
4944             /* Can't skip init of __exception_info.  */
4945             cp_error_at ("  enters catch block", new_decls);
4946           else if (problem > 1)
4947             cp_error_at ("  crosses initialization of `%#D'",
4948                          new_decls);
4949           else
4950             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
4951                            new_decls);
4952         }
4953
4954       if (b == level)
4955         break;
4956       if (b->eh_region && ! saw_eh)
4957         {
4958           if (! identified)
4959             {
4960               if (decl)
4961                 cp_pedwarn ("jump to label `%D'", decl);
4962               else
4963                 pedwarn ("jump to case label");
4964
4965               if (file)
4966                 pedwarn_with_file_and_line (file, line, "  from here");
4967               identified = 1;
4968             }
4969           error ("  enters try block");
4970           saw_eh = 1;
4971         }
4972     }
4973 }
4974
4975 static void
4976 check_previous_goto (use)
4977      struct named_label_use_list *use;
4978 {
4979   check_previous_goto_1 (use->label_decl, use->binding_level,
4980                          use->names_in_scope, use->filename_o_goto,
4981                          use->lineno_o_goto);
4982 }
4983
4984 static void
4985 check_switch_goto (level)
4986      struct binding_level *level;
4987 {
4988   check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
4989 }
4990
4991 /* Check that any previously seen jumps to a newly defined label DECL
4992    are OK.  Called by define_label.  */
4993
4994 static void
4995 check_previous_gotos (decl)
4996      tree decl;
4997 {
4998   struct named_label_use_list **usep;
4999
5000   if (! TREE_USED (decl))
5001     return;
5002
5003   for (usep = &named_label_uses; *usep; )
5004     {
5005       struct named_label_use_list *use = *usep;
5006       if (use->label_decl == decl)
5007         {
5008           check_previous_goto (use);
5009           *usep = use->next;
5010         }
5011       else
5012         usep = &(use->next);
5013     }
5014 }
5015
5016 /* Check that a new jump to a label DECL is OK.  Called by
5017    finish_goto_stmt.  */
5018
5019 void
5020 check_goto (decl)
5021      tree decl;
5022 {
5023   int identified = 0;
5024   tree bad;
5025   struct named_label_list *lab;
5026
5027   /* If the label hasn't been defined yet, defer checking.  */
5028   if (! DECL_INITIAL (decl))
5029     {
5030       use_label (decl);
5031       return;
5032     }
5033
5034   for (lab = named_labels; lab; lab = lab->next)
5035     if (decl == lab->label_decl)
5036       break;
5037
5038   /* If the label is not on named_labels it's a gcc local label, so
5039      it must be in an outer scope, so jumping to it is always OK.  */
5040   if (lab == 0)
5041     return;
5042
5043   if ((lab->eh_region || lab->bad_decls) && !identified)
5044     {
5045       cp_pedwarn_at ("jump to label `%D'", decl);
5046       pedwarn ("  from here");
5047       identified = 1;
5048     }
5049
5050   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
5051     {
5052       tree b = TREE_VALUE (bad);
5053       int u = decl_jump_unsafe (b);
5054
5055       if (u > 1 && DECL_ARTIFICIAL (b))
5056         /* Can't skip init of __exception_info.  */
5057         cp_error_at ("  enters catch block", b);
5058       else if (u > 1)
5059         cp_error_at ("  skips initialization of `%#D'", b);
5060       else
5061         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
5062     }
5063
5064   if (lab->eh_region)
5065     error ("  enters try block");
5066 }
5067
5068 /* Define a label, specifying the location in the source file.
5069    Return the LABEL_DECL node for the label, if the definition is valid.
5070    Otherwise return 0.  */
5071
5072 tree
5073 define_label (filename, line, name)
5074      const char *filename;
5075      int line;
5076      tree name;
5077 {
5078   tree decl = lookup_label (name);
5079   struct named_label_list *ent;
5080
5081   for (ent = named_labels; ent; ent = ent->next)
5082     if (ent->label_decl == decl)
5083       break;
5084
5085   /* After labels, make any new cleanups go into their
5086      own new (temporary) binding contour.  */
5087   current_binding_level->more_cleanups_ok = 0;
5088
5089   if (name == get_identifier ("wchar_t"))
5090     cp_pedwarn ("label named wchar_t");
5091
5092   if (DECL_INITIAL (decl) != NULL_TREE)
5093     {
5094       cp_error ("duplicate label `%D'", decl);
5095       return 0;
5096     }
5097   else
5098     {
5099       /* Mark label as having been defined.  */
5100       DECL_INITIAL (decl) = error_mark_node;
5101       /* Say where in the source.  */
5102       DECL_SOURCE_FILE (decl) = filename;
5103       DECL_SOURCE_LINE (decl) = line;
5104       if (ent)
5105         {
5106           ent->names_in_scope = current_binding_level->names;
5107           ent->binding_level = current_binding_level;
5108         }
5109       check_previous_gotos (decl);
5110       current_function_return_value = NULL_TREE;
5111       return decl;
5112     }
5113 }
5114
5115 struct cp_switch
5116 {
5117   struct binding_level *level;
5118   struct cp_switch *next;
5119 };
5120
5121 static struct cp_switch *switch_stack;
5122
5123 void
5124 push_switch ()
5125 {
5126   struct cp_switch *p
5127     = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5128   p->level = current_binding_level;
5129   p->next = switch_stack;
5130   switch_stack = p;
5131 }
5132
5133 void
5134 pop_switch ()
5135 {
5136   struct cp_switch *cs;
5137
5138   cs = switch_stack;
5139   switch_stack = switch_stack->next;
5140   free (cs);
5141 }
5142
5143 /* Note that we've seen a definition of a case label, and complain if this
5144    is a bad place for one.  */
5145
5146 void
5147 define_case_label ()
5148 {
5149   tree cleanup = last_cleanup_this_contour ();
5150
5151   if (! switch_stack)
5152     /* Don't crash; we'll complain in do_case.  */
5153     return;
5154
5155   if (cleanup)
5156     {
5157       static int explained = 0;
5158       cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
5159       warning ("where case label appears here");
5160       if (!explained)
5161         {
5162           warning ("(enclose actions of previous case statements requiring");
5163           warning ("destructors in their own binding contours.)");
5164           explained = 1;
5165         }
5166     }
5167
5168   check_switch_goto (switch_stack->level);
5169
5170   /* After labels, make any new cleanups go into their
5171      own new (temporary) binding contour.  */
5172
5173   current_binding_level->more_cleanups_ok = 0;
5174   current_function_return_value = NULL_TREE;
5175 }
5176 \f
5177 /* Return the list of declarations of the current level.
5178    Note that this list is in reverse order unless/until
5179    you nreverse it; and when you do nreverse it, you must
5180    store the result back using `storedecls' or you will lose.  */
5181
5182 tree
5183 getdecls ()
5184 {
5185   return current_binding_level->names;
5186 }
5187
5188 /* Return the list of type-tags (for structs, etc) of the current level.  */
5189
5190 tree
5191 gettags ()
5192 {
5193   return current_binding_level->tags;
5194 }
5195
5196 /* Store the list of declarations of the current level.
5197    This is done for the parameter declarations of a function being defined,
5198    after they are modified in the light of any missing parameters.  */
5199
5200 static void
5201 storedecls (decls)
5202      tree decls;
5203 {
5204   current_binding_level->names = decls;
5205 }
5206
5207 /* Similarly, store the list of tags of the current level.  */
5208
5209 void
5210 storetags (tags)
5211      tree tags;
5212 {
5213   current_binding_level->tags = tags;
5214 }
5215 \f
5216 /* Given NAME, an IDENTIFIER_NODE,
5217    return the structure (or union or enum) definition for that name.
5218    Searches binding levels from BINDING_LEVEL up to the global level.
5219    If THISLEVEL_ONLY is nonzero, searches only the specified context
5220    (but skips any tag-transparent contexts to find one that is
5221    meaningful for tags).
5222    FORM says which kind of type the caller wants;
5223    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5224    If the wrong kind of type is found, and it's not a template, an error is
5225    reported.  */
5226
5227 static tree
5228 lookup_tag (form, name, binding_level, thislevel_only)
5229      enum tree_code form;
5230      tree name;
5231      struct binding_level *binding_level;
5232      int thislevel_only;
5233 {
5234   register struct binding_level *level;
5235   /* Non-zero if, we should look past a template parameter level, even
5236      if THISLEVEL_ONLY.  */
5237   int allow_template_parms_p = 1;
5238
5239   for (level = binding_level; level; level = level->level_chain)
5240     {
5241       register tree tail;
5242       if (ANON_AGGRNAME_P (name))
5243         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5244           {
5245             /* There's no need for error checking here, because
5246                anon names are unique throughout the compilation.  */
5247             if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5248               return TREE_VALUE (tail);
5249           }
5250       else if (level->namespace_p)
5251         /* Do namespace lookup. */
5252         for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5253           {
5254             tree old = binding_for_name (name, tail);
5255
5256             /* If we just skipped past a template parameter level,
5257                even though THISLEVEL_ONLY, and we find a template
5258                class declaration, then we use the _TYPE node for the
5259                template.  See the example below.  */
5260             if (thislevel_only && !allow_template_parms_p
5261                 && old && BINDING_VALUE (old)
5262                 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5263               old = TREE_TYPE (BINDING_VALUE (old));
5264             else
5265               old = BINDING_TYPE (old);
5266
5267             /* If it has an original type, it is a typedef, and we
5268                should not return it.  */
5269             if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5270               old = NULL_TREE;
5271             if (old && TREE_CODE (old) != form
5272                 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5273               {
5274                 cp_error ("`%#D' redeclared as %C", old, form);
5275                 return NULL_TREE;
5276               }
5277             if (old)
5278               return old;
5279             if (thislevel_only || tail == global_namespace)
5280               return NULL_TREE;
5281           }
5282       else
5283         for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5284           {
5285             if (TREE_PURPOSE (tail) == name)
5286               {
5287                 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5288                 /* Should tighten this up; it'll probably permit
5289                    UNION_TYPE and a struct template, for example.  */
5290                 if (code != form
5291                     && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5292                   {
5293                     /* Definition isn't the kind we were looking for.  */
5294                     cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5295                               form);
5296                     return NULL_TREE;
5297                   }
5298                 return TREE_VALUE (tail);
5299               }
5300           }
5301       if (thislevel_only && ! level->tag_transparent)
5302         {
5303           if (level->template_parms_p && allow_template_parms_p)
5304             {
5305               /* We must deal with cases like this:
5306
5307                    template <class T> struct S;
5308                    template <class T> struct S {};
5309
5310                  When looking up `S', for the second declaration, we
5311                  would like to find the first declaration.  But, we
5312                  are in the pseudo-global level created for the
5313                  template parameters, rather than the (surrounding)
5314                  namespace level.  Thus, we keep going one more level,
5315                  even though THISLEVEL_ONLY is non-zero.  */
5316               allow_template_parms_p = 0;
5317               continue;
5318             }
5319           else
5320             return NULL_TREE;
5321         }
5322     }
5323   return NULL_TREE;
5324 }
5325
5326 #if 0
5327 void
5328 set_current_level_tags_transparency (tags_transparent)
5329      int tags_transparent;
5330 {
5331   current_binding_level->tag_transparent = tags_transparent;
5332 }
5333 #endif
5334
5335 /* Given a type, find the tag that was defined for it and return the tag name.
5336    Otherwise return 0.  However, the value can never be 0
5337    in the cases in which this is used.
5338
5339    C++: If NAME is non-zero, this is the new name to install.  This is
5340    done when replacing anonymous tags with real tag names.  */
5341
5342 static tree
5343 lookup_tag_reverse (type, name)
5344      tree type;
5345      tree name;
5346 {
5347   register struct binding_level *level;
5348
5349   for (level = current_binding_level; level; level = level->level_chain)
5350     {
5351       register tree tail;
5352       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5353         {
5354           if (TREE_VALUE (tail) == type)
5355             {
5356               if (name)
5357                 TREE_PURPOSE (tail) = name;
5358               return TREE_PURPOSE (tail);
5359             }
5360         }
5361     }
5362   return NULL_TREE;
5363 }
5364 \f
5365 /* Look up NAME in the NAMESPACE.  */
5366
5367 tree
5368 lookup_namespace_name (namespace, name)
5369      tree namespace, name;
5370 {
5371   tree val;
5372   tree template_id = NULL_TREE;
5373
5374   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5375
5376   if (TREE_CODE (name) == NAMESPACE_DECL)
5377     /* This happens for A::B<int> when B is a namespace. */
5378     return name;
5379   else if (TREE_CODE (name) == TEMPLATE_DECL)
5380     {
5381       /* This happens for A::B where B is a template, and there are no
5382          template arguments.  */
5383       cp_error ("invalid use of `%D'", name);
5384       return error_mark_node;
5385     }
5386
5387   namespace = ORIGINAL_NAMESPACE (namespace);
5388
5389   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5390     {
5391       template_id = name;
5392       name = TREE_OPERAND (name, 0);
5393       if (TREE_CODE (name) == OVERLOAD)
5394         name = DECL_NAME (OVL_CURRENT (name));
5395       else if (DECL_P (name))
5396         name = DECL_NAME (name);
5397     }
5398
5399   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5400
5401   val = make_node (CPLUS_BINDING);
5402   if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5403     return error_mark_node;
5404
5405   if (BINDING_VALUE (val))
5406     {
5407       val = BINDING_VALUE (val);
5408
5409       if (template_id)
5410         {
5411           if (DECL_CLASS_TEMPLATE_P (val))
5412             val = lookup_template_class (val,
5413                                          TREE_OPERAND (template_id, 1),
5414                                          /*in_decl=*/NULL_TREE,
5415                                          /*context=*/NULL_TREE,
5416                                          /*entering_scope=*/0);
5417           else if (DECL_FUNCTION_TEMPLATE_P (val)
5418                    || TREE_CODE (val) == OVERLOAD)
5419             val = lookup_template_function (val,
5420                                             TREE_OPERAND (template_id, 1));
5421           else
5422             {
5423               cp_error ("`%D::%D' is not a template",
5424                         namespace, name);
5425               return error_mark_node;
5426             }
5427         }
5428
5429       /* If we have a single function from a using decl, pull it out.  */
5430       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5431         val = OVL_FUNCTION (val);
5432       return val;
5433     }
5434
5435   cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5436   return error_mark_node;
5437 }
5438
5439 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
5440
5441 static unsigned long
5442 typename_hash (k)
5443      hash_table_key k;
5444 {
5445   unsigned long hash;
5446   tree t;
5447
5448   t = (tree) k;
5449   hash = (((unsigned long) TYPE_CONTEXT (t))
5450           ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5451
5452   return hash;
5453 }
5454
5455 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
5456
5457 static boolean
5458 typename_compare (k1, k2)
5459      hash_table_key k1;
5460      hash_table_key k2;
5461 {
5462   tree t1;
5463   tree t2;
5464   tree d1;
5465   tree d2;
5466
5467   t1 = (tree) k1;
5468   t2 = (tree) k2;
5469   d1 = TYPE_NAME (t1);
5470   d2 = TYPE_NAME (t2);
5471
5472   return (DECL_NAME (d1) == DECL_NAME (d2)
5473           && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5474           && ((TREE_TYPE (t1) != NULL_TREE)
5475               == (TREE_TYPE (t2) != NULL_TREE))
5476           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5477           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5478 }
5479
5480 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
5481    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
5482    is non-NULL, this type is being created by the implicit typename
5483    extension, and BASE_TYPE is a type named `t' in some base class of
5484    `T' which depends on template parameters.
5485
5486    Returns the new TYPENAME_TYPE.  */
5487
5488 tree
5489 build_typename_type (context, name, fullname, base_type)
5490      tree context;
5491      tree name;
5492      tree fullname;
5493      tree base_type;
5494 {
5495   tree t;
5496   tree d;
5497   struct hash_entry* e;
5498
5499   static struct hash_table ht;
5500
5501   if (!ht.table)
5502     {
5503       static struct hash_table *h = &ht;
5504       if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5505                             &typename_compare))
5506         fatal ("virtual memory exhausted");
5507       ggc_add_tree_hash_table_root (&h, 1);
5508     }
5509
5510   /* Build the TYPENAME_TYPE.  */
5511   t = make_aggr_type (TYPENAME_TYPE);
5512   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5513   TYPENAME_TYPE_FULLNAME (t) = fullname;
5514   TREE_TYPE (t) = base_type;
5515
5516   /* Build the corresponding TYPE_DECL.  */
5517   d = build_decl (TYPE_DECL, name, t);
5518   TYPE_NAME (TREE_TYPE (d)) = d;
5519   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5520   DECL_CONTEXT (d) = FROB_CONTEXT (context);
5521   DECL_ARTIFICIAL (d) = 1;
5522
5523   /* See if we already have this type.  */
5524   e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5525   if (e)
5526     t = (tree) e->key;
5527   else
5528     /* Insert the type into the table.  */
5529     hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5530
5531   return t;
5532 }
5533
5534 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
5535    unless an error occurs, in which case error_mark_node is returned.
5536    If COMPLAIN zero, don't complain about any errors that occur.  */
5537
5538 tree
5539 make_typename_type (context, name, complain)
5540      tree context, name;
5541      int complain;
5542 {
5543   tree fullname;
5544
5545   if (TYPE_P (name))
5546     {
5547       if (!(TYPE_LANG_SPECIFIC (name)
5548             && (CLASSTYPE_IS_TEMPLATE (name)
5549                 || CLASSTYPE_USE_TEMPLATE (name))))
5550         name = TYPE_IDENTIFIER (name);
5551       else
5552         /* Create a TEMPLATE_ID_EXPR for the type.  */
5553         name = build_nt (TEMPLATE_ID_EXPR,
5554                          CLASSTYPE_TI_TEMPLATE (name),
5555                          CLASSTYPE_TI_ARGS (name));
5556     }
5557   else if (TREE_CODE (name) == TYPE_DECL)
5558     name = DECL_NAME (name);
5559
5560   fullname = name;
5561
5562   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5563     {
5564       name = TREE_OPERAND (name, 0);
5565       if (TREE_CODE (name) == TEMPLATE_DECL)
5566         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5567     }
5568   if (TREE_CODE (name) != IDENTIFIER_NODE)
5569     my_friendly_abort (2000);
5570
5571   if (TREE_CODE (context) == NAMESPACE_DECL)
5572     {
5573       /* We can get here from typename_sub0 in the explicit_template_type
5574          expansion.  Just fail.  */
5575       if (complain)
5576         cp_error ("no class template named `%#T' in `%#T'",
5577                   name, context);
5578       return error_mark_node;
5579     }
5580
5581   if (! uses_template_parms (context)
5582       || currently_open_class (context))
5583     {
5584       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5585         {
5586           tree tmpl = NULL_TREE;
5587           if (IS_AGGR_TYPE (context))
5588             tmpl = lookup_field (context, name, 0, 0);
5589           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5590             {
5591               if (complain)
5592                 cp_error ("no class template named `%#T' in `%#T'",
5593                           name, context);
5594               return error_mark_node;
5595             }
5596
5597           return lookup_template_class (tmpl,
5598                                         TREE_OPERAND (fullname, 1),
5599                                         NULL_TREE, context,
5600                                         /*entering_scope=*/0);
5601         }
5602       else
5603         {
5604           tree t;
5605
5606           if (!IS_AGGR_TYPE (context))
5607             {
5608               if (complain)
5609                 cp_error ("no type named `%#T' in `%#T'", name, context);
5610               return error_mark_node;
5611             }
5612
5613           t = lookup_field (context, name, 0, 1);
5614           if (t)
5615             return TREE_TYPE (t);
5616         }
5617     }
5618
5619   /* If the CONTEXT is not a template type, then either the field is
5620      there now or its never going to be.  */
5621   if (!uses_template_parms (context))
5622     {
5623       if (complain)
5624         cp_error ("no type named `%#T' in `%#T'", name, context);
5625       return error_mark_node;
5626     }
5627
5628
5629   return build_typename_type (context, name, fullname,  NULL_TREE);
5630 }
5631
5632 /* Select the right _DECL from multiple choices. */
5633
5634 static tree
5635 select_decl (binding, flags)
5636      tree binding;
5637      int flags;
5638 {
5639   tree val;
5640   val = BINDING_VALUE (binding);
5641   if (LOOKUP_NAMESPACES_ONLY (flags))
5642     {
5643       /* We are not interested in types. */
5644       if (val && TREE_CODE (val) == NAMESPACE_DECL)
5645         return val;
5646       return NULL_TREE;
5647     }
5648
5649   /* If we could have a type and
5650      we have nothing or we need a type and have none.  */
5651   if (BINDING_TYPE (binding)
5652       && (!val || ((flags & LOOKUP_PREFER_TYPES)
5653                    && TREE_CODE (val) != TYPE_DECL)))
5654     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5655   /* Don't return non-types if we really prefer types. */
5656   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
5657            && (TREE_CODE (val) != TEMPLATE_DECL
5658                || !DECL_CLASS_TEMPLATE_P (val)))
5659     val = NULL_TREE;
5660
5661   return val;
5662 }
5663
5664 /* Unscoped lookup of a global: iterate over current namespaces,
5665    considering using-directives.  If SPACESP is non-NULL, store a list
5666    of the namespaces we've considered in it.  */
5667
5668 tree
5669 unqualified_namespace_lookup (name, flags, spacesp)
5670      tree name;
5671      int flags;
5672      tree *spacesp;
5673 {
5674   tree b = make_node (CPLUS_BINDING);
5675   tree initial = current_decl_namespace();
5676   tree scope = initial;
5677   tree siter;
5678   struct binding_level *level;
5679   tree val = NULL_TREE;
5680
5681   if (spacesp)
5682     *spacesp = NULL_TREE;
5683
5684   for (; !val; scope = CP_DECL_CONTEXT (scope))
5685     {
5686       if (spacesp)
5687         *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5688       val = binding_for_name (name, scope);
5689
5690       /* Initialize binding for this context. */
5691       BINDING_VALUE (b) = BINDING_VALUE (val);
5692       BINDING_TYPE (b) = BINDING_TYPE (val);
5693
5694       /* Add all _DECLs seen through local using-directives. */
5695       for (level = current_binding_level;
5696            !level->namespace_p;
5697            level = level->level_chain)
5698         if (!lookup_using_namespace (name, b, level->using_directives,
5699                                      scope, flags, spacesp))
5700           /* Give up because of error. */
5701           return error_mark_node;
5702
5703       /* Add all _DECLs seen through global using-directives. */
5704       /* XXX local and global using lists should work equally. */
5705       siter = initial;
5706       while (1)
5707         {
5708           if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5709                                        scope, flags, spacesp))
5710             /* Give up because of error. */
5711             return error_mark_node;
5712           if (siter == scope) break;
5713           siter = CP_DECL_CONTEXT (siter);
5714         }
5715
5716       val = select_decl (b, flags);
5717       if (scope == global_namespace)
5718         break;
5719     }
5720   return val;
5721 }
5722
5723 /* Combine prefer_type and namespaces_only into flags.  */
5724
5725 static int
5726 lookup_flags (prefer_type, namespaces_only)
5727   int prefer_type, namespaces_only;
5728 {
5729   if (namespaces_only)
5730     return LOOKUP_PREFER_NAMESPACES;
5731   if (prefer_type > 1)
5732     return LOOKUP_PREFER_TYPES;
5733   if (prefer_type > 0)
5734     return LOOKUP_PREFER_BOTH;
5735   return 0;
5736 }
5737
5738 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5739    ignore it or not.  Subroutine of lookup_name_real.  */
5740
5741 static tree
5742 qualify_lookup (val, flags)
5743      tree val;
5744      int flags;
5745 {
5746   if (val == NULL_TREE)
5747     return val;
5748   if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5749     return val;
5750   if ((flags & LOOKUP_PREFER_TYPES)
5751       && (TREE_CODE (val) == TYPE_DECL
5752           || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5753               && DECL_CLASS_TEMPLATE_P (val))))
5754     return val;
5755   if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5756     return NULL_TREE;
5757   return val;
5758 }
5759
5760 /* Any other BINDING overrides an implicit TYPENAME.  Warn about
5761    that.  */
5762
5763 static void
5764 warn_about_implicit_typename_lookup (typename, binding)
5765      tree typename;
5766      tree binding;
5767 {
5768   tree subtype = TREE_TYPE (TREE_TYPE (typename));
5769   tree name = DECL_NAME (typename);
5770
5771   if (! (TREE_CODE (binding) == TEMPLATE_DECL
5772          && CLASSTYPE_TEMPLATE_INFO (subtype)
5773          && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5774       && ! (TREE_CODE (binding) == TYPE_DECL
5775             && same_type_p (TREE_TYPE (binding), subtype)))
5776     {
5777       cp_warning ("lookup of `%D' finds `%#D'",
5778                   name, binding);
5779       cp_warning ("  instead of `%D' from dependent base class",
5780                   typename);
5781       cp_warning ("  (use `typename %T::%D' if that's what you meant)",
5782                   constructor_name (current_class_type), name);
5783     }
5784 }
5785
5786 /* Look up NAME in the current binding level and its superiors in the
5787    namespace of variables, functions and typedefs.  Return a ..._DECL
5788    node of some kind representing its definition if there is only one
5789    such declaration, or return a TREE_LIST with all the overloaded
5790    definitions if there are many, or return 0 if it is undefined.
5791
5792    If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5793    If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5794    If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5795    Otherwise we prefer non-TYPE_DECLs.
5796
5797    If NONCLASS is non-zero, we don't look for the NAME in class scope,
5798    using IDENTIFIER_CLASS_VALUE.  */
5799
5800 static tree
5801 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5802      tree name;
5803      int prefer_type, nonclass, namespaces_only;
5804 {
5805   tree t;
5806   tree val = NULL_TREE;
5807   int yylex = 0;
5808   tree from_obj = NULL_TREE;
5809   int flags;
5810   int val_is_implicit_typename = 0;
5811
5812   /* Hack: copy flag set by parser, if set. */
5813   if (only_namespace_names)
5814     namespaces_only = 1;
5815
5816   if (prefer_type == -2)
5817     {
5818       extern int looking_for_typename;
5819       tree type = NULL_TREE;
5820
5821       yylex = 1;
5822       prefer_type = looking_for_typename;
5823
5824       flags = lookup_flags (prefer_type, namespaces_only);
5825       /* If the next thing is '<', class templates are types. */
5826       if (looking_for_template)
5827         flags |= LOOKUP_TEMPLATES_EXPECTED;
5828
5829       /* std:: becomes :: for now.  */
5830       if (got_scope == std_node)
5831         got_scope = void_type_node;
5832
5833       if (got_scope)
5834         type = got_scope;
5835       else if (got_object != error_mark_node)
5836         type = got_object;
5837
5838       if (type)
5839         {
5840           if (type == error_mark_node)
5841             return error_mark_node;
5842           if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5843             type = TREE_TYPE (type);
5844
5845           if (TYPE_P (type))
5846             type = complete_type (type);
5847
5848           if (TREE_CODE (type) == VOID_TYPE)
5849             type = global_namespace;
5850           if (TREE_CODE (type) == NAMESPACE_DECL)
5851             {
5852               val = make_node (CPLUS_BINDING);
5853               flags |= LOOKUP_COMPLAIN;
5854               if (!qualified_lookup_using_namespace (name, type, val, flags))
5855                 return NULL_TREE;
5856               val = select_decl (val, flags);
5857             }
5858           else if (! IS_AGGR_TYPE (type)
5859                    || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5860                    || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5861                    || TREE_CODE (type) == TYPENAME_TYPE)
5862             /* Someone else will give an error about this if needed.  */
5863             val = NULL_TREE;
5864           else if (type == current_class_type)
5865             val = IDENTIFIER_CLASS_VALUE (name);
5866           else
5867             {
5868               val = lookup_member (type, name, 0, prefer_type);
5869               type_access_control (type, val);
5870             }
5871         }
5872       else
5873         val = NULL_TREE;
5874
5875       if (got_scope)
5876         goto done;
5877       else if (got_object && val)
5878         from_obj = val;
5879     }
5880   else
5881     {
5882       flags = lookup_flags (prefer_type, namespaces_only);
5883       /* If we're not parsing, we need to complain. */
5884       flags |= LOOKUP_COMPLAIN;
5885     }
5886
5887   /* First, look in non-namespace scopes.  */
5888
5889   if (current_class_type == NULL_TREE)
5890     nonclass = 1;
5891
5892   for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5893     {
5894       tree binding;
5895
5896       if (!LOCAL_BINDING_P (t) && nonclass)
5897         /* We're not looking for class-scoped bindings, so keep going.  */
5898         continue;
5899
5900       /* If this is the kind of thing we're looking for, we're done.  */
5901       if (qualify_lookup (BINDING_VALUE (t), flags))
5902         binding = BINDING_VALUE (t);
5903       else if ((flags & LOOKUP_PREFER_TYPES)
5904                && qualify_lookup (BINDING_TYPE (t), flags))
5905         binding = BINDING_TYPE (t);
5906       else
5907         binding = NULL_TREE;
5908
5909       /* Handle access control on types from enclosing or base classes.  */
5910       if (binding && ! yylex
5911           && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5912         type_access_control (BINDING_LEVEL (t)->this_class, binding);
5913
5914       if (binding
5915           && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5916         {
5917           if (val_is_implicit_typename && !yylex)
5918             warn_about_implicit_typename_lookup (val, binding);
5919           val = binding;
5920           val_is_implicit_typename
5921             = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5922           if (!val_is_implicit_typename)
5923             break;
5924         }
5925     }
5926
5927   /* Now lookup in namespace scopes.  */
5928   if (!val || val_is_implicit_typename)
5929     {
5930       t = unqualified_namespace_lookup (name, flags, 0);
5931       if (t)
5932         {
5933           if (val_is_implicit_typename && !yylex)
5934             warn_about_implicit_typename_lookup (val, t);
5935           val = t;
5936         }
5937     }
5938
5939  done:
5940   if (val)
5941     {
5942       /* This should only warn about types used in qualified-ids.  */
5943       if (from_obj && from_obj != val)
5944         {
5945           if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5946               && TREE_CODE (val) == TYPE_DECL
5947               && TREE_TYPE (from_obj) != TREE_TYPE (val))
5948             {
5949               cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5950                           name, got_object, TREE_TYPE (from_obj));
5951               cp_pedwarn ("  does not match lookup in the current scope (`%#T')",
5952                           TREE_TYPE (val));
5953             }
5954
5955           /* We don't change val to from_obj if got_object depends on
5956              template parms because that breaks implicit typename for
5957              destructor calls.  */
5958           if (! uses_template_parms (got_object))
5959             val = from_obj;
5960         }
5961
5962       /* If we have a single function from a using decl, pull it out.  */
5963       if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5964         val = OVL_FUNCTION (val);
5965     }
5966   else if (from_obj)
5967     val = from_obj;
5968
5969   return val;
5970 }
5971
5972 tree
5973 lookup_name_nonclass (name)
5974      tree name;
5975 {
5976   return lookup_name_real (name, 0, 1, 0);
5977 }
5978
5979 tree
5980 lookup_function_nonclass (name, args)
5981      tree name;
5982      tree args;
5983 {
5984   return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
5985 }
5986
5987 tree
5988 lookup_name_namespace_only (name)
5989      tree name;
5990 {
5991   /* type-or-namespace, nonclass, namespace_only */
5992   return lookup_name_real (name, 1, 1, 1);
5993 }
5994
5995 tree
5996 lookup_name (name, prefer_type)
5997      tree name;
5998      int prefer_type;
5999 {
6000   return lookup_name_real (name, prefer_type, 0, 0);
6001 }
6002
6003 /* Similar to `lookup_name' but look only in the innermost non-class
6004    binding level.  */
6005
6006 tree
6007 lookup_name_current_level (name)
6008      tree name;
6009 {
6010   struct binding_level *b;
6011   tree t = NULL_TREE;
6012
6013   b = current_binding_level;
6014   while (b->parm_flag == 2)
6015     b = b->level_chain;
6016
6017   if (b->namespace_p)
6018     {
6019       t = IDENTIFIER_NAMESPACE_VALUE (name);
6020
6021       /* extern "C" function() */
6022       if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6023         t = TREE_VALUE (t);
6024     }
6025   else if (IDENTIFIER_BINDING (name)
6026            && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6027     {
6028       while (1)
6029         {
6030           if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6031             return IDENTIFIER_VALUE (name);
6032
6033           if (b->keep == 2)
6034             b = b->level_chain;
6035           else
6036             break;
6037         }
6038     }
6039
6040   return t;
6041 }
6042
6043 /* Like lookup_name_current_level, but for types.  */
6044
6045 tree
6046 lookup_type_current_level (name)
6047      tree name;
6048 {
6049   register tree t = NULL_TREE;
6050
6051   my_friendly_assert (! current_binding_level->namespace_p, 980716);
6052
6053   if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6054       && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6055     {
6056       struct binding_level *b = current_binding_level;
6057       while (1)
6058         {
6059           if (purpose_member (name, b->type_shadowed))
6060             return REAL_IDENTIFIER_TYPE_VALUE (name);
6061           if (b->keep == 2)
6062             b = b->level_chain;
6063           else
6064             break;
6065         }
6066     }
6067
6068   return t;
6069 }
6070
6071 void
6072 begin_only_namespace_names ()
6073 {
6074   only_namespace_names = 1;
6075 }
6076
6077 void
6078 end_only_namespace_names ()
6079 {
6080   only_namespace_names = 0;
6081 }
6082 \f
6083 /* Arrange for the user to get a source line number, even when the
6084    compiler is going down in flames, so that she at least has a
6085    chance of working around problems in the compiler.  We used to
6086    call error(), but that let the segmentation fault continue
6087    through; now, it's much more passive by asking them to send the
6088    maintainers mail about the problem.  */
6089
6090 static void
6091 signal_catch (sig)
6092      int sig ATTRIBUTE_UNUSED;
6093 {
6094   signal (SIGSEGV, SIG_DFL);
6095 #ifdef SIGIOT
6096   signal (SIGIOT, SIG_DFL);
6097 #endif
6098 #ifdef SIGILL
6099   signal (SIGILL, SIG_DFL);
6100 #endif
6101 #ifdef SIGABRT
6102   signal (SIGABRT, SIG_DFL);
6103 #endif
6104 #ifdef SIGBUS
6105   signal (SIGBUS, SIG_DFL);
6106 #endif
6107   my_friendly_abort (0);
6108 }
6109
6110 /* Push the declarations of builtin types into the namespace.
6111    RID_INDEX, if < RID_MAX is the index of the builtin type
6112    in the array RID_POINTERS.  NAME is the name used when looking
6113    up the builtin type.  TYPE is the _TYPE node for the builtin type.  */
6114
6115 static void
6116 record_builtin_type (rid_index, name, type)
6117      enum rid rid_index;
6118      const char *name;
6119      tree type;
6120 {
6121   tree rname = NULL_TREE, tname = NULL_TREE;
6122   tree tdecl = NULL_TREE;
6123
6124   if ((int) rid_index < (int) RID_MAX)
6125     rname = ridpointers[(int) rid_index];
6126   if (name)
6127     tname = get_identifier (name);
6128
6129   TYPE_BUILT_IN (type) = 1;
6130
6131   if (tname)
6132     {
6133       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6134       set_identifier_type_value (tname, NULL_TREE);
6135       if ((int) rid_index < (int) RID_MAX)
6136         /* Built-in types live in the global namespace. */
6137         SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6138     }
6139   if (rname != NULL_TREE)
6140     {
6141       if (tname != NULL_TREE)
6142         {
6143           set_identifier_type_value (rname, NULL_TREE);
6144           SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6145         }
6146       else
6147         {
6148           tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6149           set_identifier_type_value (rname, NULL_TREE);
6150         }
6151     }
6152 }
6153
6154 /* Record one of the standard Java types.
6155  * Declare it as having the given NAME.
6156  * If SIZE > 0, it is the size of one of the integral types;
6157  * otherwise it is the negative of the size of one of the other types.  */
6158
6159 static tree
6160 record_builtin_java_type (name, size)
6161      const char *name;
6162      int size;
6163 {
6164   tree type, decl;
6165   if (size > 0)
6166     type = make_signed_type (size);
6167   else if (size > -32)
6168     { /* "__java_char" or ""__java_boolean". */
6169       type = make_unsigned_type (-size);
6170       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6171     }
6172   else
6173     { /* "__java_float" or ""__java_double". */
6174       type = make_node (REAL_TYPE);
6175       TYPE_PRECISION (type) = - size;
6176       layout_type (type);
6177     }
6178   record_builtin_type (RID_MAX, name, type);
6179   decl = TYPE_NAME (type);
6180
6181   /* Suppress generate debug symbol entries for these types,
6182      since for normal C++ they are just clutter.
6183      However, push_lang_context undoes this if extern "Java" is seen. */
6184   DECL_IGNORED_P (decl) = 1;
6185
6186   TYPE_FOR_JAVA (type) = 1;
6187   return type;
6188 }
6189
6190 /* Push a type into the namespace so that the back-ends ignore it. */
6191
6192 static void
6193 record_unknown_type (type, name)
6194      tree type;
6195      const char *name;
6196 {
6197   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6198   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
6199   DECL_IGNORED_P (decl) = 1;
6200   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6201   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6202   TYPE_ALIGN (type) = 1;
6203   TYPE_USER_ALIGN (type) = 0;
6204   TYPE_MODE (type) = TYPE_MODE (void_type_node);
6205 }
6206
6207 /* An string for which we should create an IDENTIFIER_NODE at
6208    startup.  */
6209
6210 typedef struct predefined_identifier
6211 {
6212   /* The name of the identifier.  */
6213   const char *name;
6214   /* The place where the IDENTIFIER_NODE should be stored.  */
6215   tree *node;
6216   /* Non-zero if this is the name of a constructor or destructor.  */
6217   int ctor_or_dtor_p;
6218 } predefined_identifier;
6219
6220 /* Create all the predefined identifiers.  */
6221
6222 static void
6223 initialize_predefined_identifiers ()
6224 {
6225   struct predefined_identifier *pid;
6226
6227   /* A table of identifiers to create at startup.  */
6228   static predefined_identifier predefined_identifiers[] = {
6229     { "C++", &lang_name_cplusplus, 0 },
6230     { "C", &lang_name_c, 0 },
6231     { "Java", &lang_name_java, 0 },
6232     { CTOR_NAME, &ctor_identifier, 1 },
6233     { "__base_ctor", &base_ctor_identifier, 1 },
6234     { "__comp_ctor", &complete_ctor_identifier, 1 },
6235     { DTOR_NAME, &dtor_identifier, 1 },
6236     { "__comp_dtor", &complete_dtor_identifier, 1 },
6237     { "__base_dtor", &base_dtor_identifier, 1 },
6238     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6239     { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6240     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6241     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6242     { VTABLE_INDEX_NAME, &index_identifier, 0 },
6243     { "nelts", &nelts_identifier, 0 },
6244     { THIS_NAME, &this_identifier, 0 },
6245     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6246     { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6247     { "_vptr", &vptr_identifier, 0 },
6248     { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6249     { "__vtt_parm", &vtt_parm_identifier, 0 },
6250     { "std", &std_identifier, 0 },
6251     { NULL, NULL, 0 }
6252   };
6253
6254   for (pid = predefined_identifiers; pid->name; ++pid)
6255     {
6256       *pid->node = get_identifier (pid->name);
6257       if (pid->ctor_or_dtor_p)
6258         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6259     }
6260 }
6261
6262 /* Create the predefined scalar types of C,
6263    and some nodes representing standard constants (0, 1, (void *)0).
6264    Initialize the global binding level.
6265    Make definitions for built-in primitive functions.  */
6266
6267 void
6268 init_decl_processing ()
6269 {
6270   tree fields[20];
6271   int wchar_type_size;
6272   tree array_domain_type;
6273
6274   /* Check to see that the user did not specify an invalid combination
6275      of command-line options.  */
6276   if (flag_new_abi && !flag_vtable_thunks)
6277     fatal ("the new ABI requires vtable thunks");
6278
6279   /* Create all the identifiers we need.  */
6280   initialize_predefined_identifiers ();
6281
6282   /* Let the back-end now how to save and restore language-specific
6283      per-function globals.  */
6284   init_lang_status = &push_cp_function_context;
6285   free_lang_status = &pop_cp_function_context;
6286   mark_lang_status = &mark_cp_function_context;
6287
6288   cp_parse_init ();
6289   init_decl2 ();
6290   init_pt ();
6291
6292   /* Create the global variables.  */
6293   push_to_top_level ();
6294
6295   /* Enter the global namespace. */
6296   my_friendly_assert (global_namespace == NULL_TREE, 375);
6297   push_namespace (get_identifier ("::"));
6298   global_namespace = current_namespace;
6299   current_lang_name = NULL_TREE;
6300
6301   /* Adjust various flags based on command-line settings.  */
6302   if (flag_strict_prototype == 2)
6303     flag_strict_prototype = pedantic;
6304   if (! flag_permissive && ! pedantic)
6305     flag_pedantic_errors = 1;
6306   if (!flag_no_inline)
6307     flag_inline_trees = 1;
6308
6309   strict_prototypes_lang_c = flag_strict_prototype;
6310
6311   /* Initially, C.  */
6312   current_lang_name = lang_name_c;
6313
6314   current_function_decl = NULL_TREE;
6315   current_binding_level = NULL_BINDING_LEVEL;
6316   free_binding_level = NULL_BINDING_LEVEL;
6317
6318   /* Because most segmentation signals can be traced back into user
6319      code, catch them and at least give the user a chance of working
6320      around compiler bugs.  */
6321   signal (SIGSEGV, signal_catch);
6322
6323   /* We will also catch aborts in the back-end through signal_catch and
6324      give the user a chance to see where the error might be, and to defeat
6325      aborts in the back-end when there have been errors previously in their
6326      code.  */
6327 #ifdef SIGIOT
6328   signal (SIGIOT, signal_catch);
6329 #endif
6330 #ifdef SIGILL
6331   signal (SIGILL, signal_catch);
6332 #endif
6333 #ifdef SIGABRT
6334   signal (SIGABRT, signal_catch);
6335 #endif
6336 #ifdef SIGBUS
6337   signal (SIGBUS, signal_catch);
6338 #endif
6339
6340   build_common_tree_nodes (flag_signed_char);
6341
6342   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6343   TREE_TYPE (error_mark_list) = error_mark_node;
6344
6345   /* Make the binding_level structure for global names.  */
6346   pushlevel (0);
6347   global_binding_level = current_binding_level;
6348   /* The global level is the namespace level of ::.  */
6349   NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6350   declare_namespace_level ();
6351
6352   /* Define `int' and `char' first so that dbx will output them first.  */
6353   record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6354   record_builtin_type (RID_CHAR, "char", char_type_node);
6355
6356   /* `signed' is the same as `int' */
6357   record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6358   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6359   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6360   record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
6361   record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6362   record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
6363   record_builtin_type (RID_MAX, "long long unsigned int",
6364                        long_long_unsigned_type_node);
6365   record_builtin_type (RID_MAX, "long long unsigned",
6366                        long_long_unsigned_type_node);
6367   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6368   record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
6369   record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
6370
6371   ptrdiff_type_node
6372     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6373
6374   /* Define both `signed char' and `unsigned char'.  */
6375   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6376   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6377
6378   /* `unsigned long' is the standard type for sizeof.
6379      Note that stddef.h uses `unsigned long',
6380      and this must agree, even if long and int are the same size.  */
6381   set_sizetype
6382     (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6383
6384   /* Create the widest literal types. */
6385   widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6386   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6387                         widest_integer_literal_type_node));
6388
6389   widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6390   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6391                         widest_unsigned_literal_type_node));
6392
6393   /* These are types that type_for_size and type_for_mode use.  */
6394   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6395   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6396   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6397   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6398 #if HOST_BITS_PER_WIDE_INT >= 64
6399   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6400 #endif
6401   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6402   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6403   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6404   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6405 #if HOST_BITS_PER_WIDE_INT >= 64
6406   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6407 #endif
6408
6409   build_common_tree_nodes_2 (flag_short_double);
6410
6411   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6412   java_short_type_node = record_builtin_java_type ("__java_short", 16);
6413   java_int_type_node = record_builtin_java_type ("__java_int", 32);
6414   java_long_type_node = record_builtin_java_type ("__java_long", 64);
6415   java_float_type_node = record_builtin_java_type ("__java_float", -32);
6416   java_double_type_node = record_builtin_java_type ("__java_double", -64);
6417   java_char_type_node = record_builtin_java_type ("__java_char", -16);
6418   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6419
6420   integer_two_node = build_int_2 (2, 0);
6421   TREE_TYPE (integer_two_node) = integer_type_node;
6422   integer_three_node = build_int_2 (3, 0);
6423   TREE_TYPE (integer_three_node) = integer_type_node;
6424
6425   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6426   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6427   TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6428   TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6429   TYPE_PRECISION (boolean_type_node) = 1;
6430   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6431   boolean_false_node = build_int_2 (0, 0);
6432   TREE_TYPE (boolean_false_node) = boolean_type_node;
6433   boolean_true_node = build_int_2 (1, 0);
6434   TREE_TYPE (boolean_true_node) = boolean_type_node;
6435
6436   signed_size_zero_node = build_int_2 (0, 0);
6437   record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6438   record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6439   record_builtin_type (RID_MAX, "long double", long_double_type_node);
6440
6441   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6442                         complex_integer_type_node));
6443   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6444                         complex_float_type_node));
6445   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6446                         complex_double_type_node));
6447   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6448                         complex_long_double_type_node));
6449
6450   TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6451
6452   record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6453   void_list_node = build_tree_list (NULL_TREE, void_type_node);
6454   TREE_PARMLIST (void_list_node) = 1;
6455
6456   /* Used for expressions that do nothing, but are not errors.  */
6457   void_zero_node = build_int_2 (0, 0);
6458   TREE_TYPE (void_zero_node) = void_type_node;
6459
6460   string_type_node = build_pointer_type (char_type_node);
6461   const_string_type_node
6462     = build_pointer_type (build_qualified_type (char_type_node,
6463                                                 TYPE_QUAL_CONST));
6464   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6465 #if 0
6466   record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6467 #endif
6468
6469   /* Make a type to be the domain of a few array types
6470      whose domains don't really matter.
6471      200 is small enough that it always fits in size_t.  */
6472   array_domain_type = build_index_type (build_int_2 (200, 0));
6473
6474   /* Make a type for arrays of characters.
6475      With luck nothing will ever really depend on the length of this
6476      array type.  */
6477   char_array_type_node
6478     = build_array_type (char_type_node, array_domain_type);
6479
6480   /* Likewise for arrays of ints.  */
6481   int_array_type_node
6482     = build_array_type (integer_type_node, array_domain_type);
6483
6484   if (flag_new_abi)
6485     delta_type_node = ptrdiff_type_node;
6486   else if (flag_huge_objects)
6487     delta_type_node = long_integer_type_node;
6488   else
6489     delta_type_node = short_integer_type_node;
6490
6491   if (flag_new_abi)
6492     vtable_index_type = ptrdiff_type_node;
6493   else
6494     vtable_index_type = delta_type_node;
6495
6496   default_function_type
6497     = build_function_type (integer_type_node, NULL_TREE);
6498
6499   ptr_type_node = build_pointer_type (void_type_node);
6500   const_ptr_type_node
6501     = build_pointer_type (build_qualified_type (void_type_node,
6502                                                 TYPE_QUAL_CONST));
6503   vtt_parm_type = build_pointer_type (const_ptr_type_node);
6504   c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6505   lang_type_promotes_to = convert_type_from_ellipsis;
6506
6507   void_ftype_ptr
6508     = build_exception_variant (void_ftype_ptr, empty_except_spec);
6509
6510   /* C++ extensions */
6511
6512   unknown_type_node = make_node (UNKNOWN_TYPE);
6513   record_unknown_type (unknown_type_node, "unknown type");
6514
6515   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
6516   TREE_TYPE (unknown_type_node) = unknown_type_node;
6517
6518   TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6519
6520   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6521      result.  */
6522   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6523   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6524
6525   /* This is special for C++ so functions can be overloaded.  */
6526   wchar_type_node = get_identifier (flag_short_wchar
6527                                     ? "short unsigned int"
6528                                     : WCHAR_TYPE);
6529   wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6530   wchar_type_size = TYPE_PRECISION (wchar_type_node);
6531   signed_wchar_type_node = make_signed_type (wchar_type_size);
6532   unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
6533   wchar_type_node
6534     = TREE_UNSIGNED (wchar_type_node)
6535       ? unsigned_wchar_type_node
6536       : signed_wchar_type_node;
6537   record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6538
6539   /* Artificial declaration of wchar_t -- can be bashed */
6540   wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6541                                 wchar_type_node);
6542   pushdecl (wchar_decl_node);
6543
6544   /* This is for wide string constants.  */
6545   wchar_array_type_node
6546     = build_array_type (wchar_type_node, array_domain_type);
6547
6548   if (flag_vtable_thunks)
6549     {
6550       /* Make sure we get a unique function type, so we can give
6551          its pointer type a name.  (This wins for gdb.) */
6552       tree vfunc_type = make_node (FUNCTION_TYPE);
6553       TREE_TYPE (vfunc_type) = integer_type_node;
6554       TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6555       layout_type (vfunc_type);
6556
6557       vtable_entry_type = build_pointer_type (vfunc_type);
6558     }
6559   else
6560     {
6561       vtable_entry_type = make_aggr_type (RECORD_TYPE);
6562       fields[0] = build_decl (FIELD_DECL, delta_identifier,
6563                               delta_type_node);
6564       fields[1] = build_decl (FIELD_DECL, index_identifier,
6565                               delta_type_node);
6566       fields[2] = build_decl (FIELD_DECL, pfn_identifier,
6567                               ptr_type_node);
6568       finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6569                            double_type_node);
6570
6571       /* Make this part of an invisible union.  */
6572       fields[3] = copy_node (fields[2]);
6573       TREE_TYPE (fields[3]) = delta_type_node;
6574       DECL_NAME (fields[3]) = delta2_identifier;
6575       DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6576       DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6577       DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6578       TREE_UNSIGNED (fields[3]) = 0;
6579       TREE_CHAIN (fields[2]) = fields[3];
6580       vtable_entry_type = build_qualified_type (vtable_entry_type,
6581                                                 TYPE_QUAL_CONST);
6582     }
6583   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6584
6585   vtbl_type_node
6586     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6587   layout_type (vtbl_type_node);
6588   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6589   record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6590   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6591   layout_type (vtbl_ptr_type_node);
6592   record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6593
6594   std_node = build_decl (NAMESPACE_DECL,
6595                          flag_honor_std
6596                          ? get_identifier ("fake std") : std_identifier,
6597                          void_type_node);
6598   pushdecl (std_node);
6599
6600   if (flag_new_abi)
6601     {
6602       push_namespace (get_identifier ("__cxxabiv1"));
6603       abi_node = current_namespace;
6604       pop_namespace ();
6605     }
6606
6607   global_type_node = make_node (LANG_TYPE);
6608   record_unknown_type (global_type_node, "global type");
6609
6610   /* Now, C++.  */
6611   current_lang_name = lang_name_cplusplus;
6612
6613   {
6614     tree bad_alloc_type_node, newtype, deltype;
6615     if (flag_honor_std)
6616       push_namespace (get_identifier ("std"));
6617     bad_alloc_type_node = xref_tag
6618       (class_type_node, get_identifier ("bad_alloc"), 1);
6619     if (flag_honor_std)
6620       pop_namespace ();
6621     newtype = build_exception_variant
6622       (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6623     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6624     push_cp_library_fn (NEW_EXPR, newtype);
6625     push_cp_library_fn (VEC_NEW_EXPR, newtype);
6626     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6627     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6628   }
6629
6630   abort_fndecl
6631     = build_library_fn_ptr ("__pure_virtual", void_ftype);
6632
6633   /* Perform other language dependent initializations.  */
6634   init_class_processing ();
6635   init_init_processing ();
6636   init_search_processing ();
6637   init_rtti_processing ();
6638
6639   if (flag_exceptions)
6640     init_exception_processing ();
6641   if (flag_no_inline)
6642     {
6643       flag_inline_functions = 0;
6644     }
6645
6646   if (! supports_one_only ())
6647     flag_weak = 0;
6648
6649   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
6650   make_fname_decl = cp_make_fname_decl;
6651   declare_function_name ();
6652
6653   /* Prepare to check format strings against argument lists.  */
6654   init_function_format_info ();
6655
6656   /* Show we use EH for cleanups.  */
6657   using_eh_for_cleanups ();
6658
6659   print_error_function = lang_print_error_function;
6660   valid_lang_attribute = cp_valid_lang_attribute;
6661
6662   /* Maintain consistency.  Perhaps we should just complain if they
6663      say -fwritable-strings?  */
6664   if (flag_writable_strings)
6665     flag_const_strings = 0;
6666
6667   /* Add GC roots for all of our global variables.  */
6668   ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6669   ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6670   ggc_add_tree_root (&integer_three_node, 1);
6671   ggc_add_tree_root (&integer_two_node, 1);
6672   ggc_add_tree_root (&signed_size_zero_node, 1);
6673   ggc_add_tree_root (&size_one_node, 1);
6674   ggc_add_tree_root (&size_zero_node, 1);
6675   ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6676                 mark_binding_level);
6677   ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6678   ggc_add_tree_root (&static_ctors, 1);
6679   ggc_add_tree_root (&static_dtors, 1);
6680   ggc_add_tree_root (&lastiddecl, 1);
6681
6682   ggc_add_tree_root (&last_function_parm_tags, 1);
6683   ggc_add_tree_root (&current_function_return_value, 1);
6684   ggc_add_tree_root (&current_function_parms, 1);
6685   ggc_add_tree_root (&current_function_parm_tags, 1);
6686   ggc_add_tree_root (&last_function_parms, 1);
6687   ggc_add_tree_root (&error_mark_list, 1);
6688
6689   ggc_add_tree_root (&global_namespace, 1);
6690   ggc_add_tree_root (&global_type_node, 1);
6691   ggc_add_tree_root (&anonymous_namespace_name, 1);
6692
6693   ggc_add_tree_root (&got_object, 1);
6694   ggc_add_tree_root (&got_scope, 1);
6695
6696   ggc_add_tree_root (&current_lang_name, 1);
6697   ggc_add_tree_root (&static_aggregates, 1);
6698 }
6699
6700 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6701    decl, NAME is the initialization string and TYPE_DEP indicates whether
6702    NAME depended on the type of the function. We make use of that to detect
6703    __PRETTY_FUNCTION__ inside a template fn.  Because we build a tree for
6704    the function before emitting any of it, we don't need to treat the
6705    VAR_DECL specially. We can decide whether to emit it later, if it was
6706    used.  */
6707
6708 static tree
6709 cp_make_fname_decl (id, name, type_dep)
6710      tree id;
6711      const char *name;
6712      int type_dep;
6713 {
6714   tree decl, type, init;
6715   size_t length = strlen (name);
6716   tree domain = NULL_TREE;
6717
6718   if (!processing_template_decl)
6719     type_dep = 0;
6720   if (!type_dep)
6721     domain = build_index_type (build_int_2 (length, 0));
6722
6723   type =  build_cplus_array_type
6724           (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6725            domain);
6726
6727   decl = build_decl (VAR_DECL, id, type);
6728   TREE_STATIC (decl) = 1;
6729   TREE_READONLY (decl) = 1;
6730   DECL_SOURCE_LINE (decl) = 0;
6731   DECL_ARTIFICIAL (decl) = 1;
6732   DECL_IN_SYSTEM_HEADER (decl) = 1;
6733   pushdecl (decl);
6734   if (processing_template_decl)
6735     decl = push_template_decl (decl);
6736   if (type_dep)
6737     {
6738       init = build (FUNCTION_NAME, type);
6739       DECL_PRETTY_FUNCTION_P (decl) = 1;
6740     }
6741   else
6742     {
6743       init = build_string (length + 1, name);
6744       TREE_TYPE (init) = type;
6745     }
6746   DECL_INITIAL (decl) = init;
6747   cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6748
6749   /* We will have to make sure we only emit this, if it is actually used. */
6750   return decl;
6751 }
6752
6753 /* Function to print any language-specific context for an error message.  */
6754
6755 static void
6756 lang_print_error_function (file)
6757      const char *file;
6758 {
6759   default_print_error_function (file);
6760   maybe_print_template_context ();
6761 }
6762
6763 /* Entry point for the benefit of c_common_nodes_and_builtins.
6764
6765    Make a definition for a builtin function named NAME and whose data type
6766    is TYPE.  TYPE should be a function type with argument types.
6767
6768    CLASS and CODE tell later passes how to compile calls to this function.
6769    See tree.h for possible values.
6770
6771    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6772    the name to be called if we can't opencode the function.  */
6773
6774 tree
6775 builtin_function (name, type, code, class, libname)
6776      const char *name;
6777      tree type;
6778      int code;
6779      enum built_in_class class;
6780      const char *libname;
6781 {
6782   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6783   DECL_BUILT_IN_CLASS (decl) = class;
6784   DECL_FUNCTION_CODE (decl) = code;
6785
6786   my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6787
6788   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6789      we cannot change DECL_ASSEMBLER_NAME until we have installed this
6790      function in the namespace.  */
6791   pushdecl (decl);
6792   if (libname)
6793     DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6794   make_function_rtl (decl);
6795
6796   /* Warn if a function in the namespace for users
6797      is used without an occasion to consider it declared.  */
6798   if (name[0] != '_' || name[1] != '_')
6799     DECL_ANTICIPATED (decl) = 1;
6800
6801   return decl;
6802 }
6803
6804 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6805    function.  Not called directly.  */
6806
6807 static tree
6808 build_library_fn_1 (name, operator_code, type)
6809      tree name;
6810      enum tree_code operator_code;
6811      tree type;
6812 {
6813   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6814   DECL_EXTERNAL (fn) = 1;
6815   TREE_PUBLIC (fn) = 1;
6816   DECL_ARTIFICIAL (fn) = 1;
6817   TREE_NOTHROW (fn) = 1;
6818   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6819   return fn;
6820 }
6821
6822 /* Returns the _DECL for a library function with C linkage.
6823    We assume that such functions never throw; if this is incorrect,
6824    callers should unset TREE_NOTHROW.  */
6825
6826 tree
6827 build_library_fn (name, type)
6828      tree name;
6829      tree type;
6830 {
6831   tree fn = build_library_fn_1 (name, ERROR_MARK, type);
6832   make_function_rtl (fn);
6833   return fn;
6834 }
6835
6836 /* Returns the _DECL for a library function with C++ linkage.  */
6837
6838 static tree
6839 build_cp_library_fn (name, operator_code, type)
6840      tree name;
6841      enum tree_code operator_code;
6842      tree type;
6843 {
6844   tree fn = build_library_fn_1 (name, operator_code, type);
6845   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6846   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6847   set_mangled_name_for_decl (fn);
6848   make_function_rtl (fn);
6849   return fn;
6850 }
6851
6852 /* Like build_library_fn, but takes a C string instead of an
6853    IDENTIFIER_NODE.  */
6854
6855 tree
6856 build_library_fn_ptr (name, type)
6857      const char *name;
6858      tree type;
6859 {
6860   return build_library_fn (get_identifier (name), type);
6861 }
6862
6863 /* Like build_cp_library_fn, but takes a C string instead of an
6864    IDENTIFIER_NODE.  */
6865
6866 tree
6867 build_cp_library_fn_ptr (name, type)
6868      const char *name;
6869      tree type;
6870 {
6871   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6872 }
6873
6874 /* Like build_library_fn, but also pushes the function so that we will
6875    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
6876
6877 tree
6878 push_library_fn (name, type)
6879      tree name, type;
6880 {
6881   tree fn = build_library_fn (name, type);
6882   pushdecl_top_level (fn);
6883   return fn;
6884 }
6885
6886 /* Like build_cp_library_fn, but also pushes the function so that it
6887    will be found by normal lookup.  */
6888
6889 static tree
6890 push_cp_library_fn (operator_code, type)
6891      enum tree_code operator_code;
6892      tree type;
6893 {
6894   tree fn = build_cp_library_fn (ansi_opname (operator_code),
6895                                  operator_code,
6896                                  type);
6897   pushdecl (fn);
6898   return fn;
6899 }
6900
6901 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6902    a FUNCTION_TYPE.  */
6903
6904 tree
6905 push_void_library_fn (name, parmtypes)
6906      tree name, parmtypes;
6907 {
6908   tree type = build_function_type (void_type_node, parmtypes);
6909   return push_library_fn (name, type);
6910 }
6911
6912 /* Like push_library_fn, but also note that this function throws
6913    and does not return.  Used for __throw_foo and the like.  */
6914
6915 tree
6916 push_throw_library_fn (name, type)
6917      tree name, type;
6918 {
6919   tree fn = push_library_fn (name, type);
6920   TREE_THIS_VOLATILE (fn) = 1;
6921   TREE_NOTHROW (fn) = 0;
6922   return fn;
6923 }
6924 \f
6925 /* When we call finish_struct for an anonymous union, we create
6926    default copy constructors and such.  But, an anonymous union
6927    shouldn't have such things; this function undoes the damage to the
6928    anonymous union type T.
6929
6930    (The reason that we create the synthesized methods is that we don't
6931    distinguish `union { int i; }' from `typedef union { int i; } U'.
6932    The first is an anonymous union; the second is just an ordinary
6933    union type.)  */
6934
6935 void
6936 fixup_anonymous_aggr (t)
6937      tree t;
6938 {
6939   tree *q;
6940
6941   /* Wipe out memory of synthesized methods */
6942   TYPE_HAS_CONSTRUCTOR (t) = 0;
6943   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6944   TYPE_HAS_INIT_REF (t) = 0;
6945   TYPE_HAS_CONST_INIT_REF (t) = 0;
6946   TYPE_HAS_ASSIGN_REF (t) = 0;
6947   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6948
6949   /* Splice the implicitly generated functions out of the TYPE_METHODS
6950      list.  */
6951   q = &TYPE_METHODS (t);
6952   while (*q)
6953     {
6954       if (DECL_ARTIFICIAL (*q))
6955         *q = TREE_CHAIN (*q);
6956       else
6957         q = &TREE_CHAIN (*q);
6958     }
6959
6960   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
6961   if (TYPE_METHODS (t))
6962     error ("an anonymous union cannot have function members");
6963 }
6964
6965 /* Make sure that a declaration with no declarator is well-formed, i.e.
6966    just defines a tagged type or anonymous union.
6967
6968    Returns the type defined, if any.  */
6969
6970 tree
6971 check_tag_decl (declspecs)
6972      tree declspecs;
6973 {
6974   int found_type = 0;
6975   int saw_friend = 0;
6976   tree ob_modifier = NULL_TREE;
6977   register tree link;
6978   register tree t = NULL_TREE;
6979
6980   for (link = declspecs; link; link = TREE_CHAIN (link))
6981     {
6982       register tree value = TREE_VALUE (link);
6983
6984       if (TYPE_P (value)
6985           || (TREE_CODE (value) == IDENTIFIER_NODE
6986               && IDENTIFIER_GLOBAL_VALUE (value)
6987               && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
6988         {
6989           ++found_type;
6990
6991           if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
6992             {
6993               my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6994               t = value;
6995             }
6996         }
6997       else if (value == ridpointers[(int) RID_FRIEND])
6998         {
6999           if (current_class_type == NULL_TREE
7000               || current_scope () != current_class_type)
7001             ob_modifier = value;
7002           else
7003             saw_friend = 1;
7004         }
7005       else if (value == ridpointers[(int) RID_STATIC]
7006                || value == ridpointers[(int) RID_EXTERN]
7007                || value == ridpointers[(int) RID_AUTO]
7008                || value == ridpointers[(int) RID_REGISTER]
7009                || value == ridpointers[(int) RID_INLINE]
7010                || value == ridpointers[(int) RID_VIRTUAL]
7011                || value == ridpointers[(int) RID_CONST]
7012                || value == ridpointers[(int) RID_VOLATILE]
7013                || value == ridpointers[(int) RID_EXPLICIT])
7014         ob_modifier = value;
7015     }
7016
7017   if (found_type > 1)
7018     error ("multiple types in one declaration");
7019
7020   if (t == NULL_TREE && ! saw_friend)
7021     pedwarn ("declaration does not declare anything");
7022
7023   /* Check for an anonymous union.  We're careful
7024      accessing TYPE_IDENTIFIER because some built-in types, like
7025      pointer-to-member types, do not have TYPE_NAME.  */
7026   else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
7027            && TYPE_NAME (t)
7028            && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
7029     {
7030       /* Anonymous unions are objects, so they can have specifiers.  */;
7031       SET_ANON_AGGR_TYPE_P (t);
7032
7033       if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
7034         pedwarn ("ISO C++ prohibits anonymous structs");
7035     }
7036
7037   else if (ob_modifier)
7038     {
7039       if (ob_modifier == ridpointers[(int) RID_INLINE]
7040           || ob_modifier == ridpointers[(int) RID_VIRTUAL])
7041         cp_error ("`%D' can only be specified for functions", ob_modifier);
7042       else if (ob_modifier == ridpointers[(int) RID_FRIEND])
7043         cp_error ("`%D' can only be specified inside a class", ob_modifier);
7044       else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
7045         cp_error ("`%D' can only be specified for constructors",
7046                   ob_modifier);
7047       else
7048         cp_error ("`%D' can only be specified for objects and functions",
7049                   ob_modifier);
7050     }
7051
7052   return t;
7053 }
7054
7055 /* Called when a declaration is seen that contains no names to declare.
7056    If its type is a reference to a structure, union or enum inherited
7057    from a containing scope, shadow that tag name for the current scope
7058    with a forward reference.
7059    If its type defines a new named structure or union
7060    or defines an enum, it is valid but we need not do anything here.
7061    Otherwise, it is an error.
7062
7063    C++: may have to grok the declspecs to learn about static,
7064    complain for anonymous unions.  */
7065
7066 void
7067 shadow_tag (declspecs)
7068      tree declspecs;
7069 {
7070   tree t = check_tag_decl (declspecs);
7071
7072   if (t)
7073     maybe_process_partial_specialization (t);
7074
7075   /* This is where the variables in an anonymous union are
7076      declared.  An anonymous union declaration looks like:
7077      union { ... } ;
7078      because there is no declarator after the union, the parser
7079      sends that declaration here.  */
7080   if (t && ANON_AGGR_TYPE_P (t))
7081     {
7082       fixup_anonymous_aggr (t);
7083
7084       if (TYPE_FIELDS (t))
7085         {
7086           tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
7087                                       NULL_TREE);
7088           finish_anon_union (decl);
7089         }
7090     }
7091 }
7092 \f
7093 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
7094
7095 tree
7096 groktypename (typename)
7097      tree typename;
7098 {
7099   if (TREE_CODE (typename) != TREE_LIST)
7100     return typename;
7101   return grokdeclarator (TREE_VALUE (typename),
7102                          TREE_PURPOSE (typename),
7103                          TYPENAME, 0, NULL_TREE);
7104 }
7105
7106 /* Decode a declarator in an ordinary declaration or data definition.
7107    This is called as soon as the type information and variable name
7108    have been parsed, before parsing the initializer if any.
7109    Here we create the ..._DECL node, fill in its type,
7110    and put it on the list of decls for the current context.
7111    The ..._DECL node is returned as the value.
7112
7113    Exception: for arrays where the length is not specified,
7114    the type is left null, to be filled in by `cp_finish_decl'.
7115
7116    Function definitions do not come here; they go to start_function
7117    instead.  However, external and forward declarations of functions
7118    do go through here.  Structure field declarations are done by
7119    grokfield and not through here.  */
7120
7121 tree
7122 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
7123      tree declarator, declspecs;
7124      int initialized;
7125      tree attributes, prefix_attributes;
7126 {
7127   register tree decl;
7128   register tree type, tem;
7129   tree context;
7130   extern int have_extern_spec;
7131   extern int used_extern_spec;
7132   tree attrlist;
7133
7134 #if 0
7135   /* See code below that used this.  */
7136   int init_written = initialized;
7137 #endif
7138
7139   /* This should only be done once on the top most decl.  */
7140   if (have_extern_spec && !used_extern_spec)
7141     {
7142       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
7143                                   declspecs);
7144       used_extern_spec = 1;
7145     }
7146
7147   if (attributes || prefix_attributes)
7148     attrlist = build_tree_list (attributes, prefix_attributes);
7149   else
7150     attrlist = NULL_TREE;
7151
7152   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7153                          attrlist);
7154
7155   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7156     return NULL_TREE;
7157
7158   type = TREE_TYPE (decl);
7159
7160   if (type == error_mark_node)
7161     return NULL_TREE;
7162
7163   context = DECL_CONTEXT (decl);
7164
7165   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7166       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7167     {
7168       /* When parsing the initializer, lookup should use the object's
7169          namespace. */
7170       push_decl_namespace (context);
7171     }
7172
7173   /* We are only interested in class contexts, later. */
7174   if (context && TREE_CODE (context) == NAMESPACE_DECL)
7175     context = NULL_TREE;
7176
7177   if (initialized)
7178     /* Is it valid for this decl to have an initializer at all?
7179        If not, set INITIALIZED to zero, which will indirectly
7180        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7181     switch (TREE_CODE (decl))
7182       {
7183       case TYPE_DECL:
7184         /* typedef foo = bar  means give foo the same type as bar.
7185            We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7186            Any other case of an initialization in a TYPE_DECL is an error.  */
7187         if (pedantic || list_length (declspecs) > 1)
7188           {
7189             cp_error ("typedef `%D' is initialized", decl);
7190             initialized = 0;
7191           }
7192         break;
7193
7194       case FUNCTION_DECL:
7195         cp_error ("function `%#D' is initialized like a variable", decl);
7196         initialized = 0;
7197         break;
7198
7199       default:
7200         break;
7201       }
7202
7203   if (initialized)
7204     {
7205       if (! toplevel_bindings_p ()
7206           && DECL_EXTERNAL (decl))
7207         cp_warning ("declaration of `%#D' has `extern' and is initialized",
7208                     decl);
7209       DECL_EXTERNAL (decl) = 0;
7210       if (toplevel_bindings_p ())
7211         TREE_STATIC (decl) = 1;
7212
7213       /* Tell `pushdecl' this is an initialized decl
7214          even though we don't yet have the initializer expression.
7215          Also tell `cp_finish_decl' it may store the real initializer.  */
7216       DECL_INITIAL (decl) = error_mark_node;
7217     }
7218
7219 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7220   SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7221 #endif
7222
7223   /* Set attributes here so if duplicate decl, will have proper attributes.  */
7224   cplus_decl_attributes (decl, attributes, prefix_attributes);
7225
7226   if (context && COMPLETE_TYPE_P (complete_type (context)))
7227     {
7228       push_nested_class (context, 2);
7229
7230       if (TREE_CODE (decl) == VAR_DECL)
7231         {
7232           tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7233           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7234             cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7235           else
7236             {
7237               if (DECL_CONTEXT (field) != context)
7238                 {
7239                   cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7240                               DECL_CONTEXT (field), DECL_NAME (decl),
7241                               context, DECL_NAME (decl));
7242                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7243                 }
7244               /* Static data member are tricky; an in-class initialization
7245                  still doesn't provide a definition, so the in-class
7246                  declaration will have DECL_EXTERNAL set, but will have an
7247                  initialization.  Thus, duplicate_decls won't warn
7248                  about this situation, and so we check here.  */
7249               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7250                 cp_error ("duplicate initialization of %D", decl);
7251               if (duplicate_decls (decl, field))
7252                 decl = field;
7253             }
7254         }
7255       else
7256         {
7257           tree field = check_classfn (context, decl);
7258           if (field && duplicate_decls (decl, field))
7259             decl = field;
7260         }
7261
7262       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
7263       DECL_IN_AGGR_P (decl) = 0;
7264       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7265           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7266         {
7267           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7268           /* [temp.expl.spec] An explicit specialization of a static data
7269              member of a template is a definition if the declaration
7270              includes an initializer; otherwise, it is a declaration.
7271
7272              We check for processing_specialization so this only applies
7273              to the new specialization syntax.  */
7274           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7275             DECL_EXTERNAL (decl) = 1;
7276         }
7277
7278       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7279         cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7280                     decl);
7281     }
7282
7283   /* Enter this declaration into the symbol table.  */
7284   tem = maybe_push_decl (decl);
7285
7286   if (processing_template_decl)
7287     tem = push_template_decl (tem);
7288
7289 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7290   /* Tell the back-end to use or not use .common as appropriate.  If we say
7291      -fconserve-space, we want this to save .data space, at the expense of
7292      wrong semantics.  If we say -fno-conserve-space, we want this to
7293      produce errors about redefs; to do this we force variables into the
7294      data segment.  */
7295   DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7296 #endif
7297
7298   if (! processing_template_decl)
7299     start_decl_1 (tem);
7300
7301   return tem;
7302 }
7303
7304 void
7305 start_decl_1 (decl)
7306      tree decl;
7307 {
7308   tree type = TREE_TYPE (decl);
7309   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7310
7311   if (type == error_mark_node)
7312     return;
7313
7314   /* If this type of object needs a cleanup, but we're not allowed to
7315      add any more objects with cleanups to the current scope, create a
7316      new binding level.  */
7317   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7318       && current_binding_level->more_cleanups_ok == 0)
7319     {
7320       keep_next_level (2);
7321       pushlevel (1);
7322       clear_last_expr ();
7323       add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7324     }
7325
7326   if (initialized)
7327     /* Is it valid for this decl to have an initializer at all?
7328        If not, set INITIALIZED to zero, which will indirectly
7329        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
7330     {
7331       /* Don't allow initializations for incomplete types except for
7332          arrays which might be completed by the initialization.  */
7333       if (COMPLETE_TYPE_P (complete_type (type)))
7334         ;                       /* A complete type is ok.  */
7335       else if (TREE_CODE (type) != ARRAY_TYPE)
7336         {
7337           cp_error ("variable `%#D' has initializer but incomplete type",
7338                     decl);
7339           initialized = 0;
7340           type = TREE_TYPE (decl) = error_mark_node;
7341         }
7342       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7343         {
7344           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7345             cp_error ("elements of array `%#D' have incomplete type", decl);
7346           /* else we already gave an error in start_decl.  */
7347           initialized = 0;
7348         }
7349     }
7350
7351   if (!initialized
7352       && TREE_CODE (decl) != TYPE_DECL
7353       && TREE_CODE (decl) != TEMPLATE_DECL
7354       && type != error_mark_node
7355       && IS_AGGR_TYPE (type)
7356       && ! DECL_EXTERNAL (decl))
7357     {
7358       if ((! processing_template_decl || ! uses_template_parms (type))
7359           && !COMPLETE_TYPE_P (complete_type (type)))
7360         {
7361           cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7362                  decl);
7363           /* Change the type so that assemble_variable will give
7364              DECL an rtl we can live with: (mem (const_int 0)).  */
7365           type = TREE_TYPE (decl) = error_mark_node;
7366         }
7367       else
7368         {
7369           /* If any base type in the hierarchy of TYPE needs a constructor,
7370              then we set initialized to 1.  This way any nodes which are
7371              created for the purposes of initializing this aggregate
7372              will live as long as it does.  This is necessary for global
7373              aggregates which do not have their initializers processed until
7374              the end of the file.  */
7375           initialized = TYPE_NEEDS_CONSTRUCTING (type);
7376         }
7377     }
7378
7379   if (! initialized)
7380     DECL_INITIAL (decl) = NULL_TREE;
7381 }
7382
7383 /* Handle initialization of references.
7384    These three arguments are from `cp_finish_decl', and have the
7385    same meaning here that they do there.
7386
7387    Quotes on semantics can be found in ARM 8.4.3.  */
7388
7389 static void
7390 grok_reference_init (decl, type, init)
7391      tree decl, type, init;
7392 {
7393   tree tmp;
7394
7395   if (init == NULL_TREE)
7396     {
7397       if ((DECL_LANG_SPECIFIC (decl) == 0
7398            || DECL_IN_AGGR_P (decl) == 0)
7399           && ! DECL_THIS_EXTERN (decl))
7400         cp_error ("`%D' declared as reference but not initialized", decl);
7401       return;
7402     }
7403
7404   if (init == error_mark_node)
7405     return;
7406
7407   if (TREE_CODE (init) == CONSTRUCTOR)
7408     {
7409       cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7410       return;
7411     }
7412
7413   if (TREE_CODE (init) == TREE_LIST)
7414     init = build_compound_expr (init);
7415
7416   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7417     init = convert_from_reference (init);
7418
7419   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7420       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7421     {
7422       /* Note: default conversion is only called in very special cases.  */
7423       init = default_conversion (init);
7424     }
7425
7426   /* Convert INIT to the reference type TYPE.  This may involve the
7427      creation of a temporary, whose lifetime must be the same as that
7428      of the reference.  If so, a DECL_STMT for the temporary will be
7429      added just after the DECL_STMT for DECL.  That's why we don't set
7430      DECL_INITIAL for local references (instead assigning to them
7431      explicitly); we need to allow the temporary to be initialized
7432      first.  */
7433   tmp = convert_to_reference
7434     (type, init, CONV_IMPLICIT,
7435      LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7436      decl);
7437
7438   if (tmp == error_mark_node)
7439     return;
7440   else if (tmp != NULL_TREE)
7441     {
7442       init = tmp;
7443       tmp = save_expr (tmp);
7444       if (building_stmt_tree ())
7445         {
7446           /* Initialize the declaration.  */
7447           tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7448           finish_expr_stmt (tmp);
7449         }
7450       else
7451         DECL_INITIAL (decl) = tmp;
7452     }
7453   else
7454     {
7455       cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7456       return;
7457     }
7458
7459   if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7460     {
7461       expand_static_init (decl, DECL_INITIAL (decl));
7462       DECL_INITIAL (decl) = NULL_TREE;
7463     }
7464   return;
7465 }
7466
7467 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7468    mucking with forces it does not comprehend (i.e. initialization with a
7469    constructor).  If we are at global scope and won't go into COMMON, fill
7470    it in with a dummy CONSTRUCTOR to force the variable into .data;
7471    otherwise we can use error_mark_node.  */
7472
7473 static tree
7474 obscure_complex_init (decl, init)
7475      tree decl, init;
7476 {
7477   if (! flag_no_inline && TREE_STATIC (decl))
7478     {
7479       if (extract_init (decl, init))
7480         return NULL_TREE;
7481     }
7482
7483 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7484   if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7485     DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7486                                  NULL_TREE);
7487   else
7488 #endif
7489     DECL_INITIAL (decl) = error_mark_node;
7490
7491   return init;
7492 }
7493
7494 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7495    array until we finish parsing the initializer.  If that's the
7496    situation we're in, update DECL accordingly.  */
7497
7498 static void
7499 maybe_deduce_size_from_array_init (decl, init)
7500      tree decl;
7501      tree init;
7502 {
7503   tree type = TREE_TYPE (decl);
7504
7505   if (TREE_CODE (type) == ARRAY_TYPE
7506       && TYPE_DOMAIN (type) == NULL_TREE
7507       && TREE_CODE (decl) != TYPE_DECL)
7508     {
7509       int do_default
7510         = (TREE_STATIC (decl)
7511            /* Even if pedantic, an external linkage array
7512               may have incomplete type at first.  */
7513            ? pedantic && ! DECL_EXTERNAL (decl)
7514            : !DECL_EXTERNAL (decl));
7515       tree initializer = init ? init : DECL_INITIAL (decl);
7516       int failure = complete_array_type (type, initializer, do_default);
7517
7518       if (failure == 1)
7519         cp_error ("initializer fails to determine size of `%D'", decl);
7520
7521       if (failure == 2)
7522         {
7523           if (do_default)
7524             cp_error ("array size missing in `%D'", decl);
7525           /* If a `static' var's size isn't known, make it extern as
7526              well as static, so it does not get allocated.  If it's not
7527              `static', then don't mark it extern; finish_incomplete_decl
7528              will give it a default size and it will get allocated.  */
7529           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7530             DECL_EXTERNAL (decl) = 1;
7531         }
7532
7533       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7534           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7535                               integer_zero_node))
7536         cp_error ("zero-size array `%D'", decl);
7537
7538       layout_decl (decl, 0);
7539     }
7540 }
7541
7542 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7543    any appropriate error messages regarding the layout.  */
7544
7545 static void
7546 layout_var_decl (decl)
7547      tree decl;
7548 {
7549   tree type = TREE_TYPE (decl);
7550 #if 0
7551   tree ttype = target_type (type);
7552 #endif
7553
7554   /* If we haven't already layed out this declaration, do so now.
7555      Note that we must not call complete type for an external object
7556      because it's type might involve templates that we are not
7557      supposed to isntantiate yet.  (And it's perfectly legal to say
7558      `extern X x' for some incomplete type `X'.)  */
7559   if (!DECL_EXTERNAL (decl))
7560     complete_type (type);
7561   if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7562     layout_decl (decl, 0);
7563
7564   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7565     {
7566       /* An automatic variable with an incomplete type: that is an error.
7567          Don't talk about array types here, since we took care of that
7568          message in grokdeclarator.  */
7569       cp_error ("storage size of `%D' isn't known", decl);
7570       TREE_TYPE (decl) = error_mark_node;
7571     }
7572 #if 0
7573   /* Keep this code around in case we later want to control debug info
7574      based on whether a type is "used".  (jason 1999-11-11) */
7575
7576   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7577     /* Let debugger know it should output info for this type.  */
7578     note_debug_info_needed (ttype);
7579
7580   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7581     note_debug_info_needed (DECL_CONTEXT (decl));
7582 #endif
7583
7584   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7585       && DECL_SIZE (decl) != NULL_TREE
7586       && ! TREE_CONSTANT (DECL_SIZE (decl)))
7587     {
7588       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7589         constant_expression_warning (DECL_SIZE (decl));
7590       else
7591         cp_error ("storage size of `%D' isn't constant", decl);
7592     }
7593 }
7594
7595 /* If a local static variable is declared in an inline function, or if
7596    we have a weak definition, we must endeavor to create only one
7597    instance of the variable at link-time.  */
7598
7599 static void
7600 maybe_commonize_var (decl)
7601      tree decl;
7602 {
7603   /* Static data in a function with comdat linkage also has comdat
7604      linkage.  */
7605   if (TREE_STATIC (decl)
7606       /* Don't mess with __FUNCTION__.  */
7607       && ! DECL_ARTIFICIAL (decl)
7608       && current_function_decl
7609       && DECL_CONTEXT (decl) == current_function_decl
7610       && (DECL_THIS_INLINE (current_function_decl)
7611           || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7612       && TREE_PUBLIC (current_function_decl))
7613     {
7614       /* Rather than try to get this right with inlining, we suppress
7615          inlining of such functions.  */
7616       current_function_cannot_inline
7617         = "function with static variable cannot be inline";
7618
7619       /* If flag_weak, we don't need to mess with this, as we can just
7620          make the function weak, and let it refer to its unique local
7621          copy.  This works because we don't allow the function to be
7622          inlined.  */
7623       if (! flag_weak)
7624         {
7625           if (DECL_INTERFACE_KNOWN (current_function_decl))
7626             {
7627               TREE_PUBLIC (decl) = 1;
7628               DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7629             }
7630           else if (DECL_INITIAL (decl) == NULL_TREE
7631                    || DECL_INITIAL (decl) == error_mark_node)
7632             {
7633               TREE_PUBLIC (decl) = 1;
7634               DECL_COMMON (decl) = 1;
7635             }
7636           /* else we lose. We can only do this if we can use common,
7637              which we can't if it has been initialized.  */
7638
7639           if (TREE_PUBLIC (decl))
7640             DECL_ASSEMBLER_NAME (decl)
7641               = build_static_name (current_function_decl, DECL_NAME (decl));
7642           else
7643             {
7644               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7645               cp_warning_at ("  you can work around this by removing the initializer", decl);
7646             }
7647         }
7648     }
7649   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7650     /* Set it up again; we might have set DECL_INITIAL since the last
7651        time.  */
7652     comdat_linkage (decl);
7653 }
7654
7655 /* Issue an error message if DECL is an uninitialized const variable.  */
7656
7657 static void
7658 check_for_uninitialized_const_var (decl)
7659      tree decl;
7660 {
7661   tree type = TREE_TYPE (decl);
7662
7663   /* ``Unless explicitly declared extern, a const object does not have
7664      external linkage and must be initialized. ($8.4; $12.1)'' ARM
7665      7.1.6 */
7666   if (TREE_CODE (decl) == VAR_DECL
7667       && TREE_CODE (type) != REFERENCE_TYPE
7668       && CP_TYPE_CONST_P (type)
7669       && !TYPE_NEEDS_CONSTRUCTING (type)
7670       && !DECL_INITIAL (decl))
7671     cp_error ("uninitialized const `%D'", decl);
7672 }
7673
7674 /* Verify INIT (the initializer for DECL), and record the
7675    initialization in DECL_INITIAL, if appropriate.  Returns a new
7676    value for INIT.  */
7677
7678 static tree
7679 check_initializer (decl, init)
7680      tree decl;
7681      tree init;
7682 {
7683   tree type;
7684
7685   if (TREE_CODE (decl) == FIELD_DECL)
7686     return init;
7687
7688   type = TREE_TYPE (decl);
7689
7690   /* If `start_decl' didn't like having an initialization, ignore it now.  */
7691   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7692     init = NULL_TREE;
7693
7694   /* Check the initializer.  */
7695   if (init)
7696     {
7697       /* Things that are going to be initialized need to have complete
7698          type.  */
7699       TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7700
7701       if (type == error_mark_node)
7702         /* We will have already complained.  */
7703         init = NULL_TREE;
7704       else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7705         {
7706           cp_error ("variable-sized object `%D' may not be initialized", decl);
7707           init = NULL_TREE;
7708         }
7709       else if (TREE_CODE (type) == ARRAY_TYPE
7710                && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7711         {
7712           cp_error ("elements of array `%#D' have incomplete type", decl);
7713           init = NULL_TREE;
7714         }
7715       else if (!COMPLETE_TYPE_P (type))
7716         {
7717           cp_error ("`%D' has incomplete type", decl);
7718           TREE_TYPE (decl) = error_mark_node;
7719           init = NULL_TREE;
7720         }
7721     }
7722
7723   if (TREE_CODE (decl) == CONST_DECL)
7724     {
7725       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7726
7727       DECL_INITIAL (decl) = init;
7728
7729       /* This will keep us from needing to worry about our obstacks.  */
7730       my_friendly_assert (init != NULL_TREE, 149);
7731       init = NULL_TREE;
7732     }
7733   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7734     {
7735       if (TREE_STATIC (decl))
7736         make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7737       grok_reference_init (decl, type, init);
7738       init = NULL_TREE;
7739     }
7740   else if (init)
7741     {
7742       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7743         {
7744           if (TREE_CODE (type) == ARRAY_TYPE)
7745             init = digest_init (type, init, (tree *) 0);
7746           else if (TREE_CODE (init) == CONSTRUCTOR
7747                    && TREE_HAS_CONSTRUCTOR (init))
7748             {
7749               if (TYPE_NON_AGGREGATE_CLASS (type))
7750                 {
7751                   cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7752                             decl);
7753                   init = error_mark_node;
7754                 }
7755               else
7756                 goto dont_use_constructor;
7757             }
7758         }
7759       else
7760         {
7761         dont_use_constructor:
7762           if (TREE_CODE (init) != TREE_VEC)
7763             init = store_init_value (decl, init);
7764         }
7765
7766       if (init)
7767         /* We must hide the initializer so that expand_decl
7768            won't try to do something it does not understand.  */
7769         init = obscure_complex_init (decl, init);
7770     }
7771   else if (DECL_EXTERNAL (decl))
7772     ;
7773   else if (TYPE_P (type)
7774            && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7775     {
7776       tree core_type = strip_array_types (type);
7777
7778       if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7779         {
7780           if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7781             cp_error ("structure `%D' with uninitialized const members", decl);
7782           if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7783             cp_error ("structure `%D' with uninitialized reference members",
7784                       decl);
7785         }
7786
7787       check_for_uninitialized_const_var (decl);
7788
7789       if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7790         init = obscure_complex_init (decl, NULL_TREE);
7791
7792     }
7793   else
7794     check_for_uninitialized_const_var (decl);
7795
7796   return init;
7797 }
7798
7799 /* If DECL is not a local variable, give it RTL.  */
7800
7801 static void
7802 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7803      tree decl;
7804      tree init;
7805      const char *asmspec;
7806 {
7807   int toplev;
7808   tree type;
7809
7810   type = TREE_TYPE (decl);
7811   toplev = toplevel_bindings_p ();
7812
7813   /* Handle non-variables up front.  */
7814   if (TREE_CODE (decl) != VAR_DECL)
7815     {
7816       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7817       return;
7818     }
7819
7820   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
7821   if (asmspec)
7822     DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7823
7824   if (DECL_VIRTUAL_P (decl))
7825     make_decl_rtl (decl, NULL_PTR, toplev);
7826   else if (TREE_READONLY (decl)
7827            && DECL_INITIAL (decl) != NULL_TREE
7828            && DECL_INITIAL (decl) != error_mark_node
7829            && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7830     {
7831       DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
7832
7833       if (toplev && ! TREE_PUBLIC (decl))
7834         {
7835           /* If this is a static const, change its apparent linkage
7836              if it belongs to a #pragma interface.  */
7837           if (!interface_unknown)
7838             {
7839               TREE_PUBLIC (decl) = 1;
7840               DECL_EXTERNAL (decl) = interface_only;
7841             }
7842           make_decl_rtl (decl, asmspec, toplev);
7843         }
7844       else if (toplev)
7845         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7846     }
7847   else if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7848     {
7849       my_friendly_assert (TREE_STATIC (decl), 19990828);
7850
7851       if (init == NULL_TREE
7852 #ifdef DEFAULT_STATIC_DEFS
7853           /* If this code is dead, then users must
7854              explicitly declare static member variables
7855              outside the class def'n as well.  */
7856           && TYPE_NEEDS_CONSTRUCTING (type)
7857 #endif
7858           )
7859         {
7860           DECL_EXTERNAL (decl) = 1;
7861           make_decl_rtl (decl, asmspec, 1);
7862         }
7863       else
7864         rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7865     }
7866   else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == NAMESPACE_DECL
7867            || (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)))
7868     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7869 }
7870
7871 /* Create RTL for the local static variable DECL.  */
7872
7873 void
7874 make_rtl_for_local_static (decl)
7875      tree decl;
7876 {
7877   const char *asmspec = NULL;
7878
7879   /* If we inlined this variable, we could see it's declaration
7880      again.  */
7881   if (DECL_RTL (decl))
7882     return;
7883
7884   if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7885     {
7886       /* The only way this situaton can occur is if the
7887          user specified a name for this DECL using the
7888          `attribute' syntax.  */
7889       asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
7890       DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
7891     }
7892
7893   rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
7894 }
7895
7896 /* The old ARM scoping rules injected variables declared in the
7897    initialization statement of a for-statement into the surrounding
7898    scope.  We support this usage, in order to be backward-compatible.
7899    DECL is a just-declared VAR_DECL; if necessary inject its
7900    declaration into the surrounding scope.  */
7901
7902 void
7903 maybe_inject_for_scope_var (decl)
7904      tree decl;
7905 {
7906   if (current_binding_level->is_for_scope)
7907     {
7908       struct binding_level *outer
7909         = current_binding_level->level_chain;
7910
7911       /* Check to see if the same name is already bound at the outer
7912          level, either because it was directly declared, or because a
7913          dead for-decl got preserved.  In either case, the code would
7914          not have been valid under the ARM scope rules, so clear
7915          is_for_scope for the current_binding_level.
7916
7917          Otherwise, we need to preserve the temp slot for decl to last
7918          into the outer binding level.  */
7919
7920       tree outer_binding
7921         = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7922
7923       if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7924           && (TREE_CODE (BINDING_VALUE (outer_binding))
7925               == VAR_DECL)
7926           && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7927         {
7928           BINDING_VALUE (outer_binding)
7929             = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7930           current_binding_level->is_for_scope = 0;
7931         }
7932       else if (DECL_IN_MEMORY_P (decl))
7933         preserve_temp_slots (DECL_RTL (decl));
7934     }
7935 }
7936
7937 /* Generate code to initialize DECL (a local variable).  */
7938
7939 void
7940 initialize_local_var (decl, init, flags)
7941      tree decl;
7942      tree init;
7943      int flags;
7944 {
7945   tree type = TREE_TYPE (decl);
7946
7947   /* If the type is bogus, don't bother initializing the variable.  */
7948   if (type == error_mark_node)
7949     return;
7950
7951   if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7952     {
7953       /* If we used it already as memory, it must stay in memory.  */
7954       DECL_INITIAL (decl) = NULL_TREE;
7955       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7956     }
7957
7958   /* Local statics are handled differently from ordinary automatic
7959      variables.  */
7960   if (TREE_STATIC (decl))
7961     {
7962       if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7963           || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7964         expand_static_init (decl, init);
7965       return;
7966     }
7967
7968   if (DECL_SIZE (decl) && type != error_mark_node)
7969     {
7970       int already_used;
7971
7972       /* Compute and store the initial value.  */
7973       already_used = TREE_USED (decl) || TREE_USED (type);
7974
7975       if (init || TYPE_NEEDS_CONSTRUCTING (type))
7976         {
7977           int saved_stmts_are_full_exprs_p;
7978
7979           emit_line_note (DECL_SOURCE_FILE (decl),
7980                           DECL_SOURCE_LINE (decl));
7981           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p;
7982           stmts_are_full_exprs_p = 1;
7983           if (building_stmt_tree ())
7984             finish_expr_stmt (build_aggr_init (decl, init, flags));
7985           else
7986             genrtl_expr_stmt (build_aggr_init (decl, init, flags));
7987           stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7988         }
7989
7990       /* Set this to 0 so we can tell whether an aggregate which was
7991          initialized was ever used.  Don't do this if it has a
7992          destructor, so we don't complain about the 'resource
7993          allocation is initialization' idiom.  Now set
7994          attribute((unused)) on types so decls of that type will be
7995          marked used. (see TREE_USED, above.)  */
7996       if (TYPE_NEEDS_CONSTRUCTING (type)
7997           && ! already_used
7998           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7999           && DECL_NAME (decl))
8000         TREE_USED (decl) = 0;
8001       else if (already_used)
8002         TREE_USED (decl) = 1;
8003     }
8004 }
8005
8006 /* Generate code to destroy DECL (a local variable).  */
8007
8008 static void
8009 destroy_local_var (decl)
8010      tree decl;
8011 {
8012   tree type = TREE_TYPE (decl);
8013   tree cleanup;
8014
8015   /* Only variables get cleaned up.  */
8016   if (TREE_CODE (decl) != VAR_DECL)
8017     return;
8018
8019   /* And only things with destructors need cleaning up.  */
8020   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
8021     return;
8022
8023   if (TREE_CODE (decl) == VAR_DECL &&
8024       (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
8025     /* We don't clean up things that aren't defined in this
8026        translation unit, or that need a static cleanup.  The latter
8027        are handled by finish_file.  */
8028     return;
8029
8030   /* Compute the cleanup.  */
8031   cleanup = maybe_build_cleanup (decl);
8032
8033   /* Record the cleanup required for this declaration.  */
8034   if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
8035       && cleanup)
8036     finish_decl_cleanup (decl, cleanup);
8037 }
8038
8039 /* Let the back-end know about DECL.  */
8040
8041 void
8042 emit_local_var (decl)
8043      tree decl;
8044 {
8045   /* Create RTL for this variable.  */
8046   if (DECL_RTL (decl))
8047     /* Only a RESULT_DECL should have non-NULL RTL when arriving here.
8048        All other local variables are assigned RTL in this function.  */
8049     my_friendly_assert (TREE_CODE (decl) == RESULT_DECL,
8050                         19990828);
8051   else
8052     {
8053       if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
8054         /* The user must have specified an assembler name for this
8055            variable.  Set that up now.  */
8056         rest_of_decl_compilation
8057           (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
8058            /*top_level=*/0, /*at_end=*/0);
8059       else
8060         expand_decl (decl);
8061     }
8062
8063   /* Actually do the initialization.  */
8064   if (stmts_are_full_exprs_p)
8065     expand_start_target_temps ();
8066
8067   expand_decl_init (decl);
8068
8069   if (stmts_are_full_exprs_p)
8070     expand_end_target_temps ();
8071 }
8072
8073 /* Finish processing of a declaration;
8074    install its line number and initial value.
8075    If the length of an array type is not known before,
8076    it must be determined now, from the initial value, or it is an error.
8077
8078    INIT0 holds the value of an initializer that should be allowed to escape
8079    the normal rules.
8080
8081    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8082    if the (init) syntax was used.  */
8083
8084 void
8085 cp_finish_decl (decl, init, asmspec_tree, flags)
8086      tree decl, init;
8087      tree asmspec_tree;
8088      int flags;
8089 {
8090   register tree type;
8091   tree ttype = NULL_TREE;
8092   const char *asmspec = NULL;
8093   int was_readonly = 0;
8094
8095   if (! decl)
8096     {
8097       if (init)
8098         error ("assignment (not initialization) in declaration");
8099       return;
8100     }
8101
8102   /* If a name was specified, get the string.  */
8103   if (asmspec_tree)
8104       asmspec = TREE_STRING_POINTER (asmspec_tree);
8105
8106   if (init && TREE_CODE (init) == NAMESPACE_DECL)
8107     {
8108       cp_error ("cannot initialize `%D' to namespace `%D'",
8109                 decl, init);
8110       init = NULL_TREE;
8111     }
8112
8113   if (current_class_type
8114       && CP_DECL_CONTEXT (decl) == current_class_type
8115       && TYPE_BEING_DEFINED (current_class_type)
8116       && (DECL_INITIAL (decl) || init))
8117     DECL_DEFINED_IN_CLASS_P (decl) = 1;
8118
8119   if (TREE_CODE (decl) == VAR_DECL
8120       && DECL_CONTEXT (decl)
8121       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8122       && DECL_CONTEXT (decl) != current_namespace
8123       && init)
8124     {
8125       /* Leave the namespace of the object. */
8126       pop_decl_namespace ();
8127     }
8128
8129   type = TREE_TYPE (decl);
8130
8131   if (type == error_mark_node)
8132     return;
8133
8134   /* Add this declaration to the statement-tree.  */
8135   if (building_stmt_tree () && at_function_scope_p ())
8136     add_decl_stmt (decl);
8137
8138   if (TYPE_HAS_MUTABLE_P (type))
8139     TREE_READONLY (decl) = 0;
8140
8141   if (processing_template_decl)
8142     {
8143       if (init && DECL_INITIAL (decl))
8144         DECL_INITIAL (decl) = init;
8145       goto finish_end0;
8146     }
8147
8148   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
8149   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8150
8151   /* Take care of TYPE_DECLs up front.  */
8152   if (TREE_CODE (decl) == TYPE_DECL)
8153     {
8154       if (init && DECL_INITIAL (decl))
8155         {
8156           /* typedef foo = bar; store the type of bar as the type of foo.  */
8157           TREE_TYPE (decl) = type = TREE_TYPE (init);
8158           DECL_INITIAL (decl) = init = NULL_TREE;
8159         }
8160       if (type != error_mark_node
8161           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8162         {
8163           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8164             cp_warning ("shadowing previous type declaration of `%#D'", decl);
8165           set_identifier_type_value (DECL_NAME (decl), type);
8166           CLASSTYPE_GOT_SEMICOLON (type) = 1;
8167         }
8168       GNU_xref_decl (current_function_decl, decl);
8169
8170       /* If we have installed this as the canonical typedef for this
8171          type, and that type has not been defined yet, delay emitting
8172          the debug information for it, as we will emit it later.  */
8173       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8174           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8175         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8176
8177       rest_of_decl_compilation (decl, NULL_PTR,
8178                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8179       goto finish_end;
8180     }
8181
8182   if (TREE_CODE (decl) != FUNCTION_DECL)
8183     ttype = target_type (type);
8184
8185   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8186       && TYPE_NEEDS_CONSTRUCTING (type))
8187     {
8188       /* Currently, GNU C++ puts constants in text space, making them
8189          impossible to initialize.  In the future, one would hope for
8190          an operating system which understood the difference between
8191          initialization and the running of a program.  */
8192       was_readonly = 1;
8193       TREE_READONLY (decl) = 0;
8194     }
8195
8196   if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8197     {
8198       /* This must override the asm specifier which was placed by
8199          grokclassfn.  Lay this out fresh.  */
8200       DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8201       DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8202       make_decl_rtl (decl, asmspec, 0);
8203     }
8204
8205   /* Deduce size of array from initialization, if not already known.  */
8206   maybe_deduce_size_from_array_init (decl, init);
8207   init = check_initializer (decl, init);
8208
8209   GNU_xref_decl (current_function_decl, decl);
8210
8211   if (TREE_CODE (decl) == VAR_DECL)
8212     layout_var_decl (decl);
8213
8214   /* Output the assembler code and/or RTL code for variables and functions,
8215      unless the type is an undefined structure or union.
8216      If not, it will get done when the type is completed.  */
8217   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8218       || TREE_CODE (decl) == RESULT_DECL)
8219     {
8220       if (TREE_CODE (decl) == VAR_DECL)
8221         maybe_commonize_var (decl);
8222
8223       make_rtl_for_nonlocal_decl (decl, init, asmspec);
8224
8225       if (TREE_CODE (type) == FUNCTION_TYPE
8226           || TREE_CODE (type) == METHOD_TYPE)
8227         abstract_virtuals_error (decl,
8228                                  strip_array_types (TREE_TYPE (type)));
8229       else
8230         abstract_virtuals_error (decl, strip_array_types (type));
8231
8232       if (TREE_CODE (decl) == FUNCTION_DECL)
8233         ;
8234       else if (DECL_EXTERNAL (decl)
8235                && ! (DECL_LANG_SPECIFIC (decl)
8236                      && DECL_NOT_REALLY_EXTERN (decl)))
8237         {
8238           if (init)
8239             DECL_INITIAL (decl) = init;
8240         }
8241       else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8242         {
8243           /* This is a local declaration.  */
8244           if (doing_semantic_analysis_p ())
8245             maybe_inject_for_scope_var (decl);
8246           /* Initialize the local variable.  But, if we're building a
8247              statement-tree, we'll do the initialization when we
8248              expand the tree.  */
8249           if (processing_template_decl)
8250             {
8251               if (init || DECL_INITIAL (decl) == error_mark_node)
8252                 DECL_INITIAL (decl) = init;
8253             }
8254           else
8255             {
8256               /* If we're not building RTL, then we need to do so
8257                  now.  */
8258               if (!building_stmt_tree ())
8259                 emit_local_var (decl);
8260               /* Initialize the variable.  */
8261               initialize_local_var (decl, init, flags);
8262               /* Clean up the variable.  */
8263               destroy_local_var (decl);
8264             }
8265         }
8266       else if (TREE_STATIC (decl) && type != error_mark_node)
8267         {
8268           /* Cleanups for static variables are handled by `finish_file'.  */
8269           if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8270               || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8271             expand_static_init (decl, init);
8272         }
8273     finish_end0:
8274
8275       /* Undo call to `pushclass' that was done in `start_decl'
8276          due to initialization of qualified member variable.
8277          I.e., Foo::x = 10;  */
8278       {
8279         tree context = CP_DECL_CONTEXT (decl);
8280         if (context
8281             && TYPE_P (context)
8282             && (TREE_CODE (decl) == VAR_DECL
8283                 /* We also have a pushclass done that we need to undo here
8284                    if we're at top level and declare a method.  */
8285                 || TREE_CODE (decl) == FUNCTION_DECL)
8286             /* If size hasn't been set, we're still defining it,
8287                and therefore inside the class body; don't pop
8288                the binding level..  */
8289             && COMPLETE_TYPE_P (context)
8290             && context == current_class_type)
8291           pop_nested_class ();
8292       }
8293     }
8294
8295  finish_end:
8296
8297   if (was_readonly)
8298     TREE_READONLY (decl) = 1;
8299 }
8300
8301 /* This is here for a midend callback from c-common.c */
8302
8303 void
8304 finish_decl (decl, init, asmspec_tree)
8305      tree decl, init;
8306      tree asmspec_tree;
8307 {
8308   cp_finish_decl (decl, init, asmspec_tree, 0);
8309 }
8310
8311 /* Returns a declaration for a VAR_DECL as if:
8312
8313      extern "C" TYPE NAME;
8314
8315    had been seen.  Used to create compiler-generated global
8316    variables.  */
8317
8318 tree
8319 declare_global_var (name, type)
8320      tree name;
8321      tree type;
8322 {
8323   tree decl;
8324
8325   push_to_top_level ();
8326   decl = build_decl (VAR_DECL, name, type);
8327   TREE_PUBLIC (decl) = 1;
8328   DECL_EXTERNAL (decl) = 1;
8329   DECL_ARTIFICIAL (decl) = 1;
8330   pushdecl (decl);
8331   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8332   pop_from_top_level ();
8333
8334   return decl;
8335 }
8336
8337 /* Returns a pointer to the `atexit' function.  Note that if
8338    FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8339    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
8340
8341 static tree
8342 get_atexit_node ()
8343 {
8344   tree atexit_fndecl;
8345   tree arg_types;
8346   tree fn_type;
8347   tree fn_ptr_type;
8348   const char *name;
8349
8350   if (atexit_node)
8351     return atexit_node;
8352
8353   if (flag_use_cxa_atexit)
8354     {
8355       /* The declaration for `__cxa_atexit' is:
8356
8357            int __cxa_atexit (void (*)(void *), void *, void *)
8358
8359          We build up the argument types and then then function type
8360          itself.  */
8361
8362       /* First, build the pointer-to-function type for the first
8363          argument.  */
8364       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8365       fn_type = build_function_type (void_type_node, arg_types);
8366       fn_ptr_type = build_pointer_type (fn_type);
8367       /* Then, build the rest of the argument types.  */
8368       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8369       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8370       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8371       /* And the final __cxa_atexit type.  */
8372       fn_type = build_function_type (integer_type_node, arg_types);
8373       fn_ptr_type = build_pointer_type (fn_type);
8374       name = "__cxa_atexit";
8375     }
8376   else
8377     {
8378       /* The declaration for `atexit' is:
8379
8380            int atexit (void (*)());
8381
8382          We build up the argument types and then then function type
8383          itself.  */
8384       fn_type = build_function_type (void_type_node, void_list_node);
8385       fn_ptr_type = build_pointer_type (fn_type);
8386       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8387       /* Build the final atexit type.  */
8388       fn_type = build_function_type (integer_type_node, arg_types);
8389       name = "atexit";
8390     }
8391
8392   /* Now, build the function declaration.  */
8393   push_lang_context (lang_name_c);
8394   atexit_fndecl = build_library_fn_ptr (name, fn_type);
8395   mark_used (atexit_fndecl);
8396   pop_lang_context ();
8397   atexit_node = default_conversion (atexit_fndecl);
8398
8399   return atexit_node;
8400 }
8401
8402 /* Returns the __dso_handle VAR_DECL.  */
8403
8404 static tree
8405 get_dso_handle_node ()
8406 {
8407   if (dso_handle_node)
8408     return dso_handle_node;
8409
8410   /* Declare the variable.  */
8411   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8412                                         ptr_type_node);
8413
8414   return dso_handle_node;
8415 }
8416
8417 /* Begin a new function with internal linkage whose job will be simply
8418    to destroy some particular variable.  */
8419
8420 static tree
8421 start_cleanup_fn ()
8422 {
8423   static int counter = 0;
8424   int old_interface_unknown = interface_unknown;
8425   char name[32];
8426   tree parmtypes;
8427   tree fntype;
8428   tree fndecl;
8429
8430   push_to_top_level ();
8431
8432   /* No need to mangle this.  */
8433   push_lang_context (lang_name_c);
8434
8435   interface_unknown = 1;
8436
8437   /* Build the parameter-types.  */
8438   parmtypes = void_list_node;
8439   /* Functions passed to __cxa_atexit take an additional parameter.
8440      We'll just ignore it.  After we implement the new calling
8441      convention for destructors, we can eliminate the use of
8442      additional cleanup functions entirely in the -fnew-abi case.  */
8443   if (flag_use_cxa_atexit)
8444     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8445   /* Build the function type itself.  */
8446   fntype = build_function_type (void_type_node, parmtypes);
8447   /* Build the name of the function.  */
8448   sprintf (name, "__tcf_%d", counter++);
8449   /* Build the function declaration.  */
8450   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8451   /* It's a function with internal linkage, generated by the
8452      compiler.  */
8453   TREE_PUBLIC (fndecl) = 0;
8454   DECL_ARTIFICIAL (fndecl) = 1;
8455   /* Build the parameter.  */
8456   if (flag_use_cxa_atexit)
8457     {
8458       tree parmdecl;
8459
8460       parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8461       DECL_CONTEXT (parmdecl) = fndecl;
8462       DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8463       TREE_USED (parmdecl) = 1;
8464       DECL_ARGUMENTS (fndecl) = parmdecl;
8465     }
8466
8467   pushdecl (fndecl);
8468   start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8469   do_pushlevel ();
8470
8471   interface_unknown = old_interface_unknown;
8472
8473   pop_lang_context ();
8474
8475   return current_function_decl;
8476 }
8477
8478 /* Finish the cleanup function begun by start_cleanup_fn.  */
8479
8480 static void
8481 end_cleanup_fn ()
8482 {
8483   do_poplevel ();
8484
8485   expand_body (finish_function (0));
8486
8487   pop_from_top_level ();
8488 }
8489
8490 /* Generate code to handle the destruction of DECL, an object with
8491    static storage duration.  */
8492
8493 void
8494 register_dtor_fn (decl)
8495      tree decl;
8496 {
8497   tree cleanup;
8498   tree compound_stmt;
8499   tree args;
8500   tree fcall;
8501
8502   int saved_flag_access_control;
8503
8504   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8505     return;
8506
8507   /* Call build_cleanup before we enter the anonymous function so that
8508      any access checks will be done relative to the current scope,
8509      rather than the scope of the anonymous function.  */
8510   build_cleanup (decl);
8511
8512   /* Now start the function.  */
8513   cleanup = start_cleanup_fn ();
8514
8515   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
8516      to the original function, rather than the anonymous one.  That
8517      will make the back-end think that nested functions are in use,
8518      which causes confusion.  */
8519   saved_flag_access_control = flag_access_control;
8520   flag_access_control = 0;
8521   fcall = build_cleanup (decl);
8522   flag_access_control = saved_flag_access_control;
8523
8524   /* Create the body of the anonymous function.  */
8525   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8526   finish_expr_stmt (fcall);
8527   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8528   end_cleanup_fn ();
8529
8530   /* Call atexit with the cleanup function.  */
8531   mark_addressable (cleanup);
8532   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8533   if (flag_use_cxa_atexit)
8534     {
8535       args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8536       args = tree_cons (NULL_TREE, null_pointer_node, args);
8537       args = tree_cons (NULL_TREE, cleanup, args);
8538     }
8539   else
8540     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8541   finish_expr_stmt (build_function_call (get_atexit_node (), args));
8542 }
8543
8544 void
8545 expand_static_init (decl, init)
8546      tree decl;
8547      tree init;
8548 {
8549   tree oldstatic = value_member (decl, static_aggregates);
8550
8551   if (oldstatic)
8552     {
8553       if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8554         cp_error ("multiple initializations given for `%D'", decl);
8555     }
8556   else if (! toplevel_bindings_p ())
8557     {
8558       /* Emit code to perform this initialization but once.  */
8559       tree temp;
8560       tree if_stmt;
8561       tree then_clause;
8562       tree assignment;
8563       tree temp_init;
8564
8565       /* Emit code to perform this initialization but once.  This code
8566          looks like:
8567
8568            static int temp = 0;
8569            if (!temp) {
8570              // Do initialization.
8571              temp = 1;
8572              // Register variable for destruction at end of program.
8573            }
8574
8575          Note that the `temp' variable is only set to 1 *after* the
8576          initialization is complete.  This ensures that an exception,
8577          thrown during the construction, will cause the variable to
8578          reinitialized when we pass through this code again, as per:
8579
8580            [stmt.dcl]
8581
8582            If the initialization exits by throwing an exception, the
8583            initialization is not complete, so it will be tried again
8584            the next time control enters the declaration.
8585
8586          In theory, this process should be thread-safe, too; multiple
8587          threads should not be able to initialize the variable more
8588          than once.  We don't yet attempt to ensure thread-safety.  */
8589       temp = get_temp_name (integer_type_node, 1);
8590       rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
8591
8592       /* Begin the conditional initialization.  */
8593       if_stmt = begin_if_stmt ();
8594       finish_if_stmt_cond (build_binary_op (EQ_EXPR, temp,
8595                                             integer_zero_node),
8596                            if_stmt);
8597       then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8598
8599       /* Do the initialization itself.  */
8600       if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8601           || (init && TREE_CODE (init) == TREE_LIST))
8602         assignment = build_aggr_init (decl, init, 0);
8603       else if (init)
8604         /* The initialization we're doing here is just a bitwise
8605            copy.  */
8606         assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8607       else
8608         assignment = NULL_TREE;
8609
8610       /* Once the assignment is complete, set TEMP to 1.  Since the
8611          construction of the static object is complete at this point,
8612          we want to make sure TEMP is set to 1 even if a temporary
8613          constructed during the initialization throws an exception
8614          when it is destroyed.  So, we combine the initialization and
8615          the assignment to TEMP into a single expression, ensuring
8616          that when we call finish_expr_stmt the cleanups will not be
8617          run until after TEMP is set to 1.  */
8618       temp_init = build_modify_expr (temp, NOP_EXPR, integer_one_node);
8619       if (assignment)
8620         {
8621           assignment = tree_cons (NULL_TREE, assignment,
8622                                   build_tree_list (NULL_TREE,
8623                                                    temp_init));
8624           assignment = build_compound_expr (assignment);
8625         }
8626       else
8627         assignment = temp_init;
8628       finish_expr_stmt (assignment);
8629
8630       /* Use atexit to register a function for destroying this static
8631          variable.  */
8632       register_dtor_fn (decl);
8633
8634       finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8635       finish_then_clause (if_stmt);
8636       finish_if_stmt ();
8637     }
8638   else
8639     static_aggregates = tree_cons (init, decl, static_aggregates);
8640 }
8641
8642 /* Finish the declaration of a catch-parameter.  */
8643
8644 tree
8645 start_handler_parms (declspecs, declarator)
8646      tree declspecs;
8647      tree declarator;
8648 {
8649   tree decl;
8650   if (declspecs)
8651     {
8652       decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8653                              1, NULL_TREE);
8654       if (decl == NULL_TREE)
8655         error ("invalid catch parameter");
8656     }
8657   else
8658     decl = NULL_TREE;
8659
8660   return decl;
8661 }
8662
8663 \f
8664 /* Make TYPE a complete type based on INITIAL_VALUE.
8665    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8666    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
8667
8668 int
8669 complete_array_type (type, initial_value, do_default)
8670      tree type, initial_value;
8671      int do_default;
8672 {
8673   register tree maxindex = NULL_TREE;
8674   int value = 0;
8675
8676   if (initial_value)
8677     {
8678       /* Note MAXINDEX  is really the maximum index,
8679          one less than the size.  */
8680       if (TREE_CODE (initial_value) == STRING_CST)
8681         {
8682           int eltsize
8683             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8684           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8685                                    / eltsize) - 1, 0);
8686         }
8687       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8688         {
8689           tree elts = CONSTRUCTOR_ELTS (initial_value);
8690
8691           maxindex = ssize_int (-1);
8692           for (; elts; elts = TREE_CHAIN (elts))
8693             {
8694               if (TREE_PURPOSE (elts))
8695                 maxindex = TREE_PURPOSE (elts);
8696               else
8697                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8698             }
8699           maxindex = copy_node (maxindex);
8700         }
8701       else
8702         {
8703           /* Make an error message unless that happened already.  */
8704           if (initial_value != error_mark_node)
8705             value = 1;
8706           else
8707             initial_value = NULL_TREE;
8708
8709           /* Prevent further error messages.  */
8710           maxindex = build_int_2 (0, 0);
8711         }
8712     }
8713
8714   if (!maxindex)
8715     {
8716       if (do_default)
8717         maxindex = build_int_2 (0, 0);
8718       value = 2;
8719     }
8720
8721   if (maxindex)
8722     {
8723       tree itype;
8724       tree domain;
8725
8726       domain = build_index_type (maxindex);
8727       TYPE_DOMAIN (type) = domain;
8728
8729       if (! TREE_TYPE (maxindex))
8730         TREE_TYPE (maxindex) = domain;
8731       if (initial_value)
8732         itype = TREE_TYPE (initial_value);
8733       else
8734         itype = NULL;
8735       if (itype && !TYPE_DOMAIN (itype))
8736         TYPE_DOMAIN (itype) = domain;
8737       /* The type of the main variant should never be used for arrays
8738          of different sizes.  It should only ever be completed with the
8739          size of the array.  */
8740       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8741         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8742     }
8743
8744   /* Lay out the type now that we can get the real answer.  */
8745
8746   layout_type (type);
8747
8748   return value;
8749 }
8750 \f
8751 /* Return zero if something is declared to be a member of type
8752    CTYPE when in the context of CUR_TYPE.  STRING is the error
8753    message to print in that case.  Otherwise, quietly return 1.  */
8754
8755 static int
8756 member_function_or_else (ctype, cur_type, flags)
8757      tree ctype, cur_type;
8758      enum overload_flags flags;
8759 {
8760   if (ctype && ctype != cur_type)
8761     {
8762       if (flags == DTOR_FLAG)
8763         error ("destructor for alien class `%s' cannot be a member",
8764                TYPE_NAME_STRING (ctype));
8765       else
8766         error ("constructor for alien class `%s' cannot be a member",
8767                TYPE_NAME_STRING (ctype));
8768       return 0;
8769     }
8770   return 1;
8771 }
8772 \f
8773 /* Subroutine of `grokdeclarator'.  */
8774
8775 /* Generate errors possibly applicable for a given set of specifiers.
8776    This is for ARM $7.1.2.  */
8777
8778 static void
8779 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8780      tree object;
8781      const char *type;
8782      int virtualp, quals, friendp, raises, inlinep;
8783 {
8784   if (virtualp)
8785     cp_error ("`%D' declared as a `virtual' %s", object, type);
8786   if (inlinep)
8787     cp_error ("`%D' declared as an `inline' %s", object, type);
8788   if (quals)
8789     cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8790               object, type);
8791   if (friendp)
8792     cp_error_at ("`%D' declared as a friend", object);
8793   if (raises)
8794     cp_error_at ("`%D' declared with an exception specification", object);
8795 }
8796
8797 /* CTYPE is class type, or null if non-class.
8798    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8799    or METHOD_TYPE.
8800    DECLARATOR is the function's name.
8801    VIRTUALP is truthvalue of whether the function is virtual or not.
8802    FLAGS are to be passed through to `grokclassfn'.
8803    QUALS are qualifiers indicating whether the function is `const'
8804    or `volatile'.
8805    RAISES is a list of exceptions that this function can raise.
8806    CHECK is 1 if we must find this method in CTYPE, 0 if we should
8807    not look, and -1 if we should not call `grokclassfn' at all.
8808
8809    Returns `NULL_TREE' if something goes wrong, after issuing
8810    applicable error messages.  */
8811
8812 static tree
8813 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8814             raises, check, friendp, publicp, inlinep, funcdef_flag,
8815             template_count, in_namespace)
8816      tree ctype, type;
8817      tree declarator;
8818      tree orig_declarator;
8819      int virtualp;
8820      enum overload_flags flags;
8821      tree quals, raises;
8822      int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8823      tree in_namespace;
8824 {
8825   tree cname, decl;
8826   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8827   int has_default_arg = 0;
8828   tree t;
8829
8830   if (ctype)
8831     cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8832       ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8833   else
8834     cname = NULL_TREE;
8835
8836   if (raises)
8837     {
8838       type = build_exception_variant (type, raises);
8839     }
8840
8841   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8842   /* Propagate volatile out from type to decl. */
8843   if (TYPE_VOLATILE (type))
8844     TREE_THIS_VOLATILE (decl) = 1;
8845
8846   /* If this decl has namespace scope, set that up.  */
8847   if (in_namespace)
8848     set_decl_namespace (decl, in_namespace, friendp);
8849   else if (publicp && ! ctype)
8850     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8851
8852   /* `main' and builtins have implicit 'C' linkage.  */
8853   if ((MAIN_NAME_P (declarator)
8854        || (IDENTIFIER_LENGTH (declarator) > 10
8855            && IDENTIFIER_POINTER (declarator)[0] == '_'
8856            && IDENTIFIER_POINTER (declarator)[1] == '_'
8857            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8858       && current_lang_name == lang_name_cplusplus
8859       && ctype == NULL_TREE
8860       /* NULL_TREE means global namespace.  */
8861       && DECL_CONTEXT (decl) == NULL_TREE)
8862     DECL_LANGUAGE (decl) = lang_c;
8863
8864   /* Should probably propagate const out from type to decl I bet (mrs).  */
8865   if (staticp)
8866     {
8867       DECL_STATIC_FUNCTION_P (decl) = 1;
8868       DECL_CONTEXT (decl) = ctype;
8869     }
8870
8871   if (ctype)
8872     DECL_CONTEXT (decl) = ctype;
8873
8874   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8875     {
8876       if (processing_template_decl)
8877         error ("cannot declare `::main' to be a template");
8878       if (inlinep)
8879         error ("cannot declare `::main' to be inline");
8880       else if (! publicp)
8881         error ("cannot declare `::main' to be static");
8882       inlinep = 0;
8883       publicp = 1;
8884     }
8885
8886   /* Members of anonymous types and local classes have no linkage; make
8887      them internal.  */
8888   if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8889                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8890     publicp = 0;
8891
8892   if (publicp)
8893     {
8894       /* [basic.link]: A name with no linkage (notably, the name of a class
8895          or enumeration declared in a local scope) shall not be used to
8896          declare an entity with linkage.
8897
8898          Only check this for public decls for now.  */
8899       t = no_linkage_check (TREE_TYPE (decl));
8900       if (t)
8901         {
8902           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8903             {
8904               if (DECL_EXTERN_C_P (decl))
8905                 /* Allow this; it's pretty common in C.  */;
8906               else
8907                 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8908                             decl);
8909             }
8910           else
8911             cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8912                         decl, t);
8913         }
8914     }
8915
8916   TREE_PUBLIC (decl) = publicp;
8917   if (! publicp)
8918     {
8919       DECL_INTERFACE_KNOWN (decl) = 1;
8920       DECL_NOT_REALLY_EXTERN (decl) = 1;
8921     }
8922
8923   if (inlinep)
8924     DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8925
8926   DECL_EXTERNAL (decl) = 1;
8927   if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8928     {
8929       cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8930                 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8931       quals = NULL_TREE;
8932     }
8933
8934   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8935     grok_op_properties (decl, virtualp, check < 0);
8936
8937   if (ctype && decl_function_context (decl))
8938     DECL_NO_STATIC_CHAIN (decl) = 1;
8939
8940   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8941     if (TREE_PURPOSE (t)
8942         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8943       {
8944         has_default_arg = 1;
8945         break;
8946       }
8947
8948   if (friendp
8949       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8950     {
8951       if (funcdef_flag)
8952         cp_error
8953           ("defining explicit specialization `%D' in friend declaration",
8954            orig_declarator);
8955       else
8956         {
8957           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8958             {
8959               /* Something like `template <class T> friend void f<T>()'.  */
8960               cp_error ("invalid use of template-id `%D' in declaration of primary template",
8961                         orig_declarator);
8962               return NULL_TREE;
8963             }
8964
8965
8966           /* A friend declaration of the form friend void f<>().  Record
8967              the information in the TEMPLATE_ID_EXPR.  */
8968           SET_DECL_IMPLICIT_INSTANTIATION (decl);
8969           DECL_TEMPLATE_INFO (decl)
8970             = tree_cons (TREE_OPERAND (orig_declarator, 0),
8971                          TREE_OPERAND (orig_declarator, 1),
8972                          NULL_TREE);
8973
8974           if (has_default_arg)
8975             {
8976               cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8977                         decl);
8978               return NULL_TREE;
8979             }
8980
8981           if (inlinep)
8982             {
8983               cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8984                         decl);
8985               return NULL_TREE;
8986             }
8987         }
8988     }
8989
8990   if (has_default_arg)
8991     add_defarg_fn (decl);
8992
8993   /* Plain overloading: will not be grok'd by grokclassfn.  */
8994   if (! ctype && ! processing_template_decl
8995       && !DECL_EXTERN_C_P (decl)
8996       && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8997     set_mangled_name_for_decl (decl);
8998
8999   if (funcdef_flag)
9000     /* Make the init_value nonzero so pushdecl knows this is not
9001        tentative.  error_mark_node is replaced later with the BLOCK.  */
9002     DECL_INITIAL (decl) = error_mark_node;
9003
9004   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
9005     TREE_NOTHROW (decl) = 1;
9006
9007   /* Caller will do the rest of this.  */
9008   if (check < 0)
9009     return decl;
9010
9011   if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
9012     DECL_CONSTRUCTOR_P (decl) = 1;
9013
9014   /* Function gets the ugly name, field gets the nice one.  This call
9015      may change the type of the function (because of default
9016      parameters)!  */
9017   if (ctype != NULL_TREE)
9018     grokclassfn (ctype, decl, flags, quals);
9019
9020   decl = check_explicit_specialization (orig_declarator, decl,
9021                                         template_count,
9022                                         2 * (funcdef_flag != 0) +
9023                                         4 * (friendp != 0));
9024   if (decl == error_mark_node)
9025     return NULL_TREE;
9026
9027   if (ctype != NULL_TREE
9028       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9029       && check)
9030     {
9031       tree old_decl;
9032
9033       old_decl = check_classfn (ctype, decl);
9034
9035       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9036         /* Because grokfndecl is always supposed to return a
9037            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9038            here.  We depend on our callers to figure out that its
9039            really a template that's being returned.  */
9040         old_decl = DECL_TEMPLATE_RESULT (old_decl);
9041
9042       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9043           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9044         {
9045           /* Remove the `this' parm added by grokclassfn.
9046              XXX Isn't this done in start_function, too?  */
9047           revert_static_member_fn (decl);
9048           last_function_parms = TREE_CHAIN (last_function_parms);
9049         }
9050       if (old_decl && DECL_ARTIFICIAL (old_decl))
9051         cp_error ("definition of implicitly-declared `%D'", old_decl);
9052
9053       if (old_decl)
9054         {
9055           /* Since we've smashed OLD_DECL to its
9056              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
9057           if (TREE_CODE (decl) == TEMPLATE_DECL)
9058             decl = DECL_TEMPLATE_RESULT (decl);
9059
9060           /* Attempt to merge the declarations.  This can fail, in
9061              the case of some illegal specialization declarations.  */
9062           if (!duplicate_decls (decl, old_decl))
9063             cp_error ("no `%#D' member function declared in class `%T'",
9064                       decl, ctype);
9065           return old_decl;
9066         }
9067     }
9068
9069   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9070     return NULL_TREE;
9071
9072   if (ctype == NULL_TREE || check)
9073     return decl;
9074
9075   if (virtualp)
9076     {
9077       DECL_VIRTUAL_P (decl) = 1;
9078       if (DECL_VINDEX (decl) == NULL_TREE)
9079         DECL_VINDEX (decl) = error_mark_node;
9080       IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
9081     }
9082
9083   return decl;
9084 }
9085
9086 static tree
9087 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
9088      tree type;
9089      tree declarator;
9090      RID_BIT_TYPE *specbits_in;
9091      int initialized;
9092      int constp;
9093      tree in_namespace;
9094 {
9095   tree decl;
9096   RID_BIT_TYPE specbits;
9097
9098   specbits = *specbits_in;
9099
9100   if (TREE_CODE (type) == OFFSET_TYPE)
9101     {
9102       /* If you declare a static member so that it
9103          can be initialized, the code will reach here.  */
9104       tree basetype = TYPE_OFFSET_BASETYPE (type);
9105       type = TREE_TYPE (type);
9106       decl = build_lang_decl (VAR_DECL, declarator, type);
9107       DECL_CONTEXT (decl) = basetype;
9108       /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
9109          templates.  */
9110       if (!uses_template_parms (decl))
9111         {
9112           if (flag_new_abi)
9113             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9114           else
9115             DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype,
9116                                                             declarator);
9117         }
9118     }
9119   else
9120     {
9121       tree context;
9122
9123       if (in_namespace)
9124         context = in_namespace;
9125       else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
9126         context = current_namespace;
9127       else
9128         context = NULL_TREE;
9129
9130       if (processing_template_decl && context)
9131         /* For global variables, declared in a template, we need the
9132            full lang_decl.  */
9133         decl = build_lang_decl (VAR_DECL, declarator, type);
9134       else
9135         decl = build_decl (VAR_DECL, declarator, type);
9136
9137       if (context)
9138         set_decl_namespace (decl, context, 0);
9139
9140       context = DECL_CONTEXT (decl);
9141       if (declarator && context && current_lang_name != lang_name_c)
9142         {
9143           if (flag_new_abi)
9144             DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
9145           else
9146             DECL_ASSEMBLER_NAME (decl)
9147               = build_static_name (context, declarator);
9148         }
9149     }
9150
9151   if (in_namespace)
9152     set_decl_namespace (decl, in_namespace, 0);
9153
9154   if (RIDBIT_SETP (RID_EXTERN, specbits))
9155     {
9156       DECL_THIS_EXTERN (decl) = 1;
9157       DECL_EXTERNAL (decl) = !initialized;
9158     }
9159
9160   /* In class context, static means one per class,
9161      public access, and static storage.  */
9162   if (DECL_CLASS_SCOPE_P (decl))
9163     {
9164       TREE_PUBLIC (decl) = 1;
9165       TREE_STATIC (decl) = 1;
9166       DECL_EXTERNAL (decl) = 0;
9167     }
9168   /* At top level, either `static' or no s.c. makes a definition
9169      (perhaps tentative), and absence of `static' makes it public.  */
9170   else if (toplevel_bindings_p ())
9171     {
9172       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9173                             && (DECL_THIS_EXTERN (decl) || ! constp));
9174       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9175     }
9176   /* Not at top level, only `static' makes a static definition.  */
9177   else
9178     {
9179       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9180       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9181     }
9182
9183   if (TREE_PUBLIC (decl))
9184     {
9185       /* [basic.link]: A name with no linkage (notably, the name of a class
9186          or enumeration declared in a local scope) shall not be used to
9187          declare an entity with linkage.
9188
9189          Only check this for public decls for now.  */
9190       tree t = no_linkage_check (TREE_TYPE (decl));
9191       if (t)
9192         {
9193           if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9194             /* Ignore for now; `enum { foo } e' is pretty common.  */;
9195           else
9196             cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9197                         decl, t);
9198         }
9199     }
9200
9201   return decl;
9202 }
9203
9204 /* Create and return a canonical pointer to member function type, for
9205    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
9206
9207 tree
9208 build_ptrmemfunc_type (type)
9209      tree type;
9210 {
9211   tree fields[4];
9212   tree t;
9213   tree u;
9214   tree unqualified_variant = NULL_TREE;
9215
9216   /* If a canonical type already exists for this type, use it.  We use
9217      this method instead of type_hash_canon, because it only does a
9218      simple equality check on the list of field members.  */
9219
9220   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9221     return t;
9222
9223   /* Make sure that we always have the unqualified pointer-to-member
9224      type first.  */
9225   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9226     unqualified_variant
9227       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9228
9229   t = make_aggr_type (RECORD_TYPE);
9230   /* Let the front-end know this is a pointer to member function...  */
9231   TYPE_PTRMEMFUNC_FLAG (t) = 1;
9232   /* ... and not really an aggregate.  */
9233   SET_IS_AGGR_TYPE (t, 0);
9234
9235   if (!flag_new_abi)
9236     {
9237       u = make_aggr_type (UNION_TYPE);
9238       SET_IS_AGGR_TYPE (u, 0);
9239       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9240       fields[1] = build_decl (FIELD_DECL, delta2_identifier,
9241                               delta_type_node);
9242       finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9243       TYPE_NAME (u) = NULL_TREE;
9244
9245       fields[0] = build_decl (FIELD_DECL, delta_identifier,
9246                               delta_type_node);
9247       fields[1] = build_decl (FIELD_DECL, index_identifier,
9248                               delta_type_node);
9249       fields[2] = build_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9250       finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9251     }
9252   else
9253     {
9254       fields[0] = build_decl (FIELD_DECL, pfn_identifier, type);
9255       fields[1] = build_decl (FIELD_DECL, delta_identifier,
9256                               delta_type_node);
9257       finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9258     }
9259
9260   /* Zap out the name so that the back-end will give us the debugging
9261      information for this anonymous RECORD_TYPE.  */
9262   TYPE_NAME (t) = NULL_TREE;
9263
9264   /* If this is not the unqualified form of this pointer-to-member
9265      type, set the TYPE_MAIN_VARIANT for this type to be the
9266      unqualified type.  Since they are actually RECORD_TYPEs that are
9267      not variants of each other, we must do this manually.  */
9268   if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9269     {
9270       t = build_qualified_type (t, CP_TYPE_QUALS (type));
9271       TYPE_MAIN_VARIANT (t) = unqualified_variant;
9272       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9273       TYPE_NEXT_VARIANT (unqualified_variant) = t;
9274     }
9275
9276   /* Cache this pointer-to-member type so that we can find it again
9277      later.  */
9278   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9279
9280   /* Seems to be wanted.  */
9281   CLASSTYPE_GOT_SEMICOLON (t) = 1;
9282
9283   return t;
9284 }
9285
9286 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9287    Check to see that the definition is valid.  Issue appropriate error
9288    messages.  Return 1 if the definition is particularly bad, or 0
9289    otherwise.  */
9290
9291 int
9292 check_static_variable_definition (decl, type)
9293      tree decl;
9294      tree type;
9295 {
9296   /* Motion 10 at San Diego: If a static const integral data member is
9297      initialized with an integral constant expression, the initializer
9298      may appear either in the declaration (within the class), or in
9299      the definition, but not both.  If it appears in the class, the
9300      member is a member constant.  The file-scope definition is always
9301      required.  */
9302   if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9303     {
9304       cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9305                 type);
9306       /* If we just return the declaration, crashes will sometimes
9307          occur.  We therefore return void_type_node, as if this was a
9308          friend declaration, to cause callers to completely ignore
9309          this declaration.  */
9310       return 1;
9311     }
9312   else if (!CP_TYPE_CONST_P (type))
9313     cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9314               decl);
9315   else if (pedantic && !INTEGRAL_TYPE_P (type))
9316     cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9317
9318   return 0;
9319 }
9320
9321 /* Given the SIZE (i.e., number of elements) in an array, compute an
9322    appropriate index type for the array.  If non-NULL, NAME is the
9323    name of the thing being declared.  */
9324
9325 tree
9326 compute_array_index_type (name, size)
9327      tree name;
9328      tree size;
9329 {
9330   tree itype;
9331
9332   /* The size might be the result of a cast. */
9333   STRIP_TYPE_NOPS (size);
9334
9335   /* It might be a const variable or enumeration constant.  */
9336   size = decl_constant_value (size);
9337
9338   /* If this involves a template parameter, it will be a constant at
9339      instantiation time, but we don't know what the value is yet.
9340      Even if no template parameters are involved, we may an expression
9341      that is not a constant; we don't even simplify `1 + 2' when
9342      processing a template.  */
9343   if (processing_template_decl)
9344     {
9345       /* Resolve a qualified reference to an enumerator or static
9346          const data member of ours.  */
9347       if (TREE_CODE (size) == SCOPE_REF
9348           && TREE_OPERAND (size, 0) == current_class_type)
9349         {
9350           tree t = lookup_field (current_class_type,
9351                                  TREE_OPERAND (size, 1), 0, 0);
9352           if (t)
9353             size = t;
9354         }
9355
9356       return build_index_type (build_min (MINUS_EXPR, sizetype,
9357                                           size, integer_one_node));
9358     }
9359
9360   /* The array bound must be an integer type.  */
9361   if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9362       && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9363       && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9364     {
9365       if (name)
9366         cp_error ("size of array `%D' has non-integer type", name);
9367       else
9368         cp_error ("size of array has non-integer type");
9369       size = integer_one_node;
9370     }
9371
9372   /* Normally, the array-bound will be a constant.  */
9373   if (TREE_CONSTANT (size))
9374     {
9375       /* Check to see if the array bound overflowed.  Make that an
9376          error, no matter how generous we're being.  */
9377       int old_flag_pedantic_errors = flag_pedantic_errors;
9378       int old_pedantic = pedantic;
9379       pedantic = flag_pedantic_errors = 1;
9380       constant_expression_warning (size);
9381       pedantic = old_pedantic;
9382       flag_pedantic_errors = old_flag_pedantic_errors;
9383
9384       /* An array must have a positive number of elements.  */
9385       if (INT_CST_LT (size, integer_zero_node))
9386         {
9387           if (name)
9388             cp_error ("size of array `%D' is negative", name);
9389           else
9390             cp_error ("size of array is negative");
9391           size = integer_one_node;
9392         }
9393       /* Except that an extension we allow zero-sized arrays.  We
9394          always allow them in system headers because glibc uses
9395          them.  */
9396       else if (integer_zerop (size) && pedantic && !in_system_header)
9397         {
9398           if (name)
9399             cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9400           else
9401             cp_pedwarn ("ISO C++ forbids zero-size array");
9402         }
9403     }
9404
9405   /* Compute the index of the largest element in the array.  It is
9406      one less than the number of elements in the array.  */
9407   itype
9408     = fold (build_binary_op (MINUS_EXPR,
9409                              cp_convert (ssizetype, size),
9410                              cp_convert (ssizetype,
9411                                          integer_one_node)));
9412
9413   /* Check for variable-sized arrays.  We allow such things as an
9414      extension, even though they are not allowed in ANSI/ISO C++.  */
9415   if (!TREE_CONSTANT (itype))
9416     {
9417       if (pedantic)
9418         {
9419           if (name)
9420             cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9421                         name);
9422           else
9423             cp_pedwarn ("ISO C++ forbids variable-size array");
9424         }
9425
9426       /* Create a variable-sized array index type.  */
9427       itype = variable_size (itype);
9428     }
9429   /* Make sure that there was no overflow when creating to a signed
9430      index type.  (For example, on a 32-bit machine, an array with
9431      size 2^32 - 1 is too big.)  */
9432   else if (TREE_OVERFLOW (itype))
9433     {
9434       error ("overflow in array dimension");
9435       TREE_OVERFLOW (itype) = 0;
9436     }
9437
9438   /* Create and return the appropriate index type.  */
9439   return build_index_type (itype);
9440 }
9441
9442 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9443    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
9444    with this type.  */
9445
9446 static tree
9447 create_array_type_for_decl (name, type, size)
9448      tree name;
9449      tree type;
9450      tree size;
9451 {
9452   tree itype = NULL_TREE;
9453   const char* error_msg;
9454
9455   /* If things have already gone awry, bail now.  */
9456   if (type == error_mark_node || size == error_mark_node)
9457     return error_mark_node;
9458
9459   /* Assume that everything will go OK.  */
9460   error_msg = NULL;
9461
9462   /* There are some types which cannot be array elements.  */
9463   switch (TREE_CODE (type))
9464     {
9465     case VOID_TYPE:
9466       error_msg = "array of void";
9467       break;
9468
9469     case FUNCTION_TYPE:
9470       error_msg = "array of functions";
9471       break;
9472
9473     case REFERENCE_TYPE:
9474       error_msg = "array of references";
9475       break;
9476
9477     case OFFSET_TYPE:
9478       error_msg = "array of data members";
9479       break;
9480
9481     case METHOD_TYPE:
9482       error_msg = "array of function members";
9483       break;
9484
9485     default:
9486       break;
9487     }
9488
9489   /* If something went wrong, issue an error-message and return.  */
9490   if (error_msg)
9491     {
9492       if (name)
9493         cp_error ("declaration of `%D' as %s", name, error_msg);
9494       else
9495         cp_error ("creating %s", error_msg);
9496
9497       return error_mark_node;
9498     }
9499
9500   /* [dcl.array]
9501
9502      The constant expressions that specify the bounds of the arrays
9503      can be omitted only for the first member of the sequence.  */
9504   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9505     {
9506       cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9507                 name);
9508
9509       return error_mark_node;
9510     }
9511
9512   /* Figure out the index type for the array.  */
9513   if (size)
9514     itype = compute_array_index_type (name, size);
9515
9516   return build_cplus_array_type (type, itype);
9517 }
9518
9519 /* Check that it's OK to declare a function with the indicated TYPE.
9520    SFK indicates the kind of special function (if any) that this
9521    function is.  CTYPE is the class of which this function is a
9522    member.  OPTYPE is the type given in a conversion operator
9523    declaration.  Returns the actual return type of the function; that
9524    may be different than TYPE if an error occurs, or for certain
9525    special functions.  */
9526
9527 static tree
9528 check_special_function_return_type (sfk, type, ctype, optype)
9529      special_function_kind sfk;
9530      tree type;
9531      tree ctype;
9532      tree optype;
9533 {
9534   switch (sfk)
9535     {
9536     case sfk_constructor:
9537       if (type)
9538         cp_error ("return type specification for constructor invalid");
9539
9540       /* In the old ABI, we return `this'; in the new ABI we don't
9541          bother.  */
9542       type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9543       break;
9544
9545     case sfk_destructor:
9546       if (type)
9547         cp_error ("return type specification for destructor invalid");
9548       type = void_type_node;
9549       break;
9550
9551     case sfk_conversion:
9552       if (type && !same_type_p (type, optype))
9553         cp_error ("operator `%T' declared to return `%T'", optype, type);
9554       else if (type)
9555         cp_pedwarn ("return type specified for `operator %T'",  optype);
9556       type = optype;
9557       break;
9558
9559     default:
9560       my_friendly_abort (20000408);
9561       break;
9562     }
9563
9564   return type;
9565 }
9566
9567 /* Given declspecs and a declarator,
9568    determine the name and type of the object declared
9569    and construct a ..._DECL node for it.
9570    (In one case we can return a ..._TYPE node instead.
9571     For invalid input we sometimes return 0.)
9572
9573    DECLSPECS is a chain of tree_list nodes whose value fields
9574     are the storage classes and type specifiers.
9575
9576    DECL_CONTEXT says which syntactic context this declaration is in:
9577      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9578      FUNCDEF for a function definition.  Like NORMAL but a few different
9579       error messages in each case.  Return value may be zero meaning
9580       this definition is too screwy to try to parse.
9581      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
9582       handle member functions (which have FIELD context).
9583       Return value may be zero meaning this definition is too screwy to
9584       try to parse.
9585      PARM for a parameter declaration (either within a function prototype
9586       or before a function body).  Make a PARM_DECL, or return void_type_node.
9587      CATCHPARM for a parameter declaration before a catch clause.
9588      TYPENAME if for a typename (in a cast or sizeof).
9589       Don't make a DECL node; just return the ..._TYPE node.
9590      FIELD for a struct or union field; make a FIELD_DECL.
9591      BITFIELD for a field with specified width.
9592    INITIALIZED is 1 if the decl has an initializer.
9593
9594    ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9595    normal attributes in TREE_PURPOSE, or NULL_TREE.
9596
9597    In the TYPENAME case, DECLARATOR is really an abstract declarator.
9598    It may also be so in the PARM case, for a prototype where the
9599    argument type is specified but not the name.
9600
9601    This function is where the complicated C meanings of `static'
9602    and `extern' are interpreted.
9603
9604    For C++, if there is any monkey business to do, the function which
9605    calls this one must do it, i.e., prepending instance variables,
9606    renaming overloaded function names, etc.
9607
9608    Note that for this C++, it is an error to define a method within a class
9609    which does not belong to that class.
9610
9611    Except in the case where SCOPE_REFs are implicitly known (such as
9612    methods within a class being redundantly qualified),
9613    declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9614    (class_name::decl_name).  The caller must also deal with this.
9615
9616    If a constructor or destructor is seen, and the context is FIELD,
9617    then the type gains the attribute TREE_HAS_x.  If such a declaration
9618    is erroneous, NULL_TREE is returned.
9619
9620    QUALS is used only for FUNCDEF and MEMFUNCDEF cases.  For a member
9621    function, these are the qualifiers to give to the `this' pointer. We
9622    apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9623
9624    May return void_type_node if the declarator turned out to be a friend.
9625    See grokfield for details.  */
9626
9627 tree
9628 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9629      tree declspecs;
9630      tree declarator;
9631      enum decl_context decl_context;
9632      int initialized;
9633      tree attrlist;
9634 {
9635   RID_BIT_TYPE specbits;
9636   int nclasses = 0;
9637   tree spec;
9638   tree type = NULL_TREE;
9639   int longlong = 0;
9640   int constp;
9641   int restrictp;
9642   int volatilep;
9643   int type_quals;
9644   int virtualp, explicitp, friendp, inlinep, staticp;
9645   int explicit_int = 0;
9646   int explicit_char = 0;
9647   int defaulted_int = 0;
9648   tree typedef_decl = NULL_TREE;
9649   const char *name;
9650   tree typedef_type = NULL_TREE;
9651   int funcdef_flag = 0;
9652   enum tree_code innermost_code = ERROR_MARK;
9653   int bitfield = 0;
9654 #if 0
9655   /* See the code below that used this.  */
9656   tree decl_machine_attr = NULL_TREE;
9657 #endif
9658   /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9659      All FIELD_DECLs we build here have `init' put into their DECL_INITIAL.  */
9660   tree init = NULL_TREE;
9661
9662   /* Keep track of what sort of function is being processed
9663      so that we can warn about default return values, or explicit
9664      return values which do not match prescribed defaults.  */
9665   special_function_kind sfk = sfk_none;
9666
9667   tree dname = NULL_TREE;
9668   tree ctype = current_class_type;
9669   tree ctor_return_type = NULL_TREE;
9670   enum overload_flags flags = NO_SPECIAL;
9671   tree quals = NULL_TREE;
9672   tree raises = NULL_TREE;
9673   int template_count = 0;
9674   tree in_namespace = NULL_TREE;
9675   tree inner_attrs;
9676   int ignore_attrs;
9677
9678   RIDBIT_RESET_ALL (specbits);
9679   if (decl_context == FUNCDEF)
9680     funcdef_flag = 1, decl_context = NORMAL;
9681   else if (decl_context == MEMFUNCDEF)
9682     funcdef_flag = -1, decl_context = FIELD;
9683   else if (decl_context == BITFIELD)
9684     bitfield = 1, decl_context = FIELD;
9685
9686   /* Look inside a declarator for the name being declared
9687      and get it as a string, for an error message.  */
9688   {
9689     tree *next = &declarator;
9690     register tree decl;
9691     name = NULL;
9692
9693     while (next && *next)
9694       {
9695         decl = *next;
9696         switch (TREE_CODE (decl))
9697           {
9698           case TREE_LIST:
9699             /* For attributes.  */
9700             next = &TREE_VALUE (decl);
9701             break;
9702
9703           case COND_EXPR:
9704             ctype = NULL_TREE;
9705             next = &TREE_OPERAND (decl, 0);
9706             break;
9707
9708           case BIT_NOT_EXPR:    /* For C++ destructors!  */
9709             {
9710               tree name = TREE_OPERAND (decl, 0);
9711               tree rename = NULL_TREE;
9712
9713               my_friendly_assert (flags == NO_SPECIAL, 152);
9714               flags = DTOR_FLAG;
9715               sfk = sfk_destructor;
9716               if (TREE_CODE (name) == TYPE_DECL)
9717                 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9718               my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9719               if (ctype == NULL_TREE)
9720                 {
9721                   if (current_class_type == NULL_TREE)
9722                     {
9723                       error ("destructors must be member functions");
9724                       flags = NO_SPECIAL;
9725                     }
9726                   else
9727                     {
9728                       tree t = constructor_name (current_class_name);
9729                       if (t != name)
9730                         rename = t;
9731                     }
9732                 }
9733               else
9734                 {
9735                   tree t = constructor_name (ctype);
9736                   if (t != name)
9737                     rename = t;
9738                 }
9739
9740               if (rename)
9741                 {
9742                   cp_error ("destructor `%T' must match class name `%T'",
9743                             name, rename);
9744                   TREE_OPERAND (decl, 0) = rename;
9745                 }
9746               next = &name;
9747             }
9748             break;
9749
9750           case ADDR_EXPR:       /* C++ reference declaration */
9751             /* Fall through. */
9752           case ARRAY_REF:
9753           case INDIRECT_REF:
9754             ctype = NULL_TREE;
9755             innermost_code = TREE_CODE (decl);
9756             next = &TREE_OPERAND (decl, 0);
9757             break;
9758
9759           case CALL_EXPR:
9760             if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9761               {
9762                 /* This is actually a variable declaration using
9763                    constructor syntax.  We need to call start_decl and
9764                    cp_finish_decl so we can get the variable
9765                    initialized...  */
9766
9767                 tree attributes, prefix_attributes;
9768
9769                 *next = TREE_OPERAND (decl, 0);
9770                 init = CALL_DECLARATOR_PARMS (decl);
9771
9772                 if (attrlist)
9773                   {
9774                     attributes = TREE_PURPOSE (attrlist);
9775                     prefix_attributes = TREE_VALUE (attrlist);
9776                   }
9777                 else
9778                   {
9779                     attributes = NULL_TREE;
9780                     prefix_attributes = NULL_TREE;
9781                   }
9782
9783                 decl = start_decl (declarator, declspecs, 1,
9784                                    attributes, prefix_attributes);
9785                 decl_type_access_control (decl);
9786                 if (decl)
9787                   {
9788                     /* Look for __unused__ attribute */
9789                     if (TREE_USED (TREE_TYPE (decl)))
9790                       TREE_USED (decl) = 1;
9791                     finish_decl (decl, init, NULL_TREE);
9792                   }
9793                 else
9794                   cp_error ("invalid declarator");
9795                 return 0;
9796               }
9797             innermost_code = TREE_CODE (decl);
9798             if (decl_context == FIELD && ctype == NULL_TREE)
9799               ctype = current_class_type;
9800             if (ctype
9801                 && TREE_OPERAND (decl, 0)
9802                 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9803                     && ((DECL_NAME (TREE_OPERAND (decl, 0))
9804                          == constructor_name_full (ctype))
9805                         || (DECL_NAME (TREE_OPERAND (decl, 0))
9806                             == constructor_name (ctype)))))
9807               TREE_OPERAND (decl, 0) = constructor_name (ctype);
9808             next = &TREE_OPERAND (decl, 0);
9809             decl = *next;
9810             if (ctype != NULL_TREE
9811                 && decl != NULL_TREE && flags != DTOR_FLAG
9812                 && decl == constructor_name (ctype))
9813               {
9814                 sfk = sfk_constructor;
9815                 ctor_return_type = ctype;
9816               }
9817             ctype = NULL_TREE;
9818             break;
9819
9820           case TEMPLATE_ID_EXPR:
9821               {
9822                 tree fns = TREE_OPERAND (decl, 0);
9823
9824                 if (TREE_CODE (fns) == LOOKUP_EXPR)
9825                   fns = TREE_OPERAND (fns, 0);
9826
9827                 dname = fns;
9828                 if (TREE_CODE (dname) == COMPONENT_REF)
9829                   dname = TREE_OPERAND (dname, 1);
9830                 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9831                   {
9832                     my_friendly_assert (is_overloaded_fn (dname),
9833                                         19990331);
9834                     dname = DECL_NAME (get_first_fn (dname));
9835                   }
9836               }
9837           /* Fall through. */
9838
9839           case IDENTIFIER_NODE:
9840             if (TREE_CODE (decl) == IDENTIFIER_NODE)
9841               dname = decl;
9842
9843             next = 0;
9844
9845             if (is_rid (dname))
9846               {
9847                 cp_error ("declarator-id missing; using reserved word `%D'",
9848                           dname);
9849                 name = IDENTIFIER_POINTER (dname);
9850               }
9851             else if (!IDENTIFIER_TYPENAME_P (dname))
9852               name = IDENTIFIER_POINTER (dname);
9853             else
9854               {
9855                 my_friendly_assert (flags == NO_SPECIAL, 154);
9856                 flags = TYPENAME_FLAG;
9857                 ctor_return_type = TREE_TYPE (dname);
9858                 sfk = sfk_conversion;
9859                 if (IDENTIFIER_GLOBAL_VALUE (dname)
9860                     && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9861                         == TYPE_DECL))
9862                   name = IDENTIFIER_POINTER (dname);
9863                 else
9864                   name = "<invalid operator>";
9865               }
9866             break;
9867
9868             /* C++ extension */
9869           case SCOPE_REF:
9870             {
9871               /* Perform error checking, and decide on a ctype.  */
9872               tree cname = TREE_OPERAND (decl, 0);
9873               if (cname == NULL_TREE)
9874                 ctype = NULL_TREE;
9875               else if (TREE_CODE (cname) == NAMESPACE_DECL)
9876                 {
9877                   ctype = NULL_TREE;
9878                   in_namespace = TREE_OPERAND (decl, 0);
9879                   TREE_OPERAND (decl, 0) = NULL_TREE;
9880                 }
9881               else if (! is_aggr_type (cname, 1))
9882                 TREE_OPERAND (decl, 0) = NULL_TREE;
9883               /* Must test TREE_OPERAND (decl, 1), in case user gives
9884                  us `typedef (class::memfunc)(int); memfunc *memfuncptr;'  */
9885               else if (TREE_OPERAND (decl, 1)
9886                        && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9887                 ctype = cname;
9888               else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9889                        || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9890                 {
9891                   cp_error ("`%T::%D' is not a valid declarator", cname,
9892                             TREE_OPERAND (decl, 1));
9893                   cp_error ("  perhaps you want `typename %T::%D' to make it a type",
9894                             cname, TREE_OPERAND (decl, 1));
9895                   return void_type_node;
9896                 }
9897               else if (ctype == NULL_TREE)
9898                 ctype = cname;
9899               else if (TREE_COMPLEXITY (decl) == current_class_depth)
9900                 TREE_OPERAND (decl, 0) = ctype;
9901               else
9902                 {
9903                   if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9904                     {
9905                       cp_error ("type `%T' is not derived from type `%T'",
9906                                 cname, ctype);
9907                       TREE_OPERAND (decl, 0) = NULL_TREE;
9908                     }
9909                   else
9910                     ctype = cname;
9911                 }
9912
9913               if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9914                   && ((DECL_NAME (TREE_OPERAND (decl, 1))
9915                        == constructor_name_full (ctype))
9916                       || (DECL_NAME (TREE_OPERAND (decl, 1))
9917                           == constructor_name (ctype))))
9918                 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9919               next = &TREE_OPERAND (decl, 1);
9920               decl = *next;
9921               if (ctype)
9922                 {
9923                   if (TREE_CODE (decl) == IDENTIFIER_NODE
9924                       && constructor_name (ctype) == decl)
9925                     {
9926                       sfk = sfk_constructor;
9927                       ctor_return_type = ctype;
9928                     }
9929                   else if (TREE_CODE (decl) == BIT_NOT_EXPR
9930                            && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9931                            && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9932                                || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9933                     {
9934                       sfk = sfk_destructor;
9935                       ctor_return_type = ctype;
9936                       flags = DTOR_FLAG;
9937                       TREE_OPERAND (decl, 0) = constructor_name (ctype);
9938                       next = &TREE_OPERAND (decl, 0);
9939                     }
9940                 }
9941             }
9942             break;
9943
9944           case ERROR_MARK:
9945             next = 0;
9946             break;
9947
9948           case TYPE_DECL:
9949             /* Parse error puts this typespec where
9950                a declarator should go.  */
9951             cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9952             if (TREE_TYPE (decl) == current_class_type)
9953               cp_error ("  perhaps you want `%T' for a constructor",
9954                         current_class_name);
9955             dname = DECL_NAME (decl);
9956             name = IDENTIFIER_POINTER (dname);
9957
9958             /* Avoid giving two errors for this.  */
9959             IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9960
9961             declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9962             *next = dname;
9963             next = 0;
9964             break;
9965
9966           default:
9967             cp_compiler_error ("`%D' as declarator", decl);
9968             return 0; /* We used to do a 155 abort here.  */
9969           }
9970       }
9971   }
9972
9973   /* A function definition's declarator must have the form of
9974      a function declarator.  */
9975
9976   if (funcdef_flag && innermost_code != CALL_EXPR)
9977     return 0;
9978
9979   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9980       && innermost_code != CALL_EXPR
9981       && ! (ctype && declspecs == NULL_TREE))
9982     {
9983       cp_error ("declaration of `%D' as non-function", dname);
9984       return void_type_node;
9985     }
9986
9987   /* Anything declared one level down from the top level
9988      must be one of the parameters of a function
9989      (because the body is at least two levels down).  */
9990
9991   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9992      by not allowing C++ class definitions to specify their parameters
9993      with xdecls (must be spec.d in the parmlist).
9994
9995      Since we now wait to push a class scope until we are sure that
9996      we are in a legitimate method context, we must set oldcname
9997      explicitly (since current_class_name is not yet alive).
9998
9999      We also want to avoid calling this a PARM if it is in a namespace.  */
10000
10001   if (decl_context == NORMAL && !toplevel_bindings_p ())
10002     {
10003       struct binding_level *b = current_binding_level;
10004       current_binding_level = b->level_chain;
10005       if (current_binding_level != 0 && toplevel_bindings_p ())
10006         decl_context = PARM;
10007       current_binding_level = b;
10008     }
10009
10010   if (name == NULL)
10011     name = decl_context == PARM ? "parameter" : "type name";
10012
10013   /* Look through the decl specs and record which ones appear.
10014      Some typespecs are defined as built-in typenames.
10015      Others, the ones that are modifiers of other types,
10016      are represented by bits in SPECBITS: set the bits for
10017      the modifiers that appear.  Storage class keywords are also in SPECBITS.
10018
10019      If there is a typedef name or a type, store the type in TYPE.
10020      This includes builtin typedefs such as `int'.
10021
10022      Set EXPLICIT_INT if the type is `int' or `char' and did not
10023      come from a user typedef.
10024
10025      Set LONGLONG if `long' is mentioned twice.
10026
10027      For C++, constructors and destructors have their own fast treatment.  */
10028
10029   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10030     {
10031       register int i;
10032       register tree id;
10033
10034       /* Certain parse errors slip through.  For example,
10035          `int class;' is not caught by the parser. Try
10036          weakly to recover here.  */
10037       if (TREE_CODE (spec) != TREE_LIST)
10038         return 0;
10039
10040       id = TREE_VALUE (spec);
10041
10042       if (TREE_CODE (id) == IDENTIFIER_NODE)
10043         {
10044           if (id == ridpointers[(int) RID_INT]
10045               || id == ridpointers[(int) RID_CHAR]
10046               || id == ridpointers[(int) RID_BOOL]
10047               || id == ridpointers[(int) RID_WCHAR])
10048             {
10049               if (type)
10050                 {
10051                   if (id == ridpointers[(int) RID_BOOL])
10052                     error ("`bool' is now a keyword");
10053                   else
10054                     cp_error ("extraneous `%T' ignored", id);
10055                 }
10056               else
10057                 {
10058                   if (id == ridpointers[(int) RID_INT])
10059                     explicit_int = 1;
10060                   else if (id == ridpointers[(int) RID_CHAR])
10061                     explicit_char = 1;
10062                   type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10063                 }
10064               goto found;
10065             }
10066           /* C++ aggregate types.  */
10067           if (IDENTIFIER_HAS_TYPE_VALUE (id))
10068             {
10069               if (type)
10070                 cp_error ("multiple declarations `%T' and `%T'", type, id);
10071               else
10072                 type = IDENTIFIER_TYPE_VALUE (id);
10073               goto found;
10074             }
10075
10076           for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10077             {
10078               if (ridpointers[i] == id)
10079                 {
10080                   if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10081                     {
10082                       if (pedantic && ! in_system_header && warn_long_long)
10083                         pedwarn ("ISO C++ does not support `long long'");
10084                       if (longlong)
10085                         error ("`long long long' is too long for GCC");
10086                       else
10087                         longlong = 1;
10088                     }
10089                   else if (RIDBIT_SETP (i, specbits))
10090                     pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10091                   RIDBIT_SET (i, specbits);
10092                   goto found;
10093                 }
10094             }
10095         }
10096       /* C++ aggregate types.  */
10097       else if (TREE_CODE (id) == TYPE_DECL || TREE_CODE (id) == TEMPLATE_DECL)
10098         {
10099           if (type)
10100             cp_error ("multiple declarations `%T' and `%T'", type,
10101                       TREE_TYPE (id));
10102           else
10103             {
10104               type = TREE_TYPE (id);
10105               TREE_VALUE (spec) = type;
10106             }
10107           goto found;
10108         }
10109       if (type)
10110         error ("two or more data types in declaration of `%s'", name);
10111       else if (TREE_CODE (id) == IDENTIFIER_NODE)
10112         {
10113           register tree t = lookup_name (id, 1);
10114           if (!t || TREE_CODE (t) != TYPE_DECL)
10115             error ("`%s' fails to be a typedef or built in type",
10116                    IDENTIFIER_POINTER (id));
10117           else
10118             {
10119               type = TREE_TYPE (t);
10120 #if 0
10121               /* See the code below that used this.  */
10122               decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
10123 #endif
10124               typedef_decl = t;
10125             }
10126         }
10127       else if (id != error_mark_node)
10128         /* Can't change CLASS nodes into RECORD nodes here!  */
10129         type = id;
10130
10131     found: ;
10132     }
10133
10134   typedef_type = type;
10135
10136   /* No type at all: default to `int', and set DEFAULTED_INT
10137      because it was not a user-defined typedef.  */
10138
10139   if (type == NULL_TREE
10140       && (RIDBIT_SETP (RID_SIGNED, specbits)
10141           || RIDBIT_SETP (RID_UNSIGNED, specbits)
10142           || RIDBIT_SETP (RID_LONG, specbits)
10143           || RIDBIT_SETP (RID_SHORT, specbits)))
10144     {
10145       /* These imply 'int'.  */
10146       type = integer_type_node;
10147       defaulted_int = 1;
10148     }
10149
10150   if (sfk != sfk_none)
10151     type = check_special_function_return_type (sfk, type,
10152                                                ctor_return_type,
10153                                                ctor_return_type);
10154   else if (type == NULL_TREE)
10155     {
10156       int is_main;
10157
10158       explicit_int = -1;
10159
10160           /* We handle `main' specially here, because 'main () { }' is so
10161              common.  With no options, it is allowed.  With -Wreturn-type,
10162              it is a warning.  It is only an error with -pedantic-errors.  */
10163       is_main = (funcdef_flag
10164                  && MAIN_NAME_P (dname)
10165                  && ctype == NULL_TREE
10166                  && in_namespace == NULL_TREE
10167                  && current_namespace == global_namespace);
10168
10169       if (in_system_header || flag_ms_extensions)
10170         /* Allow it, sigh.  */;
10171       else if (pedantic || ! is_main)
10172         cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10173                     name);
10174       else if (warn_return_type)
10175         cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10176                     name);
10177
10178       type = integer_type_node;
10179     }
10180
10181   ctype = NULL_TREE;
10182
10183   /* Now process the modifiers that were specified
10184      and check for invalid combinations.  */
10185
10186   /* Long double is a special combination.  */
10187
10188   if (RIDBIT_SETP (RID_LONG, specbits)
10189       && TYPE_MAIN_VARIANT (type) == double_type_node)
10190     {
10191       RIDBIT_RESET (RID_LONG, specbits);
10192       type = build_qualified_type (long_double_type_node,
10193                                    CP_TYPE_QUALS (type));
10194     }
10195
10196   /* Check all other uses of type modifiers.  */
10197
10198   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10199       || RIDBIT_SETP (RID_SIGNED, specbits)
10200       || RIDBIT_SETP (RID_LONG, specbits)
10201       || RIDBIT_SETP (RID_SHORT, specbits))
10202     {
10203       int ok = 0;
10204
10205       if (TREE_CODE (type) == REAL_TYPE)
10206         error ("short, signed or unsigned invalid for `%s'", name);
10207       else if (TREE_CODE (type) != INTEGER_TYPE)
10208         error ("long, short, signed or unsigned invalid for `%s'", name);
10209       else if (RIDBIT_SETP (RID_LONG, specbits)
10210                && RIDBIT_SETP (RID_SHORT, specbits))
10211         error ("long and short specified together for `%s'", name);
10212       else if ((RIDBIT_SETP (RID_LONG, specbits)
10213                 || RIDBIT_SETP (RID_SHORT, specbits))
10214                && explicit_char)
10215         error ("long or short specified with char for `%s'", name);
10216       else if ((RIDBIT_SETP (RID_LONG, specbits)
10217                 || RIDBIT_SETP (RID_SHORT, specbits))
10218                && TREE_CODE (type) == REAL_TYPE)
10219         error ("long or short specified with floating type for `%s'", name);
10220       else if (RIDBIT_SETP (RID_SIGNED, specbits)
10221                && RIDBIT_SETP (RID_UNSIGNED, specbits))
10222         error ("signed and unsigned given together for `%s'", name);
10223       else
10224         {
10225           ok = 1;
10226           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10227             {
10228               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10229                        name);
10230               if (flag_pedantic_errors)
10231                 ok = 0;
10232             }
10233         }
10234
10235       /* Discard the type modifiers if they are invalid.  */
10236       if (! ok)
10237         {
10238           RIDBIT_RESET (RID_UNSIGNED, specbits);
10239           RIDBIT_RESET (RID_SIGNED, specbits);
10240           RIDBIT_RESET (RID_LONG, specbits);
10241           RIDBIT_RESET (RID_SHORT, specbits);
10242           longlong = 0;
10243         }
10244     }
10245
10246   if (RIDBIT_SETP (RID_COMPLEX, specbits)
10247       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10248     {
10249       error ("complex invalid for `%s'", name);
10250       RIDBIT_RESET (RID_COMPLEX, specbits);
10251     }
10252
10253   /* Decide whether an integer type is signed or not.
10254      Optionally treat bitfields as signed by default.  */
10255   if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10256       /* [class.bit]
10257
10258          It is implementation-defined whether a plain (neither
10259          explicitly signed or unsigned) char, short, int, or long
10260          bit-field is signed or unsigned.
10261
10262          Naturally, we extend this to long long as well.  Note that
10263          this does not include wchar_t.  */
10264       || (bitfield && !flag_signed_bitfields
10265           && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10266           /* A typedef for plain `int' without `signed' can be
10267              controlled just like plain `int', but a typedef for
10268              `signed int' cannot be so controlled.  */
10269           && !(typedef_decl
10270                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10271           && (TREE_CODE (type) == INTEGER_TYPE
10272               || TREE_CODE (type) == CHAR_TYPE)
10273           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10274     {
10275       if (longlong)
10276         type = long_long_unsigned_type_node;
10277       else if (RIDBIT_SETP (RID_LONG, specbits))
10278         type = long_unsigned_type_node;
10279       else if (RIDBIT_SETP (RID_SHORT, specbits))
10280         type = short_unsigned_type_node;
10281       else if (type == char_type_node)
10282         type = unsigned_char_type_node;
10283       else if (typedef_decl)
10284         type = unsigned_type (type);
10285       else
10286         type = unsigned_type_node;
10287     }
10288   else if (RIDBIT_SETP (RID_SIGNED, specbits)
10289            && type == char_type_node)
10290     type = signed_char_type_node;
10291   else if (longlong)
10292     type = long_long_integer_type_node;
10293   else if (RIDBIT_SETP (RID_LONG, specbits))
10294     type = long_integer_type_node;
10295   else if (RIDBIT_SETP (RID_SHORT, specbits))
10296     type = short_integer_type_node;
10297
10298   if (RIDBIT_SETP (RID_COMPLEX, specbits))
10299     {
10300       /* If we just have "complex", it is equivalent to
10301          "complex double", but if any modifiers at all are specified it is
10302          the complex form of TYPE.  E.g, "complex short" is
10303          "complex short int".  */
10304
10305       if (defaulted_int && ! longlong
10306           && ! (RIDBIT_SETP (RID_LONG, specbits)
10307                 || RIDBIT_SETP (RID_SHORT, specbits)
10308                 || RIDBIT_SETP (RID_SIGNED, specbits)
10309                 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10310         type = complex_double_type_node;
10311       else if (type == integer_type_node)
10312         type = complex_integer_type_node;
10313       else if (type == float_type_node)
10314         type = complex_float_type_node;
10315       else if (type == double_type_node)
10316         type = complex_double_type_node;
10317       else if (type == long_double_type_node)
10318         type = complex_long_double_type_node;
10319       else
10320         type = build_complex_type (type);
10321     }
10322
10323   if (sfk == sfk_conversion
10324       && (RIDBIT_SETP (RID_CONST, specbits)
10325           || RIDBIT_SETP (RID_VOLATILE, specbits)
10326           || RIDBIT_SETP (RID_RESTRICT, specbits)))
10327     cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10328               ctor_return_type);
10329
10330   /* Set CONSTP if this declaration is `const', whether by
10331      explicit specification or via a typedef.
10332      Likewise for VOLATILEP.  */
10333
10334   constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10335   restrictp =
10336     !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10337   volatilep =
10338     !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10339   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10340                 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10341                 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10342   type = cp_build_qualified_type (type, type_quals);
10343   staticp = 0;
10344   inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10345   virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10346   RIDBIT_RESET (RID_VIRTUAL, specbits);
10347   explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10348   RIDBIT_RESET (RID_EXPLICIT, specbits);
10349
10350   if (RIDBIT_SETP (RID_STATIC, specbits))
10351     staticp = 1 + (decl_context == FIELD);
10352
10353   if (virtualp && staticp == 2)
10354     {
10355       cp_error ("member `%D' cannot be declared both virtual and static",
10356                 dname);
10357       staticp = 0;
10358     }
10359   friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10360   RIDBIT_RESET (RID_FRIEND, specbits);
10361
10362   /* Warn if two storage classes are given. Default to `auto'.  */
10363
10364   if (RIDBIT_ANY_SET (specbits))
10365     {
10366       if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10367       if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10368       if (decl_context == PARM && nclasses > 0)
10369         error ("storage class specifiers invalid in parameter declarations");
10370       if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10371         {
10372           if (decl_context == PARM)
10373             error ("typedef declaration invalid in parameter declaration");
10374           nclasses++;
10375         }
10376       if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10377       if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10378     }
10379
10380   /* Give error if `virtual' is used outside of class declaration.  */
10381   if (virtualp
10382       && (current_class_name == NULL_TREE || decl_context != FIELD))
10383     {
10384       error ("virtual outside class declaration");
10385       virtualp = 0;
10386     }
10387
10388   /* Static anonymous unions are dealt with here.  */
10389   if (staticp && decl_context == TYPENAME
10390       && TREE_CODE (declspecs) == TREE_LIST
10391       && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10392     decl_context = FIELD;
10393
10394   /* Warn about storage classes that are invalid for certain
10395      kinds of declarations (parameters, typenames, etc.).  */
10396
10397   if (nclasses > 1)
10398     error ("multiple storage classes in declaration of `%s'", name);
10399   else if (decl_context != NORMAL && nclasses > 0)
10400     {
10401       if ((decl_context == PARM || decl_context == CATCHPARM)
10402           && (RIDBIT_SETP (RID_REGISTER, specbits)
10403               || RIDBIT_SETP (RID_AUTO, specbits)))
10404         ;
10405       else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10406         ;
10407       else if (decl_context == FIELD
10408                /* C++ allows static class elements  */
10409                && RIDBIT_SETP (RID_STATIC, specbits))
10410         /* C++ also allows inlines and signed and unsigned elements,
10411            but in those cases we don't come in here.  */
10412         ;
10413       else
10414         {
10415           if (decl_context == FIELD)
10416             {
10417               tree tmp = NULL_TREE;
10418               register int op = 0;
10419
10420               if (declarator)
10421                 {
10422                   /* Avoid trying to get an operand off an identifier node.  */
10423                   if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10424                     tmp = declarator;
10425                   else
10426                     tmp = TREE_OPERAND (declarator, 0);
10427                   op = IDENTIFIER_OPNAME_P (tmp);
10428                   if (IDENTIFIER_TYPENAME_P (tmp))
10429                     {
10430                       if (IDENTIFIER_GLOBAL_VALUE (tmp)
10431                           && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10432                               == TYPE_DECL))
10433                         name = IDENTIFIER_POINTER (tmp);
10434                       else
10435                         name = "<invalid operator>";
10436                     }
10437                 }
10438               error ("storage class specified for %s `%s'",
10439                      op ? "member operator" : "field",
10440                      name);
10441             }
10442           else
10443             {
10444               if (decl_context == PARM || decl_context == CATCHPARM)
10445                 error ("storage class specified for parameter `%s'", name);
10446               else
10447                 error ("storage class specified for typename");
10448             }
10449           RIDBIT_RESET (RID_REGISTER, specbits);
10450           RIDBIT_RESET (RID_AUTO, specbits);
10451           RIDBIT_RESET (RID_EXTERN, specbits);
10452         }
10453     }
10454   else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10455     {
10456       if (toplevel_bindings_p ())
10457         {
10458           /* It's common practice (and completely valid) to have a const
10459              be initialized and declared extern.  */
10460           if (!(type_quals & TYPE_QUAL_CONST))
10461             warning ("`%s' initialized and declared `extern'", name);
10462         }
10463       else
10464         error ("`%s' has both `extern' and initializer", name);
10465     }
10466   else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10467            && ! toplevel_bindings_p ())
10468     error ("nested function `%s' declared `extern'", name);
10469   else if (toplevel_bindings_p ())
10470     {
10471       if (RIDBIT_SETP (RID_AUTO, specbits))
10472         error ("top-level declaration of `%s' specifies `auto'", name);
10473     }
10474
10475   if (nclasses > 0 && friendp)
10476     error ("storage class specifiers invalid in friend function declarations");
10477
10478   /* Now figure out the structure of the declarator proper.
10479      Descend through it, creating more complex types, until we reach
10480      the declared identifier (or NULL_TREE, in an absolute declarator).  */
10481
10482   inner_attrs = NULL_TREE;
10483   ignore_attrs = 0;
10484
10485   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10486          && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10487     {
10488       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10489          an INDIRECT_REF (for *...),
10490          a CALL_EXPR (for ...(...)),
10491          an identifier (for the name being declared)
10492          or a null pointer (for the place in an absolute declarator
10493          where the name was omitted).
10494          For the last two cases, we have just exited the loop.
10495
10496          For C++ it could also be
10497          a SCOPE_REF (for class :: ...).  In this case, we have converted
10498          sensible names to types, and those are the values we use to
10499          qualify the member name.
10500          an ADDR_EXPR (for &...),
10501          a BIT_NOT_EXPR (for destructors)
10502
10503          At this point, TYPE is the type of elements of an array,
10504          or for a function to return, or for a pointer to point to.
10505          After this sequence of ifs, TYPE is the type of the
10506          array or function or pointer, and DECLARATOR has had its
10507          outermost layer removed.  */
10508
10509       if (type == error_mark_node)
10510         {
10511           if (TREE_CODE (declarator) == SCOPE_REF)
10512             declarator = TREE_OPERAND (declarator, 1);
10513           else
10514             declarator = TREE_OPERAND (declarator, 0);
10515           continue;
10516         }
10517       if (quals != NULL_TREE
10518           && (declarator == NULL_TREE
10519               || TREE_CODE (declarator) != SCOPE_REF))
10520         {
10521           if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10522             ctype = TYPE_METHOD_BASETYPE (type);
10523           if (ctype != NULL_TREE)
10524             {
10525               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10526               grok_method_quals (ctype, dummy, quals);
10527               type = TREE_TYPE (dummy);
10528               ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10529               quals = NULL_TREE;
10530             }
10531         }
10532
10533       /* See the comment for the TREE_LIST case, below.  */
10534       if (ignore_attrs)
10535         ignore_attrs = 0;
10536       else if (inner_attrs)
10537         {
10538           decl_attributes (type, inner_attrs, NULL_TREE);
10539           inner_attrs = NULL_TREE;
10540         }
10541
10542       switch (TREE_CODE (declarator))
10543         {
10544         case TREE_LIST:
10545           {
10546             /* We encode a declarator with embedded attributes using
10547                a TREE_LIST.  The attributes apply to the declarator
10548                directly inside them, so we have to skip an iteration
10549                before applying them to the type.  If the declarator just
10550                inside is the declarator-id, we apply the attrs to the
10551                decl itself.  */
10552             inner_attrs = TREE_PURPOSE (declarator);
10553             ignore_attrs = 1;
10554             declarator = TREE_VALUE (declarator);
10555           }
10556           break;
10557
10558         case ARRAY_REF:
10559           {
10560             register tree size;
10561
10562             size = TREE_OPERAND (declarator, 1);
10563
10564             /* VC++ spells a zero-sized array with [].  */
10565             if (size == NULL_TREE && decl_context == FIELD && ! staticp
10566                 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10567               size = integer_zero_node;
10568
10569             declarator = TREE_OPERAND (declarator, 0);
10570
10571             type = create_array_type_for_decl (dname, type, size);
10572
10573             /* VLAs never work as fields. */
10574             if (decl_context == FIELD && !processing_template_decl
10575                 && TREE_CODE (type) == ARRAY_TYPE
10576                 && TYPE_DOMAIN (type) != NULL_TREE
10577                 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
10578               {
10579                 cp_error ("size of member `%D' is not constant", dname);
10580                 /* Proceed with arbitrary constant size, so that offset
10581                    computations don't get confused. */
10582                 type = create_array_type_for_decl (dname, TREE_TYPE (type),
10583                                                    integer_one_node);
10584               }
10585
10586             ctype = NULL_TREE;
10587           }
10588           break;
10589
10590         case CALL_EXPR:
10591           {
10592             tree arg_types;
10593             int funcdecl_p;
10594             tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10595             tree inner_decl = TREE_OPERAND (declarator, 0);
10596
10597             /* Declaring a function type.
10598                Make sure we have a valid type for the function to return.  */
10599
10600             /* We now know that the TYPE_QUALS don't apply to the
10601                decl, but to its return type.  */
10602             type_quals = TYPE_UNQUALIFIED;
10603
10604             /* Warn about some types functions can't return.  */
10605
10606             if (TREE_CODE (type) == FUNCTION_TYPE)
10607               {
10608                 error ("`%s' declared as function returning a function", name);
10609                 type = integer_type_node;
10610               }
10611             if (TREE_CODE (type) == ARRAY_TYPE)
10612               {
10613                 error ("`%s' declared as function returning an array", name);
10614                 type = integer_type_node;
10615               }
10616
10617             if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10618               inner_decl = TREE_OPERAND (inner_decl, 1);
10619
10620             if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10621               inner_decl = dname;
10622
10623             /* Pick up type qualifiers which should be applied to `this'.  */
10624             quals = CALL_DECLARATOR_QUALS (declarator);
10625
10626             /* Pick up the exception specifications.  */
10627             raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10628
10629             /* Say it's a definition only for the CALL_EXPR
10630                closest to the identifier.  */
10631             funcdecl_p
10632               = inner_decl
10633               && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10634                   || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10635                   || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10636
10637             if (ctype == NULL_TREE
10638                 && decl_context == FIELD
10639                 && funcdecl_p
10640                 && (friendp == 0 || dname == current_class_name))
10641               ctype = current_class_type;
10642
10643             if (ctype && sfk == sfk_conversion)
10644               TYPE_HAS_CONVERSION (ctype) = 1;
10645             if (ctype && constructor_name (ctype) == dname)
10646               {
10647                 /* We are within a class's scope. If our declarator name
10648                    is the same as the class name, and we are defining
10649                    a function, then it is a constructor/destructor, and
10650                    therefore returns a void type.  */
10651
10652                 if (flags == DTOR_FLAG)
10653                   {
10654                     /* ISO C++ 12.4/2.  A destructor may not be
10655                        declared const or volatile.  A destructor may
10656                        not be static.  */
10657                     if (staticp == 2)
10658                       error ("destructor cannot be static member function");
10659                     if (quals)
10660                       {
10661                         cp_error ("destructors may not be `%s'",
10662                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10663                         quals = NULL_TREE;
10664                       }
10665                     if (decl_context == FIELD)
10666                       {
10667                         if (! member_function_or_else (ctype,
10668                                                        current_class_type,
10669                                                        flags))
10670                           return void_type_node;
10671                       }
10672                   }
10673                 else            /* It's a constructor.  */
10674                   {
10675                     if (explicitp == 1)
10676                       explicitp = 2;
10677                     /* ISO C++ 12.1.  A constructor may not be
10678                        declared const or volatile.  A constructor may
10679                        not be virtual.  A constructor may not be
10680                        static.  */
10681                     if (staticp == 2)
10682                       error ("constructor cannot be static member function");
10683                     if (virtualp)
10684                       {
10685                         pedwarn ("constructors cannot be declared virtual");
10686                         virtualp = 0;
10687                       }
10688                     if (quals)
10689                       {
10690                         cp_error ("constructors may not be `%s'",
10691                                   IDENTIFIER_POINTER (TREE_VALUE (quals)));
10692                         quals = NULL_TREE;
10693                       }
10694                     {
10695                       RID_BIT_TYPE tmp_bits;
10696                       bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10697                       RIDBIT_RESET (RID_INLINE, tmp_bits);
10698                       RIDBIT_RESET (RID_STATIC, tmp_bits);
10699                       if (RIDBIT_ANY_SET (tmp_bits))
10700                         error ("return value type specifier for constructor ignored");
10701                     }
10702                     if (decl_context == FIELD)
10703                       {
10704                         if (! member_function_or_else (ctype,
10705                                                        current_class_type,
10706                                                        flags))
10707                           return void_type_node;
10708                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10709                         if (sfk != sfk_constructor)
10710                           return NULL_TREE;
10711                       }
10712                   }
10713                 if (decl_context == FIELD)
10714                   staticp = 0;
10715               }
10716             else if (friendp)
10717               {
10718                 if (initialized)
10719                   error ("can't initialize friend function `%s'", name);
10720                 if (virtualp)
10721                   {
10722                     /* Cannot be both friend and virtual.  */
10723                     error ("virtual functions cannot be friends");
10724                     RIDBIT_RESET (RID_FRIEND, specbits);
10725                     friendp = 0;
10726                   }
10727                 if (decl_context == NORMAL)
10728                   error ("friend declaration not in class definition");
10729                 if (current_function_decl && funcdef_flag)
10730                   cp_error ("can't define friend function `%s' in a local class definition",
10731                             name);
10732               }
10733
10734             /* Construct the function type and go to the next
10735                inner layer of declarator.  */
10736
10737             declarator = TREE_OPERAND (declarator, 0);
10738
10739             /* FIXME: This is where default args should be fully
10740                processed.  */
10741
10742             arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10743
10744             if (declarator && flags == DTOR_FLAG)
10745               {
10746                 /* A destructor declared in the body of a class will
10747                    be represented as a BIT_NOT_EXPR.  But, we just
10748                    want the underlying IDENTIFIER.  */
10749                 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10750                   declarator = TREE_OPERAND (declarator, 0);
10751
10752                 if (strict_prototype == 0 && arg_types == NULL_TREE)
10753                   arg_types = void_list_node;
10754                 else if (arg_types == NULL_TREE
10755                          || arg_types != void_list_node)
10756                   {
10757                     cp_error ("destructors may not have parameters");
10758                     arg_types = void_list_node;
10759                     last_function_parms = NULL_TREE;
10760                   }
10761               }
10762
10763             /* ANSI says that `const int foo ();'
10764                does not make the function foo const.  */
10765             type = build_function_type (type, arg_types);
10766
10767             {
10768               tree t;
10769               for (t = arg_types; t; t = TREE_CHAIN (t))
10770                 if (TREE_PURPOSE (t)
10771                     && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10772                   {
10773                     add_defarg_fn (type);
10774                     break;
10775                   }
10776             }
10777           }
10778           break;
10779
10780         case ADDR_EXPR:
10781         case INDIRECT_REF:
10782           /* Filter out pointers-to-references and references-to-references.
10783              We can get these if a TYPE_DECL is used.  */
10784
10785           if (TREE_CODE (type) == REFERENCE_TYPE)
10786             {
10787               error ("cannot declare %s to references",
10788                      TREE_CODE (declarator) == ADDR_EXPR
10789                      ? "references" : "pointers");
10790               declarator = TREE_OPERAND (declarator, 0);
10791               continue;
10792             }
10793
10794           if (TREE_CODE (type) == OFFSET_TYPE
10795               && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10796                   || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10797             {
10798               cp_error ("cannot declare pointer to `%#T' member",
10799                         TREE_TYPE (type));
10800               type = TREE_TYPE (type);
10801             }
10802
10803           /* Merge any constancy or volatility into the target type
10804              for the pointer.  */
10805
10806           /* We now know that the TYPE_QUALS don't apply to the decl,
10807              but to the target of the pointer.  */
10808           type_quals = TYPE_UNQUALIFIED;
10809
10810           if (TREE_CODE (declarator) == ADDR_EXPR)
10811             {
10812               if (TREE_CODE (type) == VOID_TYPE)
10813                 error ("invalid type: `void &'");
10814               else
10815                 type = build_reference_type (type);
10816             }
10817           else if (TREE_CODE (type) == METHOD_TYPE)
10818             type = build_ptrmemfunc_type (build_pointer_type (type));
10819           else
10820             type = build_pointer_type (type);
10821
10822           /* Process a list of type modifier keywords (such as
10823              const or volatile) that were given inside the `*' or `&'.  */
10824
10825           if (TREE_TYPE (declarator))
10826             {
10827               register tree typemodlist;
10828               int erred = 0;
10829
10830               constp = 0;
10831               volatilep = 0;
10832               restrictp = 0;
10833               for (typemodlist = TREE_TYPE (declarator); typemodlist;
10834                    typemodlist = TREE_CHAIN (typemodlist))
10835                 {
10836                   tree qualifier = TREE_VALUE (typemodlist);
10837
10838                   if (qualifier == ridpointers[(int) RID_CONST])
10839                     constp++;
10840                   else if (qualifier == ridpointers[(int) RID_VOLATILE])
10841                     volatilep++;
10842                   else if (qualifier == ridpointers[(int) RID_RESTRICT])
10843                     restrictp++;
10844                   else if (!erred)
10845                     {
10846                       erred = 1;
10847                       error ("invalid type modifier within pointer declarator");
10848                     }
10849                 }
10850               if (constp > 1)
10851                 pedwarn ("duplicate `const'");
10852               if (volatilep > 1)
10853                 pedwarn ("duplicate `volatile'");
10854               if (restrictp > 1)
10855                 pedwarn ("duplicate `restrict'");
10856
10857               type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10858                             | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10859                             | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10860               if (TREE_CODE (declarator) == ADDR_EXPR
10861                   && (constp || volatilep))
10862                 {
10863                   if (constp)
10864                     pedwarn ("discarding `const' applied to a reference");
10865                   if (volatilep)
10866                     pedwarn ("discarding `volatile' applied to a reference");
10867                   type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10868                 }
10869               type = cp_build_qualified_type (type, type_quals);
10870             }
10871           declarator = TREE_OPERAND (declarator, 0);
10872           ctype = NULL_TREE;
10873           break;
10874
10875         case SCOPE_REF:
10876           {
10877             /* We have converted type names to NULL_TREE if the
10878                name was bogus, or to a _TYPE node, if not.
10879
10880                The variable CTYPE holds the type we will ultimately
10881                resolve to.  The code here just needs to build
10882                up appropriate member types.  */
10883             tree sname = TREE_OPERAND (declarator, 1);
10884             tree t;
10885
10886             /* Destructors can have their visibilities changed as well.  */
10887             if (TREE_CODE (sname) == BIT_NOT_EXPR)
10888               sname = TREE_OPERAND (sname, 0);
10889
10890             if (TREE_COMPLEXITY (declarator) == 0)
10891               /* This needs to be here, in case we are called
10892                  multiple times.  */ ;
10893             else if (TREE_COMPLEXITY (declarator) == -1)
10894               /* Namespace member. */
10895               pop_decl_namespace ();
10896             else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10897               /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10898             else if (! IS_AGGR_TYPE_CODE
10899                      (TREE_CODE (TREE_OPERAND (declarator, 0))))
10900               ;
10901             else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10902               {
10903                 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10904                    that refer to ctype.  They couldn't be resolved earlier
10905                    because we hadn't pushed into the class yet.
10906                    Example: resolve 'B<T>::type' in
10907                    'B<typename B<T>::type> B<T>::f () { }'.  */
10908                 if (current_template_parms
10909                     && uses_template_parms (type)
10910                     && uses_template_parms (current_class_type))
10911                   {
10912                     tree args = current_template_args ();
10913                     type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10914                   }
10915
10916                 /* This pop_nested_class corresponds to the
10917                    push_nested_class used to push into class scope for
10918                    parsing the argument list of a function decl, in
10919                    qualified_id.  */
10920                 pop_nested_class ();
10921                 TREE_COMPLEXITY (declarator) = current_class_depth;
10922               }
10923             else
10924               my_friendly_abort (16);
10925
10926             if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10927               {
10928                 /* We had a reference to a global decl, or
10929                    perhaps we were given a non-aggregate typedef,
10930                    in which case we cleared this out, and should just
10931                    keep going as though it wasn't there.  */
10932                 declarator = sname;
10933                 continue;
10934               }
10935             ctype = TREE_OPERAND (declarator, 0);
10936
10937             t = ctype;
10938             while (t != NULL_TREE && CLASS_TYPE_P (t))
10939               {
10940                 /* You're supposed to have one `template <...>'
10941                    for every template class, but you don't need one
10942                    for a full specialization.  For example:
10943
10944                      template <class T> struct S{};
10945                      template <> struct S<int> { void f(); };
10946                      void S<int>::f () {}
10947
10948                    is correct; there shouldn't be a `template <>' for
10949                    the definition of `S<int>::f'.  */
10950                 if (CLASSTYPE_TEMPLATE_INFO (t)
10951                     && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10952                         || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
10953                   template_count += 1;
10954
10955                 t = TYPE_MAIN_DECL (t);
10956                 if (DECL_LANG_SPECIFIC (t))
10957                   t = DECL_CONTEXT (t);
10958                 else
10959                   t = NULL_TREE;
10960               }
10961
10962             if (sname == NULL_TREE)
10963               goto done_scoping;
10964
10965             if (TREE_CODE (sname) == IDENTIFIER_NODE)
10966               {
10967                 /* This is the `standard' use of the scoping operator:
10968                    basetype :: member .  */
10969
10970                 if (ctype == current_class_type)
10971                   {
10972                     /* class A {
10973                          void A::f ();
10974                        };
10975
10976                        Is this ill-formed?  */
10977
10978                     if (pedantic)
10979                       cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10980                                   ctype, name);
10981                   }
10982                 else if (TREE_CODE (type) == FUNCTION_TYPE)
10983                   {
10984                     if (current_class_type == NULL_TREE
10985                         || friendp)
10986                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
10987                                                       TYPE_ARG_TYPES (type));
10988                     else
10989                       {
10990                         cp_error ("cannot declare member function `%T::%s' within `%T'",
10991                                   ctype, name, current_class_type);
10992                         return void_type_node;
10993                       }
10994                   }
10995                 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10996                          || COMPLETE_TYPE_P (complete_type (ctype)))
10997                   {
10998                     /* Have to move this code elsewhere in this function.
10999                        this code is used for i.e., typedef int A::M; M *pm;
11000
11001                        It is?  How? jason 10/2/94 */
11002
11003                     if (current_class_type)
11004                       {
11005                         cp_error ("cannot declare member `%T::%s' within `%T'",
11006                                   ctype, name, current_class_type);
11007                         return void_type_node;
11008                       }
11009                     type = build_offset_type (ctype, type);
11010                   }
11011                 else if (uses_template_parms (ctype))
11012                   {
11013                     if (TREE_CODE (type) == FUNCTION_TYPE)
11014                       type
11015                         = build_cplus_method_type (ctype, TREE_TYPE (type),
11016                                                    TYPE_ARG_TYPES (type));
11017                   }
11018                 else
11019                   {
11020                     cp_error ("structure `%T' not yet defined", ctype);
11021                     return error_mark_node;
11022                   }
11023
11024                 declarator = sname;
11025               }
11026             else if (TREE_CODE (sname) == SCOPE_REF)
11027               my_friendly_abort (17);
11028             else
11029               {
11030               done_scoping:
11031                 declarator = TREE_OPERAND (declarator, 1);
11032                 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
11033                   /* In this case, we will deal with it later.  */
11034                   ;
11035                 else
11036                   {
11037                     if (TREE_CODE (type) == FUNCTION_TYPE)
11038                       type = build_cplus_method_type (ctype, TREE_TYPE (type),
11039                                                       TYPE_ARG_TYPES (type));
11040                     else
11041                       type = build_offset_type (ctype, type);
11042                   }
11043               }
11044           }
11045           break;
11046
11047         case BIT_NOT_EXPR:
11048           declarator = TREE_OPERAND (declarator, 0);
11049           break;
11050
11051         case RECORD_TYPE:
11052         case UNION_TYPE:
11053         case ENUMERAL_TYPE:
11054           declarator = NULL_TREE;
11055           break;
11056
11057         case ERROR_MARK:
11058           declarator = NULL_TREE;
11059           break;
11060
11061         default:
11062           my_friendly_abort (158);
11063         }
11064     }
11065
11066   /* See the comment for the TREE_LIST case, above.  */
11067   if (inner_attrs)
11068     {
11069       if (! ignore_attrs)
11070         decl_attributes (type, inner_attrs, NULL_TREE);
11071       else if (attrlist)
11072         TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
11073       else
11074         attrlist = build_decl_list (NULL_TREE, inner_attrs);
11075     }
11076
11077   /* Now TYPE has the actual type.  */
11078
11079   if (explicitp == 1 || (explicitp && friendp))
11080     {
11081       /* [dcl.fct.spec] The explicit specifier shall only be used in
11082          declarations of constructors within a class definition.  */
11083       error ("only declarations of constructors can be `explicit'");
11084       explicitp = 0;
11085     }
11086
11087   if (RIDBIT_SETP (RID_MUTABLE, specbits))
11088     {
11089       if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11090         {
11091           error ("non-member `%s' cannot be declared `mutable'", name);
11092           RIDBIT_RESET (RID_MUTABLE, specbits);
11093         }
11094       else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11095         {
11096           error ("non-object member `%s' cannot be declared `mutable'", name);
11097           RIDBIT_RESET (RID_MUTABLE, specbits);
11098         }
11099       else if (TREE_CODE (type) == FUNCTION_TYPE
11100                || TREE_CODE (type) == METHOD_TYPE)
11101         {
11102           error ("function `%s' cannot be declared `mutable'", name);
11103           RIDBIT_RESET (RID_MUTABLE, specbits);
11104         }
11105       else if (staticp)
11106         {
11107           error ("static `%s' cannot be declared `mutable'", name);
11108           RIDBIT_RESET (RID_MUTABLE, specbits);
11109         }
11110       else if (type_quals & TYPE_QUAL_CONST)
11111         {
11112           error ("const `%s' cannot be declared `mutable'", name);
11113           RIDBIT_RESET (RID_MUTABLE, specbits);
11114         }
11115     }
11116
11117   if (declarator == NULL_TREE
11118       || TREE_CODE (declarator) == IDENTIFIER_NODE
11119       || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11120           && (TREE_CODE (type) == FUNCTION_TYPE
11121               || TREE_CODE (type) == METHOD_TYPE)))
11122     /* OK */;
11123   else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11124     {
11125       cp_error ("template-id `%D' used as a declarator", declarator);
11126       declarator = dname;
11127     }
11128   else
11129     /* Unexpected declarator format.  */
11130     my_friendly_abort (990210);
11131
11132   /* If this is declaring a typedef name, return a TYPE_DECL.  */
11133
11134   if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11135     {
11136       tree decl;
11137
11138       /* Note that the grammar rejects storage classes
11139          in typenames, fields or parameters.  */
11140       if (current_lang_name == lang_name_java)
11141         TYPE_FOR_JAVA (type) = 1;
11142
11143       if (decl_context == FIELD)
11144         {
11145           if (declarator == constructor_name (current_class_type))
11146             cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11147                         declarator);
11148           decl = build_lang_decl (TYPE_DECL, declarator, type);
11149         }
11150       else
11151         decl = build_decl (TYPE_DECL, declarator, type);
11152
11153       /* If the user declares "typedef struct {...} foo" then the
11154          struct will have an anonymous name.  Fill that name in now.
11155          Nothing can refer to it, so nothing needs know about the name
11156          change.  */
11157       if (type != error_mark_node
11158           && declarator
11159           && TYPE_NAME (type)
11160           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11161           && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
11162           && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
11163         {
11164           tree oldname = TYPE_NAME (type);
11165           tree t;
11166
11167           /* Replace the anonymous name with the real name everywhere.  */
11168           lookup_tag_reverse (type, declarator);
11169           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11170             if (TYPE_NAME (t) == oldname)
11171               TYPE_NAME (t) = decl;
11172
11173           if (TYPE_LANG_SPECIFIC (type))
11174             TYPE_WAS_ANONYMOUS (type) = 1;
11175
11176           /* If this is a typedef within a template class, the nested
11177              type is a (non-primary) template.  The name for the
11178              template needs updating as well.  */
11179           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11180             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11181               = TYPE_IDENTIFIER (type);
11182
11183           if (flag_new_abi)
11184             DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
11185           else
11186             {
11187               /* XXX Temporarily set the scope.
11188                  When returning, start_decl expects it as NULL_TREE,
11189                  and will then then set it using pushdecl. */
11190               my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
11191               if (current_class_type)
11192                 DECL_CONTEXT (decl) = current_class_type;
11193               else
11194                 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11195
11196               DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
11197               DECL_ASSEMBLER_NAME (decl)
11198                 = get_identifier (build_overload_name (type, 1, 1));
11199               DECL_CONTEXT (decl) = NULL_TREE;
11200             }
11201
11202           /* FIXME remangle member functions; member functions of a
11203              type with external linkage have external linkage.  */
11204         }
11205
11206       if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
11207         {
11208           cp_error_at ("typedef name may not be class-qualified", decl);
11209           return NULL_TREE;
11210         }
11211       else if (quals)
11212         {
11213           if (ctype == NULL_TREE)
11214             {
11215               if (TREE_CODE (type) != METHOD_TYPE)
11216                 cp_error_at ("invalid type qualifier for non-member function type", decl);
11217               else
11218                 ctype = TYPE_METHOD_BASETYPE (type);
11219             }
11220           if (ctype != NULL_TREE)
11221             grok_method_quals (ctype, decl, quals);
11222         }
11223
11224       if (RIDBIT_SETP (RID_SIGNED, specbits)
11225           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11226         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11227
11228       bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11229                       inlinep, friendp, raises != NULL_TREE);
11230
11231       if (initialized)
11232         error ("typedef declaration includes an initializer");
11233
11234       return decl;
11235     }
11236
11237   /* Detect the case of an array type of unspecified size
11238      which came, as such, direct from a typedef name.
11239      We must copy the type, so that each identifier gets
11240      a distinct type, so that each identifier's size can be
11241      controlled separately by its own initializer.  */
11242
11243   if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11244       && TYPE_DOMAIN (type) == NULL_TREE)
11245     {
11246       type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11247     }
11248
11249   /* If this is a type name (such as, in a cast or sizeof),
11250      compute the type and return it now.  */
11251
11252   if (decl_context == TYPENAME)
11253     {
11254       /* Note that the grammar rejects storage classes
11255          in typenames, fields or parameters.  */
11256       if (type_quals != TYPE_UNQUALIFIED)
11257         type_quals = TYPE_UNQUALIFIED;
11258
11259       /* Special case: "friend class foo" looks like a TYPENAME context.  */
11260       if (friendp)
11261         {
11262           if (type_quals != TYPE_UNQUALIFIED)
11263             {
11264               cp_error ("type qualifiers specified for friend class declaration");
11265               type_quals = TYPE_UNQUALIFIED;
11266             }
11267           if (inlinep)
11268             {
11269               cp_error ("`inline' specified for friend class declaration");
11270               inlinep = 0;
11271             }
11272
11273           /* Only try to do this stuff if we didn't already give up.  */
11274           if (type != integer_type_node)
11275             {
11276               /* A friendly class?  */
11277               if (current_class_type)
11278                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11279               else
11280                 error ("trying to make class `%s' a friend of global scope",
11281                        TYPE_NAME_STRING (type));
11282               type = void_type_node;
11283             }
11284         }
11285       else if (quals)
11286         {
11287           if (ctype == NULL_TREE)
11288             {
11289               if (TREE_CODE (type) != METHOD_TYPE)
11290                 cp_error ("invalid qualifiers on non-member function type");
11291               else
11292                 ctype = TYPE_METHOD_BASETYPE (type);
11293             }
11294           if (ctype)
11295             {
11296               tree dummy = build_decl (TYPE_DECL, declarator, type);
11297               grok_method_quals (ctype, dummy, quals);
11298               type = TREE_TYPE (dummy);
11299             }
11300         }
11301
11302       return type;
11303     }
11304   else if (declarator == NULL_TREE && decl_context != PARM
11305            && decl_context != CATCHPARM
11306            && TREE_CODE (type) != UNION_TYPE
11307            && ! bitfield)
11308     {
11309       cp_error ("abstract declarator `%T' used as declaration", type);
11310       declarator = make_anon_name ();
11311     }
11312
11313   /* `void' at top level (not within pointer)
11314      is allowed only in typedefs or type names.
11315      We don't complain about parms either, but that is because
11316      a better error message can be made later.  */
11317
11318   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11319     {
11320       if (! declarator)
11321         error ("unnamed variable or field declared void");
11322       else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11323         {
11324           if (IDENTIFIER_OPNAME_P (declarator))
11325             my_friendly_abort (356);
11326           else
11327             error ("variable or field `%s' declared void", name);
11328         }
11329       else
11330         error ("variable or field declared void");
11331       type = integer_type_node;
11332     }
11333
11334   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11335      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
11336
11337   if (decl_context == PARM || decl_context == CATCHPARM)
11338     {
11339       if (ctype || in_namespace)
11340         error ("cannot use `::' in parameter declaration");
11341
11342       /* A parameter declared as an array of T is really a pointer to T.
11343          One declared as a function is really a pointer to a function.
11344          One declared as a member is really a pointer to member.  */
11345
11346       if (TREE_CODE (type) == ARRAY_TYPE)
11347         {
11348           /* Transfer const-ness of array into that of type pointed to.  */
11349           type = build_pointer_type (TREE_TYPE (type));
11350           type_quals = TYPE_UNQUALIFIED;
11351         }
11352       else if (TREE_CODE (type) == FUNCTION_TYPE)
11353         type = build_pointer_type (type);
11354       else if (TREE_CODE (type) == OFFSET_TYPE)
11355         type = build_pointer_type (type);
11356       else if (TREE_CODE (type) == VOID_TYPE && declarator)
11357         {
11358           error ("declaration of `%s' as void", name);
11359           return NULL_TREE;
11360         }
11361     }
11362
11363   {
11364     register tree decl;
11365
11366     if (decl_context == PARM)
11367       {
11368         decl = build_decl (PARM_DECL, declarator, type);
11369
11370         bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11371                         inlinep, friendp, raises != NULL_TREE);
11372
11373         /* Compute the type actually passed in the parmlist,
11374            for the case where there is no prototype.
11375            (For example, shorts and chars are passed as ints.)
11376            When there is a prototype, this is overridden later.  */
11377
11378         DECL_ARG_TYPE (decl) = type_promotes_to (type);
11379       }
11380     else if (decl_context == FIELD)
11381       {
11382         if (type == error_mark_node)
11383           {
11384             /* Happens when declaring arrays of sizes which
11385                are error_mark_node, for example.  */
11386             decl = NULL_TREE;
11387           }
11388         else if (in_namespace && !friendp)
11389           {
11390             /* Something like struct S { int N::j; };  */
11391             cp_error ("invalid use of `::'");
11392             decl = NULL_TREE;
11393           }
11394         else if (TREE_CODE (type) == FUNCTION_TYPE)
11395           {
11396             int publicp = 0;
11397             tree function_context;
11398
11399             /* We catch the others as conflicts with the builtin
11400                typedefs.  */
11401             if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11402               {
11403                 cp_error ("function `%D' cannot be declared friend",
11404                           declarator);
11405                 friendp = 0;
11406               }
11407
11408             if (friendp == 0)
11409               {
11410                 if (ctype == NULL_TREE)
11411                   ctype = current_class_type;
11412
11413                 if (ctype == NULL_TREE)
11414                   {
11415                     cp_error ("can't make `%D' into a method -- not in a class",
11416                               declarator);
11417                     return void_type_node;
11418                   }
11419
11420                 /* ``A union may [ ... ] not [ have ] virtual functions.''
11421                    ARM 9.5 */
11422                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11423                   {
11424                     cp_error ("function `%D' declared virtual inside a union",
11425                               declarator);
11426                     return void_type_node;
11427                   }
11428
11429                 if (declarator == ansi_opname (NEW_EXPR)
11430                     || declarator == ansi_opname (VEC_NEW_EXPR)
11431                     || declarator == ansi_opname (DELETE_EXPR)
11432                     || declarator == ansi_opname (VEC_DELETE_EXPR))
11433                   {
11434                     if (virtualp)
11435                       {
11436                         cp_error ("`%D' cannot be declared virtual, since it is always static",
11437                                   declarator);
11438                         virtualp = 0;
11439                       }
11440                   }
11441                 else if (staticp < 2)
11442                   type = build_cplus_method_type (ctype, TREE_TYPE (type),
11443                                                   TYPE_ARG_TYPES (type));
11444               }
11445
11446             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
11447             function_context = (ctype != NULL_TREE) ?
11448               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11449             publicp = (! friendp || ! staticp)
11450               && function_context == NULL_TREE;
11451             decl = grokfndecl (ctype, type,
11452                                TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11453                                ? declarator : dname,
11454                                declarator,
11455                                virtualp, flags, quals, raises,
11456                                friendp ? -1 : 0, friendp, publicp, inlinep,
11457                                funcdef_flag, template_count, in_namespace);
11458             if (decl == NULL_TREE)
11459               return decl;
11460 #if 0
11461             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
11462             /* The decl and setting of decl_machine_attr is also turned off.  */
11463             decl = build_decl_attribute_variant (decl, decl_machine_attr);
11464 #endif
11465
11466             /* [class.conv.ctor]
11467
11468                A constructor declared without the function-specifier
11469                explicit that can be called with a single parameter
11470                specifies a conversion from the type of its first
11471                parameter to the type of its class.  Such a constructor
11472                is called a converting constructor.  */
11473             if (explicitp == 2)
11474               DECL_NONCONVERTING_P (decl) = 1;
11475             else if (DECL_CONSTRUCTOR_P (decl))
11476               {
11477                 /* The constructor can be called with exactly one
11478                    parameter if there is at least one parameter, and
11479                    any subsequent parameters have default arguments.
11480                    We don't look at the first parameter, which is
11481                    really just the `this' parameter for the new
11482                    object.  */
11483                 tree arg_types =
11484                   TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11485
11486                 /* Skip the `in_chrg' argument too, if present.  */
11487                 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11488                   arg_types = TREE_CHAIN (arg_types);
11489
11490                 if (arg_types == void_list_node
11491                     || (arg_types
11492                         && TREE_CHAIN (arg_types)
11493                         && TREE_CHAIN (arg_types) != void_list_node
11494                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11495                   DECL_NONCONVERTING_P (decl) = 1;
11496               }
11497           }
11498         else if (TREE_CODE (type) == METHOD_TYPE)
11499           {
11500             /* We only get here for friend declarations of
11501                members of other classes.  */
11502             /* All method decls are public, so tell grokfndecl to set
11503                TREE_PUBLIC, also.  */
11504             decl = grokfndecl (ctype, type, declarator, declarator,
11505                                virtualp, flags, quals, raises,
11506                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11507                                template_count, in_namespace);
11508             if (decl == NULL_TREE)
11509               return NULL_TREE;
11510           }
11511         else if (!staticp && ! processing_template_decl
11512                  && !COMPLETE_TYPE_P (complete_type (type))
11513                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11514           {
11515             if (declarator)
11516               cp_error ("field `%D' has incomplete type", declarator);
11517             else
11518               cp_error ("name `%T' has incomplete type", type);
11519
11520             /* If we're instantiating a template, tell them which
11521                instantiation made the field's type be incomplete.  */
11522             if (current_class_type
11523                 && TYPE_NAME (current_class_type)
11524                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11525                 && declspecs && TREE_VALUE (declspecs)
11526                 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11527               cp_error ("  in instantiation of template `%T'",
11528                         current_class_type);
11529
11530             type = error_mark_node;
11531             decl = NULL_TREE;
11532           }
11533         else
11534           {
11535             if (friendp)
11536               {
11537                 error ("`%s' is neither function nor member function; cannot be declared friend",
11538                        IDENTIFIER_POINTER (declarator));
11539                 friendp = 0;
11540               }
11541             decl = NULL_TREE;
11542           }
11543
11544         if (friendp)
11545           {
11546             /* Friends are treated specially.  */
11547             if (ctype == current_class_type)
11548               warning ("member functions are implicitly friends of their class");
11549             else
11550               {
11551                 tree t = NULL_TREE;
11552                 if (decl && DECL_NAME (decl))
11553                   {
11554                     if (template_class_depth (current_class_type) == 0)
11555                       {
11556                         decl
11557                           = check_explicit_specialization
11558                           (declarator, decl,
11559                            template_count, 2 * (funcdef_flag != 0) + 4);
11560                         if (decl == error_mark_node)
11561                           return error_mark_node;
11562                       }
11563
11564                     t = do_friend (ctype, declarator, decl,
11565                                    last_function_parms, attrlist, flags, quals,
11566                                    funcdef_flag);
11567                   }
11568                 if (t && funcdef_flag)
11569                   return t;
11570
11571                 return void_type_node;
11572               }
11573           }
11574
11575         /* Structure field.  It may not be a function, except for C++ */
11576
11577         if (decl == NULL_TREE)
11578           {
11579             if (initialized)
11580               {
11581                 if (!staticp)
11582                   {
11583                     /* An attempt is being made to initialize a non-static
11584                        member.  But, from [class.mem]:
11585
11586                        4 A member-declarator can contain a
11587                        constant-initializer only if it declares a static
11588                        member (_class.static_) of integral or enumeration
11589                        type, see _class.static.data_.
11590
11591                        This used to be relatively common practice, but
11592                        the rest of the compiler does not correctly
11593                        handle the initialization unless the member is
11594                        static so we make it static below.  */
11595                     cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11596                                 declarator);
11597                     cp_pedwarn ("making `%D' static", declarator);
11598                     staticp = 1;
11599                   }
11600
11601                 if (uses_template_parms (type))
11602                   /* We'll check at instantiation time.  */
11603                   ;
11604                 else if (check_static_variable_definition (declarator,
11605                                                            type))
11606                   /* If we just return the declaration, crashes
11607                      will sometimes occur.  We therefore return
11608                      void_type_node, as if this was a friend
11609                      declaration, to cause callers to completely
11610                      ignore this declaration.  */
11611                   return void_type_node;
11612               }
11613
11614             /* 9.2p13 [class.mem] */
11615             if (declarator == constructor_name (current_class_type)
11616                 /* The standard does not allow non-static data members
11617                    here either, but we agreed at the 10/99 meeting
11618                    to change that in TC 1 so that they are allowed in
11619                    classes with no user-defined constructors.  */
11620                 && staticp)
11621               cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11622                           declarator);
11623
11624             if (staticp)
11625               {
11626                 /* C++ allows static class members.  All other work
11627                    for this is done by grokfield.  */
11628                 decl = build_lang_decl (VAR_DECL, declarator, type);
11629                 TREE_STATIC (decl) = 1;
11630                 /* In class context, 'static' means public access.  */
11631                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11632               }
11633             else
11634               {
11635                 decl = build_decl (FIELD_DECL, declarator, type);
11636                 DECL_NONADDRESSABLE_P (decl) = bitfield;
11637                 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11638                   {
11639                     DECL_MUTABLE_P (decl) = 1;
11640                     RIDBIT_RESET (RID_MUTABLE, specbits);
11641                   }
11642               }
11643
11644             bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11645                             inlinep, friendp, raises != NULL_TREE);
11646           }
11647       }
11648     else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11649       {
11650         tree original_name;
11651         int publicp = 0;
11652
11653         if (! declarator)
11654           return NULL_TREE;
11655
11656         if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11657           original_name = dname;
11658         else
11659           original_name = declarator;
11660
11661         if (RIDBIT_SETP (RID_AUTO, specbits))
11662           error ("storage class `auto' invalid for function `%s'", name);
11663         else if (RIDBIT_SETP (RID_REGISTER, specbits))
11664           error ("storage class `register' invalid for function `%s'", name);
11665
11666         /* Function declaration not at top level.
11667            Storage classes other than `extern' are not allowed
11668            and `extern' makes no difference.  */
11669         if (! toplevel_bindings_p ()
11670             && (RIDBIT_SETP (RID_STATIC, specbits)
11671                 || RIDBIT_SETP (RID_INLINE, specbits))
11672             && pedantic)
11673           {
11674             if (RIDBIT_SETP (RID_STATIC, specbits))
11675               pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11676             else
11677               pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11678           }
11679
11680         if (ctype == NULL_TREE)
11681           {
11682             if (virtualp)
11683               {
11684                 error ("virtual non-class function `%s'", name);
11685                 virtualp = 0;
11686               }
11687           }
11688         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11689           type = build_cplus_method_type (ctype, TREE_TYPE (type),
11690                                           TYPE_ARG_TYPES (type));
11691
11692         /* Record presence of `static'.  */
11693         publicp = (ctype != NULL_TREE
11694                    || RIDBIT_SETP (RID_EXTERN, specbits)
11695                    || !RIDBIT_SETP (RID_STATIC, specbits));
11696
11697         decl = grokfndecl (ctype, type, original_name, declarator,
11698                            virtualp, flags, quals, raises,
11699                            1, friendp,
11700                            publicp, inlinep, funcdef_flag,
11701                            template_count, in_namespace);
11702         if (decl == NULL_TREE)
11703           return NULL_TREE;
11704
11705         if (staticp == 1)
11706           {
11707             int illegal_static = 0;
11708
11709             /* Don't allow a static member function in a class, and forbid
11710                declaring main to be static.  */
11711             if (TREE_CODE (type) == METHOD_TYPE)
11712               {
11713                 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11714                 illegal_static = 1;
11715               }
11716             else if (current_function_decl)
11717               {
11718                 /* FIXME need arm citation */
11719                 error ("cannot declare static function inside another function");
11720                 illegal_static = 1;
11721               }
11722
11723             if (illegal_static)
11724               {
11725                 staticp = 0;
11726                 RIDBIT_RESET (RID_STATIC, specbits);
11727               }
11728           }
11729       }
11730     else
11731       {
11732         /* It's a variable.  */
11733
11734         /* An uninitialized decl with `extern' is a reference.  */
11735         decl = grokvardecl (type, declarator, &specbits,
11736                             initialized,
11737                             (type_quals & TYPE_QUAL_CONST) != 0,
11738                             in_namespace);
11739         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11740                         inlinep, friendp, raises != NULL_TREE);
11741
11742         if (ctype)
11743           {
11744             DECL_CONTEXT (decl) = ctype;
11745             if (staticp == 1)
11746               {
11747                 cp_pedwarn ("static member `%D' re-declared as static", decl);
11748                 staticp = 0;
11749                 RIDBIT_RESET (RID_STATIC, specbits);
11750               }
11751             if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11752               {
11753                 cp_error ("static member `%D' declared `register'", decl);
11754                 RIDBIT_RESET (RID_REGISTER, specbits);
11755               }
11756             if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11757               {
11758                 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11759                             decl);
11760                 RIDBIT_RESET (RID_EXTERN, specbits);
11761               }
11762           }
11763       }
11764
11765     my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11766
11767     /* Record `register' declaration for warnings on &
11768        and in case doing stupid register allocation.  */
11769
11770     if (RIDBIT_SETP (RID_REGISTER, specbits))
11771       DECL_REGISTER (decl) = 1;
11772
11773     if (RIDBIT_SETP (RID_EXTERN, specbits))
11774       DECL_THIS_EXTERN (decl) = 1;
11775
11776     if (RIDBIT_SETP (RID_STATIC, specbits))
11777       DECL_THIS_STATIC (decl) = 1;
11778
11779     /* Record constancy and volatility.  There's no need to do this
11780        when processing a template; we'll do this for the instantiated
11781        declaration based on the type of DECL.  */
11782     if (!processing_template_decl)
11783       c_apply_type_quals_to_decl (type_quals, decl);
11784
11785     return decl;
11786   }
11787 }
11788 \f
11789 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11790    An empty exprlist is a parmlist.  An exprlist which
11791    contains only identifiers at the global level
11792    is a parmlist.  Otherwise, it is an exprlist.  */
11793
11794 int
11795 parmlist_is_exprlist (exprs)
11796      tree exprs;
11797 {
11798   if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11799     return 0;
11800
11801   if (toplevel_bindings_p ())
11802     {
11803       /* At the global level, if these are all identifiers,
11804          then it is a parmlist.  */
11805       while (exprs)
11806         {
11807           if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11808             return 1;
11809           exprs = TREE_CHAIN (exprs);
11810         }
11811       return 0;
11812     }
11813   return 1;
11814 }
11815
11816 /* Subroutine of start_function.  Ensure that each of the parameter
11817    types (as listed in PARMS) is complete, as is required for a
11818    function definition.  */
11819
11820 static void
11821 require_complete_types_for_parms (parms)
11822      tree parms;
11823 {
11824   for (; parms; parms = TREE_CHAIN (parms))
11825     {
11826       tree type = TREE_TYPE (parms);
11827
11828       /* Try to complete the TYPE.  */
11829       type = complete_type (type);
11830
11831       if (type == error_mark_node)
11832         continue;
11833
11834       if (!COMPLETE_TYPE_P (type))
11835         {
11836           if (DECL_NAME (parms))
11837             error ("parameter `%s' has incomplete type",
11838                    IDENTIFIER_POINTER (DECL_NAME (parms)));
11839           else
11840             error ("parameter has incomplete type");
11841           TREE_TYPE (parms) = error_mark_node;
11842         }
11843       else
11844         layout_decl (parms, 0);
11845     }
11846 }
11847
11848 /* Returns non-zero if T is a local variable.  */
11849
11850 int
11851 local_variable_p (t)
11852      tree t;
11853 {
11854   if ((TREE_CODE (t) == VAR_DECL
11855        /* A VAR_DECL with a context that is a _TYPE is a static data
11856           member.  */
11857        && !TYPE_P (CP_DECL_CONTEXT (t))
11858        /* Any other non-local variable must be at namespace scope.  */
11859        && !DECL_NAMESPACE_SCOPE_P (t))
11860       || (TREE_CODE (t) == PARM_DECL))
11861     return 1;
11862
11863   return 0;
11864 }
11865
11866 /* Returns non-zero if T is an automatic local variable or a label.
11867    (These are the declarations that need to be remapped when the code
11868    containing them is duplicated.)  */
11869
11870 int
11871 nonstatic_local_decl_p (t)
11872      tree t;
11873 {
11874   return ((local_variable_p (t) && !TREE_STATIC (t))
11875           || TREE_CODE (t) == LABEL_DECL
11876           || TREE_CODE (t) == RESULT_DECL);
11877 }
11878
11879 /* Like local_variable_p, but suitable for use as a tree-walking
11880    function.  */
11881
11882 static tree
11883 local_variable_p_walkfn (tp, walk_subtrees, data)
11884      tree *tp;
11885      int *walk_subtrees ATTRIBUTE_UNUSED;
11886      void *data ATTRIBUTE_UNUSED;
11887 {
11888   return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11889           ? *tp : NULL_TREE);
11890 }
11891
11892 /* Check that ARG, which is a default-argument expression for a
11893    parameter DECL, is legal.  Returns ARG, or ERROR_MARK_NODE, if
11894    something goes wrong.  DECL may also be a _TYPE node, rather than a
11895    DECL, if there is no DECL available.  */
11896
11897 tree
11898 check_default_argument (decl, arg)
11899      tree decl;
11900      tree arg;
11901 {
11902   tree var;
11903   tree decl_type;
11904
11905   if (TREE_CODE (arg) == DEFAULT_ARG)
11906     /* We get a DEFAULT_ARG when looking at an in-class declaration
11907        with a default argument.  Ignore the argument for now; we'll
11908        deal with it after the class is complete.  */
11909     return arg;
11910
11911   if (processing_template_decl || uses_template_parms (arg))
11912     /* We don't do anything checking until instantiation-time.  Note
11913        that there may be uninstantiated arguments even for an
11914        instantiated function, since default arguments are not
11915        instantiated until they are needed.  */
11916     return arg;
11917
11918   if (TYPE_P (decl))
11919     {
11920       decl_type = decl;
11921       decl = NULL_TREE;
11922     }
11923   else
11924     decl_type = TREE_TYPE (decl);
11925
11926   if (arg == error_mark_node
11927       || decl == error_mark_node
11928       || TREE_TYPE (arg) == error_mark_node
11929       || decl_type == error_mark_node)
11930     /* Something already went wrong.  There's no need to check
11931        further.  */
11932     return error_mark_node;
11933
11934   /* [dcl.fct.default]
11935
11936      A default argument expression is implicitly converted to the
11937      parameter type.  */
11938   if (!TREE_TYPE (arg)
11939       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11940     {
11941       if (decl)
11942         cp_error ("default argument for `%#D' has type `%T'",
11943                   decl, TREE_TYPE (arg));
11944       else
11945         cp_error ("default argument for parameter of type `%T' has type `%T'",
11946                   decl_type, TREE_TYPE (arg));
11947
11948       return error_mark_node;
11949     }
11950
11951   /* [dcl.fct.default]
11952
11953      Local variables shall not be used in default argument
11954      expressions.
11955
11956      The keyword `this' shall not be used in a default argument of a
11957      member function.  */
11958   var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11959   if (var)
11960     {
11961       cp_error ("default argument `%E' uses local variable `%D'",
11962                 arg, var);
11963       return error_mark_node;
11964     }
11965
11966   /* All is well.  */
11967   return arg;
11968 }
11969
11970 /* Decode the list of parameter types for a function type.
11971    Given the list of things declared inside the parens,
11972    return a list of types.
11973
11974    The list we receive can have three kinds of elements:
11975    an IDENTIFIER_NODE for names given without types,
11976    a TREE_LIST node for arguments given as typespecs or names with typespecs,
11977    or void_type_node, to mark the end of an argument list
11978    when additional arguments are not permitted (... was not used).
11979
11980    FUNCDEF_FLAG is nonzero for a function definition, 0 for
11981    a mere declaration.  A nonempty identifier-list gets an error message
11982    when FUNCDEF_FLAG is zero.
11983    If FUNCDEF_FLAG is 1, then parameter types must be complete.
11984    If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11985
11986    If all elements of the input list contain types,
11987    we return a list of the types.
11988    If all elements contain no type (except perhaps a void_type_node
11989    at the end), we return a null list.
11990    If some have types and some do not, it is an error, and we
11991    return a null list.
11992
11993    Also set last_function_parms to either
11994    a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11995    A list of names is converted to a chain of PARM_DECLs
11996    by store_parm_decls so that ultimately it is always a chain of decls.
11997
11998    Note that in C++, parameters can take default values.  These default
11999    values are in the TREE_PURPOSE field of the TREE_LIST.  It is
12000    an error to specify default values which are followed by parameters
12001    that have no default values, or an ELLIPSES.  For simplicities sake,
12002    only parameters which are specified with their types can take on
12003    default values.  */
12004
12005 static tree
12006 grokparms (first_parm, funcdef_flag)
12007      tree first_parm;
12008      int funcdef_flag;
12009 {
12010   tree result = NULL_TREE;
12011   tree decls = NULL_TREE;
12012
12013   if (first_parm != NULL_TREE
12014       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
12015     {
12016       if (! funcdef_flag)
12017         pedwarn ("parameter names (without types) in function declaration");
12018       last_function_parms = first_parm;
12019       return NULL_TREE;
12020     }
12021   else if (first_parm != NULL_TREE
12022            && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
12023            && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
12024     my_friendly_abort (145);
12025   else
12026     {
12027       /* Types were specified.  This is a list of declarators
12028          each represented as a TREE_LIST node.  */
12029       register tree parm, chain;
12030       int any_init = 0, any_error = 0;
12031
12032       if (first_parm != NULL_TREE)
12033         {
12034           tree last_result = NULL_TREE;
12035           tree last_decl = NULL_TREE;
12036
12037           for (parm = first_parm; parm != NULL_TREE; parm = chain)
12038             {
12039               tree type = NULL_TREE, list_node = parm;
12040               register tree decl = TREE_VALUE (parm);
12041               tree init = TREE_PURPOSE (parm);
12042
12043               chain = TREE_CHAIN (parm);
12044               /* @@ weak defense against parse errors.  */
12045               if (TREE_CODE (decl) != VOID_TYPE
12046                   && TREE_CODE (decl) != TREE_LIST)
12047                 {
12048                   /* Give various messages as the need arises.  */
12049                   if (TREE_CODE (decl) == STRING_CST)
12050                     cp_error ("invalid string constant `%E'", decl);
12051                   else if (TREE_CODE (decl) == INTEGER_CST)
12052                     error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12053                   continue;
12054                 }
12055
12056               if (TREE_CODE (decl) != VOID_TYPE)
12057                 {
12058                   decl = grokdeclarator (TREE_VALUE (decl),
12059                                          TREE_PURPOSE (decl),
12060                                          PARM, init != NULL_TREE,
12061                                          NULL_TREE);
12062                   if (! decl || TREE_TYPE (decl) == error_mark_node)
12063                     continue;
12064
12065                   /* Top-level qualifiers on the parameters are
12066                      ignored for function types.  */
12067                   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
12068
12069                   if (TREE_CODE (type) == VOID_TYPE)
12070                     decl = void_type_node;
12071                   else if (TREE_CODE (type) == METHOD_TYPE)
12072                     {
12073                       if (DECL_NAME (decl))
12074                         /* Cannot use the decl here because
12075                            we don't have DECL_CONTEXT set up yet.  */
12076                         cp_error ("parameter `%D' invalidly declared method type",
12077                                   DECL_NAME (decl));
12078                       else
12079                         error ("parameter invalidly declared method type");
12080                       type = build_pointer_type (type);
12081                       TREE_TYPE (decl) = type;
12082                     }
12083                   else if (TREE_CODE (type) == OFFSET_TYPE)
12084                     {
12085                       if (DECL_NAME (decl))
12086                         cp_error ("parameter `%D' invalidly declared offset type",
12087                                   DECL_NAME (decl));
12088                       else
12089                         error ("parameter invalidly declared offset type");
12090                       type = build_pointer_type (type);
12091                       TREE_TYPE (decl) = type;
12092                     }
12093                   else if (abstract_virtuals_error (decl, type))
12094                     any_error = 1;  /* Seems like a good idea. */
12095                   else if (POINTER_TYPE_P (type))
12096                     {
12097                       tree t = type;
12098                       while (POINTER_TYPE_P (t)
12099                              || (TREE_CODE (t) == ARRAY_TYPE
12100                                  && TYPE_DOMAIN (t) != NULL_TREE))
12101                         t = TREE_TYPE (t);
12102                       if (TREE_CODE (t) == ARRAY_TYPE)
12103                         cp_error ("parameter type `%T' includes %s to array of unknown bound",
12104                                   type,
12105                                   TYPE_PTR_P (type) ? "pointer" : "reference");
12106                     }
12107                 }
12108
12109               if (TREE_CODE (decl) == VOID_TYPE)
12110                 {
12111                   if (result == NULL_TREE)
12112                     {
12113                       result = void_list_node;
12114                       last_result = result;
12115                     }
12116                   else
12117                     {
12118                       TREE_CHAIN (last_result) = void_list_node;
12119                       last_result = void_list_node;
12120                     }
12121                   if (chain
12122                       && (chain != void_list_node || TREE_CHAIN (chain)))
12123                     error ("`void' in parameter list must be entire list");
12124                   break;
12125                 }
12126
12127               /* Since there is a prototype, args are passed in their own types.  */
12128               DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
12129               if (PROMOTE_PROTOTYPES
12130                   && (TREE_CODE (type) == INTEGER_TYPE
12131                       || TREE_CODE (type) == ENUMERAL_TYPE)
12132                   && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
12133                 DECL_ARG_TYPE (decl) = integer_type_node;
12134               if (!any_error && init)
12135                 {
12136                   any_init++;
12137                   init = check_default_argument (decl, init);
12138                 }
12139               else
12140                 init = NULL_TREE;
12141
12142               if (decls == NULL_TREE)
12143                 {
12144                   decls = decl;
12145                   last_decl = decls;
12146                 }
12147               else
12148                 {
12149                   TREE_CHAIN (last_decl) = decl;
12150                   last_decl = decl;
12151                 }
12152               list_node = tree_cons (init, type, NULL_TREE);
12153               if (result == NULL_TREE)
12154                 {
12155                   result = list_node;
12156                   last_result = result;
12157                 }
12158               else
12159                 {
12160                   TREE_CHAIN (last_result) = list_node;
12161                   last_result = list_node;
12162                 }
12163             }
12164           if (last_result)
12165             TREE_CHAIN (last_result) = NULL_TREE;
12166           /* If there are no parameters, and the function does not end
12167              with `...', then last_decl will be NULL_TREE.  */
12168           if (last_decl != NULL_TREE)
12169             TREE_CHAIN (last_decl) = NULL_TREE;
12170         }
12171     }
12172
12173   last_function_parms = decls;
12174
12175   return result;
12176 }
12177
12178 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12179    FUNCTION_TYPE with the newly parsed version of its default argument, which
12180    was previously digested as text.  See snarf_defarg et al in lex.c.  */
12181
12182 void
12183 replace_defarg (arg, init)
12184      tree arg, init;
12185 {
12186   if (! processing_template_decl
12187       && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
12188     cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12189                 TREE_TYPE (init), TREE_VALUE (arg));
12190   TREE_PURPOSE (arg) = init;
12191 }
12192 \f
12193 /* D is a constructor or overloaded `operator='.  Returns non-zero if
12194    D's arguments allow it to be a copy constructor, or copy assignment
12195    operator.  */
12196
12197 int
12198 copy_args_p (d)
12199      tree d;
12200 {
12201   tree t;
12202
12203   if (!DECL_FUNCTION_MEMBER_P (d))
12204     return 0;
12205
12206   t = FUNCTION_ARG_CHAIN (d);
12207   if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
12208     t = TREE_CHAIN (t);
12209   if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
12210       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
12211           == DECL_CONTEXT (d))
12212       && (TREE_CHAIN (t) == NULL_TREE
12213           || TREE_CHAIN (t) == void_list_node
12214           || TREE_PURPOSE (TREE_CHAIN (t))))
12215     return 1;
12216   return 0;
12217 }
12218
12219 /* These memoizing functions keep track of special properties which
12220    a class may have.  `grok_ctor_properties' notices whether a class
12221    has a constructor of the form X(X&), and also complains
12222    if the class has a constructor of the form X(X).
12223    `grok_op_properties' takes notice of the various forms of
12224    operator= which are defined, as well as what sorts of type conversion
12225    may apply.  Both functions take a FUNCTION_DECL as an argument.  */
12226
12227 int
12228 grok_ctor_properties (ctype, decl)
12229      tree ctype, decl;
12230 {
12231   tree parmtypes = FUNCTION_ARG_CHAIN (decl);
12232   tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12233
12234   /* When a type has virtual baseclasses, a magical first int argument is
12235      added to any ctor so we can tell if the class has been initialized
12236      yet.  This could screw things up in this function, so we deliberately
12237      ignore the leading int if we're in that situation.  */
12238   if (DECL_HAS_IN_CHARGE_PARM_P (decl))
12239     {
12240       my_friendly_assert (parmtypes
12241                           && TREE_VALUE (parmtypes) == integer_type_node,
12242                           980529);
12243       parmtypes = TREE_CHAIN (parmtypes);
12244       parmtype = TREE_VALUE (parmtypes);
12245     }
12246
12247   /* [class.copy]
12248
12249      A non-template constructor for class X is a copy constructor if
12250      its first parameter is of type X&, const X&, volatile X& or const
12251      volatile X&, and either there are no other parameters or else all
12252      other parameters have default arguments.  */
12253   if (TREE_CODE (parmtype) == REFERENCE_TYPE
12254       && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12255       && (TREE_CHAIN (parmtypes) == NULL_TREE
12256           || TREE_CHAIN (parmtypes) == void_list_node
12257           || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12258       && !(DECL_TEMPLATE_INSTANTIATION (decl)
12259            && is_member_template (DECL_TI_TEMPLATE (decl))))
12260     {
12261       TYPE_HAS_INIT_REF (ctype) = 1;
12262       if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12263         TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12264     }
12265   /* [class.copy]
12266
12267      A declaration of a constructor for a class X is ill-formed if its
12268      first parameter is of type (optionally cv-qualified) X and either
12269      there are no other parameters or else all other parameters have
12270      default arguments.
12271
12272      We *don't* complain about member template instantiations that
12273      have this form, though; they can occur as we try to decide what
12274      constructor to use during overload resolution.  Since overload
12275      resolution will never prefer such a constructor to the
12276      non-template copy constructor (which is either explicitly or
12277      implicitly defined), there's no need to worry about their
12278      existence.  Theoretically, they should never even be
12279      instantiated, but that's hard to forestall.  */
12280   else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12281            && (TREE_CHAIN (parmtypes) == NULL_TREE
12282                || TREE_CHAIN (parmtypes) == void_list_node
12283                || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12284            && !(DECL_TEMPLATE_INSTANTIATION (decl)
12285                 && is_member_template (DECL_TI_TEMPLATE (decl))))
12286     {
12287       cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12288                 ctype, ctype);
12289       SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12290       return 0;
12291     }
12292   else if (TREE_CODE (parmtype) == VOID_TYPE
12293            || TREE_PURPOSE (parmtypes) != NULL_TREE)
12294     TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12295
12296   return 1;
12297 }
12298
12299 /* An operator with this code is unary, but can also be binary.  */
12300
12301 static int
12302 ambi_op_p (code)
12303      enum tree_code code;
12304 {
12305   return (code == INDIRECT_REF
12306           || code == ADDR_EXPR
12307           || code == CONVERT_EXPR
12308           || code == NEGATE_EXPR
12309           || code == PREINCREMENT_EXPR
12310           || code == PREDECREMENT_EXPR);
12311 }
12312
12313 /* An operator with this name can only be unary.  */
12314
12315 static int
12316 unary_op_p (code)
12317      enum tree_code code;
12318 {
12319   return (code == TRUTH_NOT_EXPR
12320           || code == BIT_NOT_EXPR
12321           || code == COMPONENT_REF
12322           || code == TYPE_EXPR);
12323 }
12324
12325 /* Do a little sanity-checking on how they declared their operator.  */
12326
12327 void
12328 grok_op_properties (decl, virtualp, friendp)
12329      tree decl;
12330      int virtualp, friendp;
12331 {
12332   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12333   tree argtype;
12334   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12335   tree name = DECL_NAME (decl);
12336   enum tree_code operator_code;
12337   int arity;
12338
12339   /* Count the number of arguments.  */
12340   for (argtype = argtypes, arity = 0;
12341        argtype && argtype != void_list_node;
12342        argtype = TREE_CHAIN (argtype))
12343     ++arity;
12344
12345   if (current_class_type == NULL_TREE)
12346     friendp = 1;
12347
12348   if (DECL_CONV_FN_P (decl))
12349     operator_code = TYPE_EXPR;
12350   else
12351     do
12352       {
12353 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P)  \
12354         if (ansi_opname (CODE) == name)                                     \
12355           {                                                                 \
12356             operator_code = CODE;                                           \
12357             break;                                                          \
12358           }                                                                 \
12359         else if (ansi_assopname (CODE) == name)                             \
12360           {                                                                 \
12361             operator_code = CODE;                                           \
12362             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;                          \
12363             break;                                                          \
12364           }
12365
12366 #include "operators.def"
12367 #undef DEF_OPERATOR
12368
12369         my_friendly_abort (20000527);
12370       }
12371     while (0);
12372   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12373   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12374
12375   if (! friendp)
12376     {
12377       switch (operator_code)
12378         {
12379         case CALL_EXPR:
12380           TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12381           break;
12382
12383         case ARRAY_REF:
12384           TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12385           break;
12386
12387         case COMPONENT_REF:
12388         case MEMBER_REF:
12389           TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12390           break;
12391
12392         case NEW_EXPR:
12393           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12394           break;
12395
12396         case DELETE_EXPR:
12397           TYPE_GETS_DELETE (current_class_type) |= 1;
12398           break;
12399
12400         case VEC_NEW_EXPR:
12401           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12402           break;
12403
12404         case VEC_DELETE_EXPR:
12405           TYPE_GETS_DELETE (current_class_type) |= 2;
12406           break;
12407
12408         default:
12409           break;
12410         }
12411     }
12412
12413   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12414     {
12415       /* When the compiler encounters the definition of A::operator new, it
12416          doesn't look at the class declaration to find out if it's static.  */
12417       if (methodp)
12418         revert_static_member_fn (decl);
12419
12420       /* Take care of function decl if we had syntax errors.  */
12421       if (argtypes == NULL_TREE)
12422         TREE_TYPE (decl)
12423           = build_function_type (ptr_type_node,
12424                                  hash_tree_chain (integer_type_node,
12425                                                   void_list_node));
12426       else
12427         TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12428     }
12429   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12430     {
12431       if (methodp)
12432         revert_static_member_fn (decl);
12433
12434       if (argtypes == NULL_TREE)
12435         TREE_TYPE (decl)
12436           = build_function_type (void_type_node,
12437                                  hash_tree_chain (ptr_type_node,
12438                                                   void_list_node));
12439       else
12440         TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12441     }
12442   else
12443     {
12444       /* An operator function must either be a non-static member function
12445          or have at least one parameter of a class, a reference to a class,
12446          an enumeration, or a reference to an enumeration.  13.4.0.6 */
12447       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12448         {
12449           if (operator_code == TYPE_EXPR
12450               || operator_code == CALL_EXPR
12451               || operator_code == COMPONENT_REF
12452               || operator_code == ARRAY_REF
12453               || operator_code == NOP_EXPR)
12454             cp_error ("`%D' must be a nonstatic member function", decl);
12455           else
12456             {
12457               tree p = argtypes;
12458
12459               if (DECL_STATIC_FUNCTION_P (decl))
12460                 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12461
12462               if (p)
12463                 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12464                   {
12465                     tree arg = TREE_VALUE (p);
12466                     if (TREE_CODE (arg) == REFERENCE_TYPE)
12467                       arg = TREE_TYPE (arg);
12468
12469                     /* This lets bad template code slip through.  */
12470                     if (IS_AGGR_TYPE (arg)
12471                         || TREE_CODE (arg) == ENUMERAL_TYPE
12472                         || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12473                         || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12474                       goto foundaggr;
12475                   }
12476               cp_error
12477                 ("`%D' must have an argument of class or enumerated type",
12478                  decl);
12479             foundaggr:
12480               ;
12481             }
12482         }
12483
12484       if (operator_code == CALL_EXPR)
12485         return;                 /* No restrictions on args. */
12486
12487       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12488         {
12489           tree t = TREE_TYPE (name);
12490           if (! friendp)
12491             {
12492               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12493               const char *what = 0;
12494
12495               if (ref)
12496                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12497
12498               if (TREE_CODE (t) == VOID_TYPE)
12499                 what = "void";
12500               else if (t == current_class_type)
12501                 what = "the same type";
12502               /* Don't force t to be complete here.  */
12503               else if (IS_AGGR_TYPE (t)
12504                        && COMPLETE_TYPE_P (t)
12505                        && DERIVED_FROM_P (t, current_class_type))
12506                 what = "a base class";
12507
12508               if (what)
12509                 warning ("conversion to %s%s will never use a type conversion operator",
12510                          ref ? "a reference to " : "", what);
12511             }
12512         }
12513
12514       if (DECL_ASSIGNMENT_OPERATOR_P (decl)
12515           && operator_code == NOP_EXPR)
12516         {
12517           tree parmtype;
12518
12519           if (arity != 2 && methodp)
12520             {
12521               cp_error ("`%D' must take exactly one argument", decl);
12522               return;
12523             }
12524           parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12525
12526           /* [class.copy]
12527
12528              A user-declared copy assignment operator X::operator= is
12529              a non-static non-template member function of class X with
12530              exactly one parameter of type X, X&, const X&, volatile
12531              X& or const volatile X&.  */
12532           if (copy_assignment_arg_p (parmtype, virtualp)
12533               && !(DECL_TEMPLATE_INSTANTIATION (decl)
12534                    && is_member_template (DECL_TI_TEMPLATE (decl)))
12535               && ! friendp)
12536             {
12537               TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12538               if (TREE_CODE (parmtype) != REFERENCE_TYPE
12539                   || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12540                 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12541             }
12542         }
12543       else if (operator_code == COND_EXPR)
12544         {
12545           /* 13.4.0.3 */
12546           cp_error ("ISO C++ prohibits overloading operator ?:");
12547         }
12548       else if (ambi_op_p (operator_code))
12549         {
12550           if (arity == 1)
12551             /* We pick the one-argument operator codes by default, so
12552                we don't have to change anything.  */
12553             ;
12554           else if (arity == 2)
12555             {
12556               /* If we thought this was a unary operator, we now know
12557                  it to be a binary operator.  */
12558               switch (operator_code)
12559                 {
12560                 case INDIRECT_REF:
12561                   operator_code = MULT_EXPR;
12562                   break;
12563
12564                 case ADDR_EXPR:
12565                   operator_code = BIT_AND_EXPR;
12566                   break;
12567
12568                 case CONVERT_EXPR:
12569                   operator_code = PLUS_EXPR;
12570                   break;
12571
12572                 case NEGATE_EXPR:
12573                   operator_code = MINUS_EXPR;
12574                   break;
12575
12576                 case PREINCREMENT_EXPR:
12577                   operator_code = POSTINCREMENT_EXPR;
12578                   break;
12579
12580                 case PREDECREMENT_EXPR:
12581                   operator_code = PREDECREMENT_EXPR;
12582                   break;
12583
12584                 default:
12585                   my_friendly_abort (20000527);
12586                 }
12587
12588               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12589
12590               if ((operator_code == POSTINCREMENT_EXPR
12591                    || operator_code == POSTDECREMENT_EXPR)
12592                   && ! processing_template_decl
12593                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12594                 {
12595                   if (methodp)
12596                     cp_error ("postfix `%D' must take `int' as its argument",
12597                               decl);
12598                   else
12599                     cp_error
12600                       ("postfix `%D' must take `int' as its second argument",
12601                        decl);
12602                 }
12603             }
12604           else
12605             {
12606               if (methodp)
12607                 cp_error ("`%D' must take either zero or one argument", decl);
12608               else
12609                 cp_error ("`%D' must take either one or two arguments", decl);
12610             }
12611
12612           /* More Effective C++ rule 6.  */
12613           if (warn_ecpp
12614               && (operator_code == POSTINCREMENT_EXPR
12615                   || operator_code == POSTDECREMENT_EXPR
12616                   || operator_code == PREINCREMENT_EXPR
12617                   || operator_code == PREDECREMENT_EXPR))
12618             {
12619               tree arg = TREE_VALUE (argtypes);
12620               tree ret = TREE_TYPE (TREE_TYPE (decl));
12621               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12622                 arg = TREE_TYPE (arg);
12623               arg = TYPE_MAIN_VARIANT (arg);
12624               if (operator_code == PREINCREMENT_EXPR
12625                   || operator_code == PREDECREMENT_EXPR)
12626                 {
12627                   if (TREE_CODE (ret) != REFERENCE_TYPE
12628                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12629                                        arg))
12630                     cp_warning ("prefix `%D' should return `%T'", decl,
12631                                 build_reference_type (arg));
12632                 }
12633               else
12634                 {
12635                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12636                     cp_warning ("postfix `%D' should return `%T'", decl, arg);
12637                 }
12638             }
12639         }
12640       else if (unary_op_p (operator_code))
12641         {
12642           if (arity != 1)
12643             {
12644               if (methodp)
12645                 cp_error ("`%D' must take `void'", decl);
12646               else
12647                 cp_error ("`%D' must take exactly one argument", decl);
12648             }
12649         }
12650       else /* if (binary_op_p (operator_code)) */
12651         {
12652           if (arity != 2)
12653             {
12654               if (methodp)
12655                 cp_error ("`%D' must take exactly one argument", decl);
12656               else
12657                 cp_error ("`%D' must take exactly two arguments", decl);
12658             }
12659
12660           /* More Effective C++ rule 7.  */
12661           if (warn_ecpp
12662               && (operator_code == TRUTH_ANDIF_EXPR
12663                   || operator_code == TRUTH_ORIF_EXPR
12664                   || operator_code == COMPOUND_EXPR))
12665             cp_warning ("user-defined `%D' always evaluates both arguments",
12666                         decl);
12667         }
12668
12669       /* Effective C++ rule 23.  */
12670       if (warn_ecpp
12671           && arity == 2
12672           && (operator_code == PLUS_EXPR
12673               || operator_code == MINUS_EXPR
12674               || operator_code == TRUNC_DIV_EXPR
12675               || operator_code == MULT_EXPR)
12676           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12677         cp_warning ("`%D' should return by value", decl);
12678
12679       /* 13.4.0.8 */
12680       for (; argtypes && argtypes != void_list_node;
12681           argtypes = TREE_CHAIN (argtypes))
12682         if (TREE_PURPOSE (argtypes))
12683           {
12684             TREE_PURPOSE (argtypes) = NULL_TREE;
12685             if (operator_code == POSTINCREMENT_EXPR
12686                 || operator_code == POSTDECREMENT_EXPR)
12687               {
12688                 if (pedantic)
12689                   cp_pedwarn ("`%D' cannot have default arguments", decl);
12690               }
12691             else
12692               cp_error ("`%D' cannot have default arguments", decl);
12693           }
12694
12695     }
12696 }
12697 \f
12698 static const char *
12699 tag_name (code)
12700      enum tag_types code;
12701 {
12702   switch (code)
12703     {
12704     case record_type:
12705       return "struct";
12706     case class_type:
12707       return "class";
12708     case union_type:
12709       return "union ";
12710     case enum_type:
12711       return "enum";
12712     default:
12713       my_friendly_abort (981122);
12714     }
12715 }
12716
12717 /* Get the struct, enum or union (CODE says which) with tag NAME.
12718    Define the tag as a forward-reference if it is not defined.
12719
12720    C++: If a class derivation is given, process it here, and report
12721    an error if multiple derivation declarations are not identical.
12722
12723    If this is a definition, come in through xref_tag and only look in
12724    the current frame for the name (since C++ allows new names in any
12725    scope.)  */
12726
12727 tree
12728 xref_tag (code_type_node, name, globalize)
12729      tree code_type_node;
12730      tree name;
12731      int globalize;
12732 {
12733   enum tag_types tag_code;
12734   enum tree_code code;
12735   register tree ref, t;
12736   struct binding_level *b = current_binding_level;
12737   int got_type = 0;
12738   tree attributes = NULL_TREE;
12739   tree context = NULL_TREE;
12740
12741   /* If we are called from the parser, code_type_node will sometimes be a
12742      TREE_LIST.  This indicates that the user wrote
12743      "class __attribute__ ((foo)) bar".  Extract the attributes so we can
12744      use them later.  */
12745   if (TREE_CODE (code_type_node) == TREE_LIST)
12746     {
12747       attributes = TREE_PURPOSE (code_type_node);
12748       code_type_node = TREE_VALUE (code_type_node);
12749     }
12750
12751   tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12752   switch (tag_code)
12753     {
12754     case record_type:
12755     case class_type:
12756       code = RECORD_TYPE;
12757       break;
12758     case union_type:
12759       code = UNION_TYPE;
12760       break;
12761     case enum_type:
12762       code = ENUMERAL_TYPE;
12763       break;
12764     default:
12765       my_friendly_abort (18);
12766     }
12767
12768   /* If a cross reference is requested, look up the type
12769      already defined for this tag and return it.  */
12770   if (TYPE_P (name))
12771     {
12772       t = name;
12773       name = TYPE_IDENTIFIER (t);
12774       got_type = 1;
12775     }
12776   else
12777     t = IDENTIFIER_TYPE_VALUE (name);
12778
12779   if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12780       && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12781     t = NULL_TREE;
12782
12783   if (! globalize)
12784     {
12785       /* If we know we are defining this tag, only look it up in
12786          this scope and don't try to find it as a type.  */
12787       ref = lookup_tag (code, name, b, 1);
12788     }
12789   else
12790     {
12791       if (t)
12792         {
12793           /* [dcl.type.elab] If the identifier resolves to a
12794              typedef-name or a template type-parameter, the
12795              elaborated-type-specifier is ill-formed.  */
12796           if (t != TYPE_MAIN_VARIANT (t)
12797               || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12798             cp_pedwarn ("using typedef-name `%D' after `%s'",
12799                         TYPE_NAME (t), tag_name (tag_code));
12800           else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12801             cp_error ("using template type parameter `%T' after `%s'",
12802                       t, tag_name (tag_code));
12803
12804           ref = t;
12805         }
12806       else
12807         ref = lookup_tag (code, name, b, 0);
12808
12809       if (! ref)
12810         {
12811           /* Try finding it as a type declaration.  If that wins,
12812              use it.  */
12813           ref = lookup_name (name, 1);
12814
12815           if (ref != NULL_TREE
12816               && processing_template_decl
12817               && DECL_CLASS_TEMPLATE_P (ref)
12818               && template_class_depth (current_class_type) == 0)
12819             /* Since GLOBALIZE is true, we're declaring a global
12820                template, so we want this type.  */
12821             ref = DECL_TEMPLATE_RESULT (ref);
12822
12823           if (ref && TREE_CODE (ref) == TYPE_DECL
12824               && TREE_CODE (TREE_TYPE (ref)) == code)
12825             ref = TREE_TYPE (ref);
12826           else
12827             ref = NULL_TREE;
12828         }
12829
12830       if (ref && current_class_type
12831           && template_class_depth (current_class_type)
12832           && PROCESSING_REAL_TEMPLATE_DECL_P ())
12833         {
12834           /* Since GLOBALIZE is non-zero, we are not looking at a
12835              definition of this tag.  Since, in addition, we are currently
12836              processing a (member) template declaration of a template
12837              class, we must be very careful; consider:
12838
12839                template <class X>
12840                struct S1
12841
12842                template <class U>
12843                struct S2
12844                { template <class V>
12845                friend struct S1; };
12846
12847              Here, the S2::S1 declaration should not be confused with the
12848              outer declaration.  In particular, the inner version should
12849              have a template parameter of level 2, not level 1.  This
12850              would be particularly important if the member declaration
12851              were instead:
12852
12853                template <class V = U> friend struct S1;
12854
12855              say, when we should tsubst into `U' when instantiating
12856              S2.  On the other hand, when presented with:
12857
12858                  template <class T>
12859                  struct S1 {
12860                    template <class U>
12861                    struct S2 {};
12862                    template <class U>
12863                    friend struct S2;
12864                  };
12865
12866               we must find the inner binding eventually.  We
12867               accomplish this by making sure that the new type we
12868               create to represent this declaration has the right
12869               TYPE_CONTEXT.  */
12870           context = TYPE_CONTEXT (ref);
12871           ref = NULL_TREE;
12872         }
12873     }
12874
12875   if (! ref)
12876     {
12877       /* If no such tag is yet defined, create a forward-reference node
12878          and record it as the "definition".
12879          When a real declaration of this type is found,
12880          the forward-reference will be altered into a real type.  */
12881       if (code == ENUMERAL_TYPE)
12882         {
12883           cp_error ("use of enum `%#D' without previous declaration", name);
12884
12885           ref = make_node (ENUMERAL_TYPE);
12886
12887           /* Give the type a default layout like unsigned int
12888              to avoid crashing if it does not get defined.  */
12889           TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12890           TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12891           TYPE_USER_ALIGN (ref) = 0;
12892           TREE_UNSIGNED (ref) = 1;
12893           TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12894           TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12895           TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12896
12897           /* Enable us to recognize when a type is created in class context.
12898              To do nested classes correctly, this should probably be cleared
12899              out when we leave this classes scope.  Currently this in only
12900              done in `start_enum'.  */
12901
12902           pushtag (name, ref, globalize);
12903         }
12904       else
12905         {
12906           struct binding_level *old_b = class_binding_level;
12907
12908           ref = make_aggr_type (code);
12909           TYPE_CONTEXT (ref) = context;
12910
12911 #ifdef NONNESTED_CLASSES
12912           /* Class types don't nest the way enums do.  */
12913           class_binding_level = (struct binding_level *)0;
12914 #endif
12915           pushtag (name, ref, globalize);
12916           class_binding_level = old_b;
12917         }
12918     }
12919   else
12920     {
12921       if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12922         redeclare_class_template (ref, current_template_parms);
12923     }
12924
12925   /* Until the type is defined, tentatively accept whatever
12926      structure tag the user hands us.  */
12927   if (!COMPLETE_TYPE_P (ref)
12928       && ref != current_class_type
12929       /* Have to check this, in case we have contradictory tag info.  */
12930       && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12931     {
12932       if (tag_code == class_type)
12933         CLASSTYPE_DECLARED_CLASS (ref) = 1;
12934       else if (tag_code == record_type)
12935         CLASSTYPE_DECLARED_CLASS (ref) = 0;
12936     }
12937
12938   TREE_TYPE (ref) = attributes;
12939
12940   return ref;
12941 }
12942
12943 tree
12944 xref_tag_from_type (old, id, globalize)
12945      tree old, id;
12946      int globalize;
12947 {
12948   tree code_type_node;
12949
12950   if (TREE_CODE (old) == RECORD_TYPE)
12951     code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12952                       ? class_type_node : record_type_node);
12953   else
12954     code_type_node = union_type_node;
12955
12956   if (id == NULL_TREE)
12957     id = TYPE_IDENTIFIER (old);
12958
12959   return xref_tag (code_type_node, id, globalize);
12960 }
12961
12962 /* REF is a type (named NAME), for which we have just seen some
12963    baseclasses.  BINFO is a list of those baseclasses; the
12964    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12965    the base-class.  CODE_TYPE_NODE indicates whether REF is a class,
12966    struct, or union.  */
12967
12968 void
12969 xref_basetypes (code_type_node, name, ref, binfo)
12970      tree code_type_node;
12971      tree name, ref;
12972      tree binfo;
12973 {
12974   /* In the declaration `A : X, Y, ... Z' we mark all the types
12975      (A, X, Y, ..., Z) so we can check for duplicates.  */
12976   tree binfos;
12977   tree base;
12978
12979   int i, len;
12980   enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12981
12982   if (tag_code == union_type)
12983     {
12984       cp_error ("derived union `%T' invalid", ref);
12985       return;
12986     }
12987
12988   len = list_length (binfo);
12989
12990   /* First, make sure that any templates in base-classes are
12991      instantiated.  This ensures that if we call ourselves recursively
12992      we do not get confused about which classes are marked and which
12993      are not.  */
12994   for (base = binfo; base; base = TREE_CHAIN (base))
12995     complete_type (TREE_VALUE (base));
12996
12997   SET_CLASSTYPE_MARKED (ref);
12998   BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12999
13000   for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
13001     {
13002       /* The base of a derived struct is public by default.  */
13003       int via_public
13004         = (TREE_PURPOSE (binfo) == access_public_node
13005            || TREE_PURPOSE (binfo) == access_public_virtual_node
13006            || (tag_code != class_type
13007                && (TREE_PURPOSE (binfo) == access_default_node
13008                    || TREE_PURPOSE (binfo) == access_default_virtual_node)));
13009       int via_protected
13010         = (TREE_PURPOSE (binfo) == access_protected_node
13011            || TREE_PURPOSE (binfo) == access_protected_virtual_node);
13012       int via_virtual
13013         = (TREE_PURPOSE (binfo) == access_private_virtual_node
13014            || TREE_PURPOSE (binfo) == access_protected_virtual_node
13015            || TREE_PURPOSE (binfo) == access_public_virtual_node
13016            || TREE_PURPOSE (binfo) == access_default_virtual_node);
13017       tree basetype = TREE_VALUE (binfo);
13018       tree base_binfo;
13019
13020       if (basetype && TREE_CODE (basetype) == TYPE_DECL)
13021         basetype = TREE_TYPE (basetype);
13022       if (!basetype
13023           || (TREE_CODE (basetype) != RECORD_TYPE
13024               && TREE_CODE (basetype) != TYPENAME_TYPE
13025               && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
13026               && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
13027         {
13028           cp_error ("base type `%T' fails to be a struct or class type",
13029                     TREE_VALUE (binfo));
13030           continue;
13031         }
13032
13033       GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
13034
13035       /* This code replaces similar code in layout_basetypes.
13036          We put the complete_type first for implicit `typename'.  */
13037       if (!COMPLETE_TYPE_P (basetype)
13038           && ! (current_template_parms && uses_template_parms (basetype)))
13039         {
13040           cp_error ("base class `%T' has incomplete type", basetype);
13041           continue;
13042         }
13043       else
13044         {
13045           if (CLASSTYPE_MARKED (basetype))
13046             {
13047               if (basetype == ref)
13048                 cp_error ("recursive type `%T' undefined", basetype);
13049               else
13050                 cp_error ("duplicate base type `%T' invalid", basetype);
13051               continue;
13052             }
13053
13054           if (TYPE_FOR_JAVA (basetype)
13055               && (current_lang_stack
13056                   == &VARRAY_TREE (current_lang_base, 0)))
13057             TYPE_FOR_JAVA (ref) = 1;
13058
13059           /* Note that the BINFO records which describe individual
13060              inheritances are *not* shared in the lattice!  They
13061              cannot be shared because a given baseclass may be
13062              inherited with different `accessibility' by different
13063              derived classes.  (Each BINFO record describing an
13064              individual inheritance contains flags which say what
13065              the `accessibility' of that particular inheritance is.)  */
13066
13067           base_binfo
13068             = make_binfo (size_zero_node, basetype,
13069                           CLASS_TYPE_P (basetype)
13070                           ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
13071                           CLASS_TYPE_P (basetype)
13072                           ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
13073
13074           TREE_VEC_ELT (binfos, i) = base_binfo;
13075           TREE_VIA_PUBLIC (base_binfo) = via_public;
13076           TREE_VIA_PROTECTED (base_binfo) = via_protected;
13077           TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
13078           BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
13079
13080           /* We need to unshare the binfos now so that lookups during class
13081              definition work.  */
13082           unshare_base_binfos (base_binfo);
13083
13084           SET_CLASSTYPE_MARKED (basetype);
13085
13086           /* We are free to modify these bits because they are meaningless
13087              at top level, and BASETYPE is a top-level type.  */
13088           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
13089             {
13090               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
13091               /* Converting to a virtual base class requires looking
13092                  up the offset of the virtual base.  */
13093               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13094             }
13095
13096           if (CLASS_TYPE_P (basetype))
13097             {
13098               TYPE_HAS_NEW_OPERATOR (ref)
13099                 |= TYPE_HAS_NEW_OPERATOR (basetype);
13100               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
13101                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13102               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13103               /* If the base-class uses multiple inheritance, so do we.  */
13104               TYPE_USES_MULTIPLE_INHERITANCE (ref)
13105                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13106               /* Likewise, if converting to a base of the base may require
13107                  code, then we may need to generate code to convert to a
13108                  base as well.  */
13109               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13110                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13111             }
13112
13113           i += 1;
13114         }
13115     }
13116   if (i)
13117     TREE_VEC_LENGTH (binfos) = i;
13118   else
13119     BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
13120
13121   if (i > 1)
13122     {
13123       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13124       /* If there is more than one non-empty they cannot be at the same
13125          address.  */
13126       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13127     }
13128
13129   /* Unmark all the types.  */
13130   while (--i >= 0)
13131     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13132   CLEAR_CLASSTYPE_MARKED (ref);
13133
13134   /* Now that we know all the base-classes, set up the list of virtual
13135      bases.  */
13136   get_vbase_types (ref);
13137 }
13138
13139 \f
13140 /* Begin compiling the definition of an enumeration type.
13141    NAME is its name (or null if anonymous).
13142    Returns the type object, as yet incomplete.
13143    Also records info about it so that build_enumerator
13144    may be used to declare the individual values as they are read.  */
13145
13146 tree
13147 start_enum (name)
13148      tree name;
13149 {
13150   register tree enumtype = NULL_TREE;
13151   struct binding_level *b = current_binding_level;
13152
13153   /* If this is the real definition for a previous forward reference,
13154      fill in the contents in the same object that used to be the
13155      forward reference.  */
13156
13157   if (name != NULL_TREE)
13158     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13159
13160   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13161     {
13162       cp_error ("multiple definition of `%#T'", enumtype);
13163       cp_error_at ("previous definition here", enumtype);
13164       /* Clear out TYPE_VALUES, and start again.  */
13165       TYPE_VALUES (enumtype) = NULL_TREE;
13166     }
13167   else
13168     {
13169       enumtype = make_node (ENUMERAL_TYPE);
13170       pushtag (name, enumtype, 0);
13171     }
13172
13173   if (current_class_type)
13174     TREE_ADDRESSABLE (b->tags) = 1;
13175
13176   GNU_xref_decl (current_function_decl, enumtype);
13177   return enumtype;
13178 }
13179
13180 /* After processing and defining all the values of an enumeration type,
13181    install their decls in the enumeration type and finish it off.
13182    ENUMTYPE is the type object and VALUES a list of name-value pairs.
13183    Returns ENUMTYPE.  */
13184
13185 tree
13186 finish_enum (enumtype)
13187      tree enumtype;
13188 {
13189   register tree minnode = NULL_TREE, maxnode = NULL_TREE;
13190   /* Calculate the maximum value of any enumerator in this type.  */
13191
13192   tree values = TYPE_VALUES (enumtype);
13193   if (values)
13194     {
13195       tree pair;
13196
13197       for (pair = values; pair; pair = TREE_CHAIN (pair))
13198         {
13199           tree decl;
13200           tree value;
13201
13202           /* The TREE_VALUE is a CONST_DECL for this enumeration
13203              constant.  */
13204           decl = TREE_VALUE (pair);
13205
13206           /* [dcl.enum]
13207
13208              Following the closing brace of an enum-specifier, each
13209              enumerator has the type of its enumeration.  Prior to the
13210              closing brace, the type of each enumerator is the type of
13211              its initializing value.  */
13212           TREE_TYPE (decl) = enumtype;
13213
13214           /* The DECL_INITIAL will be NULL if we are processing a
13215              template declaration and this enumeration constant had no
13216              explicit initializer.  */
13217           value = DECL_INITIAL (decl);
13218           if (value && !processing_template_decl)
13219             {
13220               /* Set the TREE_TYPE for the VALUE as well.  That's so
13221                  that when we call decl_constant_value we get an
13222                  entity of the right type (but with the constant
13223                  value).  Since we shouldn't ever call
13224                  decl_constant_value on a template type, there's no
13225                  reason to do that when processing_template_decl.
13226                  And, if the expression is something like a
13227                  TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13228                  wreak havoc on the intended type of the expression.
13229
13230                  Of course, there's also no point in trying to compute
13231                  minimum or maximum values if we're in a template.  */
13232               TREE_TYPE (value) = enumtype;
13233
13234               if (!minnode)
13235                 minnode = maxnode = value;
13236               else if (tree_int_cst_lt (maxnode, value))
13237                 maxnode = value;
13238               else if (tree_int_cst_lt (value, minnode))
13239                 minnode = value;
13240             }
13241
13242           if (processing_template_decl)
13243             /* If this is just a template, leave the CONST_DECL
13244                alone.  That way tsubst_copy will find CONST_DECLs for
13245                CONST_DECLs, and not INTEGER_CSTs.  */
13246             ;
13247           else
13248             /* In the list we're building up, we want the enumeration
13249                values, not the CONST_DECLs.  */
13250             TREE_VALUE (pair) = value;
13251         }
13252     }
13253   else
13254     maxnode = minnode = integer_zero_node;
13255
13256   TYPE_VALUES (enumtype) = nreverse (values);
13257
13258   if (processing_template_decl)
13259     {
13260       tree scope = current_scope ();
13261       if (scope && TREE_CODE (scope) == FUNCTION_DECL)
13262         add_tree (build_min (TAG_DEFN, enumtype));
13263     }
13264   else
13265     {
13266       int unsignedp = tree_int_cst_sgn (minnode) >= 0;
13267       int lowprec = min_precision (minnode, unsignedp);
13268       int highprec = min_precision (maxnode, unsignedp);
13269       int precision = MAX (lowprec, highprec);
13270       tree tem;
13271
13272       TYPE_SIZE (enumtype) = NULL_TREE;
13273
13274       /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'.  */
13275
13276       TYPE_PRECISION (enumtype) = precision;
13277       if (unsignedp)
13278         fixup_unsigned_type (enumtype);
13279       else
13280         fixup_signed_type (enumtype);
13281
13282       if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13283         /* Use the width of the narrowest normal C type which is wide
13284            enough.  */
13285         TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
13286                                                     (precision, 1));
13287       else
13288         TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13289
13290       TYPE_SIZE (enumtype) = 0;
13291       layout_type (enumtype);
13292
13293       /* Fix up all variant types of this enum type.  */
13294       for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
13295            tem = TYPE_NEXT_VARIANT (tem))
13296         {
13297           TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
13298           TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
13299           TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
13300           TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
13301           TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
13302           TYPE_MODE (tem) = TYPE_MODE (enumtype);
13303           TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
13304           TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
13305           TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);
13306           TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
13307         }
13308
13309       /* Finish debugging output for this type.  */
13310       rest_of_type_compilation (enumtype, namespace_bindings_p ());
13311     }
13312
13313   return enumtype;
13314 }
13315
13316 /* Build and install a CONST_DECL for an enumeration constant of the
13317    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13318    Assignment of sequential values by default is handled here.  */
13319
13320 void
13321 build_enumerator (name, value, enumtype)
13322      tree name;
13323      tree value;
13324      tree enumtype;
13325 {
13326   tree decl;
13327   tree context;
13328   tree type;
13329   tree values;
13330
13331   /* Remove no-op casts from the value.  */
13332   if (value)
13333     STRIP_TYPE_NOPS (value);
13334
13335   if (! processing_template_decl)
13336     {
13337       /* Validate and default VALUE.  */
13338       if (value != NULL_TREE)
13339         {
13340           value = decl_constant_value (value);
13341
13342           if (TREE_CODE (value) == INTEGER_CST)
13343             {
13344               value = default_conversion (value);
13345               constant_expression_warning (value);
13346             }
13347           else
13348             {
13349               cp_error ("enumerator value for `%D' not integer constant", name);
13350               value = NULL_TREE;
13351             }
13352         }
13353
13354       /* Default based on previous value.  */
13355       if (value == NULL_TREE && ! processing_template_decl)
13356         {
13357           tree prev_value;
13358
13359           if (TYPE_VALUES (enumtype))
13360             {
13361               /* The next value is the previous value ... */
13362               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13363               /* ... plus one.  */
13364               value = build_binary_op (PLUS_EXPR,
13365                                        prev_value,
13366                                        integer_one_node);
13367
13368               if (tree_int_cst_lt (value, prev_value))
13369                 cp_error ("overflow in enumeration values at `%D'", name);
13370             }
13371           else
13372             value = integer_zero_node;
13373         }
13374
13375       /* Remove no-op casts from the value.  */
13376       if (value)
13377         STRIP_TYPE_NOPS (value);
13378 #if 0
13379       /* To fix MAX_VAL enum consts. (bkoz)  */
13380       TREE_TYPE (value) = integer_type_node;
13381 #endif
13382     }
13383
13384   /* We always have to copy here; not all INTEGER_CSTs are unshared.
13385      Even in other cases, we will later (in finish_enum) be setting
13386      the type of VALUE.  But, we don't need to make a copy if this
13387      VALUE is one of the enumeration constants for this same
13388      enumeration type.  */
13389   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13390     if (TREE_VALUE (values) == value)
13391       break;
13392   /* If we didn't break out of the loop, then we do need a copy.  */
13393   if (!values && value)
13394     value = copy_node (value);
13395
13396   /* C++ associates enums with global, function, or class declarations.  */
13397   context = current_scope ();
13398
13399   /* Build the actual enumeration constant.  Note that the enumeration
13400     constants have the type of their initializers until the
13401     enumeration is complete:
13402
13403       [ dcl.enum ]
13404
13405       Following the closing brace of an enum-specifier, each enumer-
13406       ator has the type of its enumeration.  Prior to the closing
13407       brace, the type of each enumerator is the type of its
13408       initializing value.
13409
13410     In finish_enum we will reset the type.  Of course, if we're
13411     processing a template, there may be no value.   */
13412   type = value ? TREE_TYPE (value) : NULL_TREE;
13413
13414   if (context && context == current_class_type)
13415     /* This enum declaration is local to the class.  We need the full
13416       lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
13417     decl = build_lang_decl (CONST_DECL, name, type);
13418   else
13419     /* It's a global enum, or it's local to a function.  (Note local to
13420       a function could mean local to a class method.  */
13421     decl = build_decl (CONST_DECL, name, type);
13422
13423   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13424   DECL_INITIAL (decl) = value;
13425   TREE_READONLY (decl) = 1;
13426
13427   if (context && context == current_class_type)
13428     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13429       on the TYPE_FIELDS list for `S'.  (That's so that you can say
13430       things like `S::i' later.)  */
13431     finish_member_declaration (decl);
13432   else
13433     {
13434       pushdecl (decl);
13435       GNU_xref_decl (current_function_decl, decl);
13436     }
13437
13438   /* Add this enumeration constant to the list for this type.  */
13439   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13440 }
13441
13442 \f
13443 static int function_depth;
13444
13445 /* We're defining DECL.  Make sure that it's type is OK.  */
13446
13447 static void
13448 check_function_type (decl)
13449      tree decl;
13450 {
13451   tree fntype = TREE_TYPE (decl);
13452   tree return_type = complete_type (TREE_TYPE (fntype));
13453
13454   /* In a function definition, arg types must be complete.  */
13455   require_complete_types_for_parms (current_function_parms);
13456
13457   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13458     {
13459       cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13460
13461       /* Make it return void instead, but don't change the
13462          type of the DECL_RESULT, in case we have a named return value.  */
13463       if (TREE_CODE (fntype) == METHOD_TYPE)
13464         {
13465           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13466           TREE_TYPE (decl)
13467             = build_cplus_method_type (ctype,
13468                                        void_type_node,
13469                                        FUNCTION_ARG_CHAIN (decl));
13470         }
13471       else
13472         TREE_TYPE (decl)
13473           = build_function_type (void_type_node,
13474                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
13475       TREE_TYPE (decl)
13476         = build_exception_variant (fntype,
13477                                    TYPE_RAISES_EXCEPTIONS (fntype));
13478     }
13479   else
13480     abstract_virtuals_error (decl, TREE_TYPE (fntype));
13481 }
13482
13483 /* Create the FUNCTION_DECL for a function definition.
13484    DECLSPECS and DECLARATOR are the parts of the declaration;
13485    they describe the function's name and the type it returns,
13486    but twisted together in a fashion that parallels the syntax of C.
13487
13488    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13489    DECLARATOR is really the DECL for the function we are about to
13490    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13491    indicating that the function is an inline defined in-class, and
13492    SF_EXPAND indicating that we should generate RTL for this
13493    function.
13494
13495    This function creates a binding context for the function body
13496    as well as setting up the FUNCTION_DECL in current_function_decl.
13497
13498    Returns 1 on success.  If the DECLARATOR is not suitable for a function
13499    (it defines a datum instead), we return 0, which tells
13500    yyparse to report a parse error.
13501
13502    For C++, we must first check whether that datum makes any sense.
13503    For example, "class A local_a(1,2);" means that variable local_a
13504    is an aggregate of type A, which should have a constructor
13505    applied to it with the argument list [1, 2].  */
13506
13507 int
13508 start_function (declspecs, declarator, attrs, flags)
13509      tree declspecs, declarator, attrs;
13510      int flags;
13511 {
13512   tree decl1;
13513   tree ctype = NULL_TREE;
13514   tree fntype;
13515   tree restype;
13516   extern int have_extern_spec;
13517   extern int used_extern_spec;
13518   int doing_friend = 0;
13519   struct binding_level *bl;
13520
13521   /* Sanity check.  */
13522   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13523   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13524
13525   /* This should only be done once on the top most decl.  */
13526   if (have_extern_spec && !used_extern_spec)
13527     {
13528       declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13529       used_extern_spec = 1;
13530     }
13531
13532   if (flags & SF_PRE_PARSED)
13533     {
13534       decl1 = declarator;
13535
13536       fntype = TREE_TYPE (decl1);
13537       if (TREE_CODE (fntype) == METHOD_TYPE)
13538         ctype = TYPE_METHOD_BASETYPE (fntype);
13539
13540       /* ISO C++ 11.4/5.  A friend function defined in a class is in
13541          the (lexical) scope of the class in which it is defined.  */
13542       if (!ctype && DECL_FRIEND_P (decl1))
13543         {
13544           ctype = DECL_FRIEND_CONTEXT (decl1);
13545
13546           /* CTYPE could be null here if we're dealing with a template;
13547              for example, `inline friend float foo()' inside a template
13548              will have no CTYPE set.  */
13549           if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13550             ctype = NULL_TREE;
13551           else
13552             doing_friend = 1;
13553         }
13554
13555       last_function_parms = DECL_ARGUMENTS (decl1);
13556       last_function_parm_tags = NULL_TREE;
13557     }
13558   else
13559     {
13560       decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13561       /* If the declarator is not suitable for a function definition,
13562          cause a syntax error.  */
13563       if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13564
13565       fntype = TREE_TYPE (decl1);
13566
13567       restype = TREE_TYPE (fntype);
13568       if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13569         {
13570           cp_error ("semicolon missing after declaration of `%#T'", restype);
13571           shadow_tag (build_tree_list (NULL_TREE, restype));
13572           CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13573           if (TREE_CODE (fntype) == FUNCTION_TYPE)
13574             fntype = build_function_type (integer_type_node,
13575                                           TYPE_ARG_TYPES (fntype));
13576           else
13577             fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13578                                               integer_type_node,
13579                                               TYPE_ARG_TYPES (fntype));
13580           TREE_TYPE (decl1) = fntype;
13581         }
13582
13583       if (TREE_CODE (fntype) == METHOD_TYPE)
13584         ctype = TYPE_METHOD_BASETYPE (fntype);
13585       else if (DECL_MAIN_P (decl1))
13586         {
13587           /* If this doesn't return integer_type, complain.  */
13588           if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13589             {
13590               if (pedantic || warn_return_type)
13591                 pedwarn ("return type for `main' changed to `int'");
13592               TREE_TYPE (decl1) = fntype = default_function_type;
13593             }
13594         }
13595     }
13596
13597   /* Sometimes we don't notice that a function is a static member, and
13598      build a METHOD_TYPE for it.  Fix that up now.  */
13599   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13600       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13601     {
13602       revert_static_member_fn (decl1);
13603       last_function_parms = TREE_CHAIN (last_function_parms);
13604       ctype = NULL_TREE;
13605     }
13606
13607   /* Warn if function was previously implicitly declared
13608      (but not if we warned then).  */
13609   if (! warn_implicit
13610       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13611     cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13612
13613   /* Set up current_class_type, and enter the scope of the class, if
13614      appropriate.  */
13615   if (ctype)
13616     push_nested_class (ctype, 1);
13617   else if (DECL_STATIC_FUNCTION_P (decl1))
13618     push_nested_class (DECL_CONTEXT (decl1), 2);
13619
13620   /* Now that we have entered the scope of the class, we must restore
13621      the bindings for any template parameters surrounding DECL1, if it
13622      is an inline member template.  (Order is important; consider the
13623      case where a template parameter has the same name as a field of
13624      the class.)  It is not until after this point that
13625      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
13626   if (flags & SF_INCLASS_INLINE)
13627     maybe_begin_member_template_processing (decl1);
13628
13629   /* Effective C++ rule 15.  See also c_expand_return.  */
13630   if (warn_ecpp
13631       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13632       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13633     cp_warning ("`operator=' should return a reference to `*this'");
13634
13635   /* Make the init_value nonzero so pushdecl knows this is not tentative.
13636      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
13637   if (!DECL_INITIAL (decl1))
13638     DECL_INITIAL (decl1) = error_mark_node;
13639
13640 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13641   SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13642 #endif
13643
13644   /* This function exists in static storage.
13645      (This does not mean `static' in the C sense!)  */
13646   TREE_STATIC (decl1) = 1;
13647
13648   /* We must call push_template_decl after current_class_type is set
13649      up.  (If we are processing inline definitions after exiting a
13650      class scope, current_class_type will be NULL_TREE until set above
13651      by push_nested_class.)  */
13652   if (processing_template_decl)
13653     decl1 = push_template_decl (decl1);
13654
13655   /* We are now in the scope of the function being defined.  */
13656   current_function_decl = decl1;
13657
13658   /* Save the parm names or decls from this function's declarator
13659      where store_parm_decls will find them.  */
13660   current_function_parms = last_function_parms;
13661   current_function_parm_tags = last_function_parm_tags;
13662
13663   /* Make sure the parameter and return types are reasonable.  When
13664      you declare a function, these types can be incomplete, but they
13665      must be complete when you define the function.  */
13666   if (! processing_template_decl)
13667     check_function_type (decl1);
13668
13669   /* Build the return declaration for the function.  */
13670   restype = TREE_TYPE (fntype);
13671   if (!processing_template_decl)
13672     {
13673       if (!DECL_RESULT (decl1))
13674         {
13675           DECL_RESULT (decl1)
13676             = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13677           c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13678                                       DECL_RESULT (decl1));
13679         }
13680     }
13681   else
13682     /* Just use `void'.  Nobody will ever look at this anyhow.  */
13683     DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13684
13685   /* Initialize RTL machinery.  We cannot do this until
13686      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
13687      even when processing a template; this is how we get
13688      CFUN set up, and our per-function variables initialized.  */
13689   bl = current_binding_level;
13690   init_function_start (decl1, input_filename, lineno);
13691   current_binding_level = bl;
13692   expanding_p = (flags & SF_EXPAND) != 0;
13693
13694   /* Even though we're inside a function body, we still don't want to
13695      call expand_expr to calculate the size of a variable-sized array.
13696      We haven't necessarily assigned RTL to all variables yet, so it's
13697      not safe to try to expand expressions involving them.  */
13698   immediate_size_expand = 0;
13699   cfun->x_dont_save_pending_sizes_p = 1;
13700
13701   /* If we're building a statement-tree, start the tree now.  */
13702   if (processing_template_decl || !expanding_p)
13703     begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13704
13705   /* Let the user know we're compiling this function.  */
13706   announce_function (decl1);
13707
13708   /* Record the decl so that the function name is defined.
13709      If we already have a decl for this name, and it is a FUNCTION_DECL,
13710      use the old decl.  */
13711   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13712     {
13713       /* A specialization is not used to guide overload resolution.  */
13714       if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13715           && ! DECL_FUNCTION_MEMBER_P (decl1))
13716         decl1 = pushdecl (decl1);
13717       else
13718         {
13719           /* We need to set the DECL_CONTEXT. */
13720           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13721             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13722           /* And make sure we have enough default args.  */
13723           check_default_args (decl1);
13724         }
13725       fntype = TREE_TYPE (decl1);
13726     }
13727
13728   /* Reset these in case the call to pushdecl changed them.  */
13729   current_function_decl = decl1;
13730   cfun->decl = decl1;
13731
13732   /* Initialize the per-function data.  */
13733   if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13734     {
13735       /* If we already parsed this function, and we're just expanding it
13736          now, restore saved state.  */
13737       struct binding_level *bl = current_binding_level;
13738       *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13739       current_binding_level = bl;
13740
13741       /* This function is being processed in whole-function mode; we
13742          already did semantic analysis.  */
13743       cfun->x_whole_function_mode_p = 1;
13744
13745       /* If we decided that we didn't want to inline this function,
13746          make sure the back-end knows that.  */
13747       if (!current_function_cannot_inline)
13748         current_function_cannot_inline = cp_function_chain->cannot_inline;
13749
13750       /* We don't need the saved data anymore.  */
13751       free (DECL_SAVED_FUNCTION_DATA (decl1));
13752       DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13753     }
13754   else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13755     {
13756       /* We know that this was set up by `grokclassfn'.  We do not
13757          wait until `store_parm_decls', since evil parse errors may
13758          never get us to that point.  Here we keep the consistency
13759          between `current_class_type' and `current_class_ptr'.  */
13760       tree t = DECL_ARGUMENTS (decl1);
13761
13762       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13763                           162);
13764       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13765                           19990811);
13766
13767       cp_function_chain->x_current_class_ref
13768         = build_indirect_ref (t, NULL_PTR);
13769       cp_function_chain->x_current_class_ptr = t;
13770
13771       /* Constructors and destructors need to know whether they're "in
13772          charge" of initializing virtual base classes.  */
13773       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13774         current_in_charge_parm = TREE_CHAIN (t);
13775     }
13776
13777   if (DECL_INTERFACE_KNOWN (decl1))
13778     {
13779       tree ctx = decl_function_context (decl1);
13780
13781       if (DECL_NOT_REALLY_EXTERN (decl1))
13782         DECL_EXTERNAL (decl1) = 0;
13783
13784       if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13785           && TREE_PUBLIC (ctx))
13786         /* This is a function in a local class in an extern inline
13787            function.  */
13788         comdat_linkage (decl1);
13789     }
13790   /* If this function belongs to an interface, it is public.
13791      If it belongs to someone else's interface, it is also external.
13792      This only affects inlines and template instantiations.  */
13793   else if (interface_unknown == 0
13794            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13795                || flag_alt_external_templates))
13796     {
13797       if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13798           || processing_template_decl)
13799         {
13800           DECL_EXTERNAL (decl1)
13801             = (interface_only
13802                || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13803                    && !DECL_VINDEX (decl1)));
13804
13805           /* For WIN32 we also want to put these in linkonce sections.  */
13806           maybe_make_one_only (decl1);
13807         }
13808       else
13809         DECL_EXTERNAL (decl1) = 0;
13810       DECL_NOT_REALLY_EXTERN (decl1) = 0;
13811       DECL_INTERFACE_KNOWN (decl1) = 1;
13812     }
13813   else if (interface_unknown && interface_only
13814            && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13815                || flag_alt_external_templates))
13816     {
13817       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13818          interface, we will have interface_only set but not
13819          interface_known.  In that case, we don't want to use the normal
13820          heuristics because someone will supply a #pragma implementation
13821          elsewhere, and deducing it here would produce a conflict.  */
13822       comdat_linkage (decl1);
13823       DECL_EXTERNAL (decl1) = 0;
13824       DECL_INTERFACE_KNOWN (decl1) = 1;
13825       DECL_DEFER_OUTPUT (decl1) = 1;
13826     }
13827   else
13828     {
13829       /* This is a definition, not a reference.
13830          So clear DECL_EXTERNAL.  */
13831       DECL_EXTERNAL (decl1) = 0;
13832
13833       if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13834           && ! DECL_INTERFACE_KNOWN (decl1)
13835           /* Don't try to defer nested functions for now.  */
13836           && ! decl_function_context (decl1))
13837         DECL_DEFER_OUTPUT (decl1) = 1;
13838       else
13839         DECL_INTERFACE_KNOWN (decl1) = 1;
13840     }
13841
13842   if (doing_semantic_analysis_p ())
13843     {
13844       pushlevel (0);
13845       current_binding_level->parm_flag = 1;
13846     }
13847
13848   if (attrs)
13849     cplus_decl_attributes (decl1, NULL_TREE, attrs);
13850
13851   if (!building_stmt_tree ())
13852     {
13853       GNU_xref_function (decl1, current_function_parms);
13854       make_function_rtl (decl1);
13855     }
13856
13857   /* Promote the value to int before returning it.  */
13858   if (C_PROMOTING_INTEGER_TYPE_P (restype))
13859     restype = type_promotes_to (restype);
13860
13861   /* If this fcn was already referenced via a block-scope `extern' decl
13862      (or an implicit decl), propagate certain information about the usage.  */
13863   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13864     TREE_ADDRESSABLE (decl1) = 1;
13865
13866   if (DECL_RESULT (decl1) == NULL_TREE)
13867     {
13868       DECL_RESULT (decl1)
13869         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13870       TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13871       TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13872     }
13873
13874   ++function_depth;
13875
13876   if (DECL_DESTRUCTOR_P (decl1))
13877     {
13878       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13879       DECL_CONTEXT (dtor_label) = current_function_decl;
13880     }
13881   /* Under the old ABI we return `this' from constructors, so we make
13882      ordinary `return' statements in constructors jump to CTOR_LABEL;
13883      from there we return `this'.  Under the new ABI, we don't bother
13884      with any of this.  By not setting CTOR_LABEL the remainder of the
13885      machinery is automatically disabled.  */
13886   else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13887     {
13888       ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13889       DECL_CONTEXT (ctor_label) = current_function_decl;
13890     }
13891
13892   return 1;
13893 }
13894 \f
13895 /* Called after store_parm_decls for a function-try-block.  */
13896
13897 void
13898 expand_start_early_try_stmts ()
13899 {
13900   expand_start_try_stmts ();
13901 }
13902
13903 /* Store the parameter declarations into the current function declaration.
13904    This is called after parsing the parameter declarations, before
13905    digesting the body of the function.
13906
13907    Also install to binding contour return value identifier, if any.  */
13908
13909 void
13910 store_parm_decls ()
13911 {
13912   register tree fndecl = current_function_decl;
13913   register tree parm;
13914   int parms_have_cleanups = 0;
13915   tree cleanups = NULL_TREE;
13916
13917   /* This is a list of types declared among parms in a prototype.  */
13918   tree parmtags = current_function_parm_tags;
13919
13920   /* This is a chain of any other decls that came in among the parm
13921      declarations.  If a parm is declared with  enum {foo, bar} x;
13922      then CONST_DECLs for foo and bar are put here.  */
13923   tree nonparms = NULL_TREE;
13924
13925   /* Create a binding level for the parms.  */
13926   if (!building_stmt_tree ())
13927     expand_start_bindings (2);
13928
13929   if (current_function_parms)
13930     {
13931       /* This case is when the function was defined with an ANSI prototype.
13932          The parms already have decls, so we need not do anything here
13933          except record them as in effect
13934          and complain if any redundant old-style parm decls were written.  */
13935
13936       tree specparms = current_function_parms;
13937       tree next;
13938
13939       if (doing_semantic_analysis_p ())
13940         {
13941           /* Must clear this because it might contain TYPE_DECLs declared
13942              at class level.  */
13943           storedecls (NULL_TREE);
13944
13945           /* If we're doing semantic analysis, then we'll call pushdecl
13946              for each of these.  We must do them in reverse order so that
13947              they end in the correct forward order.  */
13948           specparms = nreverse (specparms);
13949         }
13950
13951       for (parm = specparms; parm; parm = next)
13952         {
13953           next = TREE_CHAIN (parm);
13954           if (TREE_CODE (parm) == PARM_DECL)
13955             {
13956               tree type = TREE_TYPE (parm);
13957
13958               if (doing_semantic_analysis_p ())
13959                 {
13960                   tree cleanup;
13961
13962                   if (DECL_NAME (parm) == NULL_TREE
13963                       || TREE_CODE (parm) != VOID_TYPE)
13964                     pushdecl (parm);
13965                   else
13966                     cp_error ("parameter `%D' declared void", parm);
13967
13968                   cleanup = (processing_template_decl
13969                              ? NULL_TREE
13970                              : maybe_build_cleanup (parm));
13971
13972                   if (cleanup)
13973                     cleanups = tree_cons (parm, cleanup, cleanups);
13974                 }
13975               else if (type != error_mark_node
13976                        && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13977                 parms_have_cleanups = 1;
13978             }
13979           else
13980             {
13981               /* If we find an enum constant or a type tag,
13982                  put it aside for the moment.  */
13983               TREE_CHAIN (parm) = NULL_TREE;
13984               nonparms = chainon (nonparms, parm);
13985             }
13986         }
13987
13988       if (doing_semantic_analysis_p ())
13989         {
13990           /* Get the decls in their original chain order
13991              and record in the function.  This is all and only the
13992              PARM_DECLs that were pushed into scope by the loop above.  */
13993           DECL_ARGUMENTS (fndecl) = getdecls ();
13994           storetags (chainon (parmtags, gettags ()));
13995         }
13996     }
13997   else
13998     DECL_ARGUMENTS (fndecl) = NULL_TREE;
13999
14000   /* Now store the final chain of decls for the arguments
14001      as the decl-chain of the current lexical scope.
14002      Put the enumerators in as well, at the front so that
14003      DECL_ARGUMENTS is not modified.  */
14004   if (doing_semantic_analysis_p ())
14005     storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
14006
14007   /* Initialize the RTL code for the function.  */
14008   DECL_SAVED_INSNS (fndecl) = 0;
14009   if (! building_stmt_tree ())
14010     expand_function_start (fndecl, parms_have_cleanups);
14011
14012   current_function_parms_stored = 1;
14013
14014   /* If this function is `main', emit a call to `__main'
14015      to run global initializers, etc.  */
14016   if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
14017     expand_main_function ();
14018
14019   /* Now that we have initialized the parms, we can start their
14020      cleanups.  We cannot do this before, since expand_decl_cleanup
14021      should not be called before the parm can be used.  */
14022   while (cleanups)
14023     {
14024       finish_decl_cleanup (TREE_PURPOSE (cleanups),
14025                            TREE_VALUE (cleanups));
14026       cleanups = TREE_CHAIN (cleanups);
14027     }
14028
14029   /* Create a binding contour which can be used to catch
14030      cleanup-generated temporaries.  Also, if the return value needs or
14031      has initialization, deal with that now.  */
14032   if (parms_have_cleanups)
14033     {
14034       pushlevel (0);
14035       if (!building_stmt_tree ())
14036         expand_start_bindings (2);
14037     }
14038
14039   /* Do the starting of the exception specifications, if we have any.  */
14040   if (flag_exceptions && !processing_template_decl
14041       && flag_enforce_eh_specs
14042       && building_stmt_tree ()
14043       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14044     current_eh_spec_try_block = expand_start_eh_spec ();
14045 }
14046
14047 /* Bind a name and initialization to the return value of
14048    the current function.  */
14049
14050 void
14051 store_return_init (decl)
14052      tree decl;
14053 {
14054   /* If this named return value comes in a register, put it in a
14055      pseudo-register.  */
14056   if (DECL_REGISTER (decl))
14057     {
14058       original_result_rtx = DECL_RTL (decl);
14059       /* Note that the mode of the old DECL_RTL may be wider than the
14060          mode of DECL_RESULT, depending on the calling conventions for
14061          the processor.  For example, on the Alpha, a 32-bit integer
14062          is returned in a DImode register -- the DECL_RESULT has
14063          SImode but the DECL_RTL for the DECL_RESULT has DImode.  So,
14064          here, we use the mode the back-end has already assigned for
14065          the return value.  */
14066       DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
14067       if (TREE_ADDRESSABLE (decl))
14068         put_var_into_stack (decl);
14069     }
14070 }
14071
14072 \f
14073 /* We have finished doing semantic analysis on DECL, but have not yet
14074    generated RTL for its body.  Save away our current state, so that
14075    when we want to generate RTL later we know what to do.  */
14076
14077 static void
14078 save_function_data (decl)
14079      tree decl;
14080 {
14081   struct language_function *f;
14082
14083   /* Save the language-specific per-function data so that we can
14084      get it back when we really expand this function.  */
14085   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
14086                       19990908);
14087
14088   /* Make a copy.  */
14089   f = ((struct language_function *)
14090        xmalloc (sizeof (struct language_function)));
14091   bcopy ((char *) cp_function_chain, (char *) f,
14092          sizeof (struct language_function));
14093   DECL_SAVED_FUNCTION_DATA (decl) = f;
14094
14095   /* Clear out the bits we don't need.  */
14096   f->x_stmt_tree.x_last_stmt = NULL_TREE;
14097   f->x_stmt_tree.x_last_expr_type = NULL_TREE;
14098   f->x_result_rtx = NULL_RTX;
14099   f->x_named_label_uses = NULL;
14100   f->bindings = NULL;
14101
14102   /* When we get back here again, we will be expanding.  */
14103   f->x_expanding_p = 1;
14104
14105   /* If we've already decided that we cannot inline this function, we
14106      must remember that fact when we actually go to expand the
14107      function.  */
14108   f->cannot_inline = current_function_cannot_inline;
14109 }
14110
14111 /* At the end of every constructor we generate to code to return
14112    `this'.  Do that now.  */
14113
14114 static void
14115 finish_constructor_body ()
14116 {
14117   /* Any return from a constructor will end up here.  */
14118   if (ctor_label)
14119     add_tree (build_min_nt (LABEL_STMT, ctor_label));
14120
14121   /* Clear CTOR_LABEL so that finish_return_stmt knows to really
14122      generate the return, rather than a goto to CTOR_LABEL.  */
14123   ctor_label = NULL_TREE;
14124   /* In check_return_expr we translate an empty return from a
14125      constructor to a return of `this'.  */
14126   finish_return_stmt (NULL_TREE);
14127   /* Mark the end of the constructor.  */
14128   add_tree (build_min_nt (CTOR_STMT));
14129 }
14130
14131 /* At the end of every destructor we generate code to restore virtual
14132    function tables to the values desired by base classes and to call
14133    to base class destructors.  Do that now.  */
14134
14135 static void
14136 finish_destructor_body ()
14137 {
14138   tree compound_stmt;
14139   tree virtual_size;
14140   tree exprstmt;
14141   tree if_stmt;
14142
14143   /* Create a block to contain all the extra code.  */
14144   compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
14145
14146   /* Any return from a destructor will end up here.  */
14147   add_tree (build_min_nt (LABEL_STMT, dtor_label));
14148
14149   /* Generate the code to call destructor on base class.  If this
14150      destructor belongs to a class with virtual functions, then set
14151      the virtual function table pointer to represent the type of our
14152      base class.  */
14153
14154   /* This side-effect makes call to `build_delete' generate the code
14155      we have to have at the end of this destructor.  `build_delete'
14156      will set the flag again.  */
14157   TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
14158
14159   exprstmt = build_delete (current_class_type,
14160                            current_class_ref,
14161                            sfk_base_destructor,
14162                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
14163                            0);
14164
14165   if (exprstmt != error_mark_node
14166       && (TREE_CODE (exprstmt) != NOP_EXPR
14167           || TREE_OPERAND (exprstmt, 0) != integer_zero_node
14168           || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
14169     {
14170       if (exprstmt != void_zero_node)
14171         /* Don't call `expand_expr_stmt' if we're not going to do
14172            anything, since -Wall will give a diagnostic.  */
14173         finish_expr_stmt (exprstmt);
14174
14175       /* Run destructors for all virtual baseclasses.  */
14176       if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
14177         {
14178           tree vbases;
14179           tree if_stmt;
14180
14181           if_stmt = begin_if_stmt ();
14182           finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14183                                       current_in_charge_parm,
14184                                       integer_two_node),
14185                                if_stmt);
14186
14187           vbases = CLASSTYPE_VBASECLASSES (current_class_type);
14188           /* The CLASSTYPE_VBASECLASSES list is in initialization
14189              order, so we have to march through it in reverse order.  */
14190           for (vbases = nreverse (copy_list (vbases));
14191                vbases;
14192                vbases = TREE_CHAIN (vbases))
14193             {
14194               tree vbase = TREE_VALUE (vbases);
14195
14196               if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase)))
14197                 {
14198                   tree vb = get_vbase
14199                     (BINFO_TYPE (vbase),
14200                      TYPE_BINFO (current_class_type));
14201                   finish_expr_stmt
14202                     (build_scoped_method_call
14203                      (current_class_ref, vb, base_dtor_identifier,
14204                       NULL_TREE));
14205                 }
14206             }
14207
14208           finish_then_clause (if_stmt);
14209           finish_if_stmt ();
14210         }
14211     }
14212
14213   virtual_size = c_sizeof (current_class_type);
14214
14215   /* At the end, call delete if that's what's requested.  */
14216
14217   /* FDIS sez: At the point of definition of a virtual destructor
14218      (including an implicit definition), non-placement operator delete
14219      shall be looked up in the scope of the destructor's class and if
14220      found shall be accessible and unambiguous.
14221
14222      This is somewhat unclear, but I take it to mean that if the class
14223      only defines placement deletes we don't do anything here.  So we
14224      pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14225      they ever try to delete one of these.  */
14226   exprstmt = build_op_delete_call
14227     (DELETE_EXPR, current_class_ptr, virtual_size,
14228      LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
14229
14230   if_stmt = begin_if_stmt ();
14231   finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
14232                               current_in_charge_parm,
14233                               integer_one_node),
14234                        if_stmt);
14235   finish_expr_stmt (exprstmt);
14236   finish_then_clause (if_stmt);
14237   finish_if_stmt ();
14238
14239   /* Close the block we started above.  */
14240   finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
14241 }
14242
14243 /* Finish up a function declaration and compile that function
14244    all the way to assembler language output.  The free the storage
14245    for the function definition.
14246
14247    FLAGS is a bitwise or of the following values:
14248      1 - CALL_POPLEVEL
14249        An extra call to poplevel (and expand_end_bindings) must be
14250        made to take care of the binding contour for the base
14251        initializers.  This is only relevant for constructors.
14252      2 - INCLASS_INLINE
14253        We just finished processing the body of an in-class inline
14254        function definition.  (This processing will have taken place
14255        after the class definition is complete.)  */
14256
14257 tree
14258 finish_function (flags)
14259      int flags;
14260 {
14261   register tree fndecl = current_function_decl;
14262   tree fntype, ctype = NULL_TREE;
14263   /* Label to use if this function is supposed to return a value.  */
14264   tree no_return_label = NULL_TREE;
14265   int call_poplevel = (flags & 1) != 0;
14266   int inclass_inline = (flags & 2) != 0;
14267   int expand_p;
14268   int nested;
14269   int current_line = lineno;
14270
14271   /* When we get some parse errors, we can end up without a
14272      current_function_decl, so cope.  */
14273   if (fndecl == NULL_TREE)
14274     return error_mark_node;
14275
14276   nested = function_depth > 1;
14277   fntype = TREE_TYPE (fndecl);
14278
14279   /*  TREE_READONLY (fndecl) = 1;
14280       This caused &foo to be of type ptr-to-const-function
14281       which then got a warning when stored in a ptr-to-function variable.  */
14282
14283   /* This happens on strange parse errors.  */
14284   if (! current_function_parms_stored)
14285     {
14286       call_poplevel = 0;
14287       store_parm_decls ();
14288     }
14289
14290   /* For a cloned function, we've already got all the code we need;
14291      there's no need to add any extra bits.  */
14292   if (building_stmt_tree () && DECL_CLONED_FUNCTION_P (fndecl))
14293     ;
14294   else if (building_stmt_tree ())
14295     {
14296       if (DECL_CONSTRUCTOR_P (fndecl))
14297         {
14298           finish_constructor_body ();
14299           if (call_poplevel)
14300             do_poplevel ();
14301         }
14302       else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
14303         finish_destructor_body ();
14304       else if (DECL_MAIN_P (fndecl))
14305         {
14306           /* Make it so that `main' always returns 0 by default.  */
14307 #ifdef VMS
14308           finish_return_stmt (integer_one_node);
14309 #else
14310           finish_return_stmt (integer_zero_node);
14311 #endif
14312         }
14313
14314       /* Finish dealing with exception specifiers.  */
14315       if (flag_exceptions && !processing_template_decl
14316           && flag_enforce_eh_specs
14317           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14318         expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14319                             (TREE_TYPE (current_function_decl)),
14320                             current_eh_spec_try_block);
14321     }
14322   else
14323     {
14324 #if 0
14325       if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
14326         {
14327           /* Keep this code around in case we later want to control debug info
14328              based on whether a type is "used".  (jason 1999-11-11) */
14329
14330           tree ttype = target_type (fntype);
14331           tree parmdecl;
14332
14333           if (IS_AGGR_TYPE (ttype))
14334             /* Let debugger know it should output info for this type.  */
14335             note_debug_info_needed (ttype);
14336
14337           for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
14338             {
14339               ttype = target_type (TREE_TYPE (parmdecl));
14340               if (IS_AGGR_TYPE (ttype))
14341                 /* Let debugger know it should output info for this type.  */
14342                 note_debug_info_needed (ttype);
14343             }
14344         }
14345 #endif
14346
14347       /* Clean house because we will need to reorder insns here.  */
14348       do_pending_stack_adjust ();
14349
14350       if (dtor_label)
14351         ;
14352       else if (DECL_CONSTRUCTOR_P (fndecl))
14353         {
14354           if (call_poplevel)
14355             do_poplevel ();
14356         }
14357       else if (return_label != NULL_RTX
14358                && flag_this_is_variable <= 0
14359                && current_function_return_value == NULL_TREE
14360                && ! DECL_NAME (DECL_RESULT (current_function_decl)))
14361         no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14362
14363       if (flag_exceptions)
14364         expand_exception_blocks ();
14365
14366       /* If this function is supposed to return a value, ensure that
14367          we do not fall into the cleanups by mistake.  The end of our
14368          function will look like this:
14369
14370          user code (may have return stmt somewhere)
14371          goto no_return_label
14372          cleanup_label:
14373          cleanups
14374          goto return_label
14375          no_return_label:
14376          NOTE_INSN_FUNCTION_END
14377          return_label:
14378          things for return
14379
14380          If the user omits a return stmt in the USER CODE section, we
14381          will have a control path which reaches NOTE_INSN_FUNCTION_END.
14382          Otherwise, we won't.  */
14383       if (no_return_label)
14384         {
14385           DECL_CONTEXT (no_return_label) = fndecl;
14386           DECL_INITIAL (no_return_label) = error_mark_node;
14387           DECL_SOURCE_FILE (no_return_label) = input_filename;
14388           DECL_SOURCE_LINE (no_return_label) = current_line;
14389           expand_goto (no_return_label);
14390         }
14391
14392       if (cleanup_label)
14393         {
14394           /* Remove the binding contour which is used
14395              to catch cleanup-generated temporaries.  */
14396           expand_end_bindings (0, 0, 0);
14397           poplevel (0, 0, 0);
14398
14399           /* Emit label at beginning of cleanup code for parameters.  */
14400           emit_label (cleanup_label);
14401         }
14402
14403       /* Get return value into register if that's where it's supposed
14404          to be.  */
14405       if (original_result_rtx)
14406         fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
14407
14408       /* Finish building code that will trigger warnings if users forget
14409          to make their functions return values.  */
14410       if (no_return_label || cleanup_label)
14411         emit_jump (return_label);
14412       if (no_return_label)
14413         {
14414           /* We don't need to call `expand_*_return' here because we
14415              don't need any cleanups here--this path of code is only
14416              for error checking purposes.  */
14417           expand_label (no_return_label);
14418         }
14419
14420       /* We hard-wired immediate_size_expand to zero in
14421          start_function.  Expand_function_end will decrement this
14422          variable.  So, we set the variable to one here, so that after
14423          the decrement it will remain zero.  */
14424       immediate_size_expand = 1;
14425
14426       /* Generate rtl for function exit.  */
14427       expand_function_end (input_filename, current_line, 1);
14428     }
14429
14430   /* We have to save this value here in case
14431      maybe_end_member_template_processing decides to pop all the
14432      template parameters.  */
14433   expand_p = !building_stmt_tree ();
14434
14435   /* If we're saving up tree structure, tie off the function now.  */
14436   if (!expand_p)
14437     finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14438
14439   /* This must come after expand_function_end because cleanups might
14440      have declarations (from inline functions) that need to go into
14441      this function's blocks.  */
14442   if (doing_semantic_analysis_p ())
14443     {
14444       if (current_binding_level->parm_flag != 1)
14445         my_friendly_abort (122);
14446       poplevel (1, 0, 1);
14447     }
14448
14449   /* Remember that we were in class scope.  */
14450   if (current_class_name)
14451     ctype = current_class_type;
14452
14453   /* Must mark the RESULT_DECL as being in this function.  */
14454   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14455
14456   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14457      to the FUNCTION_DECL node itself.  */
14458   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14459
14460   /* Save away current state, if appropriate.  */
14461   if (!expanding_p && !processing_template_decl)
14462     save_function_data (fndecl);
14463
14464   /* If this function calls `setjmp' it cannot be inlined.  When
14465      `longjmp' is called it is not guaranteed to restore the value of
14466      local variables that have been modified since the call to
14467      `setjmp'.  So, if were to inline this function into some caller
14468      `c', then when we `longjmp', we might not restore all variables
14469      in `c'.  (It might seem, at first blush, that there's no way for
14470      this function to modify local variables in `c', but their
14471      addresses may have been stored somewhere accessible to this
14472      function.)  */
14473   if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
14474     DECL_UNINLINABLE (fndecl) = 1;
14475
14476   if (expand_p)
14477     {
14478       int returns_null;
14479       int returns_value;
14480
14481       /* So we can tell if jump_optimize sets it to 1.  */
14482       can_reach_end = 0;
14483
14484       /* Before we call rest_of_compilation (which will pop the
14485          CURRENT_FUNCTION), we must save these values.  */
14486       returns_null = current_function_returns_null;
14487       returns_value = current_function_returns_value;
14488
14489       /* If this is a nested function (like a template instantiation
14490          that we're compiling in the midst of compiling something
14491          else), push a new GC context.  That will keep local variables
14492          on the stack from being collected while we're doing the
14493          compilation of this function.  */
14494       if (function_depth > 1)
14495         ggc_push_context ();
14496
14497       /* Run the optimizers and output the assembler code for this
14498          function.  */
14499       rest_of_compilation (fndecl);
14500
14501       /* Undo the call to ggc_push_context above.  */
14502       if (function_depth > 1)
14503         ggc_pop_context ();
14504
14505       if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
14506         {
14507           /* Set DECL_EXTERNAL so that assemble_external will be called as
14508              necessary.  We'll clear it again in finish_file.  */
14509           if (! DECL_EXTERNAL (fndecl))
14510             DECL_NOT_REALLY_EXTERN (fndecl) = 1;
14511           DECL_EXTERNAL (fndecl) = 1;
14512           defer_fn (fndecl);
14513         }
14514
14515 #if 0
14516       /* Keep this code around in case we later want to control debug info
14517          based on whether a type is "used".  (jason 1999-11-11) */
14518
14519       if (ctype && TREE_ASM_WRITTEN (fndecl))
14520         note_debug_info_needed (ctype);
14521 #endif
14522
14523       returns_null |= can_reach_end;
14524
14525       /* Since we don't normally go through c_expand_return for constructors,
14526          this normally gets the wrong value.
14527          Also, named return values have their return codes emitted after
14528          NOTE_INSN_FUNCTION_END, confusing jump.c.  */
14529       if (DECL_CONSTRUCTOR_P (fndecl)
14530           || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
14531         returns_null = 0;
14532
14533       if (TREE_THIS_VOLATILE (fndecl) && returns_null)
14534         cp_warning ("`noreturn' function `%D' does return", fndecl);
14535       else if ((warn_return_type || pedantic)
14536                && returns_null
14537                && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14538         {
14539           /* If this function returns non-void and control can drop through,
14540              complain.  */
14541           cp_warning ("control reaches end of non-void function `%D'", fndecl);
14542         }
14543       /* With just -W, complain only if function returns both with
14544          and without a value.  */
14545       else if (extra_warnings && returns_value && returns_null)
14546         warning ("this function may return with or without a value");
14547     }
14548   else
14549     {
14550       /* Clear out memory we no longer need.  */
14551       free_after_parsing (cfun);
14552       /* Since we never call rest_of_compilation, we never clear
14553          CFUN.  Do so explicitly.  */
14554       free_after_compilation (cfun);
14555       cfun = NULL;
14556     }
14557
14558   /* If this is a in-class inline definition, we may have to pop the
14559      bindings for the template parameters that we added in
14560      maybe_begin_member_template_processing when start_function was
14561      called.  */
14562   if (inclass_inline)
14563     maybe_end_member_template_processing ();
14564
14565   /* Leave the scope of the class.  */
14566   if (ctype)
14567     pop_nested_class ();
14568
14569   --function_depth;
14570
14571   if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14572       && !(flag_inline_trees && DECL_INLINE (fndecl)))
14573     {
14574       tree t;
14575
14576       /* Stop pointing to the local nodes about to be freed.  */
14577       /* But DECL_INITIAL must remain nonzero so we know this
14578          was an actual function definition.  */
14579       DECL_INITIAL (fndecl) = error_mark_node;
14580       for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14581         DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14582     }
14583
14584   if (DECL_STATIC_CONSTRUCTOR (fndecl))
14585     static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14586   if (DECL_STATIC_DESTRUCTOR (fndecl))
14587     static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14588
14589   /* Clean up.  */
14590   if (! nested)
14591     {
14592       /* Let the error reporting routines know that we're outside a
14593          function.  For a nested function, this value is used in
14594          pop_cp_function_context and then reset via pop_function_context.  */
14595       current_function_decl = NULL_TREE;
14596       /* We don't really care about obstacks, but the middle-end
14597          sometimes cares on what obstck things are located.  */
14598       permanent_allocation (1);
14599     }
14600
14601   return fndecl;
14602 }
14603 \f
14604 /* Create the FUNCTION_DECL for a function definition.
14605    DECLSPECS and DECLARATOR are the parts of the declaration;
14606    they describe the return type and the name of the function,
14607    but twisted together in a fashion that parallels the syntax of C.
14608
14609    This function creates a binding context for the function body
14610    as well as setting up the FUNCTION_DECL in current_function_decl.
14611
14612    Returns a FUNCTION_DECL on success.
14613
14614    If the DECLARATOR is not suitable for a function (it defines a datum
14615    instead), we return 0, which tells yyparse to report a parse error.
14616
14617    May return void_type_node indicating that this method is actually
14618    a friend.  See grokfield for more details.
14619
14620    Came here with a `.pushlevel' .
14621
14622    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14623    CHANGES TO CODE IN `grokfield'.  */
14624
14625 tree
14626 start_method (declspecs, declarator, attrlist)
14627      tree declarator, declspecs, attrlist;
14628 {
14629   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14630                                 attrlist);
14631
14632   /* Something too ugly to handle.  */
14633   if (fndecl == NULL_TREE)
14634     return NULL_TREE;
14635
14636   /* Pass friends other than inline friend functions back.  */
14637   if (fndecl == void_type_node)
14638     return fndecl;
14639
14640   if (TREE_CODE (fndecl) != FUNCTION_DECL)
14641     /* Not a function, tell parser to report parse error.  */
14642     return NULL_TREE;
14643
14644   if (DECL_IN_AGGR_P (fndecl))
14645     {
14646       if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14647         {
14648           if (DECL_CONTEXT (fndecl)
14649               && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14650             cp_error ("`%D' is already defined in class %s", fndecl,
14651                              TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14652         }
14653       return void_type_node;
14654     }
14655
14656   check_template_shadow (fndecl);
14657
14658   DECL_THIS_INLINE (fndecl) = 1;
14659
14660   if (flag_default_inline)
14661     DECL_INLINE (fndecl) = 1;
14662
14663   /* We process method specializations in finish_struct_1.  */
14664   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14665     fndecl = push_template_decl (fndecl);
14666
14667   if (! DECL_FRIEND_P (fndecl))
14668     {
14669       if (TREE_CHAIN (fndecl))
14670         {
14671           fndecl = copy_node (fndecl);
14672           TREE_CHAIN (fndecl) = NULL_TREE;
14673         }
14674
14675       if (DECL_CONSTRUCTOR_P (fndecl))
14676         {
14677           if (! grok_ctor_properties (current_class_type, fndecl))
14678             return void_type_node;
14679         }
14680       else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14681         grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14682     }
14683
14684   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14685
14686   /* Make a place for the parms */
14687   pushlevel (0);
14688   current_binding_level->parm_flag = 1;
14689
14690   DECL_IN_AGGR_P (fndecl) = 1;
14691   return fndecl;
14692 }
14693
14694 /* Go through the motions of finishing a function definition.
14695    We don't compile this method until after the whole class has
14696    been processed.
14697
14698    FINISH_METHOD must return something that looks as though it
14699    came from GROKFIELD (since we are defining a method, after all).
14700
14701    This is called after parsing the body of the function definition.
14702    STMTS is the chain of statements that makes up the function body.
14703
14704    DECL is the ..._DECL that `start_method' provided.  */
14705
14706 tree
14707 finish_method (decl)
14708      tree decl;
14709 {
14710   register tree fndecl = decl;
14711   tree old_initial;
14712
14713   register tree link;
14714
14715   if (decl == void_type_node)
14716     return decl;
14717
14718   old_initial = DECL_INITIAL (fndecl);
14719
14720   /* Undo the level for the parms (from start_method).
14721      This is like poplevel, but it causes nothing to be
14722      saved.  Saving information here confuses symbol-table
14723      output routines.  Besides, this information will
14724      be correctly output when this method is actually
14725      compiled.  */
14726
14727   /* Clear out the meanings of the local variables of this level;
14728      also record in each decl which block it belongs to.  */
14729
14730   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14731     {
14732       if (DECL_NAME (link) != NULL_TREE)
14733         pop_binding (DECL_NAME (link), link);
14734       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14735       DECL_CONTEXT (link) = NULL_TREE;
14736     }
14737
14738   GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14739                       (HOST_WIDE_INT) current_binding_level->level_chain,
14740                       current_binding_level->parm_flag,
14741                       current_binding_level->keep);
14742
14743   poplevel (0, 0, 0);
14744
14745   DECL_INITIAL (fndecl) = old_initial;
14746
14747   /* We used to check if the context of FNDECL was different from
14748      current_class_type as another way to get inside here.  This didn't work
14749      for String.cc in libg++.  */
14750   if (DECL_FRIEND_P (fndecl))
14751     {
14752       CLASSTYPE_INLINE_FRIENDS (current_class_type)
14753         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14754       decl = void_type_node;
14755     }
14756
14757   return decl;
14758 }
14759 \f
14760 /* Called when a new struct TYPE is defined.
14761    If this structure or union completes the type of any previous
14762    variable declaration, lay it out and output its rtl.  */
14763
14764 void
14765 hack_incomplete_structures (type)
14766      tree type;
14767 {
14768   tree *list;
14769   struct binding_level *level;
14770
14771   if (!type) /* Don't do this for class templates.  */
14772     return;
14773
14774   if (namespace_bindings_p ())
14775     {
14776       level = 0;
14777       list = &namespace_scope_incomplete;
14778     }
14779   else
14780     {
14781       level = innermost_nonclass_level ();
14782       list = &level->incomplete;
14783     }
14784
14785   while (1)
14786     {
14787       while (*list)
14788         {
14789           tree decl = TREE_VALUE (*list);
14790           if ((decl && TREE_TYPE (decl) == type)
14791               || (TREE_TYPE (decl)
14792                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14793                   && TREE_TYPE (TREE_TYPE (decl)) == type))
14794             {
14795               int toplevel = toplevel_bindings_p ();
14796               if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14797                   && TREE_TYPE (TREE_TYPE (decl)) == type)
14798                 layout_type (TREE_TYPE (decl));
14799               layout_decl (decl, 0);
14800               rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14801               if (! toplevel)
14802                 {
14803                   tree cleanup;
14804                   expand_decl (decl);
14805                   cleanup = maybe_build_cleanup (decl);
14806                   expand_decl_init (decl);
14807                   if (! expand_decl_cleanup (decl, cleanup))
14808                     cp_error ("parser lost in parsing declaration of `%D'",
14809                               decl);
14810                 }
14811               *list = TREE_CHAIN (*list);
14812             }
14813           else
14814             list = &TREE_CHAIN (*list);
14815         }
14816
14817       /* Keep looking through artificial binding levels generated
14818          for local variables.  */
14819       if (level && level->keep == 2)
14820         {
14821           level = level->level_chain;
14822           list = &level->incomplete;
14823         }
14824       else
14825         break;
14826     }
14827 }
14828
14829 /* If DECL is of a type which needs a cleanup, build that cleanup
14830    here.  */
14831
14832 tree
14833 maybe_build_cleanup (decl)
14834      tree decl;
14835 {
14836   tree type = TREE_TYPE (decl);
14837
14838   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14839     {
14840       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14841       tree rval;
14842
14843       if (TREE_CODE (type) == ARRAY_TYPE)
14844         rval = decl;
14845       else
14846         {
14847           mark_addressable (decl);
14848           rval = build_unary_op (ADDR_EXPR, decl, 0);
14849         }
14850
14851       /* Optimize for space over speed here.  */
14852       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14853           || flag_expensive_optimizations)
14854         flags |= LOOKUP_NONVIRTUAL;
14855
14856       rval = build_delete (TREE_TYPE (rval), rval,
14857                            sfk_complete_destructor, flags, 0);
14858
14859       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14860           && ! TYPE_HAS_DESTRUCTOR (type))
14861         rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14862                                                build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14863
14864       return rval;
14865     }
14866   return 0;
14867 }
14868 \f
14869 /* Expand a C++ expression at the statement level.
14870    This is needed to ferret out nodes which have UNKNOWN_TYPE.
14871    The C++ type checker should get all of these out when
14872    expressions are combined with other, type-providing, expressions,
14873    leaving only orphan expressions, such as:
14874
14875    &class::bar;         / / takes its address, but does nothing with it.  */
14876
14877 void
14878 cplus_expand_expr_stmt (exp)
14879      tree exp;
14880 {
14881 #if 0
14882   /* We should do this eventually, but right now this causes regex.o from
14883      libg++ to miscompile, and tString to core dump.  */
14884   exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14885 #endif
14886
14887   /* If we don't do this, we end up down inside expand_expr
14888      trying to do TYPE_MODE on the ERROR_MARK, and really
14889      go outside the bounds of the type.  */
14890   if (exp != error_mark_node)
14891     expand_expr_stmt (exp);
14892 }
14893
14894 /* When a stmt has been parsed, this function is called.  */
14895
14896 void
14897 finish_stmt ()
14898 {
14899   /* Always assume this statement was not an expression statement.  If
14900      it actually was an expression statement, its our callers
14901      responsibility to fix this up.  */
14902   last_expr_type = NULL_TREE;
14903 }
14904
14905 /* DECL was originally constructed as a non-static member function,
14906    but turned out to be static.  Update it accordingly.  */
14907
14908 void
14909 revert_static_member_fn (decl)
14910      tree decl;
14911 {
14912   tree tmp;
14913   tree function = TREE_TYPE (decl);
14914   tree args = TYPE_ARG_TYPES (function);
14915
14916   if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14917       != TYPE_UNQUALIFIED)
14918     cp_error ("static member function `%#D' declared with type qualifiers",
14919               *decl);
14920
14921   args = TREE_CHAIN (args);
14922   tmp = build_function_type (TREE_TYPE (function), args);
14923   tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14924   tmp = build_exception_variant (tmp,
14925                                  TYPE_RAISES_EXCEPTIONS (function));
14926   TREE_TYPE (decl) = tmp;
14927   if (DECL_ARGUMENTS (decl))
14928     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14929   DECL_STATIC_FUNCTION_P (decl) = 1;
14930 }
14931
14932 /* Initialize the variables used during compilation of a C++
14933    function.  */
14934
14935 static void
14936 push_cp_function_context (f)
14937      struct function *f;
14938 {
14939   struct language_function *p
14940     = ((struct language_function *)
14941        xcalloc (1, sizeof (struct language_function)));
14942   f->language = p;
14943
14944   /* It takes an explicit call to expand_body to generate RTL for a
14945      function.  */
14946   expanding_p = 0;
14947
14948   /* Whenever we start a new function, we destroy temporaries in the
14949      usual way.  */
14950   stmts_are_full_exprs_p = 1;
14951 }
14952
14953 /* Free the language-specific parts of F, now that we've finished
14954    compiling the function.  */
14955
14956 static void
14957 pop_cp_function_context (f)
14958      struct function *f;
14959 {
14960   if (f->language)
14961     free (f->language);
14962   f->language = 0;
14963 }
14964
14965 /* Mark P for GC.  */
14966
14967 static void
14968 mark_lang_function (p)
14969      struct language_function *p;
14970 {
14971   if (!p)
14972     return;
14973
14974   ggc_mark_tree (p->x_ctor_label);
14975   ggc_mark_tree (p->x_dtor_label);
14976   ggc_mark_tree (p->x_current_class_ptr);
14977   ggc_mark_tree (p->x_current_class_ref);
14978   ggc_mark_tree (p->x_eh_spec_try_block);
14979   ggc_mark_tree (p->x_scope_stmt_stack);
14980
14981   ggc_mark_rtx (p->x_result_rtx);
14982
14983   mark_named_label_lists (&p->x_named_labels, &p->x_named_label_uses);
14984   mark_stmt_tree (&p->x_stmt_tree);
14985   mark_binding_level (&p->bindings);
14986 }
14987
14988 /* Mark the language-specific data in F for GC.  */
14989
14990 static void
14991 mark_cp_function_context (f)
14992      struct function *f;
14993 {
14994   mark_lang_function (f->language);
14995 }
14996
14997 void
14998 lang_mark_false_label_stack (l)
14999      struct label_node *l;
15000 {
15001   /* C++ doesn't use false_label_stack.  It better be NULL.  */
15002   my_friendly_assert (l == NULL, 19990904);
15003 }
15004
15005 void
15006 lang_mark_tree (t)
15007      tree t;
15008 {
15009   enum tree_code code = TREE_CODE (t);
15010   if (code == IDENTIFIER_NODE)
15011     {
15012       struct lang_identifier *li = (struct lang_identifier *) t;
15013       struct lang_id2 *li2 = li->x;
15014       ggc_mark_tree (li->namespace_bindings);
15015       ggc_mark_tree (li->bindings);
15016       ggc_mark_tree (li->class_value);
15017       ggc_mark_tree (li->class_template_info);
15018
15019       if (li2)
15020         {
15021           ggc_mark_tree (li2->label_value);
15022           ggc_mark_tree (li2->implicit_decl);
15023           ggc_mark_tree (li2->error_locus);
15024         }
15025     }
15026   else if (code == CPLUS_BINDING)
15027     {
15028       if (BINDING_HAS_LEVEL_P (t))
15029         mark_binding_level (&BINDING_LEVEL (t));
15030       else
15031         ggc_mark_tree (BINDING_SCOPE (t));
15032       ggc_mark_tree (BINDING_VALUE (t));
15033     }
15034   else if (code == OVERLOAD)
15035     ggc_mark_tree (OVL_FUNCTION (t));
15036   else if (code == TEMPLATE_PARM_INDEX)
15037     ggc_mark_tree (TEMPLATE_PARM_DECL (t));
15038   else if (TREE_CODE_CLASS (code) == 'd')
15039     {
15040       struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
15041
15042       if (ld)
15043         {
15044           ggc_mark (ld);
15045           if (!DECL_GLOBAL_CTOR_P (t)
15046               && !DECL_GLOBAL_DTOR_P (t)
15047               && !DECL_THUNK_P (t))
15048             ggc_mark_tree (ld->decl_flags.u2.access);
15049           ggc_mark_tree (ld->decl_flags.context);
15050           if (TREE_CODE (t) != NAMESPACE_DECL)
15051             ggc_mark_tree (ld->decl_flags.u.template_info);
15052           else
15053             mark_binding_level (&NAMESPACE_LEVEL (t));
15054           if (CAN_HAVE_FULL_LANG_DECL_P (t))
15055             {
15056               ggc_mark_tree (ld->befriending_classes);
15057               ggc_mark_tree (ld->saved_tree);
15058               ggc_mark_tree (ld->cloned_function);
15059               if (!DECL_OVERLOADED_OPERATOR_P (t))
15060                 ggc_mark_tree (ld->u2.vtt_parm);
15061               if (TREE_CODE (t) == TYPE_DECL)
15062                 ggc_mark_tree (ld->u.sorted_fields);
15063               else if (TREE_CODE (t) == FUNCTION_DECL
15064                        && !DECL_PENDING_INLINE_P (t))
15065                 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
15066             }
15067         }
15068     }
15069   else if (TREE_CODE_CLASS (code) == 't')
15070     {
15071       struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
15072
15073       if (lt && !(TREE_CODE (t) == POINTER_TYPE
15074                   && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
15075         {
15076           ggc_mark (lt);
15077           ggc_mark_tree (lt->vfields);
15078           ggc_mark_tree (lt->vbases);
15079           ggc_mark_tree (lt->tags);
15080           ggc_mark_tree (lt->size);
15081           ggc_mark_tree (lt->pure_virtuals);
15082           ggc_mark_tree (lt->friend_classes);
15083           ggc_mark_tree (lt->rtti);
15084           ggc_mark_tree (lt->methods);
15085           ggc_mark_tree (lt->template_info);
15086           ggc_mark_tree (lt->befriending_classes);
15087         }
15088       else if (lt)
15089         /* In the case of pointer-to-member function types, the
15090            TYPE_LANG_SPECIFIC is really just a tree.  */
15091         ggc_mark_tree ((tree) lt);
15092     }
15093 }